From 4620ba2fd3c5e8f32d4708d9c1006b3e699a7df6 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Sat, 15 Sep 2012 23:06:48 +0400 Subject: [PATCH] Rewritten LoadCompiledKotlinTest to test generation framework. --- ...va => AbstractLoadCompiledKotlinTest.java} | 54 +- .../LoadCompiledKotlinTestGenerated.java | 901 ++++++++++++++++++ .../jvm/compiler/LoadKotlinCustomTest.java | 2 +- 3 files changed, 927 insertions(+), 30 deletions(-) rename compiler/tests/org/jetbrains/jet/jvm/compiler/{LoadCompiledKotlinTest.java => AbstractLoadCompiledKotlinTest.java} (62%) create mode 100644 compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java similarity index 62% rename from compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTest.java rename to compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java index ce0206778b5..98ee937e105 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java @@ -17,17 +17,19 @@ package org.jetbrains.jet.jvm.compiler; import junit.framework.Assert; -import junit.framework.Test; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.test.TestCaseWithTmpdir; +import org.jetbrains.jet.test.generator.SimpleTestClassModel; +import org.jetbrains.jet.test.generator.TestGenerator; import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.File; +import java.io.IOException; +import java.util.Arrays; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalyzeExhaust; @@ -39,40 +41,34 @@ import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; * @author Stepan Koltsov */ @SuppressWarnings("JUnitTestCaseWithNoTests") -public final class LoadCompiledKotlinTest extends TestCaseWithTmpdir { - - @NotNull - private final File testFile; - @NotNull - private final File txtFile; - - @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") - public LoadCompiledKotlinTest(@NotNull File testFile) { - this.testFile = testFile; - this.txtFile = new File(testFile.getPath().replaceFirst("\\.kt$", ".txt")); - setName(testFile.getName()); - } - - @Override - public void runTest() throws Exception { - AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(testFile, tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY); +public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir { + public void doTest(@NotNull String ktFileName) throws Exception { + File ktFile = new File(ktFileName); + File txtFile = new File(ktFileName.replaceFirst("\\.kt$", ".txt")); + AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(ktFile, tmpdir, getTestRootDisposable(), + ConfigurationKind.JDK_ONLY); NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME); assert namespaceFromSource != null; Assert.assertEquals("test", namespaceFromSource.getName().getName()); - NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceFromBinaries(tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY); + NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceFromBinaries(tmpdir, getTestRootDisposable(), + ConfigurationKind.JDK_ONLY); compareNamespaces(namespaceFromSource, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); } - public static Test suite() { - return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/loadKotlin", true, new JetTestCaseBuilder.NamedTestFactory() { - @NotNull - @Override - public Test createTest(@NotNull String dataPath, @NotNull String name, @NotNull File file) { - return new LoadCompiledKotlinTest(file); - } - }); + public static void main(String[] args) throws IOException { + String aPackage = "org.jetbrains.jet.jvm.compiler"; + String extension = "kt"; + new TestGenerator( + "compiler/tests/", + aPackage, + "LoadCompiledKotlinTestGenerated", + AbstractLoadCompiledKotlinTest.class, + Arrays.asList( + new SimpleTestClassModel(new File("compiler/testData/loadKotlin"), true, extension, "doTest") + ), + AbstractLoadCompiledKotlinTest.class + ).generateAndSave(); } - } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java new file mode 100644 index 00000000000..52a7909b740 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java @@ -0,0 +1,901 @@ +/* + * Copyright 2010-2012 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.jvm.compiler; + +import junit.framework.Assert; +import junit.framework.Test; +import junit.framework.TestSuite; + +import java.io.File; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.test.InnerTestClasses; +import org.jetbrains.jet.test.TestMetadata; + +import org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest; + +/** This class is generated by {@link org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest}. DO NOT MODIFY MANUALLY */ +@TestMetadata("compiler/testData/loadKotlin") +@InnerTestClasses({LoadCompiledKotlinTestGenerated.Class.class, LoadCompiledKotlinTestGenerated.ClassFun.class, LoadCompiledKotlinTestGenerated.ClassObject.class, LoadCompiledKotlinTestGenerated.Constructor.class, LoadCompiledKotlinTestGenerated.DataClass.class, LoadCompiledKotlinTestGenerated.Fun.class, LoadCompiledKotlinTestGenerated.Prop.class, LoadCompiledKotlinTestGenerated.Type.class, LoadCompiledKotlinTestGenerated.Visibility.class}) +public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInLoadKotlin() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin"), "kt", true); + } + + @TestMetadata("compiler/testData/loadKotlin/class") + public static class Class extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInClass() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/class"), "kt", true); + } + + @TestMetadata("Class.kt") + public void testClass() throws Exception { + doTest("compiler/testData/loadKotlin/class/Class.kt"); + } + + @TestMetadata("ClassInParam.kt") + public void testClassInParam() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassInParam.kt"); + } + + @TestMetadata("ClassInnerClass.kt") + public void testClassInnerClass() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassInnerClass.kt"); + } + + @TestMetadata("ClassOutParam.kt") + public void testClassOutParam() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassOutParam.kt"); + } + + @TestMetadata("ClassParam.kt") + public void testClassParam() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParam.kt"); + } + + @TestMetadata("ClassParamReferencesParam.kt") + public void testClassParamReferencesParam() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamReferencesParam.kt"); + } + + @TestMetadata("ClassParamReferencesParam2.kt") + public void testClassParamReferencesParam2() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamReferencesParam2.kt"); + } + + @TestMetadata("ClassParamReferencesSelf.kt") + public void testClassParamReferencesSelf() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamReferencesSelf.kt"); + } + + @TestMetadata("ClassParamUpperClassBound.kt") + public void testClassParamUpperClassBound() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamUpperClassBound.kt"); + } + + @TestMetadata("ClassParamUpperClassInterfaceBound.kt") + public void testClassParamUpperClassInterfaceBound() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamUpperClassInterfaceBound.kt"); + } + + @TestMetadata("ClassParamUpperInterfaceBound.kt") + public void testClassParamUpperInterfaceBound() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamUpperInterfaceBound.kt"); + } + + @TestMetadata("ClassParamUpperInterfaceClassBound.kt") + public void testClassParamUpperInterfaceClassBound() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassParamUpperInterfaceClassBound.kt"); + } + + @TestMetadata("ClassTwoParams.kt") + public void testClassTwoParams() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassTwoParams.kt"); + } + + @TestMetadata("ClassTwoParams2.kt") + public void testClassTwoParams2() throws Exception { + doTest("compiler/testData/loadKotlin/class/ClassTwoParams2.kt"); + } + + @TestMetadata("InheritClassSimple.kt") + public void testInheritClassSimple() throws Exception { + doTest("compiler/testData/loadKotlin/class/InheritClassSimple.kt"); + } + + @TestMetadata("InheritClassWithParam.kt") + public void testInheritClassWithParam() throws Exception { + doTest("compiler/testData/loadKotlin/class/InheritClassWithParam.kt"); + } + + @TestMetadata("InheritTraitWithParam.kt") + public void testInheritTraitWithParam() throws Exception { + doTest("compiler/testData/loadKotlin/class/InheritTraitWithParam.kt"); + } + + @TestMetadata("InnerClass.kt") + public void testInnerClass() throws Exception { + doTest("compiler/testData/loadKotlin/class/InnerClass.kt"); + } + + @TestMetadata("InnerClassExtendInnerClass.kt") + public void testInnerClassExtendInnerClass() throws Exception { + doTest("compiler/testData/loadKotlin/class/InnerClassExtendInnerClass.kt"); + } + + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + doTest("compiler/testData/loadKotlin/class/Trait.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/classFun") + public static class ClassFun extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInClassFun() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/classFun"), "kt", true); + } + + @TestMetadata("ClassInParamUsedInFun.kt") + public void testClassInParamUsedInFun() throws Exception { + doTest("compiler/testData/loadKotlin/classFun/ClassInParamUsedInFun.kt"); + } + + @TestMetadata("ClassParamUsedInFun.kt") + public void testClassParamUsedInFun() throws Exception { + doTest("compiler/testData/loadKotlin/classFun/ClassParamUsedInFun.kt"); + } + + @TestMetadata("FunDelegationToTraitImpl.kt") + public void testFunDelegationToTraitImpl() throws Exception { + doTest("compiler/testData/loadKotlin/classFun/FunDelegationToTraitImpl.kt"); + } + + @TestMetadata("FunInParamSuper.kt") + public void testFunInParamSuper() throws Exception { + doTest("compiler/testData/loadKotlin/classFun/FunInParamSuper.kt"); + } + + @TestMetadata("TraitFinalFun.kt") + public void testTraitFinalFun() throws Exception { + doTest("compiler/testData/loadKotlin/classFun/TraitFinalFun.kt"); + } + + @TestMetadata("TraitOpenFun.kt") + public void testTraitOpenFun() throws Exception { + doTest("compiler/testData/loadKotlin/classFun/TraitOpenFun.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/classObject") + public static class ClassObject extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInClassObject() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/classObject"), "kt", true); + } + + @TestMetadata("ClassObjectDeclaresVal.kt") + public void testClassObjectDeclaresVal() throws Exception { + doTest("compiler/testData/loadKotlin/classObject/ClassObjectDeclaresVal.kt"); + } + + @TestMetadata("ClassObjectDeclaresVar.kt") + public void testClassObjectDeclaresVar() throws Exception { + doTest("compiler/testData/loadKotlin/classObject/ClassObjectDeclaresVar.kt"); + } + + @TestMetadata("ClassObjectExtendsTrait.kt") + public void testClassObjectExtendsTrait() throws Exception { + doTest("compiler/testData/loadKotlin/classObject/ClassObjectExtendsTrait.kt"); + } + + @TestMetadata("ClassObjectExtendsTraitWithTP.kt") + public void testClassObjectExtendsTraitWithTP() throws Exception { + doTest("compiler/testData/loadKotlin/classObject/ClassObjectExtendsTraitWithTP.kt"); + } + + @TestMetadata("SimpleClassObject.kt") + public void testSimpleClassObject() throws Exception { + doTest("compiler/testData/loadKotlin/classObject/SimpleClassObject.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/constructor") + public static class Constructor extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInConstructor() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/constructor"), "kt", true); + } + + @TestMetadata("Constructor0.kt") + public void testConstructor0() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/Constructor0.kt"); + } + + @TestMetadata("Constructor1.kt") + public void testConstructor1() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/Constructor1.kt"); + } + + @TestMetadata("Constructor1WithParamDefaultValue.kt") + public void testConstructor1WithParamDefaultValue() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/Constructor1WithParamDefaultValue.kt"); + } + + @TestMetadata("ConstructorCollectionParameter.kt") + public void testConstructorCollectionParameter() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/ConstructorCollectionParameter.kt"); + } + + @TestMetadata("ConstructorWithTwoTypeParameters.kt") + public void testConstructorWithTwoTypeParameters() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/ConstructorWithTwoTypeParameters.kt"); + } + + @TestMetadata("ConstructorWithTwoTypeParametersAndOneIntValueParameter.kt") + public void testConstructorWithTwoTypeParametersAndOneIntValueParameter() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/ConstructorWithTwoTypeParametersAndOneIntValueParameter.kt"); + } + + @TestMetadata("ConstructorWithTwoTypeParametersAndOnePValueParameter.kt") + public void testConstructorWithTwoTypeParametersAndOnePValueParameter() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/ConstructorWithTwoTypeParametersAndOnePValueParameter.kt"); + } + + @TestMetadata("ConstructorWithTypeParameter.kt") + public void testConstructorWithTypeParameter() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/ConstructorWithTypeParameter.kt"); + } + + @TestMetadata("ConstructorWithTypeParametersEAndOnePValueParameter.kt") + public void testConstructorWithTypeParametersEAndOnePValueParameter() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/ConstructorWithTypeParametersEAndOnePValueParameter.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/dataClass") + public static class DataClass extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInDataClass() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/dataClass"), "kt", true); + } + + @TestMetadata("MixedComponents.kt") + public void testMixedComponents() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/MixedComponents.kt"); + } + + @TestMetadata("NoComponents.kt") + public void testNoComponents() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/NoComponents.kt"); + } + + @TestMetadata("OneVal.kt") + public void testOneVal() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/OneVal.kt"); + } + + @TestMetadata("OpenDataClass.kt") + public void testOpenDataClass() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/OpenDataClass.kt"); + } + + @TestMetadata("OpenPropertyFinalComponent.kt") + public void testOpenPropertyFinalComponent() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/OpenPropertyFinalComponent.kt"); + } + + @TestMetadata("TwoVals.kt") + public void testTwoVals() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/TwoVals.kt"); + } + + @TestMetadata("TwoVars.kt") + public void testTwoVars() throws Exception { + doTest("compiler/testData/loadKotlin/dataClass/TwoVars.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/fun") + @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class}) + public static class Fun extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInFun() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/fun"), "kt", true); + } + + @TestMetadata("compiler/testData/loadKotlin/fun/genericWithTypeVariables") + public static class GenericWithTypeVariables extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/fun/genericWithTypeVariables"), "kt", true); + } + + @TestMetadata("FunGenericParam.kt") + public void testFunGenericParam() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunGenericParam.kt"); + } + + @TestMetadata("FunInParam.kt") + public void testFunInParam() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunInParam.kt"); + } + + @TestMetadata("FunOutParam.kt") + public void testFunOutParam() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunOutParam.kt"); + } + + @TestMetadata("FunParamParam.kt") + public void testFunParamParam() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamParam.kt"); + } + + @TestMetadata("FunParamParamErased.kt") + public void testFunParamParamErased() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamParamErased.kt"); + } + + @TestMetadata("FunParamReferencesParam.kt") + public void testFunParamReferencesParam() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamReferencesParam.kt"); + } + + @TestMetadata("FunParamReferencesParam2.kt") + public void testFunParamReferencesParam2() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamReferencesParam2.kt"); + } + + @TestMetadata("FunParamTwoUpperBounds.kt") + public void testFunParamTwoUpperBounds() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamTwoUpperBounds.kt"); + } + + @TestMetadata("FunParamUpperClassBound.kt") + public void testFunParamUpperClassBound() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamUpperClassBound.kt"); + } + + @TestMetadata("FunParamUpperClassInterfaceBound.kt") + public void testFunParamUpperClassInterfaceBound() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamUpperClassInterfaceBound.kt"); + } + + @TestMetadata("FunParamUpperInterfaceBound.kt") + public void testFunParamUpperInterfaceBound() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamUpperInterfaceBound.kt"); + } + + @TestMetadata("FunParamUpperInterfaceClassBound.kt") + public void testFunParamUpperInterfaceClassBound() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamUpperInterfaceClassBound.kt"); + } + + @TestMetadata("FunParamVaragParam.kt") + public void testFunParamVaragParam() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunParamVaragParam.kt"); + } + + @TestMetadata("FunTwoTypeParams.kt") + public void testFunTwoTypeParams() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunTwoTypeParams.kt"); + } + + @TestMetadata("FunTwoTypeParams2.kt") + public void testFunTwoTypeParams2() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithTypeVariables/FunTwoTypeParams2.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables") + public static class GenericWithoutTypeVariables extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables"), "kt", true); + } + + @TestMetadata("FunClassParamNotNull.kt") + public void testFunClassParamNotNull() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables/FunClassParamNotNull.kt"); + } + + @TestMetadata("FunClassParamNullable.kt") + public void testFunClassParamNullable() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables/FunClassParamNullable.kt"); + } + + @TestMetadata("FunParamNullable.kt") + public void testFunParamNullable() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables/FunParamNullable.kt"); + } + + @TestMetadata("ReturnTypeClassParamNotNull.kt") + public void testReturnTypeClassParamNotNull() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables/ReturnTypeClassParamNotNull.kt"); + } + + @TestMetadata("ReturnTypeClassParamNullable.kt") + public void testReturnTypeClassParamNullable() throws Exception { + doTest("compiler/testData/loadKotlin/fun/genericWithoutTypeVariables/ReturnTypeClassParamNullable.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/fun/nonGeneric") + public static class NonGeneric extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInNonGeneric() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/fun/nonGeneric"), "kt", true); + } + + @TestMetadata("ClassFun.kt") + public void testClassFun() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ClassFun.kt"); + } + + @TestMetadata("ClassFunGetFoo.kt") + public void testClassFunGetFoo() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ClassFunGetFoo.kt"); + } + + @TestMetadata("ClassFunGetFooSetFoo.kt") + public void testClassFunGetFooSetFoo() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ClassFunGetFooSetFoo.kt"); + } + + @TestMetadata("ClassFunSetFoo.kt") + public void testClassFunSetFoo() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ClassFunSetFoo.kt"); + } + + @TestMetadata("ExtFun.kt") + public void testExtFun() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ExtFun.kt"); + } + + @TestMetadata("ExtFunInClass.kt") + public void testExtFunInClass() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ExtFunInClass.kt"); + } + + @TestMetadata("FunDefaultArg.kt") + public void testFunDefaultArg() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/FunDefaultArg.kt"); + } + + @TestMetadata("FunParamNotNull.kt") + public void testFunParamNotNull() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/FunParamNotNull.kt"); + } + + @TestMetadata("FunVarargInt.kt") + public void testFunVarargInt() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/FunVarargInt.kt"); + } + + @TestMetadata("FunVarargInteger.kt") + public void testFunVarargInteger() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/FunVarargInteger.kt"); + } + + @TestMetadata("ModifierAbstract.kt") + public void testModifierAbstract() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ModifierAbstract.kt"); + } + + @TestMetadata("ModifierOpen.kt") + public void testModifierOpen() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ModifierOpen.kt"); + } + + @TestMetadata("NsFun.kt") + public void testNsFun() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/NsFun.kt"); + } + + @TestMetadata("NsFunGetFoo.kt") + public void testNsFunGetFoo() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/NsFunGetFoo.kt"); + } + + @TestMetadata("ReturnTypeNotNull.kt") + public void testReturnTypeNotNull() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ReturnTypeNotNull.kt"); + } + + @TestMetadata("ReturnTypeNullable.kt") + public void testReturnTypeNullable() throws Exception { + doTest("compiler/testData/loadKotlin/fun/nonGeneric/ReturnTypeNullable.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Fun"); + suite.addTestSuite(Fun.class); + suite.addTestSuite(GenericWithTypeVariables.class); + suite.addTestSuite(GenericWithoutTypeVariables.class); + suite.addTestSuite(NonGeneric.class); + return suite; + } + } + + @TestMetadata("compiler/testData/loadKotlin/prop") + public static class Prop extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInProp() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/prop"), "kt", true); + } + + @TestMetadata("ClassVal.kt") + public void testClassVal() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ClassVal.kt"); + } + + @TestMetadata("ClassValAbstract.kt") + public void testClassValAbstract() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ClassValAbstract.kt"); + } + + @TestMetadata("ClassVar.kt") + public void testClassVar() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ClassVar.kt"); + } + + @TestMetadata("CollectionSize.kt") + public void testCollectionSize() throws Exception { + doTest("compiler/testData/loadKotlin/prop/CollectionSize.kt"); + } + + @TestMetadata("ExtValClass.kt") + public void testExtValClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValClass.kt"); + } + + @TestMetadata("ExtValInClass.kt") + public void testExtValInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValInClass.kt"); + } + + @TestMetadata("ExtValInt.kt") + public void testExtValInt() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValInt.kt"); + } + + @TestMetadata("ExtValIntCharSequence.kt") + public void testExtValIntCharSequence() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValIntCharSequence.kt"); + } + + @TestMetadata("ExtValIntCharSequenceQ.kt") + public void testExtValIntCharSequenceQ() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValIntCharSequenceQ.kt"); + } + + @TestMetadata("ExtValIntListQOfIntInClass.kt") + public void testExtValIntListQOfIntInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValIntListQOfIntInClass.kt"); + } + + @TestMetadata("ExtValIntTInClass.kt") + public void testExtValIntTInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValIntTInClass.kt"); + } + + @TestMetadata("ExtValIntTQInClass.kt") + public void testExtValIntTQInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValIntTQInClass.kt"); + } + + @TestMetadata("ExtValTIntInClass.kt") + public void testExtValTIntInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtValTIntInClass.kt"); + } + + @TestMetadata("ExtVarClass.kt") + public void testExtVarClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarClass.kt"); + } + + @TestMetadata("ExtVarInClass.kt") + public void testExtVarInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarInClass.kt"); + } + + @TestMetadata("ExtVarInt.kt") + public void testExtVarInt() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarInt.kt"); + } + + @TestMetadata("ExtVarIntTInClass.kt") + public void testExtVarIntTInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarIntTInClass.kt"); + } + + @TestMetadata("ExtVarIntTQInClass.kt") + public void testExtVarIntTQInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarIntTQInClass.kt"); + } + + @TestMetadata("ExtVarMapPQInt.kt") + public void testExtVarMapPQInt() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarMapPQInt.kt"); + } + + @TestMetadata("ExtVarTIntInClass.kt") + public void testExtVarTIntInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarTIntInClass.kt"); + } + + @TestMetadata("ExtVarTQIntInClass.kt") + public void testExtVarTQIntInClass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarTQIntInClass.kt"); + } + + @TestMetadata("ExtVarl.kt") + public void testExtVarl() throws Exception { + doTest("compiler/testData/loadKotlin/prop/ExtVarl.kt"); + } + + @TestMetadata("NsVal.kt") + public void testNsVal() throws Exception { + doTest("compiler/testData/loadKotlin/prop/NsVal.kt"); + } + + @TestMetadata("NsVar.kt") + public void testNsVar() throws Exception { + doTest("compiler/testData/loadKotlin/prop/NsVar.kt"); + } + + @TestMetadata("OverrideClassVal.kt") + public void testOverrideClassVal() throws Exception { + doTest("compiler/testData/loadKotlin/prop/OverrideClassVal.kt"); + } + + @TestMetadata("OverrideTraitVal.kt") + public void testOverrideTraitVal() throws Exception { + doTest("compiler/testData/loadKotlin/prop/OverrideTraitVal.kt"); + } + + @TestMetadata("PropFromSuperclass.kt") + public void testPropFromSuperclass() throws Exception { + doTest("compiler/testData/loadKotlin/prop/PropFromSuperclass.kt"); + } + + @TestMetadata("TraitFinalVar.kt") + public void testTraitFinalVar() throws Exception { + doTest("compiler/testData/loadKotlin/prop/TraitFinalVar.kt"); + } + + @TestMetadata("TraitOpenVal.kt") + public void testTraitOpenVal() throws Exception { + doTest("compiler/testData/loadKotlin/prop/TraitOpenVal.kt"); + } + + @TestMetadata("VarDelegationToTraitImpl.kt") + public void testVarDelegationToTraitImpl() throws Exception { + doTest("compiler/testData/loadKotlin/prop/VarDelegationToTraitImpl.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/type") + public static class Type extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInType() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/type"), "kt", true); + } + + @TestMetadata("Any.kt") + public void testAny() throws Exception { + doTest("compiler/testData/loadKotlin/type/Any.kt"); + } + + @TestMetadata("AnyQ.kt") + public void testAnyQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/AnyQ.kt"); + } + + @TestMetadata("ArrayOfInt.kt") + public void testArrayOfInt() throws Exception { + doTest("compiler/testData/loadKotlin/type/ArrayOfInt.kt"); + } + + @TestMetadata("ArrayOfInteger.kt") + public void testArrayOfInteger() throws Exception { + doTest("compiler/testData/loadKotlin/type/ArrayOfInteger.kt"); + } + + @TestMetadata("ArrayOfString.kt") + public void testArrayOfString() throws Exception { + doTest("compiler/testData/loadKotlin/type/ArrayOfString.kt"); + } + + @TestMetadata("Function1IntString.kt") + public void testFunction1IntString() throws Exception { + doTest("compiler/testData/loadKotlin/type/Function1IntString.kt"); + } + + @TestMetadata("Int.kt") + public void testInt() throws Exception { + doTest("compiler/testData/loadKotlin/type/Int.kt"); + } + + @TestMetadata("IntArray.kt") + public void testIntArray() throws Exception { + doTest("compiler/testData/loadKotlin/type/IntArray.kt"); + } + + @TestMetadata("IntQ.kt") + public void testIntQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/IntQ.kt"); + } + + @TestMetadata("jlInteger.kt") + public void testJlInteger() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlInteger.kt"); + } + + @TestMetadata("jlIntegerQ.kt") + public void testJlIntegerQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlIntegerQ.kt"); + } + + @TestMetadata("jlNumber.kt") + public void testJlNumber() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlNumber.kt"); + } + + @TestMetadata("jlObject.kt") + public void testJlObject() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlObject.kt"); + } + + @TestMetadata("jlObjectQ.kt") + public void testJlObjectQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlObjectQ.kt"); + } + + @TestMetadata("jlString.kt") + public void testJlString() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlString.kt"); + } + + @TestMetadata("jlStringQ.kt") + public void testJlStringQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/jlStringQ.kt"); + } + + @TestMetadata("ListOfAny.kt") + public void testListOfAny() throws Exception { + doTest("compiler/testData/loadKotlin/type/ListOfAny.kt"); + } + + @TestMetadata("ListOfAnyQ.kt") + public void testListOfAnyQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/ListOfAnyQ.kt"); + } + + @TestMetadata("ListOfStar.kt") + public void testListOfStar() throws Exception { + doTest("compiler/testData/loadKotlin/type/ListOfStar.kt"); + } + + @TestMetadata("ListOfString.kt") + public void testListOfString() throws Exception { + doTest("compiler/testData/loadKotlin/type/ListOfString.kt"); + } + + @TestMetadata("ListOfjlString.kt") + public void testListOfjlString() throws Exception { + doTest("compiler/testData/loadKotlin/type/ListOfjlString.kt"); + } + + @TestMetadata("Nothing.kt") + public void testNothing() throws Exception { + doTest("compiler/testData/loadKotlin/type/Nothing.kt"); + } + + @TestMetadata("NothingQ.kt") + public void testNothingQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/NothingQ.kt"); + } + + @TestMetadata("String.kt") + public void testString() throws Exception { + doTest("compiler/testData/loadKotlin/type/String.kt"); + } + + @TestMetadata("StringQ.kt") + public void testStringQ() throws Exception { + doTest("compiler/testData/loadKotlin/type/StringQ.kt"); + } + + @TestMetadata("Tuple0.kt") + public void testTuple0() throws Exception { + doTest("compiler/testData/loadKotlin/type/Tuple0.kt"); + } + + } + + @TestMetadata("compiler/testData/loadKotlin/visibility") + public static class Visibility extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInVisibility() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.jvm.compiler.AbstractLoadCompiledKotlinTest", new File("compiler/testData/loadKotlin/visibility"), "kt", true); + } + + @TestMetadata("InternalAbstractTraitMembersOverridden.kt") + public void testInternalAbstractTraitMembersOverridden() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/InternalAbstractTraitMembersOverridden.kt"); + } + + @TestMetadata("InternalClass.kt") + public void testInternalClass() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/InternalClass.kt"); + } + + @TestMetadata("InternalConstructor.kt") + public void testInternalConstructor() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/InternalConstructor.kt"); + } + + @TestMetadata("InternalTopLevelMembers.kt") + public void testInternalTopLevelMembers() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/InternalTopLevelMembers.kt"); + } + + @TestMetadata("InternalTraitMembers.kt") + public void testInternalTraitMembers() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/InternalTraitMembers.kt"); + } + + @TestMetadata("InternalTraitMembersInherited.kt") + public void testInternalTraitMembersInherited() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/InternalTraitMembersInherited.kt"); + } + + @TestMetadata("PrivateClass.kt") + public void testPrivateClass() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/PrivateClass.kt"); + } + + @TestMetadata("PrivateTopLevelFun.kt") + public void testPrivateTopLevelFun() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/PrivateTopLevelFun.kt"); + } + + @TestMetadata("PrivateTopLevelVal.kt") + public void testPrivateTopLevelVal() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/PrivateTopLevelVal.kt"); + } + + @TestMetadata("TopLevelVarWithPrivateSetter.kt") + public void testTopLevelVarWithPrivateSetter() throws Exception { + doTest("compiler/testData/loadKotlin/visibility/TopLevelVarWithPrivateSetter.kt"); + } + + } + + public static Test suite() { + TestSuite suite = new TestSuite("LoadCompiledKotlinTestGenerated"); + suite.addTestSuite(LoadCompiledKotlinTestGenerated.class); + suite.addTestSuite(Class.class); + suite.addTestSuite(ClassFun.class); + suite.addTestSuite(ClassObject.class); + suite.addTestSuite(Constructor.class); + suite.addTestSuite(DataClass.class); + suite.addTest(Fun.innerSuite()); + suite.addTestSuite(Prop.class); + suite.addTestSuite(Type.class); + suite.addTestSuite(Visibility.class); + return suite; + } +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java index a0d5d10c8a6..83b02e13956 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java @@ -34,7 +34,7 @@ import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; * @author Pavel Talanov */ /* - * This test should be implemented via LoadCompiledKotlinTest. + * This test should be implemented via AbstractLoadCompiledKotlinTest. * Atm it's not possible due to enums being loaded differently from binaries (in contrast to from sources). */ public final class LoadKotlinCustomTest extends TestCaseWithTmpdir {