[Test] Extract main compiler test generator to separate project

This is needed because now we have different tests modules with different
  test frameworks (JUnit3 and JUnit5) which has no dependencies between
  each other. So for keeping all test generation config in one place
  we need module which may rely on all independent test modules
This commit is contained in:
Dmitriy Novozhilov
2020-12-18 12:33:40 +03:00
committed by TeamCityServer
parent d753d21dee
commit 1f258c28fc
12 changed files with 70 additions and 29 deletions
@@ -1,677 +0,0 @@
/*
* Copyright 2010-2018 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
import org.jetbrains.kotlin.asJava.AbstractCompilerLightClassTest
import org.jetbrains.kotlin.cfg.AbstractControlFlowTest
import org.jetbrains.kotlin.cfg.AbstractDataFlowTest
import org.jetbrains.kotlin.cfg.AbstractPseudoValueTest
import org.jetbrains.kotlin.checkers.*
import org.jetbrains.kotlin.checkers.javac.*
import org.jetbrains.kotlin.cli.AbstractCliTest
import org.jetbrains.kotlin.codegen.*
import org.jetbrains.kotlin.codegen.debugInformation.AbstractIrLocalVariableTest
import org.jetbrains.kotlin.codegen.debugInformation.AbstractIrSteppingTest
import org.jetbrains.kotlin.codegen.debugInformation.AbstractLocalVariableTest
import org.jetbrains.kotlin.codegen.debugInformation.AbstractSteppingTest
import org.jetbrains.kotlin.codegen.defaultConstructor.AbstractDefaultArgumentsReflectionTest
import org.jetbrains.kotlin.codegen.flags.AbstractWriteFlagsTest
import org.jetbrains.kotlin.codegen.ir.*
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.builder.AbstractPartialRawFirBuilderTestCase
import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderLazyBodiesTestCase
import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderSourceElementMappingTestCase
import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
import org.jetbrains.kotlin.fir.java.AbstractFirOldFrontendLightClassesTest
import org.jetbrains.kotlin.fir.java.AbstractFirTypeEnhancementTest
import org.jetbrains.kotlin.fir.java.AbstractOwnFirTypeEnhancementTest
import org.jetbrains.kotlin.fir.lightTree.AbstractLightTree2FirConverterTestCase
import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite
import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME
import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME
import org.jetbrains.kotlin.integration.AbstractAntTaskTest
import org.jetbrains.kotlin.ir.AbstractIrCfgTestCase
import org.jetbrains.kotlin.ir.AbstractIrJsTextTestCase
import org.jetbrains.kotlin.ir.AbstractIrSourceRangesTestCase
import org.jetbrains.kotlin.ir.AbstractIrTextTestCase
import org.jetbrains.kotlin.jvm.compiler.*
import org.jetbrains.kotlin.jvm.compiler.ir.AbstractIrCompileJavaAgainstKotlinTest
import org.jetbrains.kotlin.jvm.compiler.ir.AbstractIrCompileKotlinAgainstJavaTest
import org.jetbrains.kotlin.jvm.compiler.ir.AbstractIrLoadJavaTest
import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJavaUsingJavacTest
import org.jetbrains.kotlin.lexer.kdoc.AbstractKDocLexerTest
import org.jetbrains.kotlin.lexer.kotlin.AbstractKotlinLexerTest
import org.jetbrains.kotlin.modules.xml.AbstractModuleXmlParserTest
import org.jetbrains.kotlin.multiplatform.AbstractMultiPlatformIntegrationTest
import org.jetbrains.kotlin.parsing.AbstractParsingTest
import org.jetbrains.kotlin.renderer.AbstractDescriptorRendererTest
import org.jetbrains.kotlin.renderer.AbstractFunctionDescriptorInExpressionRendererTest
import org.jetbrains.kotlin.repl.AbstractReplInterpreterTest
import org.jetbrains.kotlin.resolve.AbstractResolveTest
import org.jetbrains.kotlin.resolve.annotation.AbstractAnnotationParameterTest
import org.jetbrains.kotlin.resolve.calls.AbstractResolvedCallsTest
import org.jetbrains.kotlin.resolve.calls.AbstractResolvedConstructorDelegationCallsTests
import org.jetbrains.kotlin.resolve.constants.evaluate.AbstractCompileTimeConstantEvaluatorTest
import org.jetbrains.kotlin.resolve.constraintSystem.AbstractConstraintSystemTest
import org.jetbrains.kotlin.serialization.AbstractLocalClassProtoTest
import org.jetbrains.kotlin.test.TargetBackend
import org.jetbrains.kotlin.types.AbstractTypeBindingTest
import org.jetbrains.kotlin.visualizer.fir.AbstractFirVisualizer
import org.jetbrains.kotlin.visualizer.psi.AbstractPsiVisualizer
fun main(args: Array<String>) {
System.setProperty("java.awt.headless", "true")
generateTestGroupSuite(args) {
testGroup("compiler/tests-gen", "compiler/testData") {
testClass<AbstractDiagnosticsTestWithJsStdLibAndBackendCompilation> {
model("diagnostics/testsWithJsStdLibAndBackendCompilation")
}
testClass<AbstractDiagnosticsWithJdk15Test> {
model("diagnostics/testsWithJava15")
}
testClass<AbstractMultiPlatformIntegrationTest> {
model("multiplatform", extension = null, recursive = true, excludeParentDirs = true)
}
testClass<AbstractForeignAnnotationsTest> {
model("foreignAnnotations/tests")
}
testClass<AbstractForeignAnnotationsNoAnnotationInClasspathTest> {
model("foreignAnnotations/tests")
}
testClass<AbstractForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTest> {
model("foreignAnnotations/tests")
}
testClass<AbstractJavacForeignAnnotationsTest> {
model("foreignAnnotations/tests")
}
testClass<AbstractResolveTest> {
model("resolve", extension = "resolve")
}
testClass<AbstractResolvedCallsTest> {
model("resolvedCalls", excludeDirs = listOf("enhancedSignatures"))
}
testClass<AbstractResolvedConstructorDelegationCallsTests> {
model("resolveConstructorDelegationCalls")
}
testClass<AbstractConstraintSystemTest> {
model("constraintSystem", extension = "constraints")
}
testClass<AbstractParsingTest> {
model("psi", testMethod = "doParsingTest", pattern = "^(.*)\\.kts?$")
model("parseCodeFragment/expression", testMethod = "doExpressionCodeFragmentParsingTest", extension = "kt")
model("parseCodeFragment/block", testMethod = "doBlockCodeFragmentParsingTest", extension = "kt")
}
testClass<AbstractBlackBoxCodegenTest> {
model("codegen/box", targetBackend = TargetBackend.JVM)
}
testClass<AbstractLightAnalysisModeTest> {
// "ranges/stepped" is excluded because it contains hundreds of generated tests and only have a box() method.
// There isn't much to be gained from running light analysis tests on them.
model("codegen/box", targetBackend = TargetBackend.JVM, skipIgnored = true, excludeDirs = listOf("ranges/stepped"))
}
testClass<AbstractKapt3BuilderModeBytecodeShapeTest> {
model("codegen/kapt", targetBackend = TargetBackend.JVM)
}
testClass<AbstractAsmLikeInstructionListingTest> {
model("codegen/asmLike", targetBackend = TargetBackend.JVM)
}
testClass<AbstractBlackBoxInlineCodegenTest> {
model("codegen/boxInline", targetBackend = TargetBackend.JVM)
}
testClass<AbstractBlackBoxAgainstJavaCodegenTest> {
model("codegen/boxAgainstJava")
}
testClass<AbstractJdk15BlackBoxCodegenTest> {
model("codegen/java15/box")
}
testClass<AbstractJdk15IrBlackBoxCodegenTest> {
model("codegen/java15/box", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractJdk9BlackBoxCodegenTest> {
model("codegen/java9/box")
}
testClass<AbstractScriptCodegenTest> {
model("codegen/script", extension = "kts")
}
testClass<AbstractCustomScriptCodegenTest> {
model("codegen/customScript", pattern = "^(.*)$")
}
testClass<AbstractBytecodeTextTest> {
model("codegen/bytecodeText", targetBackend = TargetBackend.JVM)
}
testClass<AbstractIrTextTestCase> {
model("ir/irText")
}
testClass<AbstractIrJsTextTestCase> {
model("ir/irJsText", pattern = "^(.+)\\.kt(s)?\$")
}
testClass<AbstractIrCfgTestCase> {
model("ir/irCfg")
}
testClass<AbstractIrSourceRangesTestCase> {
model("ir/sourceRanges")
}
testClass<AbstractBytecodeListingTest> {
model("codegen/bytecodeListing", targetBackend = TargetBackend.JVM)
}
testClass<AbstractTopLevelMembersInvocationTest> {
model("codegen/topLevelMemberInvocation", extension = null, recursive = false)
}
testClass<AbstractCheckLocalVariablesTableTest> {
model("checkLocalVariablesTable", targetBackend = TargetBackend.JVM)
}
testClass<AbstractWriteFlagsTest> {
model("writeFlags", targetBackend = TargetBackend.JVM)
}
testClass<AbstractDefaultArgumentsReflectionTest> {
model("codegen/defaultArguments/reflection")
}
testClass<AbstractDumpDeclarationsTest> {
model("codegen/dumpDeclarations")
}
testClass<AbstractLoadJavaTest> {
model("loadJava/compiledJava", extension = "java", testMethod = "doTestCompiledJava")
model("loadJava/compiledJavaAndKotlin", extension = "txt", testMethod = "doTestCompiledJavaAndKotlin")
model(
"loadJava/compiledJavaIncludeObjectMethods",
extension = "java",
testMethod = "doTestCompiledJavaIncludeObjectMethods"
)
model("loadJava/compiledKotlin", testMethod = "doTestCompiledKotlin")
model("loadJava/compiledKotlinWithStdlib", testMethod = "doTestCompiledKotlinWithStdlib")
model("loadJava/javaAgainstKotlin", extension = "txt", testMethod = "doTestJavaAgainstKotlin")
model(
"loadJava/kotlinAgainstCompiledJavaWithKotlin",
extension = "kt",
testMethod = "doTestKotlinAgainstCompiledJavaWithKotlin",
recursive = false
)
model("loadJava/sourceJava", extension = "java", testMethod = "doTestSourceJava")
}
testClass<AbstractLoadJavaUsingJavacTest> {
model("loadJava/compiledJava", extension = "java", testMethod = "doTestCompiledJava")
model("loadJava/compiledJavaAndKotlin", extension = "txt", testMethod = "doTestCompiledJavaAndKotlin")
model(
"loadJava/compiledJavaIncludeObjectMethods",
extension = "java",
testMethod = "doTestCompiledJavaIncludeObjectMethods"
)
model("loadJava/compiledKotlin", testMethod = "doTestCompiledKotlin")
model("loadJava/compiledKotlinWithStdlib", testMethod = "doTestCompiledKotlinWithStdlib")
model("loadJava/javaAgainstKotlin", extension = "txt", testMethod = "doTestJavaAgainstKotlin")
model(
"loadJava/kotlinAgainstCompiledJavaWithKotlin",
extension = "kt",
testMethod = "doTestKotlinAgainstCompiledJavaWithKotlin",
recursive = false
)
model("loadJava/sourceJava", extension = "java", testMethod = "doTestSourceJava")
}
testClass<AbstractLoadKotlinWithTypeTableTest> {
model("loadJava/compiledKotlin")
}
testClass<AbstractLoadJavaWithPsiClassReadingTest> {
model("loadJava/compiledJava", extension = "java", testMethod = "doTestCompiledJava")
}
testClass<AbstractLoadJava15Test> {
model("loadJava15", extension = "java", testMethod = "doTestCompiledJava", testClassName = "CompiledJava")
model("loadJava15", extension = "java", testMethod = "doTestSourceJava", testClassName = "SourceJava")
}
testClass<AbstractLoadJava15WithPsiClassReadingTest> {
model("loadJava15", extension = "java", testMethod = "doTestCompiledJava")
}
testClass<AbstractCompileJavaAgainstKotlinTest> {
model(
"compileJavaAgainstKotlin",
testClassName = "WithoutJavac",
testMethod = "doTestWithoutJavac",
targetBackend = TargetBackend.JVM
)
model(
"compileJavaAgainstKotlin",
testClassName = "WithJavac",
testMethod = "doTestWithJavac",
targetBackend = TargetBackend.JVM
)
}
testClass<AbstractCompileKotlinAgainstJavaTest> {
model(
"compileKotlinAgainstJava",
testClassName = "WithAPT",
testMethod = "doTestWithAPT",
targetBackend = TargetBackend.JVM
)
model(
"compileKotlinAgainstJava",
testClassName = "WithoutAPT",
testMethod = "doTestWithoutAPT",
targetBackend = TargetBackend.JVM
)
}
testClass<AbstractCompileKotlinAgainstKotlinTest> {
model("compileKotlinAgainstKotlin")
}
testClass<AbstractCompileKotlinAgainstKotlinJdk15Test> {
model("compileKotlinAgainstKotlinJdk15")
}
testClass<AbstractIrCompileKotlinAgainstKotlinJdk15Test> {
model("compileKotlinAgainstKotlinJdk15", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractDescriptorRendererTest> {
model("renderer")
}
testClass<AbstractFunctionDescriptorInExpressionRendererTest> {
model("renderFunctionDescriptorInExpression")
}
testClass<AbstractModuleXmlParserTest> {
model("modules.xml", extension = "xml")
}
testClass<AbstractWriteSignatureTest> {
model("writeSignature")
}
testClass<AbstractCliTest> {
model("cli/jvm", extension = "args", testMethod = "doJvmTest", recursive = false)
model("cli/js", extension = "args", testMethod = "doJsTest", recursive = false)
model("cli/js-dce", extension = "args", testMethod = "doJsDceTest", recursive = false)
model("cli/metadata", extension = "args", testMethod = "doMetadataTest", recursive = false)
}
testClass<AbstractReplInterpreterTest> {
model("repl", extension = "repl")
}
testClass<AbstractAntTaskTest> {
model("integration/ant/jvm", extension = null, recursive = false, excludeParentDirs = true)
}
testClass<AbstractControlFlowTest> {
model("cfg")
model("cfgWithStdLib", testMethod = "doTestWithStdLib")
}
testClass<AbstractDataFlowTest> {
model("cfg-variables")
model("cfgVariablesWithStdLib", testMethod = "doTestWithStdLib")
}
testClass<AbstractPseudoValueTest> {
model("cfg")
model("cfgWithStdLib", testMethod = "doTestWithStdLib")
model("cfg-variables")
model("cfgVariablesWithStdLib", testMethod = "doTestWithStdLib")
}
testClass<AbstractAnnotationParameterTest> {
model("resolveAnnotations/parameters")
}
testClass<AbstractCompileTimeConstantEvaluatorTest> {
model("evaluate/constant", testMethod = "doConstantTest")
model("evaluate/isPure", testMethod = "doIsPureTest")
model("evaluate/usesVariableAsConstant", testMethod = "doUsesVariableAsConstantTest")
}
testClass<AbstractCompilerLightClassTest> {
model("asJava/lightClasses", excludeDirs = listOf("local", "ideRegression"), pattern = KT_OR_KTS_WITHOUT_DOTS_IN_NAME)
}
testClass<AbstractTypeBindingTest> {
model("type/binding")
}
testClass<AbstractSteppingTest>(useJunit4 = true) {
model("debug/stepping", targetBackend = TargetBackend.JVM)
}
testClass<AbstractLocalVariableTest>(useJunit4 = true) {
model("debug/localVariables", targetBackend = TargetBackend.JVM)
}
testClass<AbstractLocalClassProtoTest> {
model("serialization/local")
}
testClass<AbstractKDocLexerTest> {
model("lexer/kdoc")
}
testClass<AbstractKotlinLexerTest> {
model("lexer/kotlin")
}
testClass<AbstractComposeLikeIrBlackBoxCodegenTest> {
model("codegen/composeLike", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractComposeLikeIrBytecodeTextTest> {
model("codegen/composeLikeBytecodeText", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrBlackBoxCodegenTest> {
model("codegen/box", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractIrBlackBoxAgainstJavaCodegenTest> {
model("codegen/boxAgainstJava", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractIrCompileJavaAgainstKotlinTest> {
model(
"compileJavaAgainstKotlin",
testClassName = "WithoutJavac",
testMethod = "doTestWithoutJavac",
targetBackend = TargetBackend.JVM_IR
)
model(
"compileJavaAgainstKotlin",
testClassName = "WithJavac",
testMethod = "doTestWithJavac",
targetBackend = TargetBackend.JVM_IR
)
}
testClass<AbstractIrCompileKotlinAgainstJavaTest> {
model(
"compileKotlinAgainstJava",
testClassName = "WithAPT",
testMethod = "doTestWithAPT",
targetBackend = TargetBackend.JVM_IR
)
model(
"compileKotlinAgainstJava",
testClassName = "WithoutAPT",
testMethod = "doTestWithoutAPT",
targetBackend = TargetBackend.JVM_IR
)
}
testClass<AbstractIrCompileKotlinAgainstKotlinTest> {
model("compileKotlinAgainstKotlin", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractJvmIrAgainstOldBoxTest> {
model("compileKotlinAgainstKotlin", targetBackend = TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD)
}
testClass<AbstractJvmOldAgainstIrBoxTest> {
model(
"compileKotlinAgainstKotlin",
targetBackend = TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR
)
}
testClass<AbstractIrBytecodeListingTest> {
model("codegen/bytecodeListing", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrCheckLocalVariablesTableTest> {
model("checkLocalVariablesTable", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrWriteFlagsTest> {
model("writeFlags", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrWriteSignatureTest> {
model("writeSignature", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrLoadJavaTest> {
model("loadJava/compiledJava", extension = "java", testMethod = "doTestCompiledJava", targetBackend = TargetBackend.JVM_IR)
model(
"loadJava/compiledJavaAndKotlin",
extension = "txt",
testMethod = "doTestCompiledJavaAndKotlin",
targetBackend = TargetBackend.JVM_IR
)
model(
"loadJava/compiledJavaIncludeObjectMethods",
extension = "java",
testMethod = "doTestCompiledJavaIncludeObjectMethods",
targetBackend = TargetBackend.JVM_IR
)
model("loadJava/compiledKotlin", testMethod = "doTestCompiledKotlin", targetBackend = TargetBackend.JVM_IR)
model(
"loadJava/compiledKotlinWithStdlib",
testMethod = "doTestCompiledKotlinWithStdlib",
targetBackend = TargetBackend.JVM_IR
)
model(
"loadJava/javaAgainstKotlin",
extension = "txt",
testMethod = "doTestJavaAgainstKotlin",
targetBackend = TargetBackend.JVM_IR
)
model(
"loadJava/kotlinAgainstCompiledJavaWithKotlin",
extension = "kt",
testMethod = "doTestKotlinAgainstCompiledJavaWithKotlin",
recursive = false,
targetBackend = TargetBackend.JVM_IR
)
model("loadJava/sourceJava", extension = "java", testMethod = "doTestSourceJava", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrSteppingTest>(useJunit4 = true) {
model("debug/stepping", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrLocalVariableTest>(useJunit4 = true) {
model("debug/localVariables", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrBlackBoxInlineCodegenTest> {
model("codegen/boxInline", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrBytecodeTextTest> {
model("codegen/bytecodeText", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractIrAsmLikeInstructionListingTest> {
model("codegen/asmLike", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractIrScriptCodegenTest> {
model("codegen/script", extension = "kts", targetBackend = TargetBackend.JVM_IR)
}
}
testGroup(
"compiler/fir/fir2ir/tests-gen", "compiler/testData",
testRunnerMethodName = "runTestWithCustomIgnoreDirective",
additionalRunnerArguments = listOf("\"// IGNORE_BACKEND_FIR: \"")
) {
testClass<AbstractFirBlackBoxCodegenTest> {
model("codegen/box", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractFirBlackBoxInlineCodegenTest> {
model("codegen/boxInline", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractFirBlackBoxAgainstJavaCodegenTest> {
model("codegen/boxAgainstJava", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractFirBytecodeTextTest> {
model("codegen/bytecodeText", targetBackend = TargetBackend.JVM_IR, excludeDirs = listOf("oldLanguageVersions"))
}
testClass<AbstractFirCompileKotlinAgainstKotlinTest> {
model("compileKotlinAgainstKotlin", targetBackend = TargetBackend.JVM_IR)
}
}
testGroup(
"compiler/tests-gen", "compiler/testData",
testRunnerMethodName = "runTestWithCustomIgnoreDirective",
additionalRunnerArguments = listOf("\"// IGNORE_BACKEND_MULTI_MODULE: \"")
) {
testClass<AbstractCompileKotlinAgainstInlineKotlinTest> {
model("codegen/boxInline", targetBackend = TargetBackend.JVM)
}
testClass<AbstractIrCompileKotlinAgainstInlineKotlinTest> {
model("codegen/boxInline", targetBackend = TargetBackend.JVM_IR)
}
testClass<AbstractJvmIrAgainstOldBoxInlineTest> {
model("codegen/boxInline", targetBackend = TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD)
}
testClass<AbstractJvmOldAgainstIrBoxInlineTest> {
model(
"codegen/boxInline",
targetBackend = TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR
)
}
}
testGroup("compiler/fir/raw-fir/psi2fir/tests-gen", "compiler/fir/raw-fir/psi2fir/testData") {
testClass<AbstractRawFirBuilderTestCase> {
model("rawBuilder", testMethod = "doRawFirTest")
}
testClass<AbstractRawFirBuilderLazyBodiesTestCase> {
model("rawBuilder", testMethod = "doRawFirTest")
}
testClass<AbstractRawFirBuilderSourceElementMappingTestCase> {
model("sourceElementMapping", testMethod = "doRawFirTest")
}
}
testGroup("compiler/fir/raw-fir/psi2fir/tests-gen", "compiler/fir/raw-fir/psi2fir/testData") {
testClass<AbstractPartialRawFirBuilderTestCase> {
model("partialRawBuilder", testMethod = "doRawFirTest")
}
}
testGroup("compiler/fir/raw-fir/light-tree2fir/tests-gen", "compiler/fir/raw-fir/psi2fir/testData") {
testClass<AbstractLightTree2FirConverterTestCase> {
model("rawBuilder")
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/fir/analysis-tests/testData") {
testClass<AbstractLazyBodyIsNotTouchedTilContractsPhaseTest> {
model("resolve", pattern = KT_WITHOUT_DOTS_IN_NAME)
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/testData") {
testClass<AbstractFirLoadCompiledKotlin> {
model("loadJava/compiledKotlin", extension = "kt")
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/testData") {
testClass<AbstractFirTypeEnhancementTest> {
model("loadJava/compiledJava", extension = "java")
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/fir/analysis-tests/testData") {
testClass<AbstractOwnFirTypeEnhancementTest> {
model("enhancement", extension = "java")
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/fir/analysis-tests/testData") {
testClass<AbstractFirOldFrontendLightClassesTest> {
model("lightClasses")
}
}
testGroup(
"compiler/fir/fir2ir/tests-gen", "compiler/testData",
testRunnerMethodName = "runTestWithCustomIgnoreDirective",
additionalRunnerArguments = listOf("\"// IGNORE_BACKEND_FIR: \"")
) {
testClass<AbstractFir2IrTextTest> {
model("ir/irText")
}
}
testGroup("compiler/visualizer/tests-gen", "compiler/fir/raw-fir/psi2fir/testData") {
testClass<AbstractPsiVisualizer>("PsiVisualizerForRawFirDataGenerated") {
model("rawBuilder", testMethod = "doFirBuilderDataTest")
}
testClass<AbstractFirVisualizer>("FirVisualizerForRawFirDataGenerated") {
model("rawBuilder", testMethod = "doFirBuilderDataTest")
}
}
testGroup("compiler/visualizer/tests-gen", "compiler/visualizer/testData") {
testClass<AbstractPsiVisualizer>("PsiVisualizerForUncommonCasesGenerated") {
model("uncommonCases/testFiles", testMethod = "doUncommonCasesTest")
}
testClass<AbstractFirVisualizer>("FirVisualizerForUncommonCasesGenerated") {
model("uncommonCases/testFiles", testMethod = "doUncommonCasesTest")
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/fir/analysis-tests/testData") {
testClass<AbstractExtendedFirDiagnosticsTest> {
model("extendedCheckers", pattern = KT_WITHOUT_DOTS_IN_NAME)
}
}
testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/fir/analysis-tests/testData") {
testClass<AbstractExtendedFirWithLightTreeDiagnosticsTest> {
model("extendedCheckers", pattern = KT_WITHOUT_DOTS_IN_NAME)
}
}
}
}