From 9731ff499ec876d3fe161916cdde7894092bf8d2 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 6 Jun 2013 16:17:06 +0400 Subject: [PATCH] added generator for resolve tests --- .../jet/resolve/AbstractResolveTest.java | 38 ++ .../resolve/ExtensibleResolveTestCase.java | 4 +- .../jetbrains/jet/resolve/JetResolveTest.java | 89 ----- .../jet/resolve/JetResolveTestGenerated.java | 349 ++++++++++++++++++ .../jet/generators/tests/GenerateTests.java | 8 + 5 files changed, 398 insertions(+), 90 deletions(-) create mode 100644 compiler/tests/org/jetbrains/jet/resolve/AbstractResolveTest.java delete mode 100644 compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java create mode 100644 compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java diff --git a/compiler/tests/org/jetbrains/jet/resolve/AbstractResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/AbstractResolveTest.java new file mode 100644 index 00000000000..9ff36414900 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/resolve/AbstractResolveTest.java @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.resolve; + +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.psi.JetFile; + +public abstract class AbstractResolveTest extends ExtensibleResolveTestCase { + + @Override + protected ExpectedResolveData getExpectedResolveData() { + Project project = getProject(); + + return new ExpectedResolveData( + JetExpectedResolveDataUtil.prepareDefaultNameToDescriptors(project), + JetExpectedResolveDataUtil.prepareDefaultNameToDeclaration(project), + getEnvironment()) { + @Override + protected JetFile createJetFile(String fileName, String text) { + return createCheckAndReturnPsiFile(fileName, null, text); + } + }; + } +} diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java index 6784d4ebb0a..85aa4611ff7 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.psi.JetFile; +import java.io.File; import java.util.List; public abstract class ExtensibleResolveTestCase extends JetLiteFixture { @@ -48,7 +49,8 @@ public abstract class ExtensibleResolveTestCase extends JetLiteFixture { protected abstract ExpectedResolveData getExpectedResolveData(); protected void doTest(@NonNls String filePath) throws Exception { - String text = loadFile(filePath); + File file = new File(filePath); + String text = JetTestUtils.doLoadFile(file); List files = JetTestUtils.createTestFiles("file.kt", text, new JetTestUtils.TestFileFactory() { @Override public JetFile create(String fileName, String text) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java deleted file mode 100644 index 5ba19c671cb..00000000000 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.resolve; - -import com.intellij.openapi.application.PathManager; -import com.intellij.openapi.project.Project; -import junit.framework.Test; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.JetTestCaseBuilder; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.parsing.JetParsingTest; - -import java.io.File; - -@SuppressWarnings("JUnitTestCaseWithNoTests") -public class JetResolveTest extends ExtensibleResolveTestCase { - - private final String path; - private final String name; - - @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") - public JetResolveTest(String path, String name) { - this.path = path; - this.name = name; - } - - @Override - protected ExpectedResolveData getExpectedResolveData() { - Project project = getProject(); - - return new ExpectedResolveData( - JetExpectedResolveDataUtil.prepareDefaultNameToDescriptors(project), - JetExpectedResolveDataUtil.prepareDefaultNameToDeclaration(project), - getEnvironment()) { - @Override - protected JetFile createJetFile(String fileName, String text) { - return createCheckAndReturnPsiFile(fileName, null, text); - } - }; - } - - @Override - protected String getTestDataPath() { - return getHomeDirectory() + "/compiler/testData"; - } - - private static String getHomeDirectory() { - String resourceRoot = PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class"); - assertNotNull(resourceRoot); - - return new File(resourceRoot).getParentFile().getParentFile().getParent(); - } - - @Override - public String getName() { - return "test" + name; - } - - @Override - protected void runTest() throws Throwable { - doTest(path); - } - - public static Test suite() { - return JetTestCaseBuilder.suiteForDirectory(getHomeDirectory() + "/compiler/testData/", "/resolve/", - true, JetTestCaseBuilder.filterByExtension("resolve"), - new JetTestCaseBuilder.NamedTestFactory() { - @NotNull - @Override - public Test createTest(@NotNull String dataPath, @NotNull String name, @NotNull File file) { - return new JetResolveTest(dataPath + "/" + name + ".resolve", name); - } - }); - } -} diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java new file mode 100644 index 00000000000..07c283377e1 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java @@ -0,0 +1,349 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.resolve; + +import junit.framework.Assert; +import junit.framework.Test; +import junit.framework.TestSuite; + +import java.io.File; +import java.util.regex.Pattern; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.test.InnerTestClasses; +import org.jetbrains.jet.test.TestMetadata; + +import org.jetbrains.jet.resolve.AbstractResolveTest; + +/** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/resolve") +@InnerTestClasses({JetResolveTestGenerated.CandidatesPriority.class, JetResolveTestGenerated.DelegatedProperty.class, JetResolveTestGenerated.Imports.class, JetResolveTestGenerated.Labels.class, JetResolveTestGenerated.Regressions.class, JetResolveTestGenerated.Varargs.class}) +public class JetResolveTestGenerated extends AbstractResolveTest { + public void testAllFilesPresentInResolve() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("Basic.resolve") + public void testBasic() throws Exception { + doTest("compiler/testData/resolve/Basic.resolve"); + } + + @TestMetadata("ClassObjects.resolve") + public void testClassObjects() throws Exception { + doTest("compiler/testData/resolve/ClassObjects.resolve"); + } + + @TestMetadata("Classifiers.resolve") + public void testClassifiers() throws Exception { + doTest("compiler/testData/resolve/Classifiers.resolve"); + } + + @TestMetadata("ErrorSupertype.resolve") + public void testErrorSupertype() throws Exception { + doTest("compiler/testData/resolve/ErrorSupertype.resolve"); + } + + @TestMetadata("ExtensionFunctions.resolve") + public void testExtensionFunctions() throws Exception { + doTest("compiler/testData/resolve/ExtensionFunctions.resolve"); + } + + @TestMetadata("FunctionVariable.resolve") + public void testFunctionVariable() throws Exception { + doTest("compiler/testData/resolve/FunctionVariable.resolve"); + } + + @TestMetadata("kt304.resolve") + public void testKt304() throws Exception { + doTest("compiler/testData/resolve/kt304.resolve"); + } + + @TestMetadata("LocalObjects.resolve") + public void testLocalObjects() throws Exception { + doTest("compiler/testData/resolve/LocalObjects.resolve"); + } + + @TestMetadata("Namespaces.resolve") + public void testNamespaces() throws Exception { + doTest("compiler/testData/resolve/Namespaces.resolve"); + } + + @TestMetadata("NestedObjects.resolve") + public void testNestedObjects() throws Exception { + doTest("compiler/testData/resolve/NestedObjects.resolve"); + } + + @TestMetadata("NoReferenceForErrorAnnotation.resolve") + public void testNoReferenceForErrorAnnotation() throws Exception { + doTest("compiler/testData/resolve/NoReferenceForErrorAnnotation.resolve"); + } + + @TestMetadata("Objects.resolve") + public void testObjects() throws Exception { + doTest("compiler/testData/resolve/Objects.resolve"); + } + + @TestMetadata("PrimaryConstructorParameters.resolve") + public void testPrimaryConstructorParameters() throws Exception { + doTest("compiler/testData/resolve/PrimaryConstructorParameters.resolve"); + } + + @TestMetadata("PrimaryConstructors.resolve") + public void testPrimaryConstructors() throws Exception { + doTest("compiler/testData/resolve/PrimaryConstructors.resolve"); + } + + @TestMetadata("Projections.resolve") + public void testProjections() throws Exception { + doTest("compiler/testData/resolve/Projections.resolve"); + } + + @TestMetadata("ResolveOfInfixExpressions.resolve") + public void testResolveOfInfixExpressions() throws Exception { + doTest("compiler/testData/resolve/ResolveOfInfixExpressions.resolve"); + } + + @TestMetadata("ResolveToJava.resolve") + public void testResolveToJava() throws Exception { + doTest("compiler/testData/resolve/ResolveToJava.resolve"); + } + + @TestMetadata("ResolveToJava2.resolve") + public void testResolveToJava2() throws Exception { + doTest("compiler/testData/resolve/ResolveToJava2.resolve"); + } + + @TestMetadata("ResolveToJava3.resolve") + public void testResolveToJava3() throws Exception { + doTest("compiler/testData/resolve/ResolveToJava3.resolve"); + } + + @TestMetadata("ResolveToJavaTypeTransform.resolve") + public void testResolveToJavaTypeTransform() throws Exception { + doTest("compiler/testData/resolve/ResolveToJavaTypeTransform.resolve"); + } + + @TestMetadata("ScopeInteraction.resolve") + public void testScopeInteraction() throws Exception { + doTest("compiler/testData/resolve/ScopeInteraction.resolve"); + } + + @TestMetadata("StringTemplates.resolve") + public void testStringTemplates() throws Exception { + doTest("compiler/testData/resolve/StringTemplates.resolve"); + } + + @TestMetadata("Super.resolve") + public void testSuper() throws Exception { + doTest("compiler/testData/resolve/Super.resolve"); + } + + @TestMetadata("TryCatch.resolve") + public void testTryCatch() throws Exception { + doTest("compiler/testData/resolve/TryCatch.resolve"); + } + + @TestMetadata("compiler/testData/resolve/candidatesPriority") + public static class CandidatesPriority extends AbstractResolveTest { + public void testAllFilesPresentInCandidatesPriority() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/candidatesPriority"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("preferImplicitThisToNoReceiver.resolve") + public void testPreferImplicitThisToNoReceiver() throws Exception { + doTest("compiler/testData/resolve/candidatesPriority/preferImplicitThisToNoReceiver.resolve"); + } + + } + + @TestMetadata("compiler/testData/resolve/delegatedProperty") + public static class DelegatedProperty extends AbstractResolveTest { + public void testAllFilesPresentInDelegatedProperty() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/delegatedProperty"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("delegationByCall.resolve") + public void testDelegationByCall() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/delegationByCall.resolve"); + } + + @TestMetadata("delegationByConstructor.resolve") + public void testDelegationByConstructor() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/delegationByConstructor.resolve"); + } + + @TestMetadata("delegationByFun.resolve") + public void testDelegationByFun() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/delegationByFun.resolve"); + } + + @TestMetadata("delegationByObject.resolve") + public void testDelegationByObject() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/delegationByObject.resolve"); + } + + @TestMetadata("delegationByProperty.resolve") + public void testDelegationByProperty() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/delegationByProperty.resolve"); + } + + @TestMetadata("delegationInClass.resolve") + public void testDelegationInClass() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/delegationInClass.resolve"); + } + + @TestMetadata("localDelegation.resolve") + public void testLocalDelegation() throws Exception { + doTest("compiler/testData/resolve/delegatedProperty/localDelegation.resolve"); + } + + } + + @TestMetadata("compiler/testData/resolve/imports") + public static class Imports extends AbstractResolveTest { + public void testAllFilesPresentInImports() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/imports"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("ImportConflictAllPackage.resolve") + public void testImportConflictAllPackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictAllPackage.resolve"); + } + + @TestMetadata("ImportConflictBetweenImportedAndRootPackage.resolve") + public void testImportConflictBetweenImportedAndRootPackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve"); + } + + @TestMetadata("ImportConflictBetweenImportedAndSamePackage.resolve") + public void testImportConflictBetweenImportedAndSamePackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve"); + } + + @TestMetadata("ImportConflictForFunctions.resolve") + public void testImportConflictForFunctions() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictForFunctions.resolve"); + } + + @TestMetadata("ImportConflictPackageAndClass.resolve") + public void testImportConflictPackageAndClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve"); + } + + @TestMetadata("ImportConflictSameNameClass.resolve") + public void testImportConflictSameNameClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve"); + } + + @TestMetadata("ImportConflictWithClassObject.resolve") + public void testImportConflictWithClassObject() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve"); + } + + @TestMetadata("ImportConflictWithInFileClass.resolve") + public void testImportConflictWithInFileClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve"); + } + + @TestMetadata("ImportConflictWithInnerClass.resolve") + public void testImportConflictWithInnerClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve"); + } + + @TestMetadata("ImportConflictsWithMappedToJava.resolve") + public void testImportConflictsWithMappedToJava() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve"); + } + + @TestMetadata("ImportNonBlockingAnalysis.resolve") + public void testImportNonBlockingAnalysis() throws Exception { + doTest("compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve"); + } + + @TestMetadata("ImportResolveOrderStable.resolve") + public void testImportResolveOrderStable() throws Exception { + doTest("compiler/testData/resolve/imports/ImportResolveOrderStable.resolve"); + } + + } + + @TestMetadata("compiler/testData/resolve/labels") + public static class Labels extends AbstractResolveTest { + public void testAllFilesPresentInLabels() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/labels"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("labelForPropertyInGetter.resolve") + public void testLabelForPropertyInGetter() throws Exception { + doTest("compiler/testData/resolve/labels/labelForPropertyInGetter.resolve"); + } + + @TestMetadata("labelForPropertyInSetter.resolve") + public void testLabelForPropertyInSetter() throws Exception { + doTest("compiler/testData/resolve/labels/labelForPropertyInSetter.resolve"); + } + + } + + @TestMetadata("compiler/testData/resolve/regressions") + public static class Regressions extends AbstractResolveTest { + public void testAllFilesPresentInRegressions() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/regressions"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("kt300.resolve") + public void testKt300() throws Exception { + doTest("compiler/testData/resolve/regressions/kt300.resolve"); + } + + } + + @TestMetadata("compiler/testData/resolve/varargs") + public static class Varargs extends AbstractResolveTest { + public void testAllFilesPresentInVarargs() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/varargs"), Pattern.compile("^(.+)\\.resolve$"), true); + } + + @TestMetadata("MoreSpecificVarargsOfEqualLength.resolve") + public void testMoreSpecificVarargsOfEqualLength() throws Exception { + doTest("compiler/testData/resolve/varargs/MoreSpecificVarargsOfEqualLength.resolve"); + } + + @TestMetadata("NilaryVsVararg.resolve") + public void testNilaryVsVararg() throws Exception { + doTest("compiler/testData/resolve/varargs/NilaryVsVararg.resolve"); + } + + @TestMetadata("UnaryVsVararg.resolve") + public void testUnaryVsVararg() throws Exception { + doTest("compiler/testData/resolve/varargs/UnaryVsVararg.resolve"); + } + + } + + public static Test suite() { + TestSuite suite = new TestSuite("JetResolveTestGenerated"); + suite.addTestSuite(JetResolveTestGenerated.class); + suite.addTestSuite(CandidatesPriority.class); + suite.addTestSuite(DelegatedProperty.class); + suite.addTestSuite(Imports.class); + suite.addTestSuite(Labels.class); + suite.addTestSuite(Regressions.class); + suite.addTestSuite(Varargs.class); + return suite; + } +} diff --git a/generators/org/jetbrains/jet/generators/tests/GenerateTests.java b/generators/org/jetbrains/jet/generators/tests/GenerateTests.java index 08afc8565f7..aa82e896ad7 100644 --- a/generators/org/jetbrains/jet/generators/tests/GenerateTests.java +++ b/generators/org/jetbrains/jet/generators/tests/GenerateTests.java @@ -45,6 +45,7 @@ import org.jetbrains.jet.plugin.hierarchy.AbstractHierarchyTest; import org.jetbrains.jet.plugin.highlighter.AbstractDeprecatedHighlightingTest; import org.jetbrains.jet.plugin.quickfix.AbstractQuickFixMultiFileTest; import org.jetbrains.jet.plugin.quickfix.AbstractQuickFixTest; +import org.jetbrains.jet.resolve.AbstractResolveTest; import org.jetbrains.jet.test.generator.SimpleTestClassModel; import org.jetbrains.jet.test.generator.TestClassModel; import org.jetbrains.jet.test.generator.TestGenerator; @@ -80,6 +81,13 @@ public class GenerateTests { testModel("compiler/testData/diagnostics/tests/script", true, "ktscript", "doTest") ); + generateTest( + "compiler/tests/", + "JetResolveTestGenerated", + AbstractResolveTest.class, + testModel("compiler/testData/resolve", true, "resolve", "doTest") + ); + GenerateRangesCodegenTestData.main(args); generateTest(