diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt index 4470539fd97..c0c0df4ef6e 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt @@ -7,10 +7,11 @@ package org.jetbrains.kotlin.generators.tests.analysis.api import org.jetbrains.kotlin.generators.TestGroupSuite import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5 +import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.FrontendConfiguratorTestGenerator fun main(args: Array) { System.setProperty("java.awt.headless", "true") - generateTestGroupSuiteWithJUnit5(args) { + generateTestGroupSuiteWithJUnit5(args, additionalMethodGenerators = listOf(FrontendConfiguratorTestGenerator)) { generateTests() } } diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt index 5590ffcea64..6efa657f90e 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt @@ -5,57 +5,40 @@ package org.jetbrains.kotlin.generators.tests.analysis.api -import org.jetbrains.kotlin.analysis.api.descriptors.test.annotations.AbstractAnalysisApiFe10AnnotationsOnDeclarationsTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.annotations.AbstractAnalysisApiFe10AnnotationsOnTypesTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.callResolver.AbstractKtFe10ResolveCallTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.compileTimeConstantProvider.AbstractKtFe10CompileTimeConstantEvaluatorTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.diagnosticsProvider.AbstractKtFe10CollectDiagnosticsTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionInfoProvider.AbstractKtFe10ReturnTargetSymbolTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionInfoProvider.AbstractKtFe10WhenMissingCasesTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionTypeProvider.AbstractKtFe10DeclarationReturnTypeTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionTypeProvider.AbstractKtFe10ExpectedExpressionTypeTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionTypeProvider.AbstractKtFe10HLExpressionTypeTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.smartCastProvider.AbstractKtFe10HLSmartCastInfoTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.symbolDeclarationOverridesProvider.AbstractKtFe10OverriddenDeclarationProviderTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.symbolDeclarationRenderer.AbstractKtFe10RendererTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.typeCreator.AbstractKtFe10TypeParameterTypeTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.typeProvider.AbstractKtFe10HasCommonSubtypeTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.scopes.AbstractKtFe10SubstitutionOverridesUnwrappingTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.components.typeProvider.AbstractKtFe10IsDenotableTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.symbols.AbstractKtFe10SymbolByFqNameTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.symbols.AbstractKtFe10SymbolByPsiTest -import org.jetbrains.kotlin.analysis.api.descriptors.test.symbols.AbstractKtFe10SymbolByReferenceTest -import org.jetbrains.kotlin.analysis.api.fir.AbstractFirReferenceResolveTest -import org.jetbrains.kotlin.analysis.api.fir.annotations.AbstractAnalysisApiFirAnnotationsOnDeclarationsTest -import org.jetbrains.kotlin.analysis.api.fir.annotations.AbstractAnalysisApiFirAnnotationsOnFilesTest -import org.jetbrains.kotlin.analysis.api.fir.annotations.AbstractAnalysisApiFirAnnotationsOnTypesTest -import org.jetbrains.kotlin.analysis.api.fir.components.callResolver.AbstractFirResolveCallTest -import org.jetbrains.kotlin.analysis.api.fir.components.compileTimeConstantProvider.AbstractFirCompileTimeConstantEvaluatorTest -import org.jetbrains.kotlin.analysis.api.fir.components.diagnosticsProvider.AbstractFirCollectDiagnosticsTest -import org.jetbrains.kotlin.analysis.api.fir.components.expressionInfoProvider.AbstractFirReturnTargetSymbolTest -import org.jetbrains.kotlin.analysis.api.fir.components.expressionInfoProvider.AbstractFirWhenMissingCasesTest -import org.jetbrains.kotlin.analysis.api.fir.components.expressionTypeProvider.AbstractFirDeclarationReturnTypeTest -import org.jetbrains.kotlin.analysis.api.fir.components.expressionTypeProvider.AbstractFirExpectedExpressionTypeTest -import org.jetbrains.kotlin.analysis.api.fir.components.expressionTypeProvider.AbstractFirHLExpressionTypeTest import org.jetbrains.kotlin.analysis.api.fir.components.importOptimizer.AbstractHLImportOptimizerTest import org.jetbrains.kotlin.analysis.api.fir.components.psiTypeProvider.AbstractExpressionPsiTypeProviderTest import org.jetbrains.kotlin.analysis.api.fir.components.psiTypeProvider.AbstractPsiTypeProviderTest -import org.jetbrains.kotlin.analysis.api.fir.components.smartCastProvider.AbstractFirHLSmartCastInfoTest -import org.jetbrains.kotlin.analysis.api.fir.components.symbolDeclarationOverridesProvider.AbstractFirOverriddenDeclarationProviderTest -import org.jetbrains.kotlin.analysis.api.fir.components.symbolDeclarationRenderer.AbstractFirRendererTest -import org.jetbrains.kotlin.analysis.api.fir.components.typeCreator.AbstractFirTypeParameterTypeTest -import org.jetbrains.kotlin.analysis.api.fir.components.typeInfoProvider.AbstractFirFunctionClassKindTest import org.jetbrains.kotlin.analysis.api.fir.components.typeProvider.AbstractFirGetSuperTypesTest -import org.jetbrains.kotlin.analysis.api.fir.components.typeProvider.AbstractFirHasCommonSubtypeTest -import org.jetbrains.kotlin.analysis.api.fir.components.typeProvider.AbstractFirIsDenotableTest -import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirDelegateMemberScopeTest -import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirFileScopeTest -import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirMemberScopeByFqNameTest -import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirSubstitutionOverridesUnwrappingTest -import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByFqNameTest -import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByPsiTest -import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByReferenceTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.AbstractReferenceResolveTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnDeclarationsTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnFilesTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnTypesTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.compileTimeConstantProvider.AbstractCompileTimeConstantEvaluatorTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.diagnosticProvider.AbstractCollectDiagnosticsTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionInfoProvider.AbstractReturnTargetSymbolTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionInfoProvider.AbstractWhenMissingCasesTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionTypeProvider.AbstractDeclarationReturnTypeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionTypeProvider.AbstractExpectedExpressionTypeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionTypeProvider.AbstractHLExpressionTypeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.smartCastProvider.AbstractHLSmartCastInfoTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.symbolDeclarationOverridesProvider.AbstractOverriddenDeclarationProviderTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.symbolDeclarationRenderer.AbstractRendererTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeCreator.AbstractTypeParameterTypeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeInfoProvider.AbstractFunctionClassKindTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeInfoProvider.AbstractIsDenotableTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeProvider.AbstractHasCommonSubtypeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.fir.AbstractResolveCallTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractDelegateMemberScopeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractFileScopeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractMemberScopeByFqNameTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractSubstitutionOverridesUnwrappingTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByFqNameTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByPsiTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByReferenceTest import org.jetbrains.kotlin.generators.TestGroupSuite +import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.component +import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.group +import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.test import org.jetbrains.kotlin.generators.util.TestGeneratorUtil fun TestGroupSuite.generateAnalysisApiTests() { @@ -65,83 +48,70 @@ fun TestGroupSuite.generateAnalysisApiTests() { private fun TestGroupSuite.generateAnalysisApiNonComponentsTests() { test( - fir = AbstractFirReferenceResolveTest::class, fe10 = null, + AbstractReferenceResolveTest::class, + addFe10 = false, ) { model("referenceResolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) } group("scopes") { test( - fir = AbstractFirSubstitutionOverridesUnwrappingTest::class, - fe10 = AbstractKtFe10SubstitutionOverridesUnwrappingTest::class, + AbstractSubstitutionOverridesUnwrappingTest::class, + generateFe10 = false, ) { model("substitutionOverridesUnwrapping") } test( - fir = AbstractFirMemberScopeByFqNameTest::class, - fe10 = null, + AbstractMemberScopeByFqNameTest::class, + generateFe10 = false, ) { model("memberScopeByFqName") } test( - fir = AbstractFirFileScopeTest::class, - fe10 = null, + AbstractFileScopeTest::class, + generateFe10 = false, ) { model("fileScopeTest", extension = "kt") } test( - fir = AbstractFirDelegateMemberScopeTest::class, - fe10 = null, + AbstractDelegateMemberScopeTest::class, + generateFe10 = false, ) { model("delegatedMemberScope") } } group("symbols") { - test( - fir = AbstractFirSymbolByPsiTest::class, - fe10 = AbstractKtFe10SymbolByPsiTest::class, - ) { + test(AbstractSymbolByPsiTest::class) { model("symbolByPsi") } test( - fir = AbstractFirSymbolByFqNameTest::class, - fe10 = AbstractKtFe10SymbolByFqNameTest::class, + AbstractSymbolByFqNameTest::class ) { model("symbolByFqName") } - test( - fir = AbstractFirSymbolByReferenceTest::class, - fe10 = AbstractKtFe10SymbolByReferenceTest::class, - ) { + test(AbstractSymbolByReferenceTest::class) { model("symbolByReference") } } group("annotations") { - test( - fir = AbstractAnalysisApiFirAnnotationsOnTypesTest::class, - fe10 = AbstractAnalysisApiFe10AnnotationsOnTypesTest::class - ) { + test(AbstractAnalysisApiAnnotationsOnTypesTest::class) { model("annotationsOnTypes") } - test( - fir = AbstractAnalysisApiFirAnnotationsOnDeclarationsTest::class, - fe10 = AbstractAnalysisApiFe10AnnotationsOnDeclarationsTest::class, - ) { + test(AbstractAnalysisApiAnnotationsOnDeclarationsTest::class) { model("annotationsOnDeclaration") } test( - fir = AbstractAnalysisApiFirAnnotationsOnFilesTest::class, - fe10 = null // TODO "fails with Rewrite at slice ANNOTATION key" - /*AbstractAnalysisApiFE10AnnotationsOnFilesTest*/ + AbstractAnalysisApiAnnotationsOnFilesTest::class, + generateFe10 = false // TODO "fails with Rewrite at slice ANNOTATION key" ) { model("annotationsOnFiles") } @@ -151,121 +121,108 @@ private fun TestGroupSuite.generateAnalysisApiNonComponentsTests() { private fun TestGroupSuite.generateAnalysisApiComponentsTests() { component("callResolver") { - test( - fir = AbstractFirResolveCallTest::class, - fe10 = AbstractKtFe10ResolveCallTest::class, - ) { + test(AbstractResolveCallTest::class) { model("resolveCall") } } component("compileTimeConstantProvider") { - test( - fir = AbstractFirCompileTimeConstantEvaluatorTest::class, fe10 = AbstractKtFe10CompileTimeConstantEvaluatorTest::class, - ) { + test(AbstractCompileTimeConstantEvaluatorTest::class) { model("evaluate") } } component("expressionInfoProvider") { - test( - fir = AbstractFirWhenMissingCasesTest::class, fe10 = AbstractKtFe10WhenMissingCasesTest::class - ) { + test(AbstractWhenMissingCasesTest::class) { model("whenMissingCases") } - test( - fir = AbstractFirReturnTargetSymbolTest::class, fe10 = AbstractKtFe10ReturnTargetSymbolTest::class - ) { + test(AbstractReturnTargetSymbolTest::class) { model("returnExpressionTargetSymbol") } } component("expressionTypeProvider") { - test( - fir = AbstractFirExpectedExpressionTypeTest::class, fe10 = AbstractKtFe10ExpectedExpressionTypeTest::class - ) { + test(AbstractExpectedExpressionTypeTest::class) { model("expectedExpressionType") } test( - fir = AbstractFirHLExpressionTypeTest::class, fe10 = AbstractKtFe10HLExpressionTypeTest::class + AbstractHLExpressionTypeTest::class ) { model("expressionType") } test( - fir = AbstractFirDeclarationReturnTypeTest::class, fe10 = AbstractKtFe10DeclarationReturnTypeTest::class + AbstractDeclarationReturnTypeTest::class ) { model("declarationReturnType") } } component("diagnosticsProvider") { - test( - fir = AbstractFirCollectDiagnosticsTest::class, fe10 = AbstractKtFe10CollectDiagnosticsTest::class - ) { + test(AbstractCollectDiagnosticsTest::class) { model("diagnostics") } } component("importOptimizer") { test( - fir = AbstractHLImportOptimizerTest::class, - fe10 = null, + AbstractHLImportOptimizerTest::class, + generateFe10 = false, ) { model("analyseImports", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) } } component("psiTypeProvider") { - test(fir = AbstractPsiTypeProviderTest::class, fe10 = null) { + test(AbstractPsiTypeProviderTest::class, generateFe10 = false) { model("psiType/forDeclaration") } - test(fir = AbstractExpressionPsiTypeProviderTest::class, fe10 = null) { + test(AbstractExpressionPsiTypeProviderTest::class, generateFe10 = false) { model("psiType/forExpression") } } component("smartCastProvider") { - test(fir = AbstractFirHLSmartCastInfoTest::class, fe10 = AbstractKtFe10HLSmartCastInfoTest::class) { + test(AbstractHLSmartCastInfoTest::class) { model("smartCastInfo") } } component("symbolDeclarationOverridesProvider") { - test(fir = AbstractFirOverriddenDeclarationProviderTest::class, fe10 = AbstractKtFe10OverriddenDeclarationProviderTest::class) { + test(AbstractOverriddenDeclarationProviderTest::class) { model("overriddenSymbols") } } component("symbolDeclarationRenderer") { - test(fir = AbstractFirRendererTest::class, fe10 = AbstractKtFe10RendererTest::class) { + test(AbstractRendererTest::class) { model("renderDeclaration") } } component("typeCreator") { - test(fir = AbstractFirTypeParameterTypeTest::class, fe10 = AbstractKtFe10TypeParameterTypeTest::class) { + test(AbstractTypeParameterTypeTest::class) { model("typeParameter") } } component("typeInfoProvider") { - test(fir = AbstractFirFunctionClassKindTest::class, fe10 = null) { + test(AbstractFunctionClassKindTest::class, generateFe10 = false) { model("functionClassKind") } - test(fir = AbstractFirGetSuperTypesTest::class, fe10 = null) { + test(AbstractFirGetSuperTypesTest::class, generateFe10 = false) { model("superTypes") } - test(fir = AbstractFirIsDenotableTest::class, fe10 = AbstractKtFe10IsDenotableTest::class) { + test(AbstractIsDenotableTest::class) { model("isDenotable", excludedPattern = ".*\\.descriptors\\.kt$") } } component("typeProvider") { - test(fir = AbstractFirHasCommonSubtypeTest::class, fe10 = AbstractKtFe10HasCommonSubtypeTest::class) { + test(AbstractHasCommonSubtypeTest::class) { model("haveCommonSubtype") } } diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl.kt deleted file mode 100644 index d38d9c6841e..00000000000 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl.kt +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.generators.tests.analysis.api - -import org.jetbrains.kotlin.generators.TestGroup -import org.jetbrains.kotlin.generators.TestGroupSuite -import kotlin.reflect.KClass - -internal class FirAndFe10TestGroup( - val suite: TestGroupSuite, - val directory: String? -) - -internal fun FirAndFe10TestGroup.test( - fir: KClass<*>?, - fe10: KClass<*>?, - init: TestGroup.TestClass.() -> Unit, -) { - if (fir != null) { - analysisApiTest("analysis/analysis-api-fir/tests", fir, init) - } - - if (fe10 != null) { - analysisApiTest("analysis/analysis-api-fe10/tests", fe10, init) - } -} - -internal fun TestGroupSuite.test( - fir: KClass<*>?, - fe10: KClass<*>?, - init: TestGroup.TestClass.() -> Unit, -) { - FirAndFe10TestGroup(this, directory = null).test(fir, fe10, init) -} - - -internal fun TestGroupSuite.group( - directory: String, - init: FirAndFe10TestGroup.() -> Unit, -) { - FirAndFe10TestGroup(this, directory).init() -} - - -internal fun TestGroupSuite.component( - directory: String, - init: FirAndFe10TestGroup.() -> Unit, -) { - group("components/$directory", init) -} - -private fun FirAndFe10TestGroup.analysisApiTest( - testRoot: String, - testClass: KClass<*>, - init: TestGroup.TestClass.() -> Unit, -) { - with(suite) { - val fullTestPath = "analysis/analysis-api/testData" + directory?.let { "/$it" }.orEmpty() - testGroup(testRoot, fullTestPath) { - testClass(testClass, useJunit4 = false) { - init() - } - } - } -} - - - diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt new file mode 100644 index 00000000000..6f0cf9d5aa2 --- /dev/null +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt @@ -0,0 +1,57 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.analysis.api.dsl + +import org.jetbrains.annotations.NotNull +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel +import org.jetbrains.kotlin.utils.Printer +import kotlin.reflect.KClass + +object FrontendConfiguratorTestGenerator : MethodGenerator() { + override val kind: MethodModel.Kind get() = FrontendConfiguratorTestModelKind + + override fun generateSignature(method: FrontendConfiguratorTestModel, p: Printer): Unit = with(p) { + println("@NotNull") + println("@Override") + print("public FrontendApiTestConfiguratorService getConfigurator()") + } + + override fun generateBody(method: FrontendConfiguratorTestModel, p: Printer): Unit = with(p) { + print("return ") + printWithNoIndent(method.frontendConfiguratorType.configuratorClass.simpleName) + printWithNoIndent(".INSTANCE") + printlnWithNoIndent(";") + } +} + +object FrontendConfiguratorTestModelKind : MethodModel.Kind() + +class FrontendConfiguratorTestModel(val frontendConfiguratorType: FrontendConfiguratorType) : MethodModel { + override val kind: MethodModel.Kind get() = FrontendConfiguratorTestModelKind + override val name: String get() = "getConfigurator" + override val dataString: String? get() = null + override val tags: List get() = emptyList() + + override fun isTestMethod(): Boolean = false + override fun shouldBeGeneratedForInnerTestClass(): Boolean = false + + override fun imports(): Collection> { + return buildList { + add(NotNull::class.java) + add(FrontendApiTestConfiguratorService::class.java) + add(frontendConfiguratorType.configuratorClass.java) + } + } + + enum class FrontendConfiguratorType(val configuratorClass: KClass) { + FIR(FirFrontendApiTestConfiguratorService::class), + FE10(KtFe10FrontendApiTestConfiguratorService::class); + } +} \ No newline at end of file diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt new file mode 100644 index 00000000000..5186e97ac32 --- /dev/null +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt @@ -0,0 +1,101 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.analysis.api.dsl + +import org.jetbrains.kotlin.generators.TestGroup +import org.jetbrains.kotlin.generators.TestGroupSuite +import org.jetbrains.kotlin.generators.getDefaultSuiteTestClassName +import kotlin.reflect.KClass + +internal class FirAndFe10TestGroup( + val suite: TestGroupSuite, + val directory: String? +) + +internal fun FirAndFe10TestGroup.test( + baseClass: KClass<*>, + generateFe10: Boolean = true, + init: TestGroup.TestClass.() -> Unit, +) { + analysisApiTest( + "analysis/analysis-api-fir/tests", + FrontendConfiguratorTestModel.FrontendConfiguratorType.FIR, + baseClass, + init + ) + if (generateFe10) { + analysisApiTest( + "analysis/analysis-api-fe10/tests", + FrontendConfiguratorTestModel.FrontendConfiguratorType.FE10, + baseClass, + init + ) + } +} + + +internal fun TestGroupSuite.test( + baseClass: KClass<*>, + addFe10: Boolean = true, + init: TestGroup.TestClass.() -> Unit, +) { + FirAndFe10TestGroup(this, directory = null).test(baseClass, addFe10, init) +} + + +internal fun TestGroupSuite.group( + directory: String, + init: FirAndFe10TestGroup.() -> Unit, +) { + FirAndFe10TestGroup(this, directory).init() +} + + +internal fun TestGroupSuite.component( + directory: String, + init: FirAndFe10TestGroup.() -> Unit, +) { + group("components/$directory", init) +} + +private fun FirAndFe10TestGroup.analysisApiTest( + testRoot: String, + frontendConfiguratorType: FrontendConfiguratorTestModel.FrontendConfiguratorType, + testClass: KClass<*>, + init: TestGroup.TestClass.() -> Unit, +) { + with(suite) { + val fullTestPath = "analysis/analysis-api/testData" + directory?.let { "/$it" }.orEmpty() + testGroup(testRoot, fullTestPath) { + val prefix = when (frontendConfiguratorType) { + FrontendConfiguratorTestModel.FrontendConfiguratorType.FIR -> "Fir" + FrontendConfiguratorTestModel.FrontendConfiguratorType.FE10 -> "Fe10" + } + val fullPackage = getPackageName(prefix, testClass) + + testClass( + testClass, + suiteTestClassName = fullPackage + prefix + getDefaultSuiteTestClassName(testClass.java.simpleName), + useJunit4 = false + ) { + method(FrontendConfiguratorTestModel(frontendConfiguratorType)) + init() + } + } + } +} + +private fun getPackageName(prefix: String, testClass: KClass<*>): String { + val basePrefix = "org.jetbrains.kotlin.analysis.api.${prefix.lowercase()}" + val packagePrefix = testClass.java.name + .substringAfter("org.jetbrains.kotlin.analysis.api.impl.base.test.") + .substringBeforeLast('.', "") + + return if (packagePrefix.isEmpty()) "$basePrefix." else "$basePrefix.$packagePrefix." +} + + + diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGenerationDSL.kt index 577cff0dd6e..87eb9c38803 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGenerationDSL.kt @@ -7,19 +7,21 @@ package org.jetbrains.kotlin.generators fun generateTestGroupSuiteWithJUnit5( args: Array, + additionalMethodGenerators: List> = emptyList(), init: TestGroupSuite.() -> Unit ) { - generateTestGroupSuiteWithJUnit5(InconsistencyChecker.hasDryRunArg(args), init) + generateTestGroupSuiteWithJUnit5(InconsistencyChecker.hasDryRunArg(args), additionalMethodGenerators, init) } fun generateTestGroupSuiteWithJUnit5( dryRun: Boolean = false, + additionalMethodGenerators: List> = emptyList(), init: TestGroupSuite.() -> Unit ) { val suite = TestGroupSuite(ReflectionBasedTargetBackendComputer).apply(init) for (testGroup in suite.testGroups) { for (testClass in testGroup.testClasses) { - val (changed, testSourceFilePath) = NewTestGeneratorImpl.generateAndSave(testClass, dryRun) + val (changed, testSourceFilePath) = NewTestGeneratorImpl(additionalMethodGenerators).generateAndSave(testClass, dryRun) if (changed) { InconsistencyChecker.inconsistencyChecker(dryRun).add(testSourceFilePath) } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt index 22ba13f0b0f..a2b04b9e636 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt @@ -29,7 +29,10 @@ private val METHOD_GENERATORS = listOf( TransformingTestMethodGenerator, ) -object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { +class NewTestGeneratorImpl( + additionalMethodGenerators: List> +) : TestGenerator(METHOD_GENERATORS + additionalMethodGenerators) { + private val GENERATED_FILES = HashSet() private fun Printer.generateMetadata(testDataSource: TestEntityModel) { @@ -84,7 +87,7 @@ object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { return generatorInstance.generateAndSave(dryRun) } - private class TestGeneratorInstance( + private inner class TestGeneratorInstance( baseDir: String, suiteTestClassFqName: String, baseTestClassFqName: String, @@ -95,7 +98,8 @@ object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { private val baseTestClassName: String = baseTestClassFqName.substringAfterLast('.', baseTestClassFqName) private val suiteClassPackage: String = suiteTestClassFqName.substringBeforeLast('.', baseTestClassPackage) private val suiteClassName: String = suiteTestClassFqName.substringAfterLast('.', suiteTestClassFqName) - private val testSourceFilePath: String = baseDir + "/" + this.suiteClassPackage.replace(".", "/") + "/" + this.suiteClassName + ".java" + private val testSourceFilePath: String = + baseDir + "/" + this.suiteClassPackage.replace(".", "/") + "/" + this.suiteClassName + ".java" init { if (!GENERATED_FILES.add(testSourceFilePath)) { @@ -256,9 +260,11 @@ object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { private fun generateTestMethod(p: Printer, methodModel: MethodModel) { val generator = methodGenerators.getValue(methodModel.kind) - p.generateTestAnnotation() - p.generateTags(methodModel) - p.generateMetadata(methodModel) + if (methodModel.isTestMethod()) { + p.generateTestAnnotation() + p.generateTags(methodModel) + p.generateMetadata(methodModel) + } generator.hackyGenerateSignature(methodModel, p) p.printWithNoIndent(" {") p.println() diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt index e5cef3a31a4..3ab2e8c66ca 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt @@ -86,6 +86,11 @@ class TestGroup( get() = this@TestGroup.testsRoot val testModels = ArrayList() + private val methodModels = mutableListOf() + + fun method(method: MethodModel) { + methodModels += method + } fun model( relativeRootPath: String, @@ -117,14 +122,14 @@ class TestGroup( SingleClassTestModel( rootFile, compiledPattern, compiledExcludedPattern, filenameStartsLowerCase, testMethod, className, realTargetBackend, skipIgnored, testRunnerMethodName, additionalRunnerArguments, annotations, - extractTagsFromDirectory(rootFile) + extractTagsFromDirectory(rootFile), methodModels ) } else { SimpleTestClassModel( rootFile, recursive, excludeParentDirs, compiledPattern, compiledExcludedPattern, filenameStartsLowerCase, testMethod, className, realTargetBackend, excludeDirs, skipIgnored, testRunnerMethodName, additionalRunnerArguments, deep, annotations, - extractTagsFromDirectory(rootFile) + extractTagsFromDirectory(rootFile), methodModels ) } ) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt index b19262d8fca..e3339973fdf 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt @@ -30,7 +30,8 @@ class SimpleTestClassModel( private val additionalRunnerArguments: List, private val deep: Int?, override val annotations: Collection, - override val tags: List + override val tags: List, + private val additionalMethods: Collection, ) : TestClassModel() { override val name: String get() = testClassName @@ -63,7 +64,8 @@ class SimpleTestClassModel( additionalRunnerArguments, if (deep != null) deep - 1 else null, annotations, - extractTagsFromDirectory(file) + extractTagsFromDirectory(file), + additionalMethods.filter { it.shouldBeGeneratedForInnerTestClass() }, ) ) } @@ -100,6 +102,7 @@ class SimpleTestClassModel( val result = mutableListOf() result.add(RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments)) result.add(TestAllFilesPresentMethodModel()) + result.addAll(additionalMethods) val listFiles = rootFile.listFiles() if (listFiles != null && (deep == null || deep == 0)) { for (file in listFiles) { diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt index bee3bc2962b..1c4e513259f 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt @@ -23,7 +23,8 @@ class SingleClassTestModel( private val testRunnerMethodName: String, private val additionalRunnerArguments: List, override val annotations: List, - override val tags: List + override val tags: List, + private val additionalMethods: Collection, ) : TestClassModel() { override val name: String get() = testClassName @@ -32,6 +33,7 @@ class SingleClassTestModel( val result: MutableList = ArrayList() result.add(RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments)) result.add(TestAllFilesPresentMethodModel()) + result.addAll(additionalMethods) FileUtil.processFilesRecursively(rootFile) { file: File -> if (!file.isDirectory && filenamePattern.matcher(file.name).matches()) { result.addAll(getTestMethodsFromFile(file)) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt index 4c11d6cc50f..7ecec5dde89 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt @@ -35,6 +35,8 @@ interface MethodModel : TestEntityModel { abstract class Kind val kind: Kind + fun isTestMethod(): Boolean = true + fun shouldBeGeneratedForInnerTestClass(): Boolean = true fun shouldBeGenerated(): Boolean = true fun imports(): Collection> = emptyList() }