From e20f72fcf848bba98005bc95df05a3bdb0bdc76c Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Wed, 22 Feb 2023 17:17:38 +0100 Subject: [PATCH] [SLC] introduce tests on equality ^KT-56613 --- ...tSymbolLightClassesEqualityByFqNameTest.kt | 26 + ...ractSymbolLightClassesEqualityByPsiTest.kt | 23 + ...tractSymbolLightClassesEqualityTestBase.kt | 110 +++ ...htClassesEqualityByFqNameForLibraryTest.kt | 16 + ...LightClassesEqualityByPsiForLibraryTest.kt | 16 + ...ualityByFqNameForLibraryTestGenerated.java | 544 ++++++++++++++ ...sEqualityByPsiForLibraryTestGenerated.java | 448 ++++++++++++ ...ghtClassesEqualityByFqNameForSourceTest.kt | 16 + ...lLightClassesEqualityByPsiForSourceTest.kt | 16 + ...qualityByFqNameForSourceTestGenerated.java | 686 ++++++++++++++++++ ...esEqualityByPsiForSourceTestGenerated.java | 448 ++++++++++++ .../tests/analysis/api/lightClasses.kt | 107 ++- 12 files changed, 2402 insertions(+), 54 deletions(-) create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByFqNameTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByPsiTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityTestBase.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByFqNameForLibraryTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByPsiForLibraryTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByFqNameForSourceTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByPsiForSourceTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByFqNameTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByFqNameTest.kt new file mode 100644 index 00000000000..85291c42fc0 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByFqNameTest.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.base + +import com.intellij.psi.PsiClass +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator +import org.jetbrains.kotlin.asJava.LightClassTestCommon +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +open class AbstractSymbolLightClassesEqualityByFqNameTest( + configurator: AnalysisApiTestConfigurator, + currentExtension: String, + stopIfCompilationErrorDirectivePresent: Boolean +) : AbstractSymbolLightClassesEqualityTestBase(configurator, currentExtension, stopIfCompilationErrorDirectivePresent) { + override fun lightClassesToCheck(ktFiles: List, module: TestModule, testServices: TestServices): Collection { + val fqName = LightClassTestCommon.fqNameInTestDataFile(testDataPath.toFile()) + + val ktFile = ktFiles.first() + return listOfNotNull(findLightClass(fqName, ktFile.project)) + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByPsiTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByPsiTest.kt new file mode 100644 index 00000000000..36fe6c9c8aa --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityByPsiTest.kt @@ -0,0 +1,23 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.base + +import com.intellij.psi.PsiClass +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator +import org.jetbrains.kotlin.light.classes.symbol.base.service.getLightClassesFromFile +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +open class AbstractSymbolLightClassesEqualityByPsiTest( + configurator: AnalysisApiTestConfigurator, + currentExtension: String, + stopIfCompilationErrorDirectivePresent: Boolean +) : AbstractSymbolLightClassesEqualityTestBase(configurator, currentExtension, stopIfCompilationErrorDirectivePresent) { + override fun lightClassesToCheck(ktFiles: List, module: TestModule, testServices: TestServices): Collection { + return ktFiles.flatMap { getLightClassesFromFile(it) } + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityTestBase.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityTestBase.kt new file mode 100644 index 00000000000..e6502886c5a --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesEqualityTestBase.kt @@ -0,0 +1,110 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.base + +import com.intellij.openapi.project.Project +import com.intellij.openapi.util.SimpleModificationTracker +import com.intellij.psi.JavaElementVisitor +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiElementVisitor +import com.intellij.psi.PsiEnumConstant +import org.jetbrains.kotlin.analysis.providers.createAllLibrariesModificationTracker +import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.AssertionsService +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import java.nio.file.Path + +abstract class AbstractSymbolLightClassesEqualityTestBase( + configurator: AnalysisApiTestConfigurator, + override val currentExtension: String, + override val stopIfCompilationErrorDirectivePresent: Boolean +) : AbstractSymbolLightClassesTestBase(configurator) { + override fun getRenderResult(ktFile: KtFile, ktFiles: List, testDataFile: Path, module: TestModule, project: Project): String { + throw IllegalStateException("This test is not rendering light elements") + } + + final override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + val lightClasses = lightClassesToCheck(ktFiles, module, testServices) + if (lightClasses.isEmpty()) return + val project = lightClasses.first().project + val modificationTracker = if (stopIfCompilationErrorDirectivePresent) { + project.createAllLibrariesModificationTracker() + } else { + project.createProjectWideOutOfBlockModificationTracker() + } as SimpleModificationTracker + + val testVisitor = createTestVisitor(modificationTracker, testServices.assertions) + for (lightClass in lightClasses) { + lightClass.accept(testVisitor) + } + } + + private fun createTestVisitor( + modificationTracker: SimpleModificationTracker, + assertions: AssertionsService, + ): PsiElementVisitor = object : JavaElementVisitor() { + override fun visitClass(aClass: PsiClass) { + compareArrayElementsWithInvalidation(aClass, PsiClass::methods) + compareArrayElementsWithInvalidation(aClass, PsiClass::fields) + compareArrayElementsWithInvalidation(aClass, PsiClass::innerClasses) + + super.visitClass(aClass) + } + + override fun visitEnumConstant(enumConstant: PsiEnumConstant) { + compareElementsWithInvalidation(enumConstant, PsiEnumConstant::initializingClass) + + super.visitEnumConstant(enumConstant) + } + + private fun compareElementsWithInvalidation( + element: T, + accessor: T.() -> R, + comparator: (before: R, after: R) -> Unit = ::assertElementEquals, + ) { + val before = element.accessor() + modificationTracker.incModificationCount() + + val after = element.accessor() + comparator(before, after) + } + + private fun assertElementEquals(before: T, after: T) { + assertions.assertEquals(before, after) + } + + private fun compareArrayElementsWithInvalidation(element: T, accessor: T.() -> Array) { + compareElementsWithInvalidation(element, accessor) { before, after -> + assertions.assertEquals(before.size, after.size) { + "Element: $element\nAccessor: $accessor" + } + + if (before.isEmpty()) { + assertions.assertEquals(before, after) { + "Empty arrays must be the same" + } + } else { + assertions.assertNotEquals(before, after) { + "Not empty arrays mustn't be equal for several invocations" + } + } + + for ((index, expected) in before.withIndex()) { + val actual = after[index] + assertions.assertEquals(expected, actual) { + "Element: $element" + } + } + } + } + } + + abstract fun lightClassesToCheck(ktFiles: List, module: TestModule, testServices: TestServices): Collection +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByFqNameForLibraryTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByFqNameForLibraryTest.kt new file mode 100644 index 00000000000..4d4925c9576 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByFqNameForLibraryTest.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.decompiled + +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesEqualityByFqNameTest +import org.jetbrains.kotlin.light.classes.symbol.decompiled.test.configurators.AnalysisApiSymbolLightClassesDecompiledTestConfigurator + +abstract class AbstractSymbolLightClassesEqualityByFqNameForLibraryTest : + AbstractSymbolLightClassesEqualityByFqNameTest( + AnalysisApiSymbolLightClassesDecompiledTestConfigurator, + EXTENSIONS.LIB_JAVA, + stopIfCompilationErrorDirectivePresent = true + ) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByPsiForLibraryTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByPsiForLibraryTest.kt new file mode 100644 index 00000000000..0f0d00fbdef --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesEqualityByPsiForLibraryTest.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.decompiled + +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesEqualityByPsiTest +import org.jetbrains.kotlin.light.classes.symbol.decompiled.test.configurators.AnalysisApiSymbolLightClassesDecompiledTestConfigurator + +abstract class AbstractSymbolLightClassesEqualityByPsiForLibraryTest : + AbstractSymbolLightClassesEqualityByPsiTest( + AnalysisApiSymbolLightClassesDecompiledTestConfigurator, + EXTENSIONS.LIB_JAVA, + stopIfCompilationErrorDirectivePresent = true + ) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java new file mode 100644 index 00000000000..f6d5f9a8ae5 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java @@ -0,0 +1,544 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.decompiled; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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 org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesEqualityByFqNameForLibraryTestGenerated extends AbstractSymbolLightClassesEqualityByFqNameForLibraryTest { + @Test + public void testAllFilesPresentInLightClassByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName"), Pattern.compile("^([^.]+)\\.kt$"), null, true, "compilationErrors"); + } + + @Test + @TestMetadata("AnnotatedParameterInEnumConstructor.kt") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotatedParameterInEnumConstructor.kt"); + } + + @Test + @TestMetadata("AnnotatedParameterInInnerClassConstructor.kt") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotatedParameterInInnerClassConstructor.kt"); + } + + @Test + @TestMetadata("AnnotatedPropertyWithSites.kt") + public void testAnnotatedPropertyWithSites() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotatedPropertyWithSites.kt"); + } + + @Test + @TestMetadata("AnnotationClass.kt") + public void testAnnotationClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationClass.kt"); + } + + @Test + @TestMetadata("AnnotationJavaRepeatable.kt") + public void testAnnotationJavaRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationJavaRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationJvmRepeatable.kt") + public void testAnnotationJvmRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationJvmRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationKotlinAndJavaRepeatable.kt") + public void testAnnotationKotlinAndJavaRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationKotlinAndJavaRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationKotlinAndJvmRepeatable.kt") + public void testAnnotationKotlinAndJvmRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationKotlinAndJvmRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationRepeatable.kt") + public void testAnnotationRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationRepeatable.kt"); + } + + @Test + @TestMetadata("BackingFields.kt") + public void testBackingFields() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/BackingFields.kt"); + } + + @Test + @TestMetadata("CompanionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/CompanionObject.kt"); + } + + @Test + @TestMetadata("Constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/Constructors.kt"); + } + + @Test + @TestMetadata("DataClassWithCustomImplementedMembers.kt") + public void testDataClassWithCustomImplementedMembers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DataClassWithCustomImplementedMembers.kt"); + } + + @Test + @TestMetadata("DelegatedNested.kt") + public void testDelegatedNested() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DelegatedNested.kt"); + } + + @Test + @TestMetadata("Delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/Delegation.kt"); + } + + @Test + @TestMetadata("DeprecatedEnumEntry.kt") + public void testDeprecatedEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DeprecatedEnumEntry.kt"); + } + + @Test + @TestMetadata("DeprecatedNotHiddenInClass.kt") + public void testDeprecatedNotHiddenInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DeprecatedNotHiddenInClass.kt"); + } + + @Test + @TestMetadata("DollarsInName.kt") + public void testDollarsInName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DollarsInName.kt"); + } + + @Test + @TestMetadata("DollarsInNameNoPackage.kt") + public void testDollarsInNameNoPackage() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DollarsInNameNoPackage.kt"); + } + + @Test + @TestMetadata("EnumClass.kt") + public void testEnumClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/EnumClass.kt"); + } + + @Test + @TestMetadata("EnumClassWithEnumEntries.kt") + public void testEnumClassWithEnumEntries() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/EnumClassWithEnumEntries.kt"); + } + + @Test + @TestMetadata("EnumEntry.kt") + public void testEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/EnumEntry.kt"); + } + + @Test + @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt") + public void testExtendingInterfaceWithDefaultImpls() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ExtendingInterfaceWithDefaultImpls.kt"); + } + + @Test + @TestMetadata("HiddenDeprecated.kt") + public void testHiddenDeprecated() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/HiddenDeprecated.kt"); + } + + @Test + @TestMetadata("HiddenDeprecatedInClass.kt") + public void testHiddenDeprecatedInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/HiddenDeprecatedInClass.kt"); + } + + @Test + @TestMetadata("InheritingInterfaceDefaultImpls.kt") + public void testInheritingInterfaceDefaultImpls() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InheritingInterfaceDefaultImpls.kt"); + } + + @Test + @TestMetadata("InlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InlineReified.kt"); + } + + @Test + @TestMetadata("JavaBetween.kt") + public void testJavaBetween() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JavaBetween.kt"); + } + + @Test + @TestMetadata("JavaClassWithAnnotation.kt") + public void testJavaClassWithAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JavaClassWithAnnotation.kt"); + } + + @Test + @TestMetadata("JvmNameOnMember.kt") + public void testJvmNameOnMember() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JvmNameOnMember.kt"); + } + + @Test + @TestMetadata("JvmStatic.kt") + public void testJvmStatic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JvmStatic.kt"); + } + + @Test + @TestMetadata("LocalFunctions.kt") + public void testLocalFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/LocalFunctions.kt"); + } + + @Test + @TestMetadata("NestedObjects.kt") + public void testNestedObjects() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/NestedObjects.kt"); + } + + @Test + @TestMetadata("NonDataClassWithComponentFunctions.kt") + public void testNonDataClassWithComponentFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/NonDataClassWithComponentFunctions.kt"); + } + + @Test + @TestMetadata("OnlySecondaryConstructors.kt") + public void testOnlySecondaryConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/OnlySecondaryConstructors.kt"); + } + + @Test + @TestMetadata("PrivateObject.kt") + public void testPrivateObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/PrivateObject.kt"); + } + + @Test + @TestMetadata("PublishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/PublishedApi.kt"); + } + + @Test + @TestMetadata("SimpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/SimpleObject.kt"); + } + + @Test + @TestMetadata("SimplePublicField.kt") + public void testSimplePublicField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/SimplePublicField.kt"); + } + + @Test + @TestMetadata("SpecialAnnotationsOnAnnotationClass.kt") + public void testSpecialAnnotationsOnAnnotationClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/SpecialAnnotationsOnAnnotationClass.kt"); + } + + @Test + @TestMetadata("StubOrderForOverloads.kt") + public void testStubOrderForOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/StubOrderForOverloads.kt"); + } + + @Test + @TestMetadata("Throws.kt") + public void testThrows() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/Throws.kt"); + } + + @Test + @TestMetadata("TypePararametersInClass.kt") + public void testTypePararametersInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/TypePararametersInClass.kt"); + } + + @Test + @TestMetadata("VarArgs.kt") + public void testVarArgs() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/VarArgs.kt"); + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation") + @TestDataPath("$PROJECT_ROOT") + public class Delegation { + @Test + public void testAllFilesPresentInDelegation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation/Function.kt"); + } + + @Test + @TestMetadata("Property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation/Property.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/facades") + @TestDataPath("$PROJECT_ROOT") + public class Facades { + @Test + public void testAllFilesPresentInFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/facades"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AllPrivate.kt") + public void testAllPrivate() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/AllPrivate.kt"); + } + + @Test + @TestMetadata("InternalFacadeClass.kt") + public void testInternalFacadeClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/InternalFacadeClass.kt"); + } + + @Test + @TestMetadata("MultiFile.kt") + public void testMultiFile() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/MultiFile.kt"); + } + + @Test + @TestMetadata("SingleFile.kt") + public void testSingleFile() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/SingleFile.kt"); + } + + @Test + @TestMetadata("SingleJvmClassName.kt") + public void testSingleJvmClassName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/SingleJvmClassName.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression") + @TestDataPath("$PROJECT_ROOT") + public class IdeRegression { + @Test + public void testAllFilesPresentInIdeRegression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AllOpenAnnotatedClasses.kt") + public void testAllOpenAnnotatedClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/AllOpenAnnotatedClasses.kt"); + } + + @Test + @TestMetadata("ImplementingCharSequenceAndNumber.kt") + public void testImplementingCharSequenceAndNumber() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/ImplementingCharSequenceAndNumber.kt"); + } + + @Test + @TestMetadata("ImplementingMap.kt") + public void testImplementingMap() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/ImplementingMap.kt"); + } + + @Test + @TestMetadata("ImplementingMutableSet.kt") + public void testImplementingMutableSet() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/ImplementingMutableSet.kt"); + } + + @Test + @TestMetadata("InheritingInterfaceDefaultImpls.kt") + public void testInheritingInterfaceDefaultImpls() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/InheritingInterfaceDefaultImpls.kt"); + } + + @Test + @TestMetadata("OverridingFinalInternal.kt") + public void testOverridingFinalInternal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/OverridingFinalInternal.kt"); + } + + @Test + @TestMetadata("OverridingInternal.kt") + public void testOverridingInternal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/OverridingInternal.kt"); + } + + @Test + @TestMetadata("OverridingProtected.kt") + public void testOverridingProtected() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/OverridingProtected.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations") + @TestDataPath("$PROJECT_ROOT") + public class NullabilityAnnotations { + @Test + public void testAllFilesPresentInNullabilityAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Class.kt"); + } + + @Test + @TestMetadata("ClassObjectField.kt") + public void testClassObjectField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/ClassObjectField.kt"); + } + + @Test + @TestMetadata("ClassWithConstructor.kt") + public void testClassWithConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/ClassWithConstructor.kt"); + } + + @Test + @TestMetadata("ClassWithConstructorAndProperties.kt") + public void testClassWithConstructorAndProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/ClassWithConstructorAndProperties.kt"); + } + + @Test + @TestMetadata("FileFacade.kt") + public void testFileFacade() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/FileFacade.kt"); + } + + @Test + @TestMetadata("Generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Generic.kt"); + } + + @Test + @TestMetadata("IntOverridesAny.kt") + public void testIntOverridesAny() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/IntOverridesAny.kt"); + } + + @Test + @TestMetadata("JvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/JvmOverloads.kt"); + } + + @Test + @TestMetadata("NullableUnitReturn.kt") + public void testNullableUnitReturn() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/NullableUnitReturn.kt"); + } + + @Test + @TestMetadata("OverrideAnyWithUnit.kt") + public void testOverrideAnyWithUnit() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/OverrideAnyWithUnit.kt"); + } + + @Test + @TestMetadata("PlatformTypes.kt") + public void testPlatformTypes() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/PlatformTypes.kt"); + } + + @Test + @TestMetadata("PrimitiveBackedInlineClasses.kt") + public void testPrimitiveBackedInlineClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/PrimitiveBackedInlineClasses.kt"); + } + + @Test + @TestMetadata("Primitives.kt") + public void testPrimitives() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Primitives.kt"); + } + + @Test + @TestMetadata("PrivateInClass.kt") + public void testPrivateInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/PrivateInClass.kt"); + } + + @Test + @TestMetadata("Synthetic.kt") + public void testSynthetic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Synthetic.kt"); + } + + @Test + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Trait.kt"); + } + + @Test + @TestMetadata("UnitAsGenericArgument.kt") + public void testUnitAsGenericArgument() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/UnitAsGenericArgument.kt"); + } + + @Test + @TestMetadata("UnitParameter.kt") + public void testUnitParameter() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/UnitParameter.kt"); + } + + @Test + @TestMetadata("VoidReturn.kt") + public void testVoidReturn() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/VoidReturn.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/script") + @TestDataPath("$PROJECT_ROOT") + public class Script { + @Test + public void testAllFilesPresentInScript() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/script"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java new file mode 100644 index 00000000000..3cf0d43d436 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java @@ -0,0 +1,448 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.decompiled; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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 org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesEqualityByPsiForLibraryTestGenerated extends AbstractSymbolLightClassesEqualityByPsiForLibraryTest { + @Test + public void testAllFilesPresentInLightClassByPsi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("annotationWithSetParamPropertyModifier.kt") + public void testAnnotationWithSetParamPropertyModifier() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.kt"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotations.kt"); + } + + @Test + @TestMetadata("AnnotationsOnEnumEntry.kt") + public void testAnnotationsOnEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsOnEnumEntry.kt"); + } + + @Test + @TestMetadata("AnnotationsWithUnresolvedAnnotations.kt") + public void testAnnotationsWithUnresolvedAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsWithUnresolvedAnnotations.kt"); + } + + @Test + @TestMetadata("classModifiers.kt") + public void testClassModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.kt"); + } + + @Test + @TestMetadata("companionDuplication.kt") + public void testCompanionDuplication() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/companionDuplication.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.kt"); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dataClasses.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAll.kt") + public void testDefaultMethodInKotlinWithSettingAll() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAll.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAllCompatibility.kt") + public void testDefaultMethodInKotlinWithSettingAllCompatibility() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAllCompatibility.kt"); + } + + @Test + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/DelegatedProperty.kt"); + } + + @Test + @TestMetadata("delegatesWithAnnotations.kt") + public void testDelegatesWithAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.kt"); + } + + @Test + @TestMetadata("delegatingToInterfaces.kt") + public void testDelegatingToInterfaces() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatingToInterfaces.kt"); + } + + @Test + @TestMetadata("dollarsInNameLocal.kt") + public void testDollarsInNameLocal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dollarsInNameLocal.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/enums.kt"); + } + + @Test + @TestMetadata("exposedAnonymousType.kt") + public void testExposedAnonymousType() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/exposedAnonymousType.kt"); + } + + @Test + @TestMetadata("fieldModifiers.kt") + public void testFieldModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/fieldModifiers.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/generics.kt"); + } + + @Test + @TestMetadata("implementingKotlinCollections.kt") + public void testImplementingKotlinCollections() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/implementingKotlinCollections.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/importAliases.kt"); + } + + @Test + @TestMetadata("inferringAnonymousObjectTypes.kt") + public void testInferringAnonymousObjectTypes() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inferringAnonymousObjectTypes.kt"); + } + + @Test + @TestMetadata("inheritance.kt") + public void testInheritance() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inheritance.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineClasses.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineOnly.kt"); + } + + @Test + @TestMetadata("inlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineReified.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmName.kt"); + } + + @Test + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmOverloads.kt"); + } + + @Test + @TestMetadata("jvmRecord.kt") + public void testJvmRecord() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmRecord.kt"); + } + + @Test + @TestMetadata("jvmStaticOnPropertySetter.kt") + public void testJvmStaticOnPropertySetter() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmStaticOnPropertySetter.kt"); + } + + @Test + @TestMetadata("jvmSynthetic.kt") + public void testJvmSynthetic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSynthetic.kt"); + } + + @Test + @TestMetadata("jvmSyntheticForAccessors.kt") + public void testJvmSyntheticForAccessors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSyntheticForAccessors.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("LateinitProperties.kt") + public void testLateinitProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/lateinitProperty.kt"); + } + + @Test + @TestMetadata("localClassDerived.kt") + public void testLocalClassDerived() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/localClassDerived.kt"); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/objects.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/simpleFunctions.kt"); + } + + @Test + @TestMetadata("strangeIdentifiers.kt") + public void testStrangeIdentifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/strangeIdentifiers.kt"); + } + + @Test + @TestMetadata("targetAnnotation.kt") + public void testTargetAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/targetAnnotation.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("typeAliases.kt") + public void testTypeAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.kt"); + } + + @Test + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.kt"); + } + + @Test + @TestMetadata("typealiasInAnnotation.kt") + public void testTypealiasInAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInAnnotation.kt"); + } + + @Test + @TestMetadata("typealiasInTypeArguments.kt") + public void testTypealiasInTypeArguments() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInTypeArguments.kt"); + } + + @Test + @TestMetadata("unresolvedWithAliasedImport.kt") + public void testUnresolvedWithAliasedImport() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.kt"); + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/facades") + @TestDataPath("$PROJECT_ROOT") + public class Facades { + @Test + public void testAllFilesPresentInFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/facades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/coroutines.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/importAliases.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/inlineOnly.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmName.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/lateinitProperty.kt"); + } + + @Test + @TestMetadata("multifileFacade.kt") + public void testMultifileFacade() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacade.kt"); + } + + @Test + @TestMetadata("multifileFacadeJvmName.kt") + public void testMultifileFacadeJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacadeJvmName.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/simpleFunctions.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/wildcardOptimization.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts") + @TestDataPath("$PROJECT_ROOT") + public class Scripts { + @Test + public void testAllFilesPresentInScripts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("FunsPropsAndFields.kts") + public void testFunsPropsAndFields() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/FunsPropsAndFields.kts"); + } + + @Test + @TestMetadata("HelloWorld.kts") + public void testHelloWorld() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/HelloWorld.kts"); + } + + @Test + @TestMetadata("InnerClasses.kts") + public void testInnerClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/InnerClasses.kts"); + } + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByFqNameForSourceTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByFqNameForSourceTest.kt new file mode 100644 index 00000000000..ac6e67fb337 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByFqNameForSourceTest.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.source + +import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.AnalysisApiFirSourceTestConfigurator +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesEqualityByFqNameTest + +abstract class AbstractSymbolLightClassesEqualityByFqNameForSourceTest : + AbstractSymbolLightClassesEqualityByFqNameTest( + AnalysisApiFirSourceTestConfigurator(analyseInDependentSession = false), + EXTENSIONS.FIR_JAVA, + stopIfCompilationErrorDirectivePresent = false + ) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByPsiForSourceTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByPsiForSourceTest.kt new file mode 100644 index 00000000000..01afddc72d1 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesEqualityByPsiForSourceTest.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.source + +import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.AnalysisApiFirSourceTestConfigurator +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesEqualityByPsiTest + +abstract class AbstractSymbolLightClassesEqualityByPsiForSourceTest : + AbstractSymbolLightClassesEqualityByPsiTest( + AnalysisApiFirSourceTestConfigurator(analyseInDependentSession = false), + EXTENSIONS.FIR_JAVA, + stopIfCompilationErrorDirectivePresent = false + ) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java new file mode 100644 index 00000000000..ad3e2b353f2 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java @@ -0,0 +1,686 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.source; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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 org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesEqualityByFqNameForSourceTestGenerated extends AbstractSymbolLightClassesEqualityByFqNameForSourceTest { + @Test + public void testAllFilesPresentInLightClassByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AnnotatedParameterInEnumConstructor.kt") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotatedParameterInEnumConstructor.kt"); + } + + @Test + @TestMetadata("AnnotatedParameterInInnerClassConstructor.kt") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotatedParameterInInnerClassConstructor.kt"); + } + + @Test + @TestMetadata("AnnotatedPropertyWithSites.kt") + public void testAnnotatedPropertyWithSites() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotatedPropertyWithSites.kt"); + } + + @Test + @TestMetadata("AnnotationClass.kt") + public void testAnnotationClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationClass.kt"); + } + + @Test + @TestMetadata("AnnotationJavaRepeatable.kt") + public void testAnnotationJavaRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationJavaRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationJvmRepeatable.kt") + public void testAnnotationJvmRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationJvmRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationKotlinAndJavaRepeatable.kt") + public void testAnnotationKotlinAndJavaRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationKotlinAndJavaRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationKotlinAndJvmRepeatable.kt") + public void testAnnotationKotlinAndJvmRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationKotlinAndJvmRepeatable.kt"); + } + + @Test + @TestMetadata("AnnotationRepeatable.kt") + public void testAnnotationRepeatable() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/AnnotationRepeatable.kt"); + } + + @Test + @TestMetadata("BackingFields.kt") + public void testBackingFields() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/BackingFields.kt"); + } + + @Test + @TestMetadata("CompanionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/CompanionObject.kt"); + } + + @Test + @TestMetadata("Constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/Constructors.kt"); + } + + @Test + @TestMetadata("DataClassWithCustomImplementedMembers.kt") + public void testDataClassWithCustomImplementedMembers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DataClassWithCustomImplementedMembers.kt"); + } + + @Test + @TestMetadata("DelegatedNested.kt") + public void testDelegatedNested() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DelegatedNested.kt"); + } + + @Test + @TestMetadata("Delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/Delegation.kt"); + } + + @Test + @TestMetadata("DeprecatedEnumEntry.kt") + public void testDeprecatedEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DeprecatedEnumEntry.kt"); + } + + @Test + @TestMetadata("DeprecatedNotHiddenInClass.kt") + public void testDeprecatedNotHiddenInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DeprecatedNotHiddenInClass.kt"); + } + + @Test + @TestMetadata("DollarsInName.kt") + public void testDollarsInName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DollarsInName.kt"); + } + + @Test + @TestMetadata("DollarsInNameNoPackage.kt") + public void testDollarsInNameNoPackage() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/DollarsInNameNoPackage.kt"); + } + + @Test + @TestMetadata("EnumClass.kt") + public void testEnumClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/EnumClass.kt"); + } + + @Test + @TestMetadata("EnumClassWithEnumEntries.kt") + public void testEnumClassWithEnumEntries() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/EnumClassWithEnumEntries.kt"); + } + + @Test + @TestMetadata("EnumEntry.kt") + public void testEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/EnumEntry.kt"); + } + + @Test + @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt") + public void testExtendingInterfaceWithDefaultImpls() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ExtendingInterfaceWithDefaultImpls.kt"); + } + + @Test + @TestMetadata("HiddenDeprecated.kt") + public void testHiddenDeprecated() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/HiddenDeprecated.kt"); + } + + @Test + @TestMetadata("HiddenDeprecatedInClass.kt") + public void testHiddenDeprecatedInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/HiddenDeprecatedInClass.kt"); + } + + @Test + @TestMetadata("InheritingInterfaceDefaultImpls.kt") + public void testInheritingInterfaceDefaultImpls() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InheritingInterfaceDefaultImpls.kt"); + } + + @Test + @TestMetadata("InlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InlineReified.kt"); + } + + @Test + @TestMetadata("JavaBetween.kt") + public void testJavaBetween() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JavaBetween.kt"); + } + + @Test + @TestMetadata("JavaClassWithAnnotation.kt") + public void testJavaClassWithAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JavaClassWithAnnotation.kt"); + } + + @Test + @TestMetadata("JvmNameOnMember.kt") + public void testJvmNameOnMember() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JvmNameOnMember.kt"); + } + + @Test + @TestMetadata("JvmStatic.kt") + public void testJvmStatic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JvmStatic.kt"); + } + + @Test + @TestMetadata("LocalFunctions.kt") + public void testLocalFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/LocalFunctions.kt"); + } + + @Test + @TestMetadata("NestedObjects.kt") + public void testNestedObjects() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/NestedObjects.kt"); + } + + @Test + @TestMetadata("NonDataClassWithComponentFunctions.kt") + public void testNonDataClassWithComponentFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/NonDataClassWithComponentFunctions.kt"); + } + + @Test + @TestMetadata("OnlySecondaryConstructors.kt") + public void testOnlySecondaryConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/OnlySecondaryConstructors.kt"); + } + + @Test + @TestMetadata("PrivateObject.kt") + public void testPrivateObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/PrivateObject.kt"); + } + + @Test + @TestMetadata("PublishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/PublishedApi.kt"); + } + + @Test + @TestMetadata("SimpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/SimpleObject.kt"); + } + + @Test + @TestMetadata("SimplePublicField.kt") + public void testSimplePublicField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/SimplePublicField.kt"); + } + + @Test + @TestMetadata("SpecialAnnotationsOnAnnotationClass.kt") + public void testSpecialAnnotationsOnAnnotationClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/SpecialAnnotationsOnAnnotationClass.kt"); + } + + @Test + @TestMetadata("StubOrderForOverloads.kt") + public void testStubOrderForOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/StubOrderForOverloads.kt"); + } + + @Test + @TestMetadata("Throws.kt") + public void testThrows() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/Throws.kt"); + } + + @Test + @TestMetadata("TypePararametersInClass.kt") + public void testTypePararametersInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/TypePararametersInClass.kt"); + } + + @Test + @TestMetadata("VarArgs.kt") + public void testVarArgs() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/VarArgs.kt"); + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors") + @TestDataPath("$PROJECT_ROOT") + public class CompilationErrors { + @Test + @TestMetadata("ActualClass.kt") + public void testActualClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ActualClass.kt"); + } + + @Test + @TestMetadata("ActualTypeAlias.kt") + public void testActualTypeAlias() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ActualTypeAlias.kt"); + } + + @Test + @TestMetadata("ActualTypeAliasCustomJvmPackageName.kt") + public void testActualTypeAliasCustomJvmPackageName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt"); + } + + @Test + public void testAllFilesPresentInCompilationErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AllInlineOnly.kt") + public void testAllInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/AllInlineOnly.kt"); + } + + @Test + @TestMetadata("AnnotationModifiers.kt") + public void testAnnotationModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/AnnotationModifiers.kt"); + } + + @Test + @TestMetadata("EnumNameOverride.kt") + public void testEnumNameOverride() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/EnumNameOverride.kt"); + } + + @Test + @TestMetadata("ExpectClass.kt") + public void testExpectClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ExpectClass.kt"); + } + + @Test + @TestMetadata("ExpectObject.kt") + public void testExpectObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ExpectObject.kt"); + } + + @Test + @TestMetadata("ExpectedNestedClass.kt") + public void testExpectedNestedClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ExpectedNestedClass.kt"); + } + + @Test + @TestMetadata("ExpectedNestedClassInObject.kt") + public void testExpectedNestedClassInObject() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/ExpectedNestedClassInObject.kt"); + } + + @Test + @TestMetadata("FunctionWithoutName.kt") + public void testFunctionWithoutName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/FunctionWithoutName.kt"); + } + + @Test + @TestMetadata("JvmPackageName.kt") + public void testJvmPackageName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/JvmPackageName.kt"); + } + + @Test + @TestMetadata("LocalInAnnotation.kt") + public void testLocalInAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/LocalInAnnotation.kt"); + } + + @Test + @TestMetadata("PrivateInTrait.kt") + public void testPrivateInTrait() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/PrivateInTrait.kt"); + } + + @Test + @TestMetadata("PropertyWithoutName.kt") + public void testPropertyWithoutName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/PropertyWithoutName.kt"); + } + + @Test + @TestMetadata("RepetableAnnotations.kt") + public void testRepetableAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/RepetableAnnotations.kt"); + } + + @Test + @TestMetadata("SameName.kt") + public void testSameName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/SameName.kt"); + } + + @Test + @TestMetadata("TopLevelDestructuring.kt") + public void testTopLevelDestructuring() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/TopLevelDestructuring.kt"); + } + + @Test + @TestMetadata("TraitClassObjectField.kt") + public void testTraitClassObjectField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/TraitClassObjectField.kt"); + } + + @Test + @TestMetadata("TwoOverrides.kt") + public void testTwoOverrides() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/TwoOverrides.kt"); + } + + @Test + @TestMetadata("unresolvedQuialifierInAnnotation.kt") + public void testUnresolvedQuialifierInAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/unresolvedQuialifierInAnnotation.kt"); + } + + @Test + @TestMetadata("WrongAnnotations.kt") + public void testWrongAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/compilationErrors/WrongAnnotations.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation") + @TestDataPath("$PROJECT_ROOT") + public class Delegation { + @Test + public void testAllFilesPresentInDelegation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation/Function.kt"); + } + + @Test + @TestMetadata("Property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/delegation/Property.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/facades") + @TestDataPath("$PROJECT_ROOT") + public class Facades { + @Test + public void testAllFilesPresentInFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/facades"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AllPrivate.kt") + public void testAllPrivate() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/AllPrivate.kt"); + } + + @Test + @TestMetadata("InternalFacadeClass.kt") + public void testInternalFacadeClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/InternalFacadeClass.kt"); + } + + @Test + @TestMetadata("MultiFile.kt") + public void testMultiFile() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/MultiFile.kt"); + } + + @Test + @TestMetadata("SingleFile.kt") + public void testSingleFile() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/SingleFile.kt"); + } + + @Test + @TestMetadata("SingleJvmClassName.kt") + public void testSingleJvmClassName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/facades/SingleJvmClassName.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression") + @TestDataPath("$PROJECT_ROOT") + public class IdeRegression { + @Test + public void testAllFilesPresentInIdeRegression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AllOpenAnnotatedClasses.kt") + public void testAllOpenAnnotatedClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/AllOpenAnnotatedClasses.kt"); + } + + @Test + @TestMetadata("ImplementingCharSequenceAndNumber.kt") + public void testImplementingCharSequenceAndNumber() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/ImplementingCharSequenceAndNumber.kt"); + } + + @Test + @TestMetadata("ImplementingMap.kt") + public void testImplementingMap() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/ImplementingMap.kt"); + } + + @Test + @TestMetadata("ImplementingMutableSet.kt") + public void testImplementingMutableSet() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/ImplementingMutableSet.kt"); + } + + @Test + @TestMetadata("InheritingInterfaceDefaultImpls.kt") + public void testInheritingInterfaceDefaultImpls() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/InheritingInterfaceDefaultImpls.kt"); + } + + @Test + @TestMetadata("OverridingFinalInternal.kt") + public void testOverridingFinalInternal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/OverridingFinalInternal.kt"); + } + + @Test + @TestMetadata("OverridingInternal.kt") + public void testOverridingInternal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/OverridingInternal.kt"); + } + + @Test + @TestMetadata("OverridingProtected.kt") + public void testOverridingProtected() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/ideRegression/OverridingProtected.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations") + @TestDataPath("$PROJECT_ROOT") + public class NullabilityAnnotations { + @Test + public void testAllFilesPresentInNullabilityAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Class.kt"); + } + + @Test + @TestMetadata("ClassObjectField.kt") + public void testClassObjectField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/ClassObjectField.kt"); + } + + @Test + @TestMetadata("ClassWithConstructor.kt") + public void testClassWithConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/ClassWithConstructor.kt"); + } + + @Test + @TestMetadata("ClassWithConstructorAndProperties.kt") + public void testClassWithConstructorAndProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/ClassWithConstructorAndProperties.kt"); + } + + @Test + @TestMetadata("FileFacade.kt") + public void testFileFacade() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/FileFacade.kt"); + } + + @Test + @TestMetadata("Generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Generic.kt"); + } + + @Test + @TestMetadata("IntOverridesAny.kt") + public void testIntOverridesAny() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/IntOverridesAny.kt"); + } + + @Test + @TestMetadata("JvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/JvmOverloads.kt"); + } + + @Test + @TestMetadata("NullableUnitReturn.kt") + public void testNullableUnitReturn() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/NullableUnitReturn.kt"); + } + + @Test + @TestMetadata("OverrideAnyWithUnit.kt") + public void testOverrideAnyWithUnit() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/OverrideAnyWithUnit.kt"); + } + + @Test + @TestMetadata("PlatformTypes.kt") + public void testPlatformTypes() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/PlatformTypes.kt"); + } + + @Test + @TestMetadata("PrimitiveBackedInlineClasses.kt") + public void testPrimitiveBackedInlineClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/PrimitiveBackedInlineClasses.kt"); + } + + @Test + @TestMetadata("Primitives.kt") + public void testPrimitives() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Primitives.kt"); + } + + @Test + @TestMetadata("PrivateInClass.kt") + public void testPrivateInClass() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/PrivateInClass.kt"); + } + + @Test + @TestMetadata("Synthetic.kt") + public void testSynthetic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Synthetic.kt"); + } + + @Test + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/Trait.kt"); + } + + @Test + @TestMetadata("UnitAsGenericArgument.kt") + public void testUnitAsGenericArgument() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/UnitAsGenericArgument.kt"); + } + + @Test + @TestMetadata("UnitParameter.kt") + public void testUnitParameter() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/UnitParameter.kt"); + } + + @Test + @TestMetadata("VoidReturn.kt") + public void testVoidReturn() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/nullabilityAnnotations/VoidReturn.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByFqName/script") + @TestDataPath("$PROJECT_ROOT") + public class Script { + @Test + public void testAllFilesPresentInScript() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByFqName/script"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java new file mode 100644 index 00000000000..98a892aa226 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java @@ -0,0 +1,448 @@ +/* + * Copyright 2010-2023 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.light.classes.symbol.source; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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 org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesEqualityByPsiForSourceTestGenerated extends AbstractSymbolLightClassesEqualityByPsiForSourceTest { + @Test + public void testAllFilesPresentInLightClassByPsi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("annotationWithSetParamPropertyModifier.kt") + public void testAnnotationWithSetParamPropertyModifier() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.kt"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotations.kt"); + } + + @Test + @TestMetadata("AnnotationsOnEnumEntry.kt") + public void testAnnotationsOnEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsOnEnumEntry.kt"); + } + + @Test + @TestMetadata("AnnotationsWithUnresolvedAnnotations.kt") + public void testAnnotationsWithUnresolvedAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsWithUnresolvedAnnotations.kt"); + } + + @Test + @TestMetadata("classModifiers.kt") + public void testClassModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.kt"); + } + + @Test + @TestMetadata("companionDuplication.kt") + public void testCompanionDuplication() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/companionDuplication.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.kt"); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dataClasses.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAll.kt") + public void testDefaultMethodInKotlinWithSettingAll() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAll.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAllCompatibility.kt") + public void testDefaultMethodInKotlinWithSettingAllCompatibility() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAllCompatibility.kt"); + } + + @Test + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/DelegatedProperty.kt"); + } + + @Test + @TestMetadata("delegatesWithAnnotations.kt") + public void testDelegatesWithAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.kt"); + } + + @Test + @TestMetadata("delegatingToInterfaces.kt") + public void testDelegatingToInterfaces() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatingToInterfaces.kt"); + } + + @Test + @TestMetadata("dollarsInNameLocal.kt") + public void testDollarsInNameLocal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dollarsInNameLocal.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/enums.kt"); + } + + @Test + @TestMetadata("exposedAnonymousType.kt") + public void testExposedAnonymousType() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/exposedAnonymousType.kt"); + } + + @Test + @TestMetadata("fieldModifiers.kt") + public void testFieldModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/fieldModifiers.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/generics.kt"); + } + + @Test + @TestMetadata("implementingKotlinCollections.kt") + public void testImplementingKotlinCollections() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/implementingKotlinCollections.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/importAliases.kt"); + } + + @Test + @TestMetadata("inferringAnonymousObjectTypes.kt") + public void testInferringAnonymousObjectTypes() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inferringAnonymousObjectTypes.kt"); + } + + @Test + @TestMetadata("inheritance.kt") + public void testInheritance() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inheritance.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineClasses.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineOnly.kt"); + } + + @Test + @TestMetadata("inlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineReified.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmName.kt"); + } + + @Test + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmOverloads.kt"); + } + + @Test + @TestMetadata("jvmRecord.kt") + public void testJvmRecord() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmRecord.kt"); + } + + @Test + @TestMetadata("jvmStaticOnPropertySetter.kt") + public void testJvmStaticOnPropertySetter() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmStaticOnPropertySetter.kt"); + } + + @Test + @TestMetadata("jvmSynthetic.kt") + public void testJvmSynthetic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSynthetic.kt"); + } + + @Test + @TestMetadata("jvmSyntheticForAccessors.kt") + public void testJvmSyntheticForAccessors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSyntheticForAccessors.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("LateinitProperties.kt") + public void testLateinitProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/lateinitProperty.kt"); + } + + @Test + @TestMetadata("localClassDerived.kt") + public void testLocalClassDerived() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/localClassDerived.kt"); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/objects.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/simpleFunctions.kt"); + } + + @Test + @TestMetadata("strangeIdentifiers.kt") + public void testStrangeIdentifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/strangeIdentifiers.kt"); + } + + @Test + @TestMetadata("targetAnnotation.kt") + public void testTargetAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/targetAnnotation.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("typeAliases.kt") + public void testTypeAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.kt"); + } + + @Test + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.kt"); + } + + @Test + @TestMetadata("typealiasInAnnotation.kt") + public void testTypealiasInAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInAnnotation.kt"); + } + + @Test + @TestMetadata("typealiasInTypeArguments.kt") + public void testTypealiasInTypeArguments() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInTypeArguments.kt"); + } + + @Test + @TestMetadata("unresolvedWithAliasedImport.kt") + public void testUnresolvedWithAliasedImport() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.kt"); + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/facades") + @TestDataPath("$PROJECT_ROOT") + public class Facades { + @Test + public void testAllFilesPresentInFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/facades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/coroutines.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/importAliases.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/inlineOnly.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmName.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/lateinitProperty.kt"); + } + + @Test + @TestMetadata("multifileFacade.kt") + public void testMultifileFacade() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacade.kt"); + } + + @Test + @TestMetadata("multifileFacadeJvmName.kt") + public void testMultifileFacadeJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacadeJvmName.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/simpleFunctions.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/wildcardOptimization.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts") + @TestDataPath("$PROJECT_ROOT") + public class Scripts { + @Test + public void testAllFilesPresentInScripts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("FunsPropsAndFields.kts") + public void testFunsPropsAndFields() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/FunsPropsAndFields.kts"); + } + + @Test + @TestMetadata("HelloWorld.kts") + public void testHelloWorld() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/HelloWorld.kts"); + } + + @Test + @TestMetadata("InnerClasses.kts") + public void testInnerClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/InnerClasses.kts"); + } + } +} diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt index f96379041b9..2018288ae07 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.generators.tests.analysis.api +import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.TestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesEquivalentTest @@ -12,60 +13,7 @@ import org.jetbrains.kotlin.light.classes.symbol.decompiled.* import org.jetbrains.kotlin.light.classes.symbol.source.* internal fun TestGroupSuite.generateSymbolLightClassesTests() { - testGroup( - "analysis/symbol-light-classes/tests", - "compiler/testData", - ) { - run { - testClass { - model( - "asJava/lightClasses/lightClassByFqName", - pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME - ) - } - - testClass { - model( - "asJava/lightClasses/lightClassByFqName", - excludeDirs = listOf("compilationErrors"), - pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME - ) - } - - testClass { - model( - "asJava/lightClasses/lightClassByFqName", - pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME - ) - } - - testClass { - model( - "asJava/lightClasses/lightClassByFqName", - excludeDirs = listOf("compilationErrors"), - pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME - ) - } - } - - run { - testClass { - model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) - } - - testClass { - model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) - } - - testClass { - model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) - } - - testClass { - model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) - } - } - } + generateCompilerTestDataBasedLightClassesTests() testGroup( "analysis/symbol-light-classes/tests", @@ -104,3 +52,54 @@ internal fun TestGroupSuite.generateSymbolLightClassesTests() { } } } + +private fun TestGroupSuite.generateCompilerTestDataBasedLightClassesTests() { + testGroup( + "analysis/symbol-light-classes/tests", + "compiler/testData", + ) { + lightClassesByFqNameTests() + lightClassesByPsiTests() + } +} + +private fun TestGroup.lightClassesByPsiTests() { + val modelInit: TestGroup.TestClass.() -> Unit = { + model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) + } + + testClass(init = modelInit) + testClass(init = modelInit) + + testClass(init = modelInit) + testClass(init = modelInit) + + testClass(init = modelInit) + testClass(init = modelInit) +} + +private fun TestGroup.lightClassesByFqNameTests() { + val sourceModelInit: TestGroup.TestClass.() -> Unit = { + model( + "asJava/lightClasses/lightClassByFqName", + pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME + ) + } + + val libraryModelInit: TestGroup.TestClass.() -> Unit = { + model( + "asJava/lightClasses/lightClassByFqName", + excludeDirs = listOf("compilationErrors"), + pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME + ) + } + + testClass(init = sourceModelInit) + testClass(init = libraryModelInit) + + testClass(init = sourceModelInit) + testClass(init = libraryModelInit) + + testClass(init = sourceModelInit) + testClass(init = libraryModelInit) +}