FIR IDE: simplify test generation dsl

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<String>) {
     System.setProperty("java.awt.headless", "true")
-    generateTestGroupSuiteWithJUnit5(args) {
+    generateTestGroupSuiteWithJUnit5(args, additionalMethodGenerators = listOf(FrontendConfiguratorTestGenerator)) {
         generateTests()
     }
 }

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")
         }
     }

generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl.kt

@@ -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()
-            }
-        }
-    }
-}
-
-
-

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<FrontendConfiguratorTestModel>() {
+    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<String> get() = emptyList()
+
+    override fun isTestMethod(): Boolean = false
+    override fun shouldBeGeneratedForInnerTestClass(): Boolean = false
+
+    override fun imports(): Collection<Class<*>> {
+        return buildList {
+            add(NotNull::class.java)
+            add(FrontendApiTestConfiguratorService::class.java)
+            add(frontendConfiguratorType.configuratorClass.java)
+        }
+    }
+
+    enum class FrontendConfiguratorType(val configuratorClass: KClass<out FrontendApiTestConfiguratorService>) {
+        FIR(FirFrontendApiTestConfiguratorService::class),
+        FE10(KtFe10FrontendApiTestConfiguratorService::class);
+    }
+}

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."
+}
+
+
+