diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/ir/LightTreeFir2IrSpecificTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/ir/LightTreeFir2IrSpecificTextTestGenerated.java new file mode 100644 index 00000000000..d03b571e313 --- /dev/null +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/ir/LightTreeFir2IrSpecificTextTestGenerated.java @@ -0,0 +1,77 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners.ir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/fir/fir2ir/testData/ir/irText") +@TestDataPath("$PROJECT_ROOT") +public class LightTreeFir2IrSpecificTextTestGenerated extends AbstractLightTreeFir2IrTextTest { + @Test + public void testAllFilesPresentInIrText() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/fir2ir/testData/ir/irText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("sample.kt") + public void testSample() throws Exception { + runTest("compiler/fir/fir2ir/testData/ir/irText/sample.kt"); + } + + @Nested + @TestMetadata("compiler/fir/fir2ir/testData/ir/irText/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/fir2ir/testData/ir/irText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/fir/fir2ir/testData/ir/irText/properties/backingField") + @TestDataPath("$PROJECT_ROOT") + public class BackingField { + @Test + public void testAllFilesPresentInBackingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/fir2ir/testData/ir/irText/properties/backingField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("backingFieldVisibility.kt") + public void testBackingFieldVisibility() throws Exception { + runTest("compiler/fir/fir2ir/testData/ir/irText/properties/backingField/backingFieldVisibility.kt"); + } + + @Test + @TestMetadata("explicitBackingFieldType.kt") + public void testExplicitBackingFieldType() throws Exception { + runTest("compiler/fir/fir2ir/testData/ir/irText/properties/backingField/explicitBackingFieldType.kt"); + } + + @Test + @TestMetadata("independentBackingFieldType.kt") + public void testIndependentBackingFieldType() throws Exception { + runTest("compiler/fir/fir2ir/testData/ir/irText/properties/backingField/independentBackingFieldType.kt"); + } + + @Test + @TestMetadata("propertyTypeNarrowing.kt") + public void testPropertyTypeNarrowing() throws Exception { + runTest("compiler/fir/fir2ir/testData/ir/irText/properties/backingField/propertyTypeNarrowing.kt"); + } + } + } +} diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/ir/LightTreeFir2IrTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/ir/LightTreeFir2IrTextTestGenerated.java new file mode 100644 index 00000000000..11d277f8f8e --- /dev/null +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/ir/LightTreeFir2IrTextTestGenerated.java @@ -0,0 +1,3269 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners.ir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/ir/irText") +@TestDataPath("$PROJECT_ROOT") +public class LightTreeFir2IrTextTestGenerated extends AbstractLightTreeFir2IrTextTest { + @Test + public void testAllFilesPresentInIrText() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/classes") + @TestDataPath("$PROJECT_ROOT") + public class Classes { + @Test + @TestMetadata("47424.kt") + public void test47424() throws Exception { + runTest("compiler/testData/ir/irText/classes/47424.kt"); + } + + @Test + @TestMetadata("abstractMembers.kt") + public void testAbstractMembers() throws Exception { + runTest("compiler/testData/ir/irText/classes/abstractMembers.kt"); + } + + @Test + public void testAllFilesPresentInClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("annotationClasses.kt") + public void testAnnotationClasses() throws Exception { + runTest("compiler/testData/ir/irText/classes/annotationClasses.kt"); + } + + @Test + @TestMetadata("argumentReorderingInDelegatingConstructorCall.kt") + public void testArgumentReorderingInDelegatingConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.kt"); + } + + @Test + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt"); + } + + @Test + @TestMetadata("classMembers.kt") + public void testClassMembers() throws Exception { + runTest("compiler/testData/ir/irText/classes/classMembers.kt"); + } + + @Test + @TestMetadata("classes.kt") + public void testClasses() throws Exception { + runTest("compiler/testData/ir/irText/classes/classes.kt"); + } + + @Test + @TestMetadata("cloneable.kt") + public void testCloneable() throws Exception { + runTest("compiler/testData/ir/irText/classes/cloneable.kt"); + } + + @Test + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/ir/irText/classes/companionObject.kt"); + } + + @Test + @TestMetadata("delegatedGenericImplementation.kt") + public void testDelegatedGenericImplementation() throws Exception { + runTest("compiler/testData/ir/irText/classes/delegatedGenericImplementation.kt"); + } + + @Test + @TestMetadata("delegatedImplementation.kt") + public void testDelegatedImplementation() throws Exception { + runTest("compiler/testData/ir/irText/classes/delegatedImplementation.kt"); + } + + @Test + @TestMetadata("delegatedImplementationOfJavaInterface.kt") + public void testDelegatedImplementationOfJavaInterface() throws Exception { + runTest("compiler/testData/ir/irText/classes/delegatedImplementationOfJavaInterface.kt"); + } + + @Test + @TestMetadata("delegatedImplementationWithExplicitOverride.kt") + public void testDelegatedImplementationWithExplicitOverride() throws Exception { + runTest("compiler/testData/ir/irText/classes/delegatedImplementationWithExplicitOverride.kt"); + } + + @Test + @TestMetadata("delegatingConstructorCallToTypeAliasConstructor.kt") + public void testDelegatingConstructorCallToTypeAliasConstructor() throws Exception { + runTest("compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("delegatingConstructorCallsInSecondaryConstructors.kt") + public void testDelegatingConstructorCallsInSecondaryConstructors() throws Exception { + runTest("compiler/testData/ir/irText/classes/delegatingConstructorCallsInSecondaryConstructors.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/ir/irText/classes/enum.kt"); + } + + @Test + @TestMetadata("enumClassModality.kt") + public void testEnumClassModality() throws Exception { + runTest("compiler/testData/ir/irText/classes/enumClassModality.kt"); + } + + @Test + @TestMetadata("enumWithMultipleCtors.kt") + public void testEnumWithMultipleCtors() throws Exception { + runTest("compiler/testData/ir/irText/classes/enumWithMultipleCtors.kt"); + } + + @Test + @TestMetadata("enumWithSecondaryCtor.kt") + public void testEnumWithSecondaryCtor() throws Exception { + runTest("compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt"); + } + + @Test + @TestMetadata("fakeOverridesForJavaStaticMembers.kt") + public void testFakeOverridesForJavaStaticMembers() throws Exception { + runTest("compiler/testData/ir/irText/classes/fakeOverridesForJavaStaticMembers.kt"); + } + + @Test + @TestMetadata("implicitNotNullOnDelegatedImplementation.kt") + public void testImplicitNotNullOnDelegatedImplementation() throws Exception { + runTest("compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.kt"); + } + + @Test + @TestMetadata("initBlock.kt") + public void testInitBlock() throws Exception { + runTest("compiler/testData/ir/irText/classes/initBlock.kt"); + } + + @Test + @TestMetadata("initVal.kt") + public void testInitVal() throws Exception { + runTest("compiler/testData/ir/irText/classes/initVal.kt"); + } + + @Test + @TestMetadata("initValInLambda.kt") + public void testInitValInLambda() throws Exception { + runTest("compiler/testData/ir/irText/classes/initValInLambda.kt"); + } + + @Test + @TestMetadata("initVar.kt") + public void testInitVar() throws Exception { + runTest("compiler/testData/ir/irText/classes/initVar.kt"); + } + + @Test + @TestMetadata("inlineClass.kt") + public void testInlineClass() throws Exception { + runTest("compiler/testData/ir/irText/classes/inlineClass.kt"); + } + + @Test + @TestMetadata("inlineClassSyntheticMethods.kt") + public void testInlineClassSyntheticMethods() throws Exception { + runTest("compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.kt"); + } + + @Test + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + runTest("compiler/testData/ir/irText/classes/innerClass.kt"); + } + + @Test + @TestMetadata("innerClassWithDelegatingConstructor.kt") + public void testInnerClassWithDelegatingConstructor() throws Exception { + runTest("compiler/testData/ir/irText/classes/innerClassWithDelegatingConstructor.kt"); + } + + @Test + @TestMetadata("kt19306.kt") + public void testKt19306() throws Exception { + runTest("compiler/testData/ir/irText/classes/kt19306.kt"); + } + + @Test + @TestMetadata("kt43217.kt") + public void testKt43217() throws Exception { + runTest("compiler/testData/ir/irText/classes/kt43217.kt"); + } + + @Test + @TestMetadata("kt44013.kt") + public void testKt44013() throws Exception { + runTest("compiler/testData/ir/irText/classes/kt44013.kt"); + } + + @Test + @TestMetadata("kt45853.kt") + public void testKt45853() throws Exception { + runTest("compiler/testData/ir/irText/classes/kt45853.kt"); + } + + @Test + @TestMetadata("kt45934.kt") + public void testKt45934() throws Exception { + runTest("compiler/testData/ir/irText/classes/kt45934.kt"); + } + + @Test + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + runTest("compiler/testData/ir/irText/classes/localClasses.kt"); + } + + @Test + @TestMetadata("objectLiteralExpressions.kt") + public void testObjectLiteralExpressions() throws Exception { + runTest("compiler/testData/ir/irText/classes/objectLiteralExpressions.kt"); + } + + @Test + @TestMetadata("objectWithInitializers.kt") + public void testObjectWithInitializers() throws Exception { + runTest("compiler/testData/ir/irText/classes/objectWithInitializers.kt"); + } + + @Test + @TestMetadata("outerClassAccess.kt") + public void testOuterClassAccess() throws Exception { + runTest("compiler/testData/ir/irText/classes/outerClassAccess.kt"); + } + + @Test + @TestMetadata("primaryConstructor.kt") + public void testPrimaryConstructor() throws Exception { + runTest("compiler/testData/ir/irText/classes/primaryConstructor.kt"); + } + + @Test + @TestMetadata("primaryConstructorWithSuperConstructorCall.kt") + public void testPrimaryConstructorWithSuperConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/classes/primaryConstructorWithSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("qualifiedSuperCalls.kt") + public void testQualifiedSuperCalls() throws Exception { + runTest("compiler/testData/ir/irText/classes/qualifiedSuperCalls.kt"); + } + + @Test + @TestMetadata("sealedClasses.kt") + public void testSealedClasses() throws Exception { + runTest("compiler/testData/ir/irText/classes/sealedClasses.kt"); + } + + @Test + @TestMetadata("secondaryConstructorWithInitializersFromClassBody.kt") + public void testSecondaryConstructorWithInitializersFromClassBody() throws Exception { + runTest("compiler/testData/ir/irText/classes/secondaryConstructorWithInitializersFromClassBody.kt"); + } + + @Test + @TestMetadata("secondaryConstructors.kt") + public void testSecondaryConstructors() throws Exception { + runTest("compiler/testData/ir/irText/classes/secondaryConstructors.kt"); + } + + @Test + @TestMetadata("superCalls.kt") + public void testSuperCalls() throws Exception { + runTest("compiler/testData/ir/irText/classes/superCalls.kt"); + } + + @Test + @TestMetadata("superCallsComposed.kt") + public void testSuperCallsComposed() throws Exception { + runTest("compiler/testData/ir/irText/classes/superCallsComposed.kt"); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/classes/dataClasses") + @TestDataPath("$PROJECT_ROOT") + public class DataClasses { + @Test + public void testAllFilesPresentInDataClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/classes/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("dataClassWithArrayMembers.kt") + public void testDataClassWithArrayMembers() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/dataClassWithArrayMembers.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/dataClasses.kt"); + } + + @Test + @TestMetadata("dataClassesGeneric.kt") + public void testDataClassesGeneric() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/dataClassesGeneric.kt"); + } + + @Test + @TestMetadata("kt31649.kt") + public void testKt31649() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/kt31649.kt"); + } + + @Test + @TestMetadata("kt49936.kt") + public void testKt49936() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/kt49936.kt"); + } + + @Test + @TestMetadata("lambdaInDataClassDefaultParameter.kt") + public void testLambdaInDataClassDefaultParameter() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/lambdaInDataClassDefaultParameter.kt"); + } + + @Test + @TestMetadata("openDataClass.kt") + public void testOpenDataClass() throws Exception { + runTest("compiler/testData/ir/irText/classes/dataClasses/openDataClass.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations") + @TestDataPath("$PROJECT_ROOT") + public class Declarations { + @Test + public void testAllFilesPresentInDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("catchParameterInTopLevelProperty.kt") + public void testCatchParameterInTopLevelProperty() throws Exception { + runTest("compiler/testData/ir/irText/declarations/catchParameterInTopLevelProperty.kt"); + } + + @Test + @TestMetadata("classLevelProperties.kt") + public void testClassLevelProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/classLevelProperties.kt"); + } + + @Test + @TestMetadata("constValInitializers.kt") + public void testConstValInitializers() throws Exception { + runTest("compiler/testData/ir/irText/declarations/constValInitializers.kt"); + } + + @Test + @TestMetadata("defaultArguments.kt") + public void testDefaultArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/defaultArguments.kt"); + } + + @Test + @TestMetadata("delegatedProperties.kt") + public void testDelegatedProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/delegatedProperties.kt"); + } + + @Test + @TestMetadata("deprecatedProperty.kt") + public void testDeprecatedProperty() throws Exception { + runTest("compiler/testData/ir/irText/declarations/deprecatedProperty.kt"); + } + + @Test + @TestMetadata("extensionProperties.kt") + public void testExtensionProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/extensionProperties.kt"); + } + + @Test + @TestMetadata("fakeOverrides.kt") + public void testFakeOverrides() throws Exception { + runTest("compiler/testData/ir/irText/declarations/fakeOverrides.kt"); + } + + @Test + @TestMetadata("fileWithAnnotations.kt") + public void testFileWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/fileWithAnnotations.kt"); + } + + @Test + @TestMetadata("fileWithTypeAliasesOnly.kt") + public void testFileWithTypeAliasesOnly() throws Exception { + runTest("compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.kt"); + } + + @Test + @TestMetadata("genericDelegatedProperty.kt") + public void testGenericDelegatedProperty() throws Exception { + runTest("compiler/testData/ir/irText/declarations/genericDelegatedProperty.kt"); + } + + @Test + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.kt"); + } + + @Test + @TestMetadata("interfaceProperties.kt") + public void testInterfaceProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/interfaceProperties.kt"); + } + + @Test + @TestMetadata("kt27005.kt") + public void testKt27005() throws Exception { + runTest("compiler/testData/ir/irText/declarations/kt27005.kt"); + } + + @Test + @TestMetadata("kt29833.kt") + public void testKt29833() throws Exception { + runTest("compiler/testData/ir/irText/declarations/kt29833.kt"); + } + + @Test + @TestMetadata("kt35550.kt") + public void testKt35550() throws Exception { + runTest("compiler/testData/ir/irText/declarations/kt35550.kt"); + } + + @Test + @TestMetadata("kt45308.kt") + public void testKt45308() throws Exception { + runTest("compiler/testData/ir/irText/declarations/kt45308.kt"); + } + + @Test + @TestMetadata("kt47527.kt") + public void testKt47527() throws Exception { + runTest("compiler/testData/ir/irText/declarations/kt47527.kt"); + } + + @Test + @TestMetadata("localClassWithOverrides.kt") + public void testLocalClassWithOverrides() throws Exception { + runTest("compiler/testData/ir/irText/declarations/localClassWithOverrides.kt"); + } + + @Test + @TestMetadata("localDelegatedProperties.kt") + public void testLocalDelegatedProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/localDelegatedProperties.kt"); + } + + @Test + @TestMetadata("localVarInDoWhile.kt") + public void testLocalVarInDoWhile() throws Exception { + runTest("compiler/testData/ir/irText/declarations/localVarInDoWhile.kt"); + } + + @Test + @TestMetadata("packageLevelProperties.kt") + public void testPackageLevelProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/packageLevelProperties.kt"); + } + + @Test + @TestMetadata("primaryCtorDefaultArguments.kt") + public void testPrimaryCtorDefaultArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/primaryCtorDefaultArguments.kt"); + } + + @Test + @TestMetadata("primaryCtorProperties.kt") + public void testPrimaryCtorProperties() throws Exception { + runTest("compiler/testData/ir/irText/declarations/primaryCtorProperties.kt"); + } + + @Test + @TestMetadata("typeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("compiler/testData/ir/irText/declarations/typeAlias.kt"); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("annotationOnClassWithInitializer.kt") + public void testAnnotationOnClassWithInitializer() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/annotationOnClassWithInitializer.kt"); + } + + @Test + @TestMetadata("annotationsInAnnotationArguments.kt") + public void testAnnotationsInAnnotationArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/annotationsInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("annotationsOnDelegatedMembers.kt") + public void testAnnotationsOnDelegatedMembers() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/annotationsOnDelegatedMembers.kt"); + } + + @Test + @TestMetadata("annotationsWithDefaultParameterValues.kt") + public void testAnnotationsWithDefaultParameterValues() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/annotationsWithDefaultParameterValues.kt"); + } + + @Test + @TestMetadata("annotationsWithVarargParameters.kt") + public void testAnnotationsWithVarargParameters() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/annotationsWithVarargParameters.kt"); + } + + @Test + @TestMetadata("arrayInAnnotationArguments.kt") + public void testArrayInAnnotationArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/arrayInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("classLiteralInAnnotation.kt") + public void testClassLiteralInAnnotation() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/classLiteralInAnnotation.kt"); + } + + @Test + @TestMetadata("classesWithAnnotations.kt") + public void testClassesWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.kt"); + } + + @Test + @TestMetadata("constExpressionsInAnnotationArguments.kt") + public void testConstExpressionsInAnnotationArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/constExpressionsInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("constructorsWithAnnotations.kt") + public void testConstructorsWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/constructorsWithAnnotations.kt"); + } + + @Test + @TestMetadata("delegateFieldWithAnnotations.kt") + public void testDelegateFieldWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/delegateFieldWithAnnotations.kt"); + } + + @Test + @TestMetadata("delegatedPropertyAccessorsWithAnnotations.kt") + public void testDelegatedPropertyAccessorsWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/delegatedPropertyAccessorsWithAnnotations.kt"); + } + + @Test + @TestMetadata("enumEntriesWithAnnotations.kt") + public void testEnumEntriesWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.kt"); + } + + @Test + @TestMetadata("enumsInAnnotationArguments.kt") + public void testEnumsInAnnotationArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("fieldsWithAnnotations.kt") + public void testFieldsWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/fieldsWithAnnotations.kt"); + } + + @Test + @TestMetadata("fileAnnotations.kt") + public void testFileAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/fileAnnotations.kt"); + } + + @Test + @TestMetadata("functionsWithAnnotations.kt") + public void testFunctionsWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/functionsWithAnnotations.kt"); + } + + @Test + @TestMetadata("genericAnnotationClasses.kt") + public void testGenericAnnotationClasses() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/genericAnnotationClasses.kt"); + } + + @Test + @TestMetadata("inheritingDeprecation.kt") + public void testInheritingDeprecation() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/inheritingDeprecation.kt"); + } + + @Test + @TestMetadata("javaAnnotation.kt") + public void testJavaAnnotation() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/javaAnnotation.kt"); + } + + @Test + @TestMetadata("javaAnnotationWithSingleArrayArgument.kt") + public void testJavaAnnotationWithSingleArrayArgument() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/javaAnnotationWithSingleArrayArgument.kt"); + } + + @Test + @TestMetadata("localDelegatedPropertiesWithAnnotations.kt") + public void testLocalDelegatedPropertiesWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/localDelegatedPropertiesWithAnnotations.kt"); + } + + @Test + @TestMetadata("multipleAnnotationsInSquareBrackets.kt") + public void testMultipleAnnotationsInSquareBrackets() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/multipleAnnotationsInSquareBrackets.kt"); + } + + @Test + @TestMetadata("primaryConstructorParameterWithAnnotations.kt") + public void testPrimaryConstructorParameterWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/primaryConstructorParameterWithAnnotations.kt"); + } + + @Test + @TestMetadata("propertiesWithAnnotations.kt") + public void testPropertiesWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/propertiesWithAnnotations.kt"); + } + + @Test + @TestMetadata("propertyAccessorsFromClassHeaderWithAnnotations.kt") + public void testPropertyAccessorsFromClassHeaderWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/propertyAccessorsFromClassHeaderWithAnnotations.kt"); + } + + @Test + @TestMetadata("propertyAccessorsWithAnnotations.kt") + public void testPropertyAccessorsWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/propertyAccessorsWithAnnotations.kt"); + } + + @Test + @TestMetadata("propertySetterParameterWithAnnotations.kt") + public void testPropertySetterParameterWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/propertySetterParameterWithAnnotations.kt"); + } + + @Test + @TestMetadata("receiverParameterWithAnnotations.kt") + public void testReceiverParameterWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/receiverParameterWithAnnotations.kt"); + } + + @Test + @TestMetadata("spreadOperatorInAnnotationArguments.kt") + public void testSpreadOperatorInAnnotationArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/spreadOperatorInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("typeAliasesWithAnnotations.kt") + public void testTypeAliasesWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.kt"); + } + + @Test + @TestMetadata("typeParametersWithAnnotations.kt") + public void testTypeParametersWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/typeParametersWithAnnotations.kt"); + } + + @Test + @TestMetadata("valueParametersWithAnnotations.kt") + public void testValueParametersWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/valueParametersWithAnnotations.kt"); + } + + @Test + @TestMetadata("varargsInAnnotationArguments.kt") + public void testVarargsInAnnotationArguments() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/varargsInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("variablesWithAnnotations.kt") + public void testVariablesWithAnnotations() throws Exception { + runTest("compiler/testData/ir/irText/declarations/annotations/variablesWithAnnotations.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations/contextReceivers") + @TestDataPath("$PROJECT_ROOT") + public class ContextReceivers { + @Test + public void testAllFilesPresentInContextReceivers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/contextReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("arrayAccessCompositeOperators.kt") + public void testArrayAccessCompositeOperators() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/arrayAccessCompositeOperators.kt"); + } + + @Test + @TestMetadata("arrayAccessOperators.kt") + public void testArrayAccessOperators() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/arrayAccessOperators.kt"); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/class.kt"); + } + + @Test + @TestMetadata("compoundAssignmentOperators.kt") + public void testCompoundAssignmentOperators() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/compoundAssignmentOperators.kt"); + } + + @Test + @TestMetadata("contextualFunctionConversion.kt") + public void testContextualFunctionConversion() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/contextualFunctionConversion.kt"); + } + + @Test + @TestMetadata("contextualInlineCall.kt") + public void testContextualInlineCall() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/contextualInlineCall.kt"); + } + + @Test + @TestMetadata("contextualPrimaryConstructorWithParams.kt") + public void testContextualPrimaryConstructorWithParams() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/contextualPrimaryConstructorWithParams.kt"); + } + + @Test + @TestMetadata("delegatedPropertiesOperators.kt") + public void testDelegatedPropertiesOperators() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/delegatedPropertiesOperators.kt"); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/function.kt"); + } + + @Test + @TestMetadata("functionalType.kt") + public void testFunctionalType() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/functionalType.kt"); + } + + @Test + @TestMetadata("genericOuterClass.kt") + public void testGenericOuterClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/genericOuterClass.kt"); + } + + @Test + @TestMetadata("iteratorOperator.kt") + public void testIteratorOperator() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/iteratorOperator.kt"); + } + + @Test + @TestMetadata("lazy.kt") + public void testLazy() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/lazy.kt"); + } + + @Test + @TestMetadata("overloadPriority.kt") + public void testOverloadPriority() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/overloadPriority.kt"); + } + + @Test + @TestMetadata("overloading.kt") + public void testOverloading() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/overloading.kt"); + } + + @Test + @TestMetadata("passingLambdaToContextualParam.kt") + public void testPassingLambdaToContextualParam() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/passingLambdaToContextualParam.kt"); + } + + @Test + @TestMetadata("plusMatrix.kt") + public void testPlusMatrix() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/plusMatrix.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/property.kt"); + } + + @Test + @TestMetadata("thisWithCustomLabel.kt") + public void testThisWithCustomLabel() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/thisWithCustomLabel.kt"); + } + + @Test + @TestMetadata("typeParameterAsContextReceiver.kt") + public void testTypeParameterAsContextReceiver() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/typeParameterAsContextReceiver.kt"); + } + + @Test + @TestMetadata("unaryOperators.kt") + public void testUnaryOperators() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/unaryOperators.kt"); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP") + @TestDataPath("$PROJECT_ROOT") + public class FromKEEP { + @Test + public void testAllFilesPresentInFromKEEP() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("canvas.kt") + public void testCanvas() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/canvas.kt"); + } + + @Test + @TestMetadata("compareTo.kt") + public void testCompareTo() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/compareTo.kt"); + } + + @Test + @TestMetadata("dp.kt") + public void testDp() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/dp.kt"); + } + + @Test + @TestMetadata("functionalType.kt") + public void testFunctionalType() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/functionalType.kt"); + } + + @Test + @TestMetadata("monoidSum.kt") + public void testMonoidSum() throws Exception { + runTest("compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/monoidSum.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations/multiplatform") + @TestDataPath("$PROJECT_ROOT") + public class Multiplatform { + @Test + public void testAllFilesPresentInMultiplatform() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("expectClassInherited.kt") + public void testExpectClassInherited() throws Exception { + runTest("compiler/testData/ir/irText/declarations/multiplatform/expectClassInherited.kt"); + } + + @Test + @TestMetadata("expectedEnumClass.kt") + public void testExpectedEnumClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.kt"); + } + + @Test + @TestMetadata("expectedSealedClass.kt") + public void testExpectedSealedClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/multiplatform/expectedSealedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations/parameters") + @TestDataPath("$PROJECT_ROOT") + public class Parameters { + @Test + public void testAllFilesPresentInParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/class.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/constructor.kt"); + } + + @Test + @TestMetadata("dataClassMembers.kt") + public void testDataClassMembers() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/dataClassMembers.kt"); + } + + @Test + @TestMetadata("defaultPropertyAccessors.kt") + public void testDefaultPropertyAccessors() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/defaultPropertyAccessors.kt"); + } + + @Test + @TestMetadata("delegatedMembers.kt") + public void testDelegatedMembers() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/delegatedMembers.kt"); + } + + @Test + @TestMetadata("fun.kt") + public void testFun() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/fun.kt"); + } + + @Test + @TestMetadata("genericInnerClass.kt") + public void testGenericInnerClass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/genericInnerClass.kt"); + } + + @Test + @TestMetadata("lambdas.kt") + public void testLambdas() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/lambdas.kt"); + } + + @Test + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/localFun.kt"); + } + + @Test + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/propertyAccessors.kt"); + } + + @Test + @TestMetadata("typeParameterBeforeBound.kt") + public void testTypeParameterBeforeBound() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.kt"); + } + + @Test + @TestMetadata("typeParameterBoundedBySubclass.kt") + public void testTypeParameterBoundedBySubclass() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/typeParameterBoundedBySubclass.kt"); + } + + @Test + @TestMetadata("useNextParamInLambda.kt") + public void testUseNextParamInLambda() throws Exception { + runTest("compiler/testData/ir/irText/declarations/parameters/useNextParamInLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/declarations/provideDelegate") + @TestDataPath("$PROJECT_ROOT") + public class ProvideDelegate { + @Test + public void testAllFilesPresentInProvideDelegate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("differentReceivers.kt") + public void testDifferentReceivers() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/differentReceivers.kt"); + } + + @Test + @TestMetadata("javaDelegate.kt") + public void testJavaDelegate() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/javaDelegate.kt"); + } + + @Test + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/local.kt"); + } + + @Test + @TestMetadata("localDifferentReceivers.kt") + public void testLocalDifferentReceivers() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/localDifferentReceivers.kt"); + } + + @Test + @TestMetadata("member.kt") + public void testMember() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/member.kt"); + } + + @Test + @TestMetadata("memberExtension.kt") + public void testMemberExtension() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/memberExtension.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/ir/irText/declarations/provideDelegate/topLevel.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/errors") + @TestDataPath("$PROJECT_ROOT") + public class Errors { + @Test + public void testAllFilesPresentInErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/errors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("suppressedNonPublicCall.kt") + public void testSuppressedNonPublicCall() throws Exception { + runTest("compiler/testData/ir/irText/errors/suppressedNonPublicCall.kt"); + } + + @Test + @TestMetadata("unresolvedReference.kt") + public void testUnresolvedReference() throws Exception { + runTest("compiler/testData/ir/irText/errors/unresolvedReference.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/expressions") + @TestDataPath("$PROJECT_ROOT") + public class Expressions { + @Test + public void testAllFilesPresentInExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("argumentMappedWithError.kt") + public void testArgumentMappedWithError() throws Exception { + runTest("compiler/testData/ir/irText/expressions/argumentMappedWithError.kt"); + } + + @Test + @TestMetadata("arrayAccess.kt") + public void testArrayAccess() throws Exception { + runTest("compiler/testData/ir/irText/expressions/arrayAccess.kt"); + } + + @Test + @TestMetadata("arrayAssignment.kt") + public void testArrayAssignment() throws Exception { + runTest("compiler/testData/ir/irText/expressions/arrayAssignment.kt"); + } + + @Test + @TestMetadata("arrayAugmentedAssignment1.kt") + public void testArrayAugmentedAssignment1() throws Exception { + runTest("compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.kt"); + } + + @Test + @TestMetadata("arrayAugmentedAssignment2.kt") + public void testArrayAugmentedAssignment2() throws Exception { + runTest("compiler/testData/ir/irText/expressions/arrayAugmentedAssignment2.kt"); + } + + @Test + @TestMetadata("assignments.kt") + public void testAssignments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/assignments.kt"); + } + + @Test + @TestMetadata("augmentedAssignment1.kt") + public void testAugmentedAssignment1() throws Exception { + runTest("compiler/testData/ir/irText/expressions/augmentedAssignment1.kt"); + } + + @Test + @TestMetadata("augmentedAssignment2.kt") + public void testAugmentedAssignment2() throws Exception { + runTest("compiler/testData/ir/irText/expressions/augmentedAssignment2.kt"); + } + + @Test + @TestMetadata("augmentedAssignmentWithExpression.kt") + public void testAugmentedAssignmentWithExpression() throws Exception { + runTest("compiler/testData/ir/irText/expressions/augmentedAssignmentWithExpression.kt"); + } + + @Test + @TestMetadata("badBreakContinue.kt") + public void testBadBreakContinue() throws Exception { + runTest("compiler/testData/ir/irText/expressions/badBreakContinue.kt"); + } + + @Test + @TestMetadata("bangbang.kt") + public void testBangbang() throws Exception { + runTest("compiler/testData/ir/irText/expressions/bangbang.kt"); + } + + @Test + @TestMetadata("booleanConstsInAndAndOrOr.kt") + public void testBooleanConstsInAndAndOrOr() throws Exception { + runTest("compiler/testData/ir/irText/expressions/booleanConstsInAndAndOrOr.kt"); + } + + @Test + @TestMetadata("booleanOperators.kt") + public void testBooleanOperators() throws Exception { + runTest("compiler/testData/ir/irText/expressions/booleanOperators.kt"); + } + + @Test + @TestMetadata("boundCallableReferences.kt") + public void testBoundCallableReferences() throws Exception { + runTest("compiler/testData/ir/irText/expressions/boundCallableReferences.kt"); + } + + @Test + @TestMetadata("boxOk.kt") + public void testBoxOk() throws Exception { + runTest("compiler/testData/ir/irText/expressions/boxOk.kt"); + } + + @Test + @TestMetadata("breakContinue.kt") + public void testBreakContinue() throws Exception { + runTest("compiler/testData/ir/irText/expressions/breakContinue.kt"); + } + + @Test + @TestMetadata("breakContinueInLoopHeader.kt") + public void testBreakContinueInLoopHeader() throws Exception { + runTest("compiler/testData/ir/irText/expressions/breakContinueInLoopHeader.kt"); + } + + @Test + @TestMetadata("breakContinueInWhen.kt") + public void testBreakContinueInWhen() throws Exception { + runTest("compiler/testData/ir/irText/expressions/breakContinueInWhen.kt"); + } + + @Test + @TestMetadata("callWithReorderedArguments.kt") + public void testCallWithReorderedArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callWithReorderedArguments.kt"); + } + + @Test + @TestMetadata("calls.kt") + public void testCalls() throws Exception { + runTest("compiler/testData/ir/irText/expressions/calls.kt"); + } + + @Test + @TestMetadata("castToTypeParameter.kt") + public void testCastToTypeParameter() throws Exception { + runTest("compiler/testData/ir/irText/expressions/castToTypeParameter.kt"); + } + + @Test + @TestMetadata("catchParameterAccess.kt") + public void testCatchParameterAccess() throws Exception { + runTest("compiler/testData/ir/irText/expressions/catchParameterAccess.kt"); + } + + @Test + @TestMetadata("chainOfSafeCalls.kt") + public void testChainOfSafeCalls() throws Exception { + runTest("compiler/testData/ir/irText/expressions/chainOfSafeCalls.kt"); + } + + @Test + @TestMetadata("chainedFunSuspendConversionForSimpleExpression.kt") + public void testChainedFunSuspendConversionForSimpleExpression() throws Exception { + runTest("compiler/testData/ir/irText/expressions/chainedFunSuspendConversionForSimpleExpression.kt"); + } + + @Test + @TestMetadata("classReference.kt") + public void testClassReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/classReference.kt"); + } + + @Test + @TestMetadata("coercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/testData/ir/irText/expressions/coercionToUnit.kt"); + } + + @Test + @TestMetadata("complexAugmentedAssignment.kt") + public void testComplexAugmentedAssignment() throws Exception { + runTest("compiler/testData/ir/irText/expressions/complexAugmentedAssignment.kt"); + } + + @Test + @TestMetadata("constructorWithOwnTypeParametersCall.kt") + public void testConstructorWithOwnTypeParametersCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall.kt"); + } + + @Test + @TestMetadata("contructorCall.kt") + public void testContructorCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/contructorCall.kt"); + } + + @Test + @TestMetadata("conventionComparisons.kt") + public void testConventionComparisons() throws Exception { + runTest("compiler/testData/ir/irText/expressions/conventionComparisons.kt"); + } + + @Test + @TestMetadata("destructuring1.kt") + public void testDestructuring1() throws Exception { + runTest("compiler/testData/ir/irText/expressions/destructuring1.kt"); + } + + @Test + @TestMetadata("destructuringWithUnderscore.kt") + public void testDestructuringWithUnderscore() throws Exception { + runTest("compiler/testData/ir/irText/expressions/destructuringWithUnderscore.kt"); + } + + @Test + @TestMetadata("dotQualified.kt") + public void testDotQualified() throws Exception { + runTest("compiler/testData/ir/irText/expressions/dotQualified.kt"); + } + + @Test + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/ir/irText/expressions/elvis.kt"); + } + + @Test + @TestMetadata("enumEntryAsReceiver.kt") + public void testEnumEntryAsReceiver() throws Exception { + runTest("compiler/testData/ir/irText/expressions/enumEntryAsReceiver.kt"); + } + + @Test + @TestMetadata("enumEntryReferenceFromEnumEntryClass.kt") + public void testEnumEntryReferenceFromEnumEntryClass() throws Exception { + runTest("compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.kt"); + } + + @Test + @TestMetadata("equality.kt") + public void testEquality() throws Exception { + runTest("compiler/testData/ir/irText/expressions/equality.kt"); + } + + @Test + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + runTest("compiler/testData/ir/irText/expressions/equals.kt"); + } + + @Test + @TestMetadata("exclExclOnPlatformType.kt") + public void testExclExclOnPlatformType() throws Exception { + runTest("compiler/testData/ir/irText/expressions/exclExclOnPlatformType.kt"); + } + + @Test + @TestMetadata("exhaustiveWhenElseBranch.kt") + public void testExhaustiveWhenElseBranch() throws Exception { + runTest("compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.kt"); + } + + @Test + @TestMetadata("extFunInvokeAsFun.kt") + public void testExtFunInvokeAsFun() throws Exception { + runTest("compiler/testData/ir/irText/expressions/extFunInvokeAsFun.kt"); + } + + @Test + @TestMetadata("extFunSafeInvoke.kt") + public void testExtFunSafeInvoke() throws Exception { + runTest("compiler/testData/ir/irText/expressions/extFunSafeInvoke.kt"); + } + + @Test + @TestMetadata("extensionPropertyGetterCall.kt") + public void testExtensionPropertyGetterCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/extensionPropertyGetterCall.kt"); + } + + @Test + @TestMetadata("field.kt") + public void testField() throws Exception { + runTest("compiler/testData/ir/irText/expressions/field.kt"); + } + + @Test + @TestMetadata("for.kt") + public void testFor() throws Exception { + runTest("compiler/testData/ir/irText/expressions/for.kt"); + } + + @Test + @TestMetadata("forWithBreakContinue.kt") + public void testForWithBreakContinue() throws Exception { + runTest("compiler/testData/ir/irText/expressions/forWithBreakContinue.kt"); + } + + @Test + @TestMetadata("forWithImplicitReceivers.kt") + public void testForWithImplicitReceivers() throws Exception { + runTest("compiler/testData/ir/irText/expressions/forWithImplicitReceivers.kt"); + } + + @Test + @TestMetadata("funImportedFromObject.kt") + public void testFunImportedFromObject() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funImportedFromObject.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructorReference.kt") + public void testFunInterfaceConstructorReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterfaceConstructorReference.kt"); + } + + @Test + @TestMetadata("genericConstructorCallWithTypeArguments.kt") + public void testGenericConstructorCallWithTypeArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.kt"); + } + + @Test + @TestMetadata("genericPropertyCall.kt") + public void testGenericPropertyCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/genericPropertyCall.kt"); + } + + @Test + @TestMetadata("genericPropertyRef.kt") + public void testGenericPropertyRef() throws Exception { + runTest("compiler/testData/ir/irText/expressions/genericPropertyRef.kt"); + } + + @Test + @TestMetadata("identity.kt") + public void testIdentity() throws Exception { + runTest("compiler/testData/ir/irText/expressions/identity.kt"); + } + + @Test + @TestMetadata("ifElseIf.kt") + public void testIfElseIf() throws Exception { + runTest("compiler/testData/ir/irText/expressions/ifElseIf.kt"); + } + + @Test + @TestMetadata("implicitCastInReturnFromConstructor.kt") + public void testImplicitCastInReturnFromConstructor() throws Exception { + runTest("compiler/testData/ir/irText/expressions/implicitCastInReturnFromConstructor.kt"); + } + + @Test + @TestMetadata("implicitCastOnPlatformType.kt") + public void testImplicitCastOnPlatformType() throws Exception { + runTest("compiler/testData/ir/irText/expressions/implicitCastOnPlatformType.kt"); + } + + @Test + @TestMetadata("implicitCastToNonNull.kt") + public void testImplicitCastToNonNull() throws Exception { + runTest("compiler/testData/ir/irText/expressions/implicitCastToNonNull.kt"); + } + + @Test + @TestMetadata("implicitCastToTypeParameter.kt") + public void testImplicitCastToTypeParameter() throws Exception { + runTest("compiler/testData/ir/irText/expressions/implicitCastToTypeParameter.kt"); + } + + @Test + @TestMetadata("implicitNotNullInDestructuringAssignment.kt") + public void testImplicitNotNullInDestructuringAssignment() throws Exception { + runTest("compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.kt"); + } + + @Test + @TestMetadata("in.kt") + public void testIn() throws Exception { + runTest("compiler/testData/ir/irText/expressions/in.kt"); + } + + @Test + @TestMetadata("incrementDecrement.kt") + public void testIncrementDecrement() throws Exception { + runTest("compiler/testData/ir/irText/expressions/incrementDecrement.kt"); + } + + @Test + @TestMetadata("interfaceThisRef.kt") + public void testInterfaceThisRef() throws Exception { + runTest("compiler/testData/ir/irText/expressions/interfaceThisRef.kt"); + } + + @Test + @TestMetadata("javaSyntheticGenericPropretyAccess.kt") + public void testJavaSyntheticGenericPropretyAccess() throws Exception { + runTest("compiler/testData/ir/irText/expressions/javaSyntheticGenericPropretyAccess.kt"); + } + + @Test + @TestMetadata("javaSyntheticPropertyAccess.kt") + public void testJavaSyntheticPropertyAccess() throws Exception { + runTest("compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.kt"); + } + + @Test + @TestMetadata("jvmFieldReferenceWithIntersectionTypes.kt") + public void testJvmFieldReferenceWithIntersectionTypes() throws Exception { + runTest("compiler/testData/ir/irText/expressions/jvmFieldReferenceWithIntersectionTypes.kt"); + } + + @Test + @TestMetadata("jvmInstanceFieldReference.kt") + public void testJvmInstanceFieldReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.kt"); + } + + @Test + @TestMetadata("jvmStaticFieldReference.kt") + public void testJvmStaticFieldReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/jvmStaticFieldReference.kt"); + } + + @Test + @TestMetadata("kt16904.kt") + public void testKt16904() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt16904.kt"); + } + + @Test + @TestMetadata("kt16905.kt") + public void testKt16905() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt16905.kt"); + } + + @Test + @TestMetadata("kt23030.kt") + public void testKt23030() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt23030.kt"); + } + + @Test + @TestMetadata("kt24804.kt") + public void testKt24804() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt24804.kt"); + } + + @Test + @TestMetadata("kt27933.kt") + public void testKt27933() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt27933.kt"); + } + + @Test + @TestMetadata("kt28006.kt") + public void testKt28006() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt28006.kt"); + } + + @Test + @TestMetadata("kt28456.kt") + public void testKt28456() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt28456.kt"); + } + + @Test + @TestMetadata("kt28456a.kt") + public void testKt28456a() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt28456a.kt"); + } + + @Test + @TestMetadata("kt28456b.kt") + public void testKt28456b() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt28456b.kt"); + } + + @Test + @TestMetadata("kt30020.kt") + public void testKt30020() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt30020.kt"); + } + + @Test + @TestMetadata("kt30796.kt") + public void testKt30796() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt30796.kt"); + } + + @Test + @TestMetadata("kt35730.kt") + public void testKt35730() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt35730.kt"); + } + + @Test + @TestMetadata("kt36956.kt") + public void testKt36956() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt36956.kt"); + } + + @Test + @TestMetadata("kt36963.kt") + public void testKt36963() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt36963.kt"); + } + + @Test + @TestMetadata("kt37570.kt") + public void testKt37570() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt37570.kt"); + } + + @Test + @TestMetadata("kt37779.kt") + public void testKt37779() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt37779.kt"); + } + + @Test + @TestMetadata("kt42321.kt") + public void testKt42321() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt42321.kt"); + } + + @Test + @TestMetadata("kt44993.kt") + public void testKt44993() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt44993.kt"); + } + + @Test + @TestMetadata("kt45022.kt") + public void testKt45022() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt45022.kt"); + } + + @Test + @TestMetadata("kt47082.kt") + public void testKt47082() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt47082.kt"); + } + + @Test + @TestMetadata("kt47245.kt") + public void testKt47245() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt47245.kt"); + } + + @Test + @TestMetadata("kt47328.kt") + public void testKt47328() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt47328.kt"); + } + + @Test + @TestMetadata("kt47450.kt") + public void testKt47450() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt47450.kt"); + } + + @Test + @TestMetadata("kt48708.kt") + public void testKt48708() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt48708.kt"); + } + + @Test + @TestMetadata("kt48806.kt") + public void testKt48806() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt48806.kt"); + } + + @Test + @TestMetadata("kt49203.kt") + public void testKt49203() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt49203.kt"); + } + + @Test + @TestMetadata("kt50028.kt") + public void testKt50028() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt50028.kt"); + } + + @Test + @TestMetadata("kt51036.kt") + public void testKt51036() throws Exception { + runTest("compiler/testData/ir/irText/expressions/kt51036.kt"); + } + + @Test + @TestMetadata("lambdaInCAO.kt") + public void testLambdaInCAO() throws Exception { + runTest("compiler/testData/ir/irText/expressions/lambdaInCAO.kt"); + } + + @Test + @TestMetadata("literals.kt") + public void testLiterals() throws Exception { + runTest("compiler/testData/ir/irText/expressions/literals.kt"); + } + + @Test + @TestMetadata("memberTypeArguments.kt") + public void testMemberTypeArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/memberTypeArguments.kt"); + } + + @Test + @TestMetadata("membersImportedFromObject.kt") + public void testMembersImportedFromObject() throws Exception { + runTest("compiler/testData/ir/irText/expressions/membersImportedFromObject.kt"); + } + + @Test + @TestMetadata("multipleSmartCasts.kt") + public void testMultipleSmartCasts() throws Exception { + runTest("compiler/testData/ir/irText/expressions/multipleSmartCasts.kt"); + } + + @Test + @TestMetadata("multipleThisReferences.kt") + public void testMultipleThisReferences() throws Exception { + runTest("compiler/testData/ir/irText/expressions/multipleThisReferences.kt"); + } + + @Test + @TestMetadata("nullCheckOnGenericLambdaReturn.kt") + public void testNullCheckOnGenericLambdaReturn() throws Exception { + runTest("compiler/testData/ir/irText/expressions/nullCheckOnGenericLambdaReturn.kt"); + } + + @Test + @TestMetadata("nullCheckOnLambdaReturn.kt") + public void testNullCheckOnLambdaReturn() throws Exception { + runTest("compiler/testData/ir/irText/expressions/nullCheckOnLambdaReturn.kt"); + } + + @Test + @TestMetadata("objectAsCallable.kt") + public void testObjectAsCallable() throws Exception { + runTest("compiler/testData/ir/irText/expressions/objectAsCallable.kt"); + } + + @Test + @TestMetadata("objectByNameInsideObject.kt") + public void testObjectByNameInsideObject() throws Exception { + runTest("compiler/testData/ir/irText/expressions/objectByNameInsideObject.kt"); + } + + @Test + @TestMetadata("objectClassReference.kt") + public void testObjectClassReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/objectClassReference.kt"); + } + + @Test + @TestMetadata("objectReference.kt") + public void testObjectReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/objectReference.kt"); + } + + @Test + @TestMetadata("objectReferenceInClosureInSuperConstructorCall.kt") + public void testObjectReferenceInClosureInSuperConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("objectReferenceInFieldInitializer.kt") + public void testObjectReferenceInFieldInitializer() throws Exception { + runTest("compiler/testData/ir/irText/expressions/objectReferenceInFieldInitializer.kt"); + } + + @Test + @TestMetadata("outerClassInstanceReference.kt") + public void testOuterClassInstanceReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/outerClassInstanceReference.kt"); + } + + @Test + @TestMetadata("primitiveComparisons.kt") + public void testPrimitiveComparisons() throws Exception { + runTest("compiler/testData/ir/irText/expressions/primitiveComparisons.kt"); + } + + @Test + @TestMetadata("primitivesImplicitConversions.kt") + public void testPrimitivesImplicitConversions() throws Exception { + runTest("compiler/testData/ir/irText/expressions/primitivesImplicitConversions.kt"); + } + + @Test + @TestMetadata("propertyReferences.kt") + public void testPropertyReferences() throws Exception { + runTest("compiler/testData/ir/irText/expressions/propertyReferences.kt"); + } + + @Test + @TestMetadata("protectedJavaFieldRef.kt") + public void testProtectedJavaFieldRef() throws Exception { + runTest("compiler/testData/ir/irText/expressions/protectedJavaFieldRef.kt"); + } + + @Test + @TestMetadata("references.kt") + public void testReferences() throws Exception { + runTest("compiler/testData/ir/irText/expressions/references.kt"); + } + + @Test + @TestMetadata("reflectionLiterals.kt") + public void testReflectionLiterals() throws Exception { + runTest("compiler/testData/ir/irText/expressions/reflectionLiterals.kt"); + } + + @Test + @TestMetadata("safeAssignment.kt") + public void testSafeAssignment() throws Exception { + runTest("compiler/testData/ir/irText/expressions/safeAssignment.kt"); + } + + @Test + @TestMetadata("safeCallWithIncrementDecrement.kt") + public void testSafeCallWithIncrementDecrement() throws Exception { + runTest("compiler/testData/ir/irText/expressions/safeCallWithIncrementDecrement.kt"); + } + + @Test + @TestMetadata("safeCalls.kt") + public void testSafeCalls() throws Exception { + runTest("compiler/testData/ir/irText/expressions/safeCalls.kt"); + } + + @Test + @TestMetadata("setFieldWithImplicitCast.kt") + public void testSetFieldWithImplicitCast() throws Exception { + runTest("compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.kt"); + } + + @Test + @TestMetadata("signedToUnsignedConversions.kt") + public void testSignedToUnsignedConversions() throws Exception { + runTest("compiler/testData/ir/irText/expressions/signedToUnsignedConversions.kt"); + } + + @Test + @TestMetadata("simpleOperators.kt") + public void testSimpleOperators() throws Exception { + runTest("compiler/testData/ir/irText/expressions/simpleOperators.kt"); + } + + @Test + @TestMetadata("simpleUnaryOperators.kt") + public void testSimpleUnaryOperators() throws Exception { + runTest("compiler/testData/ir/irText/expressions/simpleUnaryOperators.kt"); + } + + @Test + @TestMetadata("smartCasts.kt") + public void testSmartCasts() throws Exception { + runTest("compiler/testData/ir/irText/expressions/smartCasts.kt"); + } + + @Test + @TestMetadata("smartCastsWithDestructuring.kt") + public void testSmartCastsWithDestructuring() throws Exception { + runTest("compiler/testData/ir/irText/expressions/smartCastsWithDestructuring.kt"); + } + + @Test + @TestMetadata("specializedTypeAliasConstructorCall.kt") + public void testSpecializedTypeAliasConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.kt"); + } + + @Test + @TestMetadata("stringComparisons.kt") + public void testStringComparisons() throws Exception { + runTest("compiler/testData/ir/irText/expressions/stringComparisons.kt"); + } + + @Test + @TestMetadata("stringPlus.kt") + public void testStringPlus() throws Exception { + runTest("compiler/testData/ir/irText/expressions/stringPlus.kt"); + } + + @Test + @TestMetadata("stringTemplates.kt") + public void testStringTemplates() throws Exception { + runTest("compiler/testData/ir/irText/expressions/stringTemplates.kt"); + } + + @Test + @TestMetadata("suspendConversionForExtensionFunction.kt") + public void testSuspendConversionForExtensionFunction() throws Exception { + runTest("compiler/testData/ir/irText/expressions/suspendConversionForExtensionFunction.kt"); + } + + @Test + @TestMetadata("suspendConversionInVararg.kt") + public void testSuspendConversionInVararg() throws Exception { + runTest("compiler/testData/ir/irText/expressions/suspendConversionInVararg.kt"); + } + + @Test + @TestMetadata("suspendConversionOnArbitraryExpression.kt") + public void testSuspendConversionOnArbitraryExpression() throws Exception { + runTest("compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.kt"); + } + + @Test + @TestMetadata("suspendConversionWithFunInterfaces.kt") + public void testSuspendConversionWithFunInterfaces() throws Exception { + runTest("compiler/testData/ir/irText/expressions/suspendConversionWithFunInterfaces.kt"); + } + + @Test + @TestMetadata("temporaryInEnumEntryInitializer.kt") + public void testTemporaryInEnumEntryInitializer() throws Exception { + runTest("compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.kt"); + } + + @Test + @TestMetadata("temporaryInInitBlock.kt") + public void testTemporaryInInitBlock() throws Exception { + runTest("compiler/testData/ir/irText/expressions/temporaryInInitBlock.kt"); + } + + @Test + @TestMetadata("thisOfGenericOuterClass.kt") + public void testThisOfGenericOuterClass() throws Exception { + runTest("compiler/testData/ir/irText/expressions/thisOfGenericOuterClass.kt"); + } + + @Test + @TestMetadata("thisRefToObjectInNestedClassConstructorCall.kt") + public void testThisRefToObjectInNestedClassConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/thisRefToObjectInNestedClassConstructorCall.kt"); + } + + @Test + @TestMetadata("thisReferenceBeforeClassDeclared.kt") + public void testThisReferenceBeforeClassDeclared() throws Exception { + runTest("compiler/testData/ir/irText/expressions/thisReferenceBeforeClassDeclared.kt"); + } + + @Test + @TestMetadata("throw.kt") + public void testThrow() throws Exception { + runTest("compiler/testData/ir/irText/expressions/throw.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/ir/irText/expressions/tryCatch.kt"); + } + + @Test + @TestMetadata("tryCatchWithImplicitCast.kt") + public void testTryCatchWithImplicitCast() throws Exception { + runTest("compiler/testData/ir/irText/expressions/tryCatchWithImplicitCast.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorReference.kt") + public void testTypeAliasConstructorReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/typeAliasConstructorReference.kt"); + } + + @Test + @TestMetadata("typeArguments.kt") + public void testTypeArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/typeArguments.kt"); + } + + @Test + @TestMetadata("typeOperators.kt") + public void testTypeOperators() throws Exception { + runTest("compiler/testData/ir/irText/expressions/typeOperators.kt"); + } + + @Test + @TestMetadata("typeParameterClassLiteral.kt") + public void testTypeParameterClassLiteral() throws Exception { + runTest("compiler/testData/ir/irText/expressions/typeParameterClassLiteral.kt"); + } + + @Test + @TestMetadata("unsignedIntegerLiterals.kt") + public void testUnsignedIntegerLiterals() throws Exception { + runTest("compiler/testData/ir/irText/expressions/unsignedIntegerLiterals.kt"); + } + + @Test + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/ir/irText/expressions/useImportedMember.kt"); + } + + @Test + @TestMetadata("values.kt") + public void testValues() throws Exception { + runTest("compiler/testData/ir/irText/expressions/values.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/ir/irText/expressions/vararg.kt"); + } + + @Test + @TestMetadata("varargWithImplicitCast.kt") + public void testVarargWithImplicitCast() throws Exception { + runTest("compiler/testData/ir/irText/expressions/varargWithImplicitCast.kt"); + } + + @Test + @TestMetadata("variableAsFunctionCall.kt") + public void testVariableAsFunctionCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/variableAsFunctionCall.kt"); + } + + @Test + @TestMetadata("variableAsFunctionCallWithGenerics.kt") + public void testVariableAsFunctionCallWithGenerics() throws Exception { + runTest("compiler/testData/ir/irText/expressions/variableAsFunctionCallWithGenerics.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/ir/irText/expressions/when.kt"); + } + + @Test + @TestMetadata("whenCoercedToUnit.kt") + public void testWhenCoercedToUnit() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenCoercedToUnit.kt"); + } + + @Test + @TestMetadata("whenElse.kt") + public void testWhenElse() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenElse.kt"); + } + + @Test + @TestMetadata("whenReturn.kt") + public void testWhenReturn() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenReturn.kt"); + } + + @Test + @TestMetadata("whenReturnUnit.kt") + public void testWhenReturnUnit() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenReturnUnit.kt"); + } + + @Test + @TestMetadata("whenSmartCastToEnum.kt") + public void testWhenSmartCastToEnum() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenSmartCastToEnum.kt"); + } + + @Test + @TestMetadata("whenUnusedExpression.kt") + public void testWhenUnusedExpression() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenUnusedExpression.kt"); + } + + @Test + @TestMetadata("whenWithSubjectVariable.kt") + public void testWhenWithSubjectVariable() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whenWithSubjectVariable.kt"); + } + + @Test + @TestMetadata("whileDoWhile.kt") + public void testWhileDoWhile() throws Exception { + runTest("compiler/testData/ir/irText/expressions/whileDoWhile.kt"); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/expressions/callableReferences") + @TestDataPath("$PROJECT_ROOT") + public class CallableReferences { + @Test + @TestMetadata("adaptedExtensionFunctions.kt") + public void testAdaptedExtensionFunctions() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.kt"); + } + + @Test + @TestMetadata("adaptedWithCoercionToUnit.kt") + public void testAdaptedWithCoercionToUnit() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/adaptedWithCoercionToUnit.kt"); + } + + @Test + public void testAllFilesPresentInCallableReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("boundInlineAdaptedReference.kt") + public void testBoundInlineAdaptedReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/boundInlineAdaptedReference.kt"); + } + + @Test + @TestMetadata("boundInnerGenericConstructor.kt") + public void testBoundInnerGenericConstructor() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/boundInnerGenericConstructor.kt"); + } + + @Test + @TestMetadata("caoWithAdaptationForSam.kt") + public void testCaoWithAdaptationForSam() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.kt"); + } + + @Test + @TestMetadata("constructorWithAdaptedArguments.kt") + public void testConstructorWithAdaptedArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/constructorWithAdaptedArguments.kt"); + } + + @Test + @TestMetadata("funWithDefaultParametersAsKCallableStar.kt") + public void testFunWithDefaultParametersAsKCallableStar() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/funWithDefaultParametersAsKCallableStar.kt"); + } + + @Test + @TestMetadata("genericLocalClassConstructorReference.kt") + public void testGenericLocalClassConstructorReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/genericLocalClassConstructorReference.kt"); + } + + @Test + @TestMetadata("genericMember.kt") + public void testGenericMember() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/genericMember.kt"); + } + + @Test + @TestMetadata("importedFromObject.kt") + public void testImportedFromObject() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/importedFromObject.kt"); + } + + @Test + @TestMetadata("kt37131.kt") + public void testKt37131() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/kt37131.kt"); + } + + @Test + @TestMetadata("kt46069.kt") + public void testKt46069() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/kt46069.kt"); + } + + @Test + @TestMetadata("suspendConversion.kt") + public void testSuspendConversion() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/suspendConversion.kt"); + } + + @Test + @TestMetadata("typeArguments.kt") + public void testTypeArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/typeArguments.kt"); + } + + @Test + @TestMetadata("unboundMemberReferenceWithAdaptedArguments.kt") + public void testUnboundMemberReferenceWithAdaptedArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/unboundMemberReferenceWithAdaptedArguments.kt"); + } + + @Test + @TestMetadata("varargFunImportedFromObject.kt") + public void testVarargFunImportedFromObject() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/varargFunImportedFromObject.kt"); + } + + @Test + @TestMetadata("withAdaptationForSam.kt") + public void testWithAdaptationForSam() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/withAdaptationForSam.kt"); + } + + @Test + @TestMetadata("withAdaptedArguments.kt") + public void testWithAdaptedArguments() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/withAdaptedArguments.kt"); + } + + @Test + @TestMetadata("withArgumentAdaptationAndReceiver.kt") + public void testWithArgumentAdaptationAndReceiver() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/withArgumentAdaptationAndReceiver.kt"); + } + + @Test + @TestMetadata("withVarargViewedAsArray.kt") + public void testWithVarargViewedAsArray() throws Exception { + runTest("compiler/testData/ir/irText/expressions/callableReferences/withVarargViewedAsArray.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/expressions/floatingPointComparisons") + @TestDataPath("$PROJECT_ROOT") + public class FloatingPointComparisons { + @Test + public void testAllFilesPresentInFloatingPointComparisons() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/floatingPointComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("comparableWithDoubleOrFloat.kt") + public void testComparableWithDoubleOrFloat() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/comparableWithDoubleOrFloat.kt"); + } + + @Test + @TestMetadata("eqeqRhsConditionPossiblyAffectingLhs.kt") + public void testEqeqRhsConditionPossiblyAffectingLhs() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/eqeqRhsConditionPossiblyAffectingLhs.kt"); + } + + @Test + @TestMetadata("floatingPointCompareTo.kt") + public void testFloatingPointCompareTo() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointCompareTo.kt"); + } + + @Test + @TestMetadata("floatingPointEqeq.kt") + public void testFloatingPointEqeq() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEqeq.kt"); + } + + @Test + @TestMetadata("floatingPointEquals.kt") + public void testFloatingPointEquals() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEquals.kt"); + } + + @Test + @TestMetadata("floatingPointExcleq.kt") + public void testFloatingPointExcleq() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointExcleq.kt"); + } + + @Test + @TestMetadata("floatingPointLess.kt") + public void testFloatingPointLess() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointLess.kt"); + } + + @Test + @TestMetadata("nullableAnyAsIntToDouble.kt") + public void testNullableAnyAsIntToDouble() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableAnyAsIntToDouble.kt"); + } + + @Test + @TestMetadata("nullableFloatingPointEqeq.kt") + public void testNullableFloatingPointEqeq() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableFloatingPointEqeq.kt"); + } + + @Test + @TestMetadata("typeParameterWithPrimitiveNumericSupertype.kt") + public void testTypeParameterWithPrimitiveNumericSupertype() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/typeParameterWithPrimitiveNumericSupertype.kt"); + } + + @Test + @TestMetadata("whenByFloatingPoint.kt") + public void testWhenByFloatingPoint() throws Exception { + runTest("compiler/testData/ir/irText/expressions/floatingPointComparisons/whenByFloatingPoint.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/expressions/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("arrayAsVarargAfterSamArgument_fi.kt") + public void testArrayAsVarargAfterSamArgument_fi() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/arrayAsVarargAfterSamArgument_fi.kt"); + } + + @Test + @TestMetadata("basicFunInterfaceConversion.kt") + public void testBasicFunInterfaceConversion() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/basicFunInterfaceConversion.kt"); + } + + @Test + @TestMetadata("castFromAny.kt") + public void testCastFromAny() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/castFromAny.kt"); + } + + @Test + @TestMetadata("functionSupertype.kt") + public void testFunctionSupertype() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/functionSupertype.kt"); + } + + @Test + @TestMetadata("partialSam.kt") + public void testPartialSam() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/partialSam.kt"); + } + + @Test + @TestMetadata("samConversionInVarargs.kt") + public void testSamConversionInVarargs() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargs.kt"); + } + + @Test + @TestMetadata("samConversionInVarargsMixed.kt") + public void testSamConversionInVarargsMixed() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargsMixed.kt"); + } + + @Test + @TestMetadata("samConversionOnCallableReference.kt") + public void testSamConversionOnCallableReference() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/samConversionOnCallableReference.kt"); + } + + @Test + @TestMetadata("samConversionsWithSmartCasts.kt") + public void testSamConversionsWithSmartCasts() throws Exception { + runTest("compiler/testData/ir/irText/expressions/funInterface/samConversionsWithSmartCasts.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/expressions/sam") + @TestDataPath("$PROJECT_ROOT") + public class Sam { + @Test + public void testAllFilesPresentInSam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("arrayAsVarargAfterSamArgument.kt") + public void testArrayAsVarargAfterSamArgument() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/arrayAsVarargAfterSamArgument.kt"); + } + + @Test + @TestMetadata("genericSamProjectedOut.kt") + public void testGenericSamProjectedOut() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/genericSamProjectedOut.kt"); + } + + @Test + @TestMetadata("genericSamSmartcast.kt") + public void testGenericSamSmartcast() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/genericSamSmartcast.kt"); + } + + @Test + @TestMetadata("samByProjectedType.kt") + public void testSamByProjectedType() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samByProjectedType.kt"); + } + + @Test + @TestMetadata("samConstructors.kt") + public void testSamConstructors() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samConstructors.kt"); + } + + @Test + @TestMetadata("samConversionInGenericConstructorCall.kt") + public void testSamConversionInGenericConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall.kt"); + } + + @Test + @TestMetadata("samConversionToGeneric.kt") + public void testSamConversionToGeneric() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.kt"); + } + + @Test + @TestMetadata("samConversions.kt") + public void testSamConversions() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samConversions.kt"); + } + + @Test + @TestMetadata("samConversionsWithSmartCasts.kt") + public void testSamConversionsWithSmartCasts() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samConversionsWithSmartCasts.kt"); + } + + @Test + @TestMetadata("samOperators.kt") + public void testSamOperators() throws Exception { + runTest("compiler/testData/ir/irText/expressions/sam/samOperators.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/firProblems") + @TestDataPath("$PROJECT_ROOT") + public class FirProblems { + @Test + @TestMetadata("AbstractMutableMap.kt") + public void testAbstractMutableMap() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/AbstractMutableMap.kt"); + } + + @Test + @TestMetadata("AllCandidates.kt") + public void testAllCandidates() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/AllCandidates.kt"); + } + + @Test + public void testAllFilesPresentInFirProblems() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/firProblems"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("AnnotationInAnnotation.kt") + public void testAnnotationInAnnotation() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/AnnotationInAnnotation.kt"); + } + + @Test + @TestMetadata("AnnotationLoader.kt") + public void testAnnotationLoader() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/AnnotationLoader.kt"); + } + + @Test + @TestMetadata("ArrayListOverrides.kt") + public void testArrayListOverrides() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/ArrayListOverrides.kt"); + } + + @Test + @TestMetadata("ArrayMap.kt") + public void testArrayMap() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/ArrayMap.kt"); + } + + @Test + @TestMetadata("candidateSymbol.kt") + public void testCandidateSymbol() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/candidateSymbol.kt"); + } + + @Test + @TestMetadata("ClashResolutionDescriptor.kt") + public void testClashResolutionDescriptor() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/ClashResolutionDescriptor.kt"); + } + + @Test + @TestMetadata("coercionToUnitForNestedWhen.kt") + public void testCoercionToUnitForNestedWhen() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/coercionToUnitForNestedWhen.kt"); + } + + @Test + @TestMetadata("DeepCopyIrTree.kt") + public void testDeepCopyIrTree() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/DeepCopyIrTree.kt"); + } + + @Test + @TestMetadata("DelegationAndInheritanceFromJava.kt") + public void testDelegationAndInheritanceFromJava() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/DelegationAndInheritanceFromJava.kt"); + } + + @Test + @TestMetadata("deprecated.kt") + public void testDeprecated() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/deprecated.kt"); + } + + @Test + @TestMetadata("Fir2IrClassifierStorage.kt") + public void testFir2IrClassifierStorage() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/Fir2IrClassifierStorage.kt"); + } + + @Test + @TestMetadata("FirBuilder.kt") + public void testFirBuilder() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/FirBuilder.kt"); + } + + @Test + @TestMetadata("FlushFromAnonymous.kt") + public void testFlushFromAnonymous() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/FlushFromAnonymous.kt"); + } + + @Test + @TestMetadata("functionLiteralGenericSignature.kt") + public void testFunctionLiteralGenericSignature() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/functionLiteralGenericSignature.kt"); + } + + @Test + @TestMetadata("ImplicitReceiverStack.kt") + public void testImplicitReceiverStack() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/ImplicitReceiverStack.kt"); + } + + @Test + @TestMetadata("inapplicableCollectionSet.kt") + public void testInapplicableCollectionSet() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/inapplicableCollectionSet.kt"); + } + + @Test + @TestMetadata("InnerClassInAnonymous.kt") + public void testInnerClassInAnonymous() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/InnerClassInAnonymous.kt"); + } + + @Test + @TestMetadata("JCTree.kt") + public void testJCTree() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/JCTree.kt"); + } + + @Test + @TestMetadata("kt19251.kt") + public void testKt19251() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/kt19251.kt"); + } + + @Test + @TestMetadata("kt43342.kt") + public void testKt43342() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/kt43342.kt"); + } + + @Test + @TestMetadata("lambdaInEnumEntryConstructorCall.kt") + public void testLambdaInEnumEntryConstructorCall() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/lambdaInEnumEntryConstructorCall.kt"); + } + + @Test + @TestMetadata("localClassUsedBeforeDeclaration.kt") + public void testLocalClassUsedBeforeDeclaration() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/localClassUsedBeforeDeclaration.kt"); + } + + @Test + @TestMetadata("Modality.kt") + public void testModality() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/Modality.kt"); + } + + @Test + @TestMetadata("MultiList.kt") + public void testMultiList() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/MultiList.kt"); + } + + @Test + @TestMetadata("putIfAbsent.kt") + public void testPutIfAbsent() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/putIfAbsent.kt"); + } + + @Test + @TestMetadata("readWriteProperty.kt") + public void testReadWriteProperty() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/readWriteProperty.kt"); + } + + @Test + @TestMetadata("recursiveCapturedTypeInPropertyReference.kt") + public void testRecursiveCapturedTypeInPropertyReference() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/recursiveCapturedTypeInPropertyReference.kt"); + } + + @Test + @TestMetadata("SafeLetWithReturn.kt") + public void testSafeLetWithReturn() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/SafeLetWithReturn.kt"); + } + + @Test + @TestMetadata("SameJavaFieldReferences.kt") + public void testSameJavaFieldReferences() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/SameJavaFieldReferences.kt"); + } + + @Test + @TestMetadata("SignatureClash.kt") + public void testSignatureClash() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/SignatureClash.kt"); + } + + @Test + @TestMetadata("SimpleTypeMarker.kt") + public void testSimpleTypeMarker() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/SimpleTypeMarker.kt"); + } + + @Test + @TestMetadata("SyntheticSetterType.kt") + public void testSyntheticSetterType() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/SyntheticSetterType.kt"); + } + + @Test + @TestMetadata("throwableStackTrace.kt") + public void testThrowableStackTrace() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/throwableStackTrace.kt"); + } + + @Test + @TestMetadata("TypeParameterBounds.kt") + public void testTypeParameterBounds() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/TypeParameterBounds.kt"); + } + + @Test + @TestMetadata("typeParameterFromJavaClass.kt") + public void testTypeParameterFromJavaClass() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/typeParameterFromJavaClass.kt"); + } + + @Test + @TestMetadata("typeVariableAfterBuildMap.kt") + public void testTypeVariableAfterBuildMap() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.kt"); + } + + @Test + @TestMetadata("V8ArrayToList.kt") + public void testV8ArrayToList() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/V8ArrayToList.kt"); + } + + @Test + @TestMetadata("VarInInit.kt") + public void testVarInInit() throws Exception { + runTest("compiler/testData/ir/irText/firProblems/VarInInit.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/lambdas") + @TestDataPath("$PROJECT_ROOT") + public class Lambdas { + @Test + public void testAllFilesPresentInLambdas() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("anonymousFunction.kt") + public void testAnonymousFunction() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/anonymousFunction.kt"); + } + + @Test + @TestMetadata("destructuringInLambda.kt") + public void testDestructuringInLambda() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/destructuringInLambda.kt"); + } + + @Test + @TestMetadata("extensionLambda.kt") + public void testExtensionLambda() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/extensionLambda.kt"); + } + + @Test + @TestMetadata("justLambda.kt") + public void testJustLambda() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/justLambda.kt"); + } + + @Test + @TestMetadata("lambdaReturningUnit.kt") + public void testLambdaReturningUnit() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/lambdaReturningUnit.kt"); + } + + @Test + @TestMetadata("localFunction.kt") + public void testLocalFunction() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/localFunction.kt"); + } + + @Test + @TestMetadata("multipleImplicitReceivers.kt") + public void testMultipleImplicitReceivers() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.kt"); + } + + @Test + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/nonLocalReturn.kt"); + } + + @Test + @TestMetadata("samAdapter.kt") + public void testSamAdapter() throws Exception { + runTest("compiler/testData/ir/irText/lambdas/samAdapter.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/regressions") + @TestDataPath("$PROJECT_ROOT") + public class Regressions { + @Test + public void testAllFilesPresentInRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("coercionInLoop.kt") + public void testCoercionInLoop() throws Exception { + runTest("compiler/testData/ir/irText/regressions/coercionInLoop.kt"); + } + + @Test + @TestMetadata("integerCoercionToT.kt") + public void testIntegerCoercionToT() throws Exception { + runTest("compiler/testData/ir/irText/regressions/integerCoercionToT.kt"); + } + + @Test + @TestMetadata("kt24114.kt") + public void testKt24114() throws Exception { + runTest("compiler/testData/ir/irText/regressions/kt24114.kt"); + } + + @Test + @TestMetadata("kt44855.kt") + public void testKt44855() throws Exception { + runTest("compiler/testData/ir/irText/regressions/kt44855.kt"); + } + + @Test + @TestMetadata("kt45236.kt") + public void testKt45236() throws Exception { + runTest("compiler/testData/ir/irText/regressions/kt45236.kt"); + } + + @Test + @TestMetadata("newInferenceFixationOrder1.kt") + public void testNewInferenceFixationOrder1() throws Exception { + runTest("compiler/testData/ir/irText/regressions/newInferenceFixationOrder1.kt"); + } + + @Test + @TestMetadata("typeAliasCtorForGenericClass.kt") + public void testTypeAliasCtorForGenericClass() throws Exception { + runTest("compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.kt"); + } + + @Test + @TestMetadata("typeParametersInImplicitCast.kt") + public void testTypeParametersInImplicitCast() throws Exception { + runTest("compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/singletons") + @TestDataPath("$PROJECT_ROOT") + public class Singletons { + @Test + public void testAllFilesPresentInSingletons() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/singletons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("companion.kt") + public void testCompanion() throws Exception { + runTest("compiler/testData/ir/irText/singletons/companion.kt"); + } + + @Test + @TestMetadata("enumEntry.kt") + public void testEnumEntry() throws Exception { + runTest("compiler/testData/ir/irText/singletons/enumEntry.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/ir/irText/singletons/object.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/stubs") + @TestDataPath("$PROJECT_ROOT") + public class Stubs { + @Test + public void testAllFilesPresentInStubs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/stubs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("builtinMap.kt") + public void testBuiltinMap() throws Exception { + runTest("compiler/testData/ir/irText/stubs/builtinMap.kt"); + } + + @Test + @TestMetadata("constFromBuiltins.kt") + public void testConstFromBuiltins() throws Exception { + runTest("compiler/testData/ir/irText/stubs/constFromBuiltins.kt"); + } + + @Test + @TestMetadata("genericClassInDifferentModule.kt") + public void testGenericClassInDifferentModule() throws Exception { + runTest("compiler/testData/ir/irText/stubs/genericClassInDifferentModule.kt"); + } + + @Test + @TestMetadata("javaConstructorWithTypeParameters.kt") + public void testJavaConstructorWithTypeParameters() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaConstructorWithTypeParameters.kt"); + } + + @Test + @TestMetadata("javaEnum.kt") + public void testJavaEnum() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaEnum.kt"); + } + + @Test + @TestMetadata("javaInnerClass.kt") + public void testJavaInnerClass() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaInnerClass.kt"); + } + + @Test + @TestMetadata("javaMethod.kt") + public void testJavaMethod() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaMethod.kt"); + } + + @Test + @TestMetadata("javaNestedClass.kt") + public void testJavaNestedClass() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaNestedClass.kt"); + } + + @Test + @TestMetadata("javaStaticMethod.kt") + public void testJavaStaticMethod() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaStaticMethod.kt"); + } + + @Test + @TestMetadata("javaSyntheticProperty.kt") + public void testJavaSyntheticProperty() throws Exception { + runTest("compiler/testData/ir/irText/stubs/javaSyntheticProperty.kt"); + } + + @Test + @TestMetadata("jdkClassSyntheticProperty.kt") + public void testJdkClassSyntheticProperty() throws Exception { + runTest("compiler/testData/ir/irText/stubs/jdkClassSyntheticProperty.kt"); + } + + @Test + @TestMetadata("kotlinInnerClass.kt") + public void testKotlinInnerClass() throws Exception { + runTest("compiler/testData/ir/irText/stubs/kotlinInnerClass.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/ir/irText/stubs/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + @TestMetadata("abbreviatedTypes.kt") + public void testAbbreviatedTypes() throws Exception { + runTest("compiler/testData/ir/irText/types/abbreviatedTypes.kt"); + } + + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("asOnPlatformType.kt") + public void testAsOnPlatformType() throws Exception { + runTest("compiler/testData/ir/irText/types/asOnPlatformType.kt"); + } + + @Test + @TestMetadata("castsInsideCoroutineInference.kt") + public void testCastsInsideCoroutineInference() throws Exception { + runTest("compiler/testData/ir/irText/types/castsInsideCoroutineInference.kt"); + } + + @Test + @TestMetadata("coercionToUnitInLambdaReturnValue.kt") + public void testCoercionToUnitInLambdaReturnValue() throws Exception { + runTest("compiler/testData/ir/irText/types/coercionToUnitInLambdaReturnValue.kt"); + } + + @Test + @TestMetadata("definitelyNonNull.kt") + public void testDefinitelyNonNull() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNonNull.kt"); + } + + @Test + @TestMetadata("definitelyNonNullOverride.kt") + public void testDefinitelyNonNullOverride() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNonNullOverride.kt"); + } + + @Test + @TestMetadata("definitelyNonNullSAM.kt") + public void testDefinitelyNonNullSAM() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNonNullSAM.kt"); + } + + @Test + @TestMetadata("definitelyNonNullWithJava.kt") + public void testDefinitelyNonNullWithJava() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNonNullWithJava.kt"); + } + + @Test + @TestMetadata("definitelyNotNullAsArgument.kt") + public void testDefinitelyNotNullAsArgument() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNotNullAsArgument.kt"); + } + + @Test + @TestMetadata("definitelyNotNullAsReceiver.kt") + public void testDefinitelyNotNullAsReceiver() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNotNullAsReceiver.kt"); + } + + @Test + @TestMetadata("definitelyNotNullWithIntersection1.kt") + public void testDefinitelyNotNullWithIntersection1() throws Exception { + runTest("compiler/testData/ir/irText/types/definitelyNotNullWithIntersection1.kt"); + } + + @Test + @TestMetadata("genericDelegatedDeepProperty.kt") + public void testGenericDelegatedDeepProperty() throws Exception { + runTest("compiler/testData/ir/irText/types/genericDelegatedDeepProperty.kt"); + } + + @Test + @TestMetadata("genericFunWithStar.kt") + public void testGenericFunWithStar() throws Exception { + runTest("compiler/testData/ir/irText/types/genericFunWithStar.kt"); + } + + @Test + @TestMetadata("genericPropertyReferenceType.kt") + public void testGenericPropertyReferenceType() throws Exception { + runTest("compiler/testData/ir/irText/types/genericPropertyReferenceType.kt"); + } + + @Test + @TestMetadata("inStarProjectionInReceiverType.kt") + public void testInStarProjectionInReceiverType() throws Exception { + runTest("compiler/testData/ir/irText/types/inStarProjectionInReceiverType.kt"); + } + + @Test + @TestMetadata("intersectionType1.kt") + public void testIntersectionType1() throws Exception { + runTest("compiler/testData/ir/irText/types/intersectionType1.kt"); + } + + @Test + @TestMetadata("intersectionType2.kt") + public void testIntersectionType2() throws Exception { + runTest("compiler/testData/ir/irText/types/intersectionType2.kt"); + } + + @Test + @TestMetadata("intersectionType3.kt") + public void testIntersectionType3() throws Exception { + runTest("compiler/testData/ir/irText/types/intersectionType3.kt"); + } + + @Test + @TestMetadata("intersectionTypeInSamType.kt") + public void testIntersectionTypeInSamType() throws Exception { + runTest("compiler/testData/ir/irText/types/intersectionTypeInSamType.kt"); + } + + @Test + @TestMetadata("javaWildcardType.kt") + public void testJavaWildcardType() throws Exception { + runTest("compiler/testData/ir/irText/types/javaWildcardType.kt"); + } + + @Test + @TestMetadata("kt36143.kt") + public void testKt36143() throws Exception { + runTest("compiler/testData/ir/irText/types/kt36143.kt"); + } + + @Test + @TestMetadata("kt49526.kt") + public void testKt49526() throws Exception { + runTest("compiler/testData/ir/irText/types/kt49526.kt"); + } + + @Test + @TestMetadata("localVariableOfIntersectionType.kt") + public void testLocalVariableOfIntersectionType() throws Exception { + runTest("compiler/testData/ir/irText/types/localVariableOfIntersectionType.kt"); + } + + @Test + @TestMetadata("rawTypeInSignature.kt") + public void testRawTypeInSignature() throws Exception { + runTest("compiler/testData/ir/irText/types/rawTypeInSignature.kt"); + } + + @Test + @TestMetadata("receiverOfIntersectionType.kt") + public void testReceiverOfIntersectionType() throws Exception { + runTest("compiler/testData/ir/irText/types/receiverOfIntersectionType.kt"); + } + + @Test + @TestMetadata("smartCastOnFakeOverrideReceiver.kt") + public void testSmartCastOnFakeOverrideReceiver() throws Exception { + runTest("compiler/testData/ir/irText/types/smartCastOnFakeOverrideReceiver.kt"); + } + + @Test + @TestMetadata("smartCastOnFieldReceiverOfGenericType.kt") + public void testSmartCastOnFieldReceiverOfGenericType() throws Exception { + runTest("compiler/testData/ir/irText/types/smartCastOnFieldReceiverOfGenericType.kt"); + } + + @Test + @TestMetadata("smartCastOnReceiverOfGenericType.kt") + public void testSmartCastOnReceiverOfGenericType() throws Exception { + runTest("compiler/testData/ir/irText/types/smartCastOnReceiverOfGenericType.kt"); + } + + @Test + @TestMetadata("starProjection.kt") + public void testStarProjection() throws Exception { + runTest("compiler/testData/ir/irText/types/starProjection.kt"); + } + + @Test + @TestMetadata("typeAliasWithUnsafeVariance.kt") + public void testTypeAliasWithUnsafeVariance() throws Exception { + runTest("compiler/testData/ir/irText/types/typeAliasWithUnsafeVariance.kt"); + } + + @Test + @TestMetadata("typeCheckOnDefinitelyNotNull.kt") + public void testTypeCheckOnDefinitelyNotNull() throws Exception { + runTest("compiler/testData/ir/irText/types/typeCheckOnDefinitelyNotNull.kt"); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/types/nullChecks") + @TestDataPath("$PROJECT_ROOT") + public class NullChecks { + @Test + public void testAllFilesPresentInNullChecks() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("enhancedNullability.kt") + public void testEnhancedNullability() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/enhancedNullability.kt"); + } + + @Test + @TestMetadata("enhancedNullabilityInDestructuringAssignment.kt") + public void testEnhancedNullabilityInDestructuringAssignment() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.kt"); + } + + @Test + @TestMetadata("enhancedNullabilityInForLoop.kt") + public void testEnhancedNullabilityInForLoop() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.kt"); + } + + @Test + @TestMetadata("explicitEqualsAndCompareToCallsOnPlatformTypeReceiver.kt") + public void testExplicitEqualsAndCompareToCallsOnPlatformTypeReceiver() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/explicitEqualsAndCompareToCallsOnPlatformTypeReceiver.kt"); + } + + @Test + @TestMetadata("implicitNotNullOnPlatformType.kt") + public void testImplicitNotNullOnPlatformType() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.kt"); + } + + @Test + @TestMetadata("nullCheckInElvisRhs.kt") + public void testNullCheckInElvisRhs() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckInElvisRhs.kt"); + } + + @Test + @TestMetadata("nullCheckOnInterfaceDelegation.kt") + public void testNullCheckOnInterfaceDelegation() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnInterfaceDelegation.kt"); + } + + @Test + @TestMetadata("nullabilityAssertionOnExtensionReceiver.kt") + public void testNullabilityAssertionOnExtensionReceiver() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.kt"); + } + + @Test + @TestMetadata("platformTypeReceiver.kt") + public void testPlatformTypeReceiver() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/platformTypeReceiver.kt"); + } + + @Test + @TestMetadata("typeParameterWithMixedNullableAndNotNullableBounds.kt") + public void testTypeParameterWithMixedNullableAndNotNullableBounds() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/typeParameterWithMixedNullableAndNotNullableBounds.kt"); + } + + @Test + @TestMetadata("typeParameterWithMultipleNotNullableBounds.kt") + public void testTypeParameterWithMultipleNotNullableBounds() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/typeParameterWithMultipleNotNullableBounds.kt"); + } + + @Test + @TestMetadata("typeParameterWithMultipleNullableBounds.kt") + public void testTypeParameterWithMultipleNullableBounds() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/typeParameterWithMultipleNullableBounds.kt"); + } + + @Nested + @TestMetadata("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult") + @TestDataPath("$PROJECT_ROOT") + public class NullCheckOnLambdaResult { + @Test + public void testAllFilesPresentInNullCheckOnLambdaResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("nnStringVsT.kt") + public void testNnStringVsT() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsT.kt"); + } + + @Test + @TestMetadata("nnStringVsTAny.kt") + public void testNnStringVsTAny() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTAny.kt"); + } + + @Test + @TestMetadata("nnStringVsTConstrained.kt") + public void testNnStringVsTConstrained() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTConstrained.kt"); + } + + @Test + @TestMetadata("nnStringVsTXArray.kt") + public void testNnStringVsTXArray() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTXArray.kt"); + } + + @Test + @TestMetadata("nnStringVsTXString.kt") + public void testNnStringVsTXString() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTXString.kt"); + } + + @Test + @TestMetadata("stringVsAny.kt") + public void testStringVsAny() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsAny.kt"); + } + + @Test + @TestMetadata("stringVsT.kt") + public void testStringVsT() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsT.kt"); + } + + @Test + @TestMetadata("stringVsTAny.kt") + public void testStringVsTAny() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTAny.kt"); + } + + @Test + @TestMetadata("stringVsTConstrained.kt") + public void testStringVsTConstrained() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTConstrained.kt"); + } + + @Test + @TestMetadata("stringVsTXArray.kt") + public void testStringVsTXArray() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXArray.kt"); + } + + @Test + @TestMetadata("stringVsTXString.kt") + public void testStringVsTXString() throws Exception { + runTest("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXString.kt"); + } + } + } + } +} diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest.kt new file mode 100644 index 00000000000..ec11df57891 --- /dev/null +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest.kt @@ -0,0 +1,23 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.incremental + +import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments +import org.jetbrains.kotlin.incremental.testingUtils.BuildLogFinder +import java.io.File + +abstract class AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest : AbstractIncrementalJvmCompilerRunnerTest() { + override fun createCompilerArguments(destinationDir: File, testDir: File): K2JVMCompilerArguments = + super.createCompilerArguments(destinationDir, testDir).apply { + useFir = true + useIR = true + useFirIC = true + useFirLT = true + } + + override val buildLogFinder: BuildLogFinder + get() = BuildLogFinder(isGradleEnabled = true, isFirEnabled = true) // TODO: investigate cases that need isGradleEnabled - the combination looks fragile +} diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalFirLightTreeJvmCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalFirLightTreeJvmCompilerRunnerTest.kt new file mode 100644 index 00000000000..25bd8565db8 --- /dev/null +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalFirLightTreeJvmCompilerRunnerTest.kt @@ -0,0 +1,23 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.incremental + +import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments +import org.jetbrains.kotlin.incremental.testingUtils.BuildLogFinder +import java.io.File + +abstract class AbstractIncrementalFirLightTreeJvmCompilerRunnerTest : AbstractIncrementalJvmCompilerRunnerTest() { + override fun createCompilerArguments(destinationDir: File, testDir: File): K2JVMCompilerArguments = + super.createCompilerArguments(destinationDir, testDir).apply { + useFir = true + useIR = true + useFirIC = false + useFirLT = true + } + + override val buildLogFinder: BuildLogFinder + get() = BuildLogFinder(isGradleEnabled = true, isFirEnabled = true) // TODO: investigate cases that need isGradleEnabled - the combination looks fragile +} diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalFirICLightTreeJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalFirICLightTreeJvmCompilerRunnerTestGenerated.java new file mode 100644 index 00000000000..34d16154617 --- /dev/null +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalFirICLightTreeJvmCompilerRunnerTestGenerated.java @@ -0,0 +1,2707 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.incremental; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@RunWith(JUnit3RunnerWithInners.class) +public class IncrementalFirICLightTreeJvmCompilerRunnerTestGenerated extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + @TestMetadata("jps/jps-plugin/testData/incremental/pureKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PureKotlin extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("accessingFunctionsViaPackagePart") + public void testAccessingFunctionsViaPackagePart() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/accessingFunctionsViaPackagePart/"); + } + + @TestMetadata("accessingPropertiesViaField") + public void testAccessingPropertiesViaField() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/accessingPropertiesViaField/"); + } + + @TestMetadata("addClass") + public void testAddClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addClass/"); + } + + @TestMetadata("addFileWithFunctionOverload") + public void testAddFileWithFunctionOverload() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addFileWithFunctionOverload/"); + } + + @TestMetadata("addMemberTypeAlias") + public void testAddMemberTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addMemberTypeAlias/"); + } + + @TestMetadata("addTopLevelTypeAlias") + public void testAddTopLevelTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addTopLevelTypeAlias/"); + } + + @TestMetadata("allConstants") + public void testAllConstants() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/allConstants/"); + } + + public void testAllFilesPresentInPureKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + } + + @TestMetadata("annotations") + public void testAnnotations() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/annotations/"); + } + + @TestMetadata("anonymousObjectChanged") + public void testAnonymousObjectChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/anonymousObjectChanged/"); + } + + @TestMetadata("changeTypeImplicitlyWithCircularDependency") + public void testChangeTypeImplicitlyWithCircularDependency() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeTypeImplicitlyWithCircularDependency/"); + } + + @TestMetadata("changeWithRemovingUsage") + public void testChangeWithRemovingUsage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeWithRemovingUsage/"); + } + + @TestMetadata("classInlineFunctionChanged") + public void testClassInlineFunctionChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classInlineFunctionChanged/"); + } + + @TestMetadata("classObjectConstantChanged") + public void testClassObjectConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classObjectConstantChanged/"); + } + + @TestMetadata("classRecreated") + public void testClassRecreated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classRecreated/"); + } + + @TestMetadata("classRemoved") + public void testClassRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classRemoved/"); + } + + @TestMetadata("classSignatureChanged") + public void testClassSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classSignatureChanged/"); + } + + @TestMetadata("classSignatureUnchanged") + public void testClassSignatureUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classSignatureUnchanged/"); + } + + @TestMetadata("companionConstantChanged") + public void testCompanionConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/companionConstantChanged/"); + } + + @TestMetadata("compilationErrorThenFixedOtherPackage") + public void testCompilationErrorThenFixedOtherPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedOtherPackage/"); + } + + @TestMetadata("compilationErrorThenFixedSamePackage") + public void testCompilationErrorThenFixedSamePackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedSamePackage/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart") + public void testCompilationErrorThenFixedWithPhantomPart() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart2") + public void testCompilationErrorThenFixedWithPhantomPart2() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart2/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart3") + public void testCompilationErrorThenFixedWithPhantomPart3() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart3/"); + } + + @TestMetadata("constantRemoved") + public void testConstantRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantRemoved/"); + } + + @TestMetadata("constantValueChanged") + public void testConstantValueChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantValueChanged/"); + } + + @TestMetadata("constantsUnchanged") + public void testConstantsUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantsUnchanged/"); + } + + @TestMetadata("defaultArgumentInConstructorAdded") + public void testDefaultArgumentInConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorAdded/"); + } + + @TestMetadata("defaultArgumentInConstructorRemoved") + public void testDefaultArgumentInConstructorRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorRemoved/"); + } + + @TestMetadata("defaultValueAdded") + public void testDefaultValueAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueAdded/"); + } + + @TestMetadata("defaultValueChanged") + public void testDefaultValueChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueChanged/"); + } + + @TestMetadata("defaultValueInConstructorChanged") + public void testDefaultValueInConstructorChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorChanged/"); + } + + @TestMetadata("defaultValueInConstructorRemoved") + public void testDefaultValueInConstructorRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorRemoved/"); + } + + @TestMetadata("defaultValueRemoved1") + public void testDefaultValueRemoved1() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved1/"); + } + + @TestMetadata("defaultValueRemoved2") + public void testDefaultValueRemoved2() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved2/"); + } + + @TestMetadata("delegatedPropertyInlineExtensionAccessor") + public void testDelegatedPropertyInlineExtensionAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineExtensionAccessor/"); + } + + @TestMetadata("delegatedPropertyInlineMethodAccessor") + public void testDelegatedPropertyInlineMethodAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineMethodAccessor/"); + } + + @TestMetadata("dependencyClassReferenced") + public void testDependencyClassReferenced() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/dependencyClassReferenced/"); + } + + @TestMetadata("fileWithConstantRemoved") + public void testFileWithConstantRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/fileWithConstantRemoved/"); + } + + @TestMetadata("fileWithInlineFunctionRemoved") + public void testFileWithInlineFunctionRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/"); + } + + @TestMetadata("filesExchangePackages") + public void testFilesExchangePackages() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/filesExchangePackages/"); + } + + @TestMetadata("funRedeclaration") + public void testFunRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/"); + } + + @TestMetadata("funVsConstructorOverloadConflict") + public void testFunVsConstructorOverloadConflict() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/"); + } + + @TestMetadata("functionBecameInline") + public void testFunctionBecameInline() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/functionBecameInline/"); + } + + @TestMetadata("functionReferencingClass") + public void testFunctionReferencingClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/functionReferencingClass/"); + } + + @TestMetadata("independentClasses") + public void testIndependentClasses() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/independentClasses/"); + } + + @TestMetadata("inlineFunctionBecomesNonInline") + public void testInlineFunctionBecomesNonInline() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionBecomesNonInline/"); + } + + @TestMetadata("inlineFunctionUsageAdded") + public void testInlineFunctionUsageAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionUsageAdded/"); + } + + @TestMetadata("inlineFunctionsCircularDependency") + public void testInlineFunctionsCircularDependency() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionsCircularDependency/"); + } + + @TestMetadata("inlineFunctionsUnchanged") + public void testInlineFunctionsUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionsUnchanged/"); + } + + @TestMetadata("inlineLinesChanged") + public void testInlineLinesChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineLinesChanged/"); + } + + @TestMetadata("inlineModifiedWithUsage") + public void testInlineModifiedWithUsage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineModifiedWithUsage/"); + } + + @TestMetadata("inlinePrivateFunctionAdded") + public void testInlinePrivateFunctionAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePrivateFunctionAdded/"); + } + + @TestMetadata("inlinePropertyInClass") + public void testInlinePropertyInClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/"); + } + + @TestMetadata("inlinePropertyOnTopLevel") + public void testInlinePropertyOnTopLevel() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/"); + } + + @TestMetadata("inlineSuspendFunctionChanged") + public void testInlineSuspendFunctionChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/"); + } + + @TestMetadata("inlineTwoFunctionsOneChanged") + public void testInlineTwoFunctionsOneChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineTwoFunctionsOneChanged/"); + } + + @TestMetadata("inlineUsedWhereDeclared") + public void testInlineUsedWhereDeclared() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineUsedWhereDeclared/"); + } + + @TestMetadata("innerClassesFromSupertypes") + public void testInnerClassesFromSupertypes() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/innerClassesFromSupertypes/"); + } + + @TestMetadata("internalClassChanged") + public void testInternalClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalClassChanged/"); + } + + @TestMetadata("internalMemberInClassChanged") + public void testInternalMemberInClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalMemberInClassChanged/"); + } + + @TestMetadata("internalTypealias") + public void testInternalTypealias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealias/"); + } + + @TestMetadata("internalTypealiasConstructor") + public void testInternalTypealiasConstructor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealiasConstructor/"); + } + + @TestMetadata("internalTypealiasObject") + public void testInternalTypealiasObject() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealiasObject/"); + } + + @TestMetadata("localClassChanged") + public void testLocalClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/localClassChanged/"); + } + + @TestMetadata("moveClass") + public void testMoveClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveClass/"); + } + + @TestMetadata("moveFileWithChangingPackage") + public void testMoveFileWithChangingPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveFileWithChangingPackage/"); + } + + @TestMetadata("moveFileWithoutChangingPackage") + public void testMoveFileWithoutChangingPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveFileWithoutChangingPackage/"); + } + + @TestMetadata("multiplePackagesModified") + public void testMultiplePackagesModified() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/multiplePackagesModified/"); + } + + @TestMetadata("objectConstantChanged") + public void testObjectConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/objectConstantChanged/"); + } + + @TestMetadata("ourClassReferenced") + public void testOurClassReferenced() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/ourClassReferenced/"); + } + + @TestMetadata("overloadInlined") + public void testOverloadInlined() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/overloadInlined/"); + } + + @TestMetadata("packageConstantChanged") + public void testPackageConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageConstantChanged/"); + } + + @TestMetadata("packageFileAdded") + public void testPackageFileAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileAdded/"); + } + + @TestMetadata("packageFileChangedPackage") + public void testPackageFileChangedPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileChangedPackage/"); + } + + @TestMetadata("packageFileChangedThenOtherRemoved") + public void testPackageFileChangedThenOtherRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileChangedThenOtherRemoved/"); + } + + @TestMetadata("packageFileRemoved") + public void testPackageFileRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileRemoved/"); + } + + @TestMetadata("packageFilesChangedInTurn") + public void testPackageFilesChangedInTurn() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFilesChangedInTurn/"); + } + + @TestMetadata("packageInlineFunctionAccessingField") + public void testPackageInlineFunctionAccessingField() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionAccessingField/"); + } + + @TestMetadata("packageInlineFunctionFromOurPackage") + public void testPackageInlineFunctionFromOurPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionFromOurPackage/"); + } + + @TestMetadata("packagePrivateOnlyChanged") + public void testPackagePrivateOnlyChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packagePrivateOnlyChanged/"); + } + + @TestMetadata("packageRecreated") + public void testPackageRecreated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRecreated/"); + } + + @TestMetadata("packageRecreatedAfterRenaming") + public void testPackageRecreatedAfterRenaming() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRecreatedAfterRenaming/"); + } + + @TestMetadata("packageRemoved") + public void testPackageRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRemoved/"); + } + + @TestMetadata("parameterWithDefaultValueAdded") + public void testParameterWithDefaultValueAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/parameterWithDefaultValueAdded/"); + } + + @TestMetadata("parameterWithDefaultValueRemoved") + public void testParameterWithDefaultValueRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/parameterWithDefaultValueRemoved/"); + } + + @TestMetadata("privateConstantsChanged") + public void testPrivateConstantsChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateConstantsChanged/"); + } + + @TestMetadata("privateMethodAdded") + public void testPrivateMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodAdded/"); + } + + @TestMetadata("privateMethodDeleted") + public void testPrivateMethodDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodDeleted/"); + } + + @TestMetadata("privateMethodSignatureChanged") + public void testPrivateMethodSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodSignatureChanged/"); + } + + @TestMetadata("privateSecondaryConstructorAdded") + public void testPrivateSecondaryConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorAdded/"); + } + + @TestMetadata("privateSecondaryConstructorDeleted") + public void testPrivateSecondaryConstructorDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorDeleted/"); + } + + @TestMetadata("privateValAccessorChanged") + public void testPrivateValAccessorChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValAccessorChanged/"); + } + + @TestMetadata("privateValAdded") + public void testPrivateValAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValAdded/"); + } + + @TestMetadata("privateValDeleted") + public void testPrivateValDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValDeleted/"); + } + + @TestMetadata("privateValSignatureChanged") + public void testPrivateValSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValSignatureChanged/"); + } + + @TestMetadata("privateVarAdded") + public void testPrivateVarAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarAdded/"); + } + + @TestMetadata("privateVarDeleted") + public void testPrivateVarDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarDeleted/"); + } + + @TestMetadata("privateVarSignatureChanged") + public void testPrivateVarSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarSignatureChanged/"); + } + + @TestMetadata("propertyRedeclaration") + public void testPropertyRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/"); + } + + @TestMetadata("publicPropertyWithPrivateSetter") + public void testPublicPropertyWithPrivateSetter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/publicPropertyWithPrivateSetter/"); + } + + @TestMetadata("removeAndRestoreCompanion") + public void testRemoveAndRestoreCompanion() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanion/"); + } + + @TestMetadata("removeAndRestoreCompanionWithImplicitUsages") + public void testRemoveAndRestoreCompanionWithImplicitUsages() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanionWithImplicitUsages/"); + } + + @TestMetadata("removeClass") + public void testRemoveClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeClass/"); + } + + @TestMetadata("removeClassInDefaultPackage") + public void testRemoveClassInDefaultPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeClassInDefaultPackage/"); + } + + @TestMetadata("removeFileWithFunctionOverload") + public void testRemoveFileWithFunctionOverload() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeFileWithFunctionOverload/"); + } + + @TestMetadata("removeMemberTypeAlias") + public void testRemoveMemberTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeMemberTypeAlias/"); + } + + @TestMetadata("removeTopLevelTypeAlias") + public void testRemoveTopLevelTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeTopLevelTypeAlias/"); + } + + @TestMetadata("removeUnusedFile") + public void testRemoveUnusedFile() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeUnusedFile/"); + } + + @TestMetadata("renameClass") + public void testRenameClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameClass/"); + } + + @TestMetadata("renameFileWithFunctionOverload") + public void testRenameFileWithFunctionOverload() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameFileWithFunctionOverload/"); + } + + @TestMetadata("returnTypeChanged") + public void testReturnTypeChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); + } + + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + + @TestMetadata("secondaryConstructorInlined") + public void testSecondaryConstructorInlined() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); + } + + @TestMetadata("serializedSubClassAndChangedInterfaces") + public void testSerializedSubClassAndChangedInterfaces() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/serializedSubClassAndChangedInterfaces/"); + } + + @TestMetadata("simpleClassDependency") + public void testSimpleClassDependency() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/simpleClassDependency/"); + } + + @TestMetadata("soleFileChangesPackage") + public void testSoleFileChangesPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/soleFileChangesPackage/"); + } + + @TestMetadata("subpackage") + public void testSubpackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/subpackage/"); + } + + @TestMetadata("suspendWithStateMachine") + public void testSuspendWithStateMachine() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/suspendWithStateMachine/"); + } + + @TestMetadata("topLevelFunctionSameSignature") + public void testTopLevelFunctionSameSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelFunctionSameSignature/"); + } + + @TestMetadata("topLevelMembersInTwoFiles") + public void testTopLevelMembersInTwoFiles() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelMembersInTwoFiles/"); + } + + @TestMetadata("topLevelPrivateValUsageAdded") + public void testTopLevelPrivateValUsageAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelPrivateValUsageAdded/"); + } + + @TestMetadata("traitClassObjectConstantChanged") + public void testTraitClassObjectConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/traitClassObjectConstantChanged/"); + } + + @TestMetadata("valAddCustomAccessor") + public void testValAddCustomAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/valAddCustomAccessor/"); + } + + @TestMetadata("valRemoveCustomAccessor") + public void testValRemoveCustomAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/valRemoveCustomAccessor/"); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/classHierarchyAffected") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassHierarchyAffected extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassHierarchyAffected() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + } + + @TestMetadata("annotationFlagRemoved") + public void testAnnotationFlagRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved/"); + } + + @TestMetadata("annotationListChanged") + public void testAnnotationListChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged/"); + } + + @TestMetadata("bridgeGenerated") + public void testBridgeGenerated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated/"); + } + + @TestMetadata("classBecameFinal") + public void testClassBecameFinal() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal/"); + } + + @TestMetadata("classBecameInterface") + public void testClassBecameInterface() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface/"); + } + + @TestMetadata("classBecamePrivate") + public void testClassBecamePrivate() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate/"); + } + + @TestMetadata("classMovedIntoOtherClass") + public void testClassMovedIntoOtherClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass/"); + } + + @TestMetadata("classRemoved") + public void testClassRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classRemoved/"); + } + + @TestMetadata("classRemovedAndRestored") + public void testClassRemovedAndRestored() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored/"); + } + + @TestMetadata("companionObjectInheritedMemberChanged") + public void testCompanionObjectInheritedMemberChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged/"); + } + + @TestMetadata("companionObjectMemberChanged") + public void testCompanionObjectMemberChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged/"); + } + + @TestMetadata("companionObjectNameChanged") + public void testCompanionObjectNameChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectNameChanged/"); + } + + @TestMetadata("companionObjectToSimpleObject") + public void testCompanionObjectToSimpleObject() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject/"); + } + + @TestMetadata("constructorVisibilityChanged") + public void testConstructorVisibilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged/"); + } + + @TestMetadata("enumEntryAdded") + public void testEnumEntryAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded/"); + } + + @TestMetadata("enumEntryRemoved") + public void testEnumEntryRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/"); + } + + @TestMetadata("enumMemberChanged") + public void testEnumMemberChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged/"); + } + + @TestMetadata("flagsAndMemberInDifferentClassesChanged") + public void testFlagsAndMemberInDifferentClassesChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged/"); + } + + @TestMetadata("flagsAndMemberInSameClassChanged") + public void testFlagsAndMemberInSameClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged/"); + } + + @TestMetadata("implcitUpcast") + public void testImplcitUpcast() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast/"); + } + + @TestMetadata("inferredTypeArgumentChanged") + public void testInferredTypeArgumentChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged/"); + } + + @TestMetadata("inferredTypeChanged") + public void testInferredTypeChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged/"); + } + + @TestMetadata("interfaceAnyMethods") + public void testInterfaceAnyMethods() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/interfaceAnyMethods/"); + } + + @TestMetadata("lambdaParameterAffected") + public void testLambdaParameterAffected() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected/"); + } + + @TestMetadata("methodAdded") + public void testMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodAdded/"); + } + + @TestMetadata("methodAnnotationAdded") + public void testMethodAnnotationAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded/"); + } + + @TestMetadata("methodNullabilityChanged") + public void testMethodNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged/"); + } + + @TestMetadata("methodParameterWithDefaultValueAdded") + public void testMethodParameterWithDefaultValueAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded/"); + } + + @TestMetadata("methodRemoved") + public void testMethodRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved/"); + } + + @TestMetadata("overrideExplicit") + public void testOverrideExplicit() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit/"); + } + + @TestMetadata("overrideImplicit") + public void testOverrideImplicit() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit/"); + } + + @TestMetadata("propertyNullabilityChanged") + public void testPropertyNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged/"); + } + + @TestMetadata("sealedClassImplAdded") + public void testSealedClassImplAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded/"); + } + + @TestMetadata("sealedClassIndirectImplAdded") + public void testSealedClassIndirectImplAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded/"); + } + + @TestMetadata("sealedClassNestedImplAdded") + public void testSealedClassNestedImplAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded/"); + } + + @TestMetadata("secondaryConstructorAdded") + public void testSecondaryConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/"); + } + + @TestMetadata("starProjectionUpperBoundChanged") + public void testStarProjectionUpperBoundChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged/"); + } + + @TestMetadata("supertypesListChanged") + public void testSupertypesListChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged/"); + } + + @TestMetadata("typeParameterListChanged") + public void testTypeParameterListChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged/"); + } + + @TestMetadata("varianceChanged") + public void testVarianceChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged/"); + } + + @TestMetadata("withIntermediateBodiesChanged") + public void testWithIntermediateBodiesChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/withIntermediateBodiesChanged/"); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunCallSite extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunCallSite() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("classProperty") + public void testClassProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/classProperty/"); + } + + @TestMetadata("companionObjectProperty") + public void testCompanionObjectProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty/"); + } + + @TestMetadata("coroutine") + public void testCoroutine() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/coroutine/"); + } + + @TestMetadata("function") + public void testFunction() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/function/"); + } + + @TestMetadata("functionIndirect") + public void testFunctionIndirect() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/functionIndirect/"); + } + + @TestMetadata("getter") + public void testGetter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/getter/"); + } + + @TestMetadata("lambda") + public void testLambda() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/lambda/"); + } + + @TestMetadata("localFun") + public void testLocalFun() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/localFun/"); + } + + @TestMetadata("method") + public void testMethod() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/method/"); + } + + @TestMetadata("parameterDefaultValue") + public void testParameterDefaultValue() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue/"); + } + + @TestMetadata("primaryConstructorParameterDefaultValue") + public void testPrimaryConstructorParameterDefaultValue() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue/"); + } + + @TestMetadata("superCall") + public void testSuperCall() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/superCall/"); + } + + @TestMetadata("thisCall") + public void testThisCall() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/thisCall/"); + } + + @TestMetadata("topLevelObjectProperty") + public void testTopLevelObjectProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty/"); + } + + @TestMetadata("topLevelProperty") + public void testTopLevelProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/classProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassProperty extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompanionObjectProperty extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInCompanionObjectProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/coroutine") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Coroutine extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInCoroutine() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/function") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Function extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/functionIndirect") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionIndirect extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunctionIndirect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/functionIndirect"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/getter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Getter extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInGetter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/lambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Lambda extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/localFun") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LocalFun extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInLocalFun() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/method") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Method extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethod() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ParameterDefaultValue extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInParameterDefaultValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrimaryConstructorParameterDefaultValue extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/superCall") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SuperCall extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInSuperCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/thisCall") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ThisCall extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInThisCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelObjectProperty extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelObjectProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelProperty extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithJava extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInWithJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConvertBetweenJavaAndKotlin extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("javaToKotlin") + public void testJavaToKotlin() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin/"); + } + + @TestMetadata("javaToKotlinAndBack") + public void testJavaToKotlinAndBack() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack/"); + } + + @TestMetadata("javaToKotlinAndRemove") + public void testJavaToKotlinAndRemove() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove/"); + } + + @TestMetadata("kotlinToJava") + public void testKotlinToJava() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaToKotlin extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaToKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaToKotlinAndBack extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaToKotlinAndRemove extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinToJava extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInKotlinToJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaUsedInKotlin extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaUsedInKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("changeFieldType") + public void testChangeFieldType() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/"); + } + + @TestMetadata("changeNotUsedSignature") + public void testChangeNotUsedSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature/"); + } + + @TestMetadata("changePropertyOverrideType") + public void testChangePropertyOverrideType() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/"); + } + + @TestMetadata("changeSignature") + public void testChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/"); + } + + @TestMetadata("changeSignaturePackagePrivate") + public void testChangeSignaturePackagePrivate() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/"); + } + + @TestMetadata("changeSignaturePackagePrivateNonRoot") + public void testChangeSignaturePackagePrivateNonRoot() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot/"); + } + + @TestMetadata("changeSignatureStatic") + public void testChangeSignatureStatic() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/"); + } + + @TestMetadata("constantChanged") + public void testConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/"); + } + + @TestMetadata("constantPropertyChanged") + public void testConstantPropertyChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/"); + } + + @TestMetadata("constantUnchanged") + public void testConstantUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/"); + } + + @TestMetadata("enumEntryAdded") + public void testEnumEntryAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded/"); + } + + @TestMetadata("enumEntryRemoved") + public void testEnumEntryRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved/"); + } + + @TestMetadata("javaAndKotlinChangedSimultaneously") + public void testJavaAndKotlinChangedSimultaneously() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously/"); + } + + @TestMetadata("javaFieldNullabilityChanged") + public void testJavaFieldNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged/"); + } + + @TestMetadata("javaMethodParamNullabilityChanged") + public void testJavaMethodParamNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged/"); + } + + @TestMetadata("javaMethodReturnTypeNullabilityChanged") + public void testJavaMethodReturnTypeNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged/"); + } + + @TestMetadata("methodAddedInSuper") + public void testMethodAddedInSuper() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper/"); + } + + @TestMetadata("methodRenamed") + public void testMethodRenamed() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed/"); + } + + @TestMetadata("mixedInheritance") + public void testMixedInheritance() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/"); + } + + @TestMetadata("notChangeSignature") + public void testNotChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/"); + } + + @TestMetadata("rawErrorTypeDuringSerialization") + public void testRawErrorTypeDuringSerialization() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/rawErrorTypeDuringSerialization/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeFieldType extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeFieldType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeNotUsedSignature extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangePropertyOverrideType extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangePropertyOverrideType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignature extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignaturePackagePrivate extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignaturePackagePrivateNonRoot extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignatureStatic extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignatureStatic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantPropertyChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantPropertyChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantUnchanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantUnchanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnumEntryAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInEnumEntryAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnumEntryRemoved extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInEnumEntryRemoved() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaAndKotlinChangedSimultaneously extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaFieldNullabilityChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaMethodParamNullabilityChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaMethodReturnTypeNullabilityChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddedInSuper extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddedInSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodRenamed extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodRenamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MixedInheritance extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMixedInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotChangeSignature extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInNotChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/rawErrorTypeDuringSerialization") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class RawErrorTypeDuringSerialization extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInRawErrorTypeDuringSerialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/rawErrorTypeDuringSerialization"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SamConversions extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInSamConversions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("methodAddDefault") + public void testMethodAddDefault() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddDefault/"); + } + + @TestMetadata("methodAdded") + public void testMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/"); + } + + @TestMetadata("methodAddedSamAdapter") + public void testMethodAddedSamAdapter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter/"); + } + + @TestMetadata("methodSignatureChanged") + public void testMethodSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged/"); + } + + @TestMetadata("methodSignatureChangedSamAdapter") + public void testMethodSignatureChangedSamAdapter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddDefault") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddDefault extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddedSamAdapter extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodSignatureChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodSignatureChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodSignatureChangedSamAdapter extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinUsedInJava extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("addOptionalParameter") + public void testAddOptionalParameter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter/"); + } + + public void testAllFilesPresentInKotlinUsedInJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("changeNotUsedSignature") + public void testChangeNotUsedSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature/"); + } + + @TestMetadata("changeSignature") + public void testChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature/"); + } + + @TestMetadata("constantChanged") + public void testConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged/"); + } + + @TestMetadata("constantUnchanged") + public void testConstantUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged/"); + } + + @TestMetadata("funRenamed") + public void testFunRenamed() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed/"); + } + + @TestMetadata("jvmFieldChanged") + public void testJvmFieldChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged/"); + } + + @TestMetadata("jvmFieldUnchanged") + public void testJvmFieldUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged/"); + } + + @TestMetadata("methodAddedInSuper") + public void testMethodAddedInSuper() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper/"); + } + + @TestMetadata("notChangeSignature") + public void testNotChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature/"); + } + + @TestMetadata("onlyTopLevelFunctionInFileRemoved") + public void testOnlyTopLevelFunctionInFileRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved/"); + } + + @TestMetadata("packageFileAdded") + public void testPackageFileAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded/"); + } + + @TestMetadata("privateChanges") + public void testPrivateChanges() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges/"); + } + + @TestMetadata("propertyRenamed") + public void testPropertyRenamed() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AddOptionalParameter extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAddOptionalParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeNotUsedSignature extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignature extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantUnchanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantUnchanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunRenamed extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunRenamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmFieldChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvmFieldChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmFieldUnchanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvmFieldUnchanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddedInSuper extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddedInSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotChangeSignature extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInNotChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OnlyTopLevelFunctionInFileRemoved extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageFileAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageFileAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrivateChanges extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPrivateChanges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PropertyRenamed extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPropertyRenamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Other extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("accessingFunctionsViaRenamedFileClass") + public void testAccessingFunctionsViaRenamedFileClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass/"); + } + + public void testAllFilesPresentInOther() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("allKotlinFilesRemovedThenNewAdded") + public void testAllKotlinFilesRemovedThenNewAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded/"); + } + + @TestMetadata("classRedeclaration") + public void testClassRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/classRedeclaration/"); + } + + @TestMetadata("classToPackageFacade") + public void testClassToPackageFacade() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/classToPackageFacade/"); + } + + @TestMetadata("conflictingPlatformDeclarations") + public void testConflictingPlatformDeclarations() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations/"); + } + + @TestMetadata("defaultValueInConstructorAdded") + public void testDefaultValueInConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded/"); + } + + @TestMetadata("inlineFunctionWithJvmNameInClass") + public void testInlineFunctionWithJvmNameInClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass/"); + } + + @TestMetadata("inlineTopLevelFunctionWithJvmName") + public void testInlineTopLevelFunctionWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName/"); + } + + @TestMetadata("inlineTopLevelValPropertyWithJvmName") + public void testInlineTopLevelValPropertyWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName/"); + } + + @TestMetadata("innerClassNotGeneratedWhenRebuilding") + public void testInnerClassNotGeneratedWhenRebuilding() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding/"); + } + + @TestMetadata("jvmNameChanged") + public void testJvmNameChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/jvmNameChanged/"); + } + + @TestMetadata("mainRedeclaration") + public void testMainRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/mainRedeclaration/"); + } + + @TestMetadata("multifileClassAddTopLevelFunWithDefault") + public void testMultifileClassAddTopLevelFunWithDefault() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault/"); + } + + @TestMetadata("multifileClassFileAdded") + public void testMultifileClassFileAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded/"); + } + + @TestMetadata("multifileClassFileChanged") + public void testMultifileClassFileChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged/"); + } + + @TestMetadata("multifileClassFileMovedToAnotherMultifileClass") + public void testMultifileClassFileMovedToAnotherMultifileClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass/"); + } + + @TestMetadata("multifileClassInlineFunction") + public void testMultifileClassInlineFunction() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction/"); + } + + @TestMetadata("multifileClassInlineFunctionAccessingField") + public void testMultifileClassInlineFunctionAccessingField() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField/"); + } + + @TestMetadata("multifileClassRecreated") + public void testMultifileClassRecreated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreated/"); + } + + @TestMetadata("multifileClassRecreatedAfterRenaming") + public void testMultifileClassRecreatedAfterRenaming() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming/"); + } + + @TestMetadata("multifileClassRemoved") + public void testMultifileClassRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRemoved/"); + } + + @TestMetadata("multifileDependantUsage") + public void testMultifileDependantUsage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileDependantUsage/"); + } + + @TestMetadata("multifilePackagePartMethodAdded") + public void testMultifilePackagePartMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded/"); + } + + @TestMetadata("multifilePartsWithProperties") + public void testMultifilePartsWithProperties() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties/"); + } + + @TestMetadata("optionalParameter") + public void testOptionalParameter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/optionalParameter/"); + } + + @TestMetadata("packageFacadeToClass") + public void testPackageFacadeToClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass/"); + } + + @TestMetadata("packageMultifileClassOneFileWithPublicChanges") + public void testPackageMultifileClassOneFileWithPublicChanges() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges/"); + } + + @TestMetadata("packageMultifileClassPrivateOnlyChanged") + public void testPackageMultifileClassPrivateOnlyChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged/"); + } + + @TestMetadata("publicPropertyWithPrivateSetterMultiFileFacade") + public void testPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade/"); + } + + @TestMetadata("topLevelFunctionWithJvmName") + public void testTopLevelFunctionWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName/"); + } + + @TestMetadata("topLevelPropertyWithJvmName") + public void testTopLevelPropertyWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AccessingFunctionsViaRenamedFileClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AllKotlinFilesRemovedThenNewAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/classRedeclaration") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassRedeclaration extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassRedeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/classToPackageFacade") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassToPackageFacade extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassToPackageFacade() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConflictingPlatformDeclarations extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultValueInConstructorAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionWithJvmNameInClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionWithJvmNameInClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineTopLevelFunctionWithJvmName extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineTopLevelValPropertyWithJvmName extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InnerClassNotGeneratedWhenRebuilding extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/jvmNameChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmNameChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvmNameChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/mainRedeclaration") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MainRedeclaration extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMainRedeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassAddTopLevelFunWithDefault extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassFileAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassFileAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassFileChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassFileChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassFileMovedToAnotherMultifileClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassInlineFunction extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassInlineFunctionAccessingField extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreated") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassRecreated extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassRecreated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassRecreatedAfterRenaming extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRemoved") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassRemoved extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassRemoved() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileDependantUsage") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileDependantUsage extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileDependantUsage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileDependantUsage"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifilePackagePartMethodAdded extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifilePartsWithProperties extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/optionalParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OptionalParameter extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOptionalParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageFacadeToClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageFacadeToClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageMultifileClassOneFileWithPublicChanges extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageMultifileClassPrivateOnlyChanged extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PublicPropertyWithPrivateSetterMultiFileFacade extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelFunctionWithJvmName extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelPropertyWithJvmName extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IncrementalJvmCompilerOnly extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("addAnnotationToJavaClass") + public void testAddAnnotationToJavaClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/"); + } + + @TestMetadata("addNestedClass") + public void testAddNestedClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/"); + } + + public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("changeAnnotationInJavaClass") + public void testChangeAnnotationInJavaClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/"); + } + + @TestMetadata("inlineFunctionRegeneratedObjectStability") + public void testInlineFunctionRegeneratedObjectStability() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability/"); + } + + @TestMetadata("inlineFunctionSmapStability") + public void testInlineFunctionSmapStability() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AddAnnotationToJavaClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAddAnnotationToJavaClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AddNestedClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAddNestedClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeAnnotationInJavaClass extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeAnnotationInJavaClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionRegeneratedObjectStability extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionRegeneratedObjectStability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionSmapStability extends AbstractIncrementalFirICLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionSmapStability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } +} diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalFirLightTreeJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalFirLightTreeJvmCompilerRunnerTestGenerated.java new file mode 100644 index 00000000000..9ac11b50cee --- /dev/null +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalFirLightTreeJvmCompilerRunnerTestGenerated.java @@ -0,0 +1,2707 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.incremental; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@RunWith(JUnit3RunnerWithInners.class) +public class IncrementalFirLightTreeJvmCompilerRunnerTestGenerated extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + @TestMetadata("jps/jps-plugin/testData/incremental/pureKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PureKotlin extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("accessingFunctionsViaPackagePart") + public void testAccessingFunctionsViaPackagePart() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/accessingFunctionsViaPackagePart/"); + } + + @TestMetadata("accessingPropertiesViaField") + public void testAccessingPropertiesViaField() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/accessingPropertiesViaField/"); + } + + @TestMetadata("addClass") + public void testAddClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addClass/"); + } + + @TestMetadata("addFileWithFunctionOverload") + public void testAddFileWithFunctionOverload() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addFileWithFunctionOverload/"); + } + + @TestMetadata("addMemberTypeAlias") + public void testAddMemberTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addMemberTypeAlias/"); + } + + @TestMetadata("addTopLevelTypeAlias") + public void testAddTopLevelTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/addTopLevelTypeAlias/"); + } + + @TestMetadata("allConstants") + public void testAllConstants() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/allConstants/"); + } + + public void testAllFilesPresentInPureKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + } + + @TestMetadata("annotations") + public void testAnnotations() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/annotations/"); + } + + @TestMetadata("anonymousObjectChanged") + public void testAnonymousObjectChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/anonymousObjectChanged/"); + } + + @TestMetadata("changeTypeImplicitlyWithCircularDependency") + public void testChangeTypeImplicitlyWithCircularDependency() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeTypeImplicitlyWithCircularDependency/"); + } + + @TestMetadata("changeWithRemovingUsage") + public void testChangeWithRemovingUsage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeWithRemovingUsage/"); + } + + @TestMetadata("classInlineFunctionChanged") + public void testClassInlineFunctionChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classInlineFunctionChanged/"); + } + + @TestMetadata("classObjectConstantChanged") + public void testClassObjectConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classObjectConstantChanged/"); + } + + @TestMetadata("classRecreated") + public void testClassRecreated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classRecreated/"); + } + + @TestMetadata("classRemoved") + public void testClassRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classRemoved/"); + } + + @TestMetadata("classSignatureChanged") + public void testClassSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classSignatureChanged/"); + } + + @TestMetadata("classSignatureUnchanged") + public void testClassSignatureUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/classSignatureUnchanged/"); + } + + @TestMetadata("companionConstantChanged") + public void testCompanionConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/companionConstantChanged/"); + } + + @TestMetadata("compilationErrorThenFixedOtherPackage") + public void testCompilationErrorThenFixedOtherPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedOtherPackage/"); + } + + @TestMetadata("compilationErrorThenFixedSamePackage") + public void testCompilationErrorThenFixedSamePackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedSamePackage/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart") + public void testCompilationErrorThenFixedWithPhantomPart() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart2") + public void testCompilationErrorThenFixedWithPhantomPart2() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart2/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart3") + public void testCompilationErrorThenFixedWithPhantomPart3() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart3/"); + } + + @TestMetadata("constantRemoved") + public void testConstantRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantRemoved/"); + } + + @TestMetadata("constantValueChanged") + public void testConstantValueChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantValueChanged/"); + } + + @TestMetadata("constantsUnchanged") + public void testConstantsUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantsUnchanged/"); + } + + @TestMetadata("defaultArgumentInConstructorAdded") + public void testDefaultArgumentInConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorAdded/"); + } + + @TestMetadata("defaultArgumentInConstructorRemoved") + public void testDefaultArgumentInConstructorRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorRemoved/"); + } + + @TestMetadata("defaultValueAdded") + public void testDefaultValueAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueAdded/"); + } + + @TestMetadata("defaultValueChanged") + public void testDefaultValueChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueChanged/"); + } + + @TestMetadata("defaultValueInConstructorChanged") + public void testDefaultValueInConstructorChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorChanged/"); + } + + @TestMetadata("defaultValueInConstructorRemoved") + public void testDefaultValueInConstructorRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorRemoved/"); + } + + @TestMetadata("defaultValueRemoved1") + public void testDefaultValueRemoved1() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved1/"); + } + + @TestMetadata("defaultValueRemoved2") + public void testDefaultValueRemoved2() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved2/"); + } + + @TestMetadata("delegatedPropertyInlineExtensionAccessor") + public void testDelegatedPropertyInlineExtensionAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineExtensionAccessor/"); + } + + @TestMetadata("delegatedPropertyInlineMethodAccessor") + public void testDelegatedPropertyInlineMethodAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineMethodAccessor/"); + } + + @TestMetadata("dependencyClassReferenced") + public void testDependencyClassReferenced() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/dependencyClassReferenced/"); + } + + @TestMetadata("fileWithConstantRemoved") + public void testFileWithConstantRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/fileWithConstantRemoved/"); + } + + @TestMetadata("fileWithInlineFunctionRemoved") + public void testFileWithInlineFunctionRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/"); + } + + @TestMetadata("filesExchangePackages") + public void testFilesExchangePackages() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/filesExchangePackages/"); + } + + @TestMetadata("funRedeclaration") + public void testFunRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/"); + } + + @TestMetadata("funVsConstructorOverloadConflict") + public void testFunVsConstructorOverloadConflict() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/"); + } + + @TestMetadata("functionBecameInline") + public void testFunctionBecameInline() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/functionBecameInline/"); + } + + @TestMetadata("functionReferencingClass") + public void testFunctionReferencingClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/functionReferencingClass/"); + } + + @TestMetadata("independentClasses") + public void testIndependentClasses() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/independentClasses/"); + } + + @TestMetadata("inlineFunctionBecomesNonInline") + public void testInlineFunctionBecomesNonInline() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionBecomesNonInline/"); + } + + @TestMetadata("inlineFunctionUsageAdded") + public void testInlineFunctionUsageAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionUsageAdded/"); + } + + @TestMetadata("inlineFunctionsCircularDependency") + public void testInlineFunctionsCircularDependency() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionsCircularDependency/"); + } + + @TestMetadata("inlineFunctionsUnchanged") + public void testInlineFunctionsUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionsUnchanged/"); + } + + @TestMetadata("inlineLinesChanged") + public void testInlineLinesChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineLinesChanged/"); + } + + @TestMetadata("inlineModifiedWithUsage") + public void testInlineModifiedWithUsage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineModifiedWithUsage/"); + } + + @TestMetadata("inlinePrivateFunctionAdded") + public void testInlinePrivateFunctionAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePrivateFunctionAdded/"); + } + + @TestMetadata("inlinePropertyInClass") + public void testInlinePropertyInClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/"); + } + + @TestMetadata("inlinePropertyOnTopLevel") + public void testInlinePropertyOnTopLevel() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/"); + } + + @TestMetadata("inlineSuspendFunctionChanged") + public void testInlineSuspendFunctionChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/"); + } + + @TestMetadata("inlineTwoFunctionsOneChanged") + public void testInlineTwoFunctionsOneChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineTwoFunctionsOneChanged/"); + } + + @TestMetadata("inlineUsedWhereDeclared") + public void testInlineUsedWhereDeclared() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineUsedWhereDeclared/"); + } + + @TestMetadata("innerClassesFromSupertypes") + public void testInnerClassesFromSupertypes() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/innerClassesFromSupertypes/"); + } + + @TestMetadata("internalClassChanged") + public void testInternalClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalClassChanged/"); + } + + @TestMetadata("internalMemberInClassChanged") + public void testInternalMemberInClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalMemberInClassChanged/"); + } + + @TestMetadata("internalTypealias") + public void testInternalTypealias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealias/"); + } + + @TestMetadata("internalTypealiasConstructor") + public void testInternalTypealiasConstructor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealiasConstructor/"); + } + + @TestMetadata("internalTypealiasObject") + public void testInternalTypealiasObject() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealiasObject/"); + } + + @TestMetadata("localClassChanged") + public void testLocalClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/localClassChanged/"); + } + + @TestMetadata("moveClass") + public void testMoveClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveClass/"); + } + + @TestMetadata("moveFileWithChangingPackage") + public void testMoveFileWithChangingPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveFileWithChangingPackage/"); + } + + @TestMetadata("moveFileWithoutChangingPackage") + public void testMoveFileWithoutChangingPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveFileWithoutChangingPackage/"); + } + + @TestMetadata("multiplePackagesModified") + public void testMultiplePackagesModified() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/multiplePackagesModified/"); + } + + @TestMetadata("objectConstantChanged") + public void testObjectConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/objectConstantChanged/"); + } + + @TestMetadata("ourClassReferenced") + public void testOurClassReferenced() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/ourClassReferenced/"); + } + + @TestMetadata("overloadInlined") + public void testOverloadInlined() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/overloadInlined/"); + } + + @TestMetadata("packageConstantChanged") + public void testPackageConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageConstantChanged/"); + } + + @TestMetadata("packageFileAdded") + public void testPackageFileAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileAdded/"); + } + + @TestMetadata("packageFileChangedPackage") + public void testPackageFileChangedPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileChangedPackage/"); + } + + @TestMetadata("packageFileChangedThenOtherRemoved") + public void testPackageFileChangedThenOtherRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileChangedThenOtherRemoved/"); + } + + @TestMetadata("packageFileRemoved") + public void testPackageFileRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileRemoved/"); + } + + @TestMetadata("packageFilesChangedInTurn") + public void testPackageFilesChangedInTurn() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFilesChangedInTurn/"); + } + + @TestMetadata("packageInlineFunctionAccessingField") + public void testPackageInlineFunctionAccessingField() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionAccessingField/"); + } + + @TestMetadata("packageInlineFunctionFromOurPackage") + public void testPackageInlineFunctionFromOurPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionFromOurPackage/"); + } + + @TestMetadata("packagePrivateOnlyChanged") + public void testPackagePrivateOnlyChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packagePrivateOnlyChanged/"); + } + + @TestMetadata("packageRecreated") + public void testPackageRecreated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRecreated/"); + } + + @TestMetadata("packageRecreatedAfterRenaming") + public void testPackageRecreatedAfterRenaming() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRecreatedAfterRenaming/"); + } + + @TestMetadata("packageRemoved") + public void testPackageRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRemoved/"); + } + + @TestMetadata("parameterWithDefaultValueAdded") + public void testParameterWithDefaultValueAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/parameterWithDefaultValueAdded/"); + } + + @TestMetadata("parameterWithDefaultValueRemoved") + public void testParameterWithDefaultValueRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/parameterWithDefaultValueRemoved/"); + } + + @TestMetadata("privateConstantsChanged") + public void testPrivateConstantsChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateConstantsChanged/"); + } + + @TestMetadata("privateMethodAdded") + public void testPrivateMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodAdded/"); + } + + @TestMetadata("privateMethodDeleted") + public void testPrivateMethodDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodDeleted/"); + } + + @TestMetadata("privateMethodSignatureChanged") + public void testPrivateMethodSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodSignatureChanged/"); + } + + @TestMetadata("privateSecondaryConstructorAdded") + public void testPrivateSecondaryConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorAdded/"); + } + + @TestMetadata("privateSecondaryConstructorDeleted") + public void testPrivateSecondaryConstructorDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorDeleted/"); + } + + @TestMetadata("privateValAccessorChanged") + public void testPrivateValAccessorChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValAccessorChanged/"); + } + + @TestMetadata("privateValAdded") + public void testPrivateValAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValAdded/"); + } + + @TestMetadata("privateValDeleted") + public void testPrivateValDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValDeleted/"); + } + + @TestMetadata("privateValSignatureChanged") + public void testPrivateValSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValSignatureChanged/"); + } + + @TestMetadata("privateVarAdded") + public void testPrivateVarAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarAdded/"); + } + + @TestMetadata("privateVarDeleted") + public void testPrivateVarDeleted() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarDeleted/"); + } + + @TestMetadata("privateVarSignatureChanged") + public void testPrivateVarSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarSignatureChanged/"); + } + + @TestMetadata("propertyRedeclaration") + public void testPropertyRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/"); + } + + @TestMetadata("publicPropertyWithPrivateSetter") + public void testPublicPropertyWithPrivateSetter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/publicPropertyWithPrivateSetter/"); + } + + @TestMetadata("removeAndRestoreCompanion") + public void testRemoveAndRestoreCompanion() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanion/"); + } + + @TestMetadata("removeAndRestoreCompanionWithImplicitUsages") + public void testRemoveAndRestoreCompanionWithImplicitUsages() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanionWithImplicitUsages/"); + } + + @TestMetadata("removeClass") + public void testRemoveClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeClass/"); + } + + @TestMetadata("removeClassInDefaultPackage") + public void testRemoveClassInDefaultPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeClassInDefaultPackage/"); + } + + @TestMetadata("removeFileWithFunctionOverload") + public void testRemoveFileWithFunctionOverload() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeFileWithFunctionOverload/"); + } + + @TestMetadata("removeMemberTypeAlias") + public void testRemoveMemberTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeMemberTypeAlias/"); + } + + @TestMetadata("removeTopLevelTypeAlias") + public void testRemoveTopLevelTypeAlias() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeTopLevelTypeAlias/"); + } + + @TestMetadata("removeUnusedFile") + public void testRemoveUnusedFile() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeUnusedFile/"); + } + + @TestMetadata("renameClass") + public void testRenameClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameClass/"); + } + + @TestMetadata("renameFileWithFunctionOverload") + public void testRenameFileWithFunctionOverload() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameFileWithFunctionOverload/"); + } + + @TestMetadata("returnTypeChanged") + public void testReturnTypeChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); + } + + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + + @TestMetadata("secondaryConstructorInlined") + public void testSecondaryConstructorInlined() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); + } + + @TestMetadata("serializedSubClassAndChangedInterfaces") + public void testSerializedSubClassAndChangedInterfaces() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/serializedSubClassAndChangedInterfaces/"); + } + + @TestMetadata("simpleClassDependency") + public void testSimpleClassDependency() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/simpleClassDependency/"); + } + + @TestMetadata("soleFileChangesPackage") + public void testSoleFileChangesPackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/soleFileChangesPackage/"); + } + + @TestMetadata("subpackage") + public void testSubpackage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/subpackage/"); + } + + @TestMetadata("suspendWithStateMachine") + public void testSuspendWithStateMachine() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/suspendWithStateMachine/"); + } + + @TestMetadata("topLevelFunctionSameSignature") + public void testTopLevelFunctionSameSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelFunctionSameSignature/"); + } + + @TestMetadata("topLevelMembersInTwoFiles") + public void testTopLevelMembersInTwoFiles() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelMembersInTwoFiles/"); + } + + @TestMetadata("topLevelPrivateValUsageAdded") + public void testTopLevelPrivateValUsageAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelPrivateValUsageAdded/"); + } + + @TestMetadata("traitClassObjectConstantChanged") + public void testTraitClassObjectConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/traitClassObjectConstantChanged/"); + } + + @TestMetadata("valAddCustomAccessor") + public void testValAddCustomAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/valAddCustomAccessor/"); + } + + @TestMetadata("valRemoveCustomAccessor") + public void testValRemoveCustomAccessor() throws Exception { + runTest("jps/jps-plugin/testData/incremental/pureKotlin/valRemoveCustomAccessor/"); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/classHierarchyAffected") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassHierarchyAffected extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassHierarchyAffected() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + } + + @TestMetadata("annotationFlagRemoved") + public void testAnnotationFlagRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved/"); + } + + @TestMetadata("annotationListChanged") + public void testAnnotationListChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged/"); + } + + @TestMetadata("bridgeGenerated") + public void testBridgeGenerated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated/"); + } + + @TestMetadata("classBecameFinal") + public void testClassBecameFinal() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal/"); + } + + @TestMetadata("classBecameInterface") + public void testClassBecameInterface() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface/"); + } + + @TestMetadata("classBecamePrivate") + public void testClassBecamePrivate() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate/"); + } + + @TestMetadata("classMovedIntoOtherClass") + public void testClassMovedIntoOtherClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass/"); + } + + @TestMetadata("classRemoved") + public void testClassRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classRemoved/"); + } + + @TestMetadata("classRemovedAndRestored") + public void testClassRemovedAndRestored() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored/"); + } + + @TestMetadata("companionObjectInheritedMemberChanged") + public void testCompanionObjectInheritedMemberChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged/"); + } + + @TestMetadata("companionObjectMemberChanged") + public void testCompanionObjectMemberChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged/"); + } + + @TestMetadata("companionObjectNameChanged") + public void testCompanionObjectNameChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectNameChanged/"); + } + + @TestMetadata("companionObjectToSimpleObject") + public void testCompanionObjectToSimpleObject() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject/"); + } + + @TestMetadata("constructorVisibilityChanged") + public void testConstructorVisibilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged/"); + } + + @TestMetadata("enumEntryAdded") + public void testEnumEntryAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded/"); + } + + @TestMetadata("enumEntryRemoved") + public void testEnumEntryRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/"); + } + + @TestMetadata("enumMemberChanged") + public void testEnumMemberChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged/"); + } + + @TestMetadata("flagsAndMemberInDifferentClassesChanged") + public void testFlagsAndMemberInDifferentClassesChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged/"); + } + + @TestMetadata("flagsAndMemberInSameClassChanged") + public void testFlagsAndMemberInSameClassChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged/"); + } + + @TestMetadata("implcitUpcast") + public void testImplcitUpcast() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast/"); + } + + @TestMetadata("inferredTypeArgumentChanged") + public void testInferredTypeArgumentChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged/"); + } + + @TestMetadata("inferredTypeChanged") + public void testInferredTypeChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged/"); + } + + @TestMetadata("interfaceAnyMethods") + public void testInterfaceAnyMethods() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/interfaceAnyMethods/"); + } + + @TestMetadata("lambdaParameterAffected") + public void testLambdaParameterAffected() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected/"); + } + + @TestMetadata("methodAdded") + public void testMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodAdded/"); + } + + @TestMetadata("methodAnnotationAdded") + public void testMethodAnnotationAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded/"); + } + + @TestMetadata("methodNullabilityChanged") + public void testMethodNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged/"); + } + + @TestMetadata("methodParameterWithDefaultValueAdded") + public void testMethodParameterWithDefaultValueAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded/"); + } + + @TestMetadata("methodRemoved") + public void testMethodRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved/"); + } + + @TestMetadata("overrideExplicit") + public void testOverrideExplicit() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit/"); + } + + @TestMetadata("overrideImplicit") + public void testOverrideImplicit() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit/"); + } + + @TestMetadata("propertyNullabilityChanged") + public void testPropertyNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged/"); + } + + @TestMetadata("sealedClassImplAdded") + public void testSealedClassImplAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded/"); + } + + @TestMetadata("sealedClassIndirectImplAdded") + public void testSealedClassIndirectImplAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded/"); + } + + @TestMetadata("sealedClassNestedImplAdded") + public void testSealedClassNestedImplAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded/"); + } + + @TestMetadata("secondaryConstructorAdded") + public void testSecondaryConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/"); + } + + @TestMetadata("starProjectionUpperBoundChanged") + public void testStarProjectionUpperBoundChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged/"); + } + + @TestMetadata("supertypesListChanged") + public void testSupertypesListChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged/"); + } + + @TestMetadata("typeParameterListChanged") + public void testTypeParameterListChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged/"); + } + + @TestMetadata("varianceChanged") + public void testVarianceChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged/"); + } + + @TestMetadata("withIntermediateBodiesChanged") + public void testWithIntermediateBodiesChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/withIntermediateBodiesChanged/"); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunCallSite extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunCallSite() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("classProperty") + public void testClassProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/classProperty/"); + } + + @TestMetadata("companionObjectProperty") + public void testCompanionObjectProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty/"); + } + + @TestMetadata("coroutine") + public void testCoroutine() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/coroutine/"); + } + + @TestMetadata("function") + public void testFunction() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/function/"); + } + + @TestMetadata("functionIndirect") + public void testFunctionIndirect() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/functionIndirect/"); + } + + @TestMetadata("getter") + public void testGetter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/getter/"); + } + + @TestMetadata("lambda") + public void testLambda() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/lambda/"); + } + + @TestMetadata("localFun") + public void testLocalFun() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/localFun/"); + } + + @TestMetadata("method") + public void testMethod() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/method/"); + } + + @TestMetadata("parameterDefaultValue") + public void testParameterDefaultValue() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue/"); + } + + @TestMetadata("primaryConstructorParameterDefaultValue") + public void testPrimaryConstructorParameterDefaultValue() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue/"); + } + + @TestMetadata("superCall") + public void testSuperCall() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/superCall/"); + } + + @TestMetadata("thisCall") + public void testThisCall() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/thisCall/"); + } + + @TestMetadata("topLevelObjectProperty") + public void testTopLevelObjectProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty/"); + } + + @TestMetadata("topLevelProperty") + public void testTopLevelProperty() throws Exception { + runTest("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/classProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassProperty extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompanionObjectProperty extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInCompanionObjectProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/coroutine") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Coroutine extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInCoroutine() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/function") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Function extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/functionIndirect") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionIndirect extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunctionIndirect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/functionIndirect"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/getter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Getter extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInGetter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/lambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Lambda extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/localFun") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LocalFun extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInLocalFun() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/method") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Method extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethod() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ParameterDefaultValue extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInParameterDefaultValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrimaryConstructorParameterDefaultValue extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/superCall") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SuperCall extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInSuperCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/thisCall") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ThisCall extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInThisCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelObjectProperty extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelObjectProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelProperty extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithJava extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInWithJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConvertBetweenJavaAndKotlin extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("javaToKotlin") + public void testJavaToKotlin() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin/"); + } + + @TestMetadata("javaToKotlinAndBack") + public void testJavaToKotlinAndBack() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack/"); + } + + @TestMetadata("javaToKotlinAndRemove") + public void testJavaToKotlinAndRemove() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove/"); + } + + @TestMetadata("kotlinToJava") + public void testKotlinToJava() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaToKotlin extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaToKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaToKotlinAndBack extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaToKotlinAndRemove extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinToJava extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInKotlinToJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaUsedInKotlin extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaUsedInKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("changeFieldType") + public void testChangeFieldType() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/"); + } + + @TestMetadata("changeNotUsedSignature") + public void testChangeNotUsedSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature/"); + } + + @TestMetadata("changePropertyOverrideType") + public void testChangePropertyOverrideType() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/"); + } + + @TestMetadata("changeSignature") + public void testChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/"); + } + + @TestMetadata("changeSignaturePackagePrivate") + public void testChangeSignaturePackagePrivate() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/"); + } + + @TestMetadata("changeSignaturePackagePrivateNonRoot") + public void testChangeSignaturePackagePrivateNonRoot() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot/"); + } + + @TestMetadata("changeSignatureStatic") + public void testChangeSignatureStatic() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/"); + } + + @TestMetadata("constantChanged") + public void testConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/"); + } + + @TestMetadata("constantPropertyChanged") + public void testConstantPropertyChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/"); + } + + @TestMetadata("constantUnchanged") + public void testConstantUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/"); + } + + @TestMetadata("enumEntryAdded") + public void testEnumEntryAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded/"); + } + + @TestMetadata("enumEntryRemoved") + public void testEnumEntryRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved/"); + } + + @TestMetadata("javaAndKotlinChangedSimultaneously") + public void testJavaAndKotlinChangedSimultaneously() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously/"); + } + + @TestMetadata("javaFieldNullabilityChanged") + public void testJavaFieldNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged/"); + } + + @TestMetadata("javaMethodParamNullabilityChanged") + public void testJavaMethodParamNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged/"); + } + + @TestMetadata("javaMethodReturnTypeNullabilityChanged") + public void testJavaMethodReturnTypeNullabilityChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged/"); + } + + @TestMetadata("methodAddedInSuper") + public void testMethodAddedInSuper() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper/"); + } + + @TestMetadata("methodRenamed") + public void testMethodRenamed() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed/"); + } + + @TestMetadata("mixedInheritance") + public void testMixedInheritance() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/"); + } + + @TestMetadata("notChangeSignature") + public void testNotChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/"); + } + + @TestMetadata("rawErrorTypeDuringSerialization") + public void testRawErrorTypeDuringSerialization() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/rawErrorTypeDuringSerialization/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeFieldType extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeFieldType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeNotUsedSignature extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangePropertyOverrideType extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangePropertyOverrideType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignature extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignaturePackagePrivate extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignaturePackagePrivateNonRoot extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignatureStatic extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignatureStatic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantPropertyChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantPropertyChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantUnchanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantUnchanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnumEntryAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInEnumEntryAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnumEntryRemoved extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInEnumEntryRemoved() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaAndKotlinChangedSimultaneously extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaFieldNullabilityChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaMethodParamNullabilityChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaMethodReturnTypeNullabilityChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddedInSuper extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddedInSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodRenamed extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodRenamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MixedInheritance extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMixedInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotChangeSignature extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInNotChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/rawErrorTypeDuringSerialization") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class RawErrorTypeDuringSerialization extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInRawErrorTypeDuringSerialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/rawErrorTypeDuringSerialization"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SamConversions extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInSamConversions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("methodAddDefault") + public void testMethodAddDefault() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddDefault/"); + } + + @TestMetadata("methodAdded") + public void testMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/"); + } + + @TestMetadata("methodAddedSamAdapter") + public void testMethodAddedSamAdapter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter/"); + } + + @TestMetadata("methodSignatureChanged") + public void testMethodSignatureChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged/"); + } + + @TestMetadata("methodSignatureChangedSamAdapter") + public void testMethodSignatureChangedSamAdapter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddDefault") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddDefault extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddedSamAdapter extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodSignatureChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodSignatureChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodSignatureChangedSamAdapter extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinUsedInJava extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("addOptionalParameter") + public void testAddOptionalParameter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter/"); + } + + public void testAllFilesPresentInKotlinUsedInJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("changeNotUsedSignature") + public void testChangeNotUsedSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature/"); + } + + @TestMetadata("changeSignature") + public void testChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature/"); + } + + @TestMetadata("constantChanged") + public void testConstantChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged/"); + } + + @TestMetadata("constantUnchanged") + public void testConstantUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged/"); + } + + @TestMetadata("funRenamed") + public void testFunRenamed() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed/"); + } + + @TestMetadata("jvmFieldChanged") + public void testJvmFieldChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged/"); + } + + @TestMetadata("jvmFieldUnchanged") + public void testJvmFieldUnchanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged/"); + } + + @TestMetadata("methodAddedInSuper") + public void testMethodAddedInSuper() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper/"); + } + + @TestMetadata("notChangeSignature") + public void testNotChangeSignature() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature/"); + } + + @TestMetadata("onlyTopLevelFunctionInFileRemoved") + public void testOnlyTopLevelFunctionInFileRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved/"); + } + + @TestMetadata("packageFileAdded") + public void testPackageFileAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded/"); + } + + @TestMetadata("privateChanges") + public void testPrivateChanges() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges/"); + } + + @TestMetadata("propertyRenamed") + public void testPropertyRenamed() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AddOptionalParameter extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAddOptionalParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeNotUsedSignature extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeSignature extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstantUnchanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConstantUnchanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunRenamed extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunRenamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmFieldChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvmFieldChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmFieldUnchanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvmFieldUnchanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodAddedInSuper extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMethodAddedInSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotChangeSignature extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInNotChangeSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OnlyTopLevelFunctionInFileRemoved extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageFileAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageFileAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrivateChanges extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPrivateChanges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PropertyRenamed extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPropertyRenamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Other extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("accessingFunctionsViaRenamedFileClass") + public void testAccessingFunctionsViaRenamedFileClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass/"); + } + + public void testAllFilesPresentInOther() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("allKotlinFilesRemovedThenNewAdded") + public void testAllKotlinFilesRemovedThenNewAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded/"); + } + + @TestMetadata("classRedeclaration") + public void testClassRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/classRedeclaration/"); + } + + @TestMetadata("classToPackageFacade") + public void testClassToPackageFacade() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/classToPackageFacade/"); + } + + @TestMetadata("conflictingPlatformDeclarations") + public void testConflictingPlatformDeclarations() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations/"); + } + + @TestMetadata("defaultValueInConstructorAdded") + public void testDefaultValueInConstructorAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded/"); + } + + @TestMetadata("inlineFunctionWithJvmNameInClass") + public void testInlineFunctionWithJvmNameInClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass/"); + } + + @TestMetadata("inlineTopLevelFunctionWithJvmName") + public void testInlineTopLevelFunctionWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName/"); + } + + @TestMetadata("inlineTopLevelValPropertyWithJvmName") + public void testInlineTopLevelValPropertyWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName/"); + } + + @TestMetadata("innerClassNotGeneratedWhenRebuilding") + public void testInnerClassNotGeneratedWhenRebuilding() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding/"); + } + + @TestMetadata("jvmNameChanged") + public void testJvmNameChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/jvmNameChanged/"); + } + + @TestMetadata("mainRedeclaration") + public void testMainRedeclaration() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/mainRedeclaration/"); + } + + @TestMetadata("multifileClassAddTopLevelFunWithDefault") + public void testMultifileClassAddTopLevelFunWithDefault() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault/"); + } + + @TestMetadata("multifileClassFileAdded") + public void testMultifileClassFileAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded/"); + } + + @TestMetadata("multifileClassFileChanged") + public void testMultifileClassFileChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged/"); + } + + @TestMetadata("multifileClassFileMovedToAnotherMultifileClass") + public void testMultifileClassFileMovedToAnotherMultifileClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass/"); + } + + @TestMetadata("multifileClassInlineFunction") + public void testMultifileClassInlineFunction() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction/"); + } + + @TestMetadata("multifileClassInlineFunctionAccessingField") + public void testMultifileClassInlineFunctionAccessingField() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField/"); + } + + @TestMetadata("multifileClassRecreated") + public void testMultifileClassRecreated() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreated/"); + } + + @TestMetadata("multifileClassRecreatedAfterRenaming") + public void testMultifileClassRecreatedAfterRenaming() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming/"); + } + + @TestMetadata("multifileClassRemoved") + public void testMultifileClassRemoved() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRemoved/"); + } + + @TestMetadata("multifileDependantUsage") + public void testMultifileDependantUsage() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifileDependantUsage/"); + } + + @TestMetadata("multifilePackagePartMethodAdded") + public void testMultifilePackagePartMethodAdded() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded/"); + } + + @TestMetadata("multifilePartsWithProperties") + public void testMultifilePartsWithProperties() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties/"); + } + + @TestMetadata("optionalParameter") + public void testOptionalParameter() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/optionalParameter/"); + } + + @TestMetadata("packageFacadeToClass") + public void testPackageFacadeToClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass/"); + } + + @TestMetadata("packageMultifileClassOneFileWithPublicChanges") + public void testPackageMultifileClassOneFileWithPublicChanges() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges/"); + } + + @TestMetadata("packageMultifileClassPrivateOnlyChanged") + public void testPackageMultifileClassPrivateOnlyChanged() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged/"); + } + + @TestMetadata("publicPropertyWithPrivateSetterMultiFileFacade") + public void testPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade/"); + } + + @TestMetadata("topLevelFunctionWithJvmName") + public void testTopLevelFunctionWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName/"); + } + + @TestMetadata("topLevelPropertyWithJvmName") + public void testTopLevelPropertyWithJvmName() throws Exception { + runTest("jps/jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AccessingFunctionsViaRenamedFileClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AllKotlinFilesRemovedThenNewAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/classRedeclaration") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassRedeclaration extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassRedeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/classToPackageFacade") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassToPackageFacade extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInClassToPackageFacade() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConflictingPlatformDeclarations extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultValueInConstructorAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionWithJvmNameInClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionWithJvmNameInClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineTopLevelFunctionWithJvmName extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineTopLevelValPropertyWithJvmName extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InnerClassNotGeneratedWhenRebuilding extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/jvmNameChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmNameChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvmNameChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/mainRedeclaration") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MainRedeclaration extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMainRedeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassAddTopLevelFunWithDefault extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassFileAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassFileAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassFileChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassFileChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassFileMovedToAnotherMultifileClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassInlineFunction extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassInlineFunctionAccessingField extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreated") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassRecreated extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassRecreated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassRecreatedAfterRenaming extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRemoved") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClassRemoved extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileClassRemoved() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifileDependantUsage") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileDependantUsage extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifileDependantUsage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifileDependantUsage"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifilePackagePartMethodAdded extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifilePartsWithProperties extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/optionalParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OptionalParameter extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOptionalParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageFacadeToClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageFacadeToClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageMultifileClassOneFileWithPublicChanges extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageMultifileClassPrivateOnlyChanged extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PublicPropertyWithPrivateSetterMultiFileFacade extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelFunctionWithJvmName extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelPropertyWithJvmName extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IncrementalJvmCompilerOnly extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("addAnnotationToJavaClass") + public void testAddAnnotationToJavaClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/"); + } + + @TestMetadata("addNestedClass") + public void testAddNestedClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/"); + } + + public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("changeAnnotationInJavaClass") + public void testChangeAnnotationInJavaClass() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/"); + } + + @TestMetadata("inlineFunctionRegeneratedObjectStability") + public void testInlineFunctionRegeneratedObjectStability() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability/"); + } + + @TestMetadata("inlineFunctionSmapStability") + public void testInlineFunctionSmapStability() throws Exception { + runTest("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability/"); + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AddAnnotationToJavaClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAddAnnotationToJavaClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AddNestedClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInAddNestedClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ChangeAnnotationInJavaClass extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInChangeAnnotationInJavaClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionRegeneratedObjectStability extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionRegeneratedObjectStability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + + @TestMetadata("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionSmapStability extends AbstractIncrementalFirLightTreeJvmCompilerRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionSmapStability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/ir/AbstractIrTextTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/ir/AbstractIrTextTest.kt index 8589b70c548..c4165c03def 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/ir/AbstractIrTextTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/ir/AbstractIrTextTest.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.test.builders.firHandlersStep import org.jetbrains.kotlin.test.builders.irHandlersStep import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_IR import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_KT_IR +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade @@ -122,3 +123,14 @@ open class AbstractFir2IrTextTest : AbstractIrTextTestBase() } } } + +open class AbstractLightTreeFir2IrTextTest : AbstractFir2IrTextTest() { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + with (builder) { + defaultDirectives { + +FirDiagnosticsDirectives.USE_LIGHT_TREE + } + } + } +} \ No newline at end of file diff --git a/compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit5CompilerTests.kt b/compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit5CompilerTests.kt index 1abece31ed4..d3c99e14646 100644 --- a/compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit5CompilerTests.kt +++ b/compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit5CompilerTests.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.test.runners.* import org.jetbrains.kotlin.test.runners.codegen.* import org.jetbrains.kotlin.test.runners.ir.AbstractFir2IrTextTest import org.jetbrains.kotlin.test.runners.ir.AbstractIrTextTest +import org.jetbrains.kotlin.test.runners.ir.AbstractLightTreeFir2IrTextTest import org.jetbrains.kotlin.test.runners.ir.interpreter.AbstractIrInterpreterAfterFir2IrTest import org.jetbrains.kotlin.test.runners.ir.interpreter.AbstractIrInterpreterAfterPsi2IrTest import org.jetbrains.kotlin.visualizer.fir.AbstractFirVisualizerTest @@ -253,6 +254,12 @@ fun generateJUnit5CompilerTests(args: Array) { model("ir/irText") } + testClass( + suiteTestClassName = "LightTreeFir2IrSpecificTextTestGenerated" + ) { + model("ir/irText") + } + testClass( suiteTestClassName = "Fir2IrSpecificBytecodeListingTestGenerated" ) { @@ -277,6 +284,10 @@ fun generateJUnit5CompilerTests(args: Array) { model("ir/irText") } + testClass { + model("ir/irText") + } + testClass { model("codegen/bytecodeText") } diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 07ab2b935b9..25ff363549e 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -53,6 +53,8 @@ fun main(args: Array) { testClass(init = incrementalJvmTestData(TargetBackend.JVM_IR)) testClass(init = incrementalJvmTestData(TargetBackend.JVM)) testClass(init = incrementalJvmTestData(TargetBackend.JVM_IR)) + testClass(init = incrementalJvmTestData(TargetBackend.JVM_IR)) + testClass(init = incrementalJvmTestData(TargetBackend.JVM_IR)) testClass { model("incremental/pureKotlin", extension = null, recursive = false)