From a795c38eb7c998bf07f4b7b181d5223356f2088d Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Thu, 20 Feb 2020 17:01:07 +0100 Subject: [PATCH] Introduce base class for codegen and diagnostic tests Extract base TestFile and TestModule classes. Move coroutinePackage related logic to base class --- .../android/tests/AndroidTestGenerator.kt | 3 +- .../kotlin/fir/AbstractFir2IrTextTest.kt | 38 ++++----- .../java/AbstractFirTypeEnhancementTest.kt | 2 +- .../asJava/AbstractCompilerLightClassTest.kt | 18 +++- .../checkers/AbstractDiagnosticsTest.kt | 3 +- .../kotlin/checkers/BaseDiagnosticsTest.kt | 38 ++++----- .../checkers/KotlinMultiFileTestWithJava.java | 41 ++++----- .../AbstractBlackBoxAgainstJavaCodegenTest.kt | 2 +- .../codegen/AbstractBlackBoxCodegenTest.java | 4 +- ...bstractCompileKotlinAgainstKotlinTest.java | 4 +- ...stractKapt3BuilderModeBytecodeShapeTest.kt | 2 +- .../kotlin/codegen/AbstractLineNumberTest.kt | 7 +- .../kotlin/codegen/CodegenTestCase.java | 52 ++---------- .../jetbrains/kotlin/codegen/SMAPTestUtil.kt | 7 +- ...bstractDefaultArgumentsReflectionTest.java | 3 +- .../codegen/flags/AbstractWriteFlagsTest.java | 4 +- .../compiler/AbstractWriteSignatureTest.kt | 2 +- .../jetbrains/kotlin/test/KotlinBaseTest.kt | 84 +++++++++++++++++++ .../org/jetbrains/kotlin/test/TestFiles.java | 39 +++++++-- .../AbstractBlackBoxCodegenTestSpec.kt | 16 ++-- .../AbstractCustomScriptCodegenTest.kt | 2 +- .../kotlin/visualizer/AbstractVisualizer.kt | 16 +++- .../AbstractKotlinEvaluateExpressionTest.kt | 6 +- .../test/DebuggerTestCompilerFacility.kt | 2 +- .../debugger/test/KotlinDescriptorTestCase.kt | 4 +- .../debugger/test/util/SteppingInstruction.kt | 8 +- .../js/test/AbstractJsLineNumberTest.kt | 22 ++--- .../jetbrains/kotlin/js/test/BasicBoxTest.kt | 14 ++-- .../kapt3/test/AbstractKotlinKapt3Test.kt | 2 +- 29 files changed, 257 insertions(+), 188 deletions(-) create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt index be40b754114..668a9d8b116 100644 --- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt +++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.codegen.CodegenTestCase import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.test.KotlinBaseTest import java.io.File import java.util.regex.Pattern @@ -34,7 +35,7 @@ private data class OldPackageAndNew(val oldFqName: FqName, val newFqName: FqName internal fun patchFilesAndAddTest( testFile: File, - testFiles: List, + testFiles: List, filesHolder: CodegenTestsOnAndroidGenerator.FilesWriter ): FqName? { if (testFiles.any { it.name.endsWith(".java") }) { diff --git a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/AbstractFir2IrTextTest.kt b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/AbstractFir2IrTextTest.kt index 853f86904cf..561dff00e12 100644 --- a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/AbstractFir2IrTextTest.kt +++ b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/AbstractFir2IrTextTest.kt @@ -36,26 +36,24 @@ abstract class AbstractFir2IrTextTest : AbstractIrTextTestCase() { buildFragmentAndTestIt(wholeFile, testFiles) } - override fun doTest(filePath: String?) { - if (filePath != null) { - val originalTextPath = filePath.replace(".kt", ".txt") - val firTextPath = filePath.replace(".kt", ".fir.txt") - val originalText = File(originalTextPath) - val firText = File(firTextPath) - if (originalText.exists() && firText.exists()) { - val originalLines = originalText.readLines() - val firLines = firText.readLines() - TestCase.assertFalse( - "Dumps via FIR & via old FE are the same. Please delete .fir.txt dump and add // FIR_IDENTICAL to test source", - firLines.withIndex().all { (index, line) -> - val trimmed = line.trim() - val originalTrimmed = originalLines.getOrNull(index)?.trim() - trimmed.isEmpty() && originalTrimmed?.isEmpty() != false || trimmed == originalTrimmed - } && originalLines.withIndex().all { (index, line) -> - index < firLines.size || line.trim().isEmpty() - } - ) - } + override fun doTest(filePath: String) { + val originalTextPath = filePath.replace(".kt", ".txt") + val firTextPath = filePath.replace(".kt", ".fir.txt") + val originalText = File(originalTextPath) + val firText = File(firTextPath) + if (originalText.exists() && firText.exists()) { + val originalLines = originalText.readLines() + val firLines = firText.readLines() + TestCase.assertFalse( + "Dumps via FIR & via old FE are the same. Please delete .fir.txt dump and add // FIR_IDENTICAL to test source", + firLines.withIndex().all { (index, line) -> + val trimmed = line.trim() + val originalTrimmed = originalLines.getOrNull(index)?.trim() + trimmed.isEmpty() && originalTrimmed?.isEmpty() != false || trimmed == originalTrimmed + } && originalLines.withIndex().all { (index, line) -> + index < firLines.size || line.trim().isEmpty() + } + ) } super.doTest(filePath) } diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index d5cdc8ac9a0..a2c10adb9c5 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt @@ -102,7 +102,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { val content = javaLines.joinToString(separator = "\n") if (InTextDirectivesUtils.isDirectiveDefined(content, "SKIP_IN_FIR_TEST")) return - val srcFiles = TestFiles.createTestFiles( + val srcFiles = TestFiles.createTestFiles( javaFile.name, FileUtil.loadFile(javaFile, true), object : TestFiles.TestFileFactoryNoModules() { override fun create(fileName: String, text: String, directives: Map): File { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt index 1781da9c890..bbe314f2778 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.asJava import com.intellij.psi.PsiClass import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.asJava.finder.JavaElementFinder +import org.jetbrains.kotlin.test.KotlinBaseTest import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.name.FqName @@ -29,12 +30,12 @@ import org.jetbrains.kotlin.util.KotlinFrontEndException import org.junit.Assert import java.io.File -abstract class AbstractCompilerLightClassTest : KotlinMultiFileTestWithJava() { +abstract class AbstractCompilerLightClassTest : KotlinMultiFileTestWithJava() { override fun getConfigurationKind(): ConfigurationKind = ConfigurationKind.ALL override fun isKotlinSourceRootNeeded(): Boolean = true - override fun doMultiFileTest(file: File, modules: MutableMap, files: MutableList) { + override fun doMultiFileTest(file: File, files: List) { val environment = createEnvironment(file) val expectedFile = KotlinTestUtils.replaceExtension(file, "java") val allowFrontendExceptions = InTextDirectivesUtils.isDirectiveDefined(file.readText(), "// ALLOW_FRONTEND_EXCEPTION") @@ -47,9 +48,18 @@ abstract class AbstractCompilerLightClassTest : KotlinMultiFileTestWithJava, + friends: MutableList + ): TestModule? = null - override fun createTestFile(module: Void?, fileName: String, text: String, directives: Map): Void? = null + override fun createTestFile( + module: TestModule?, + fileName: String, + text: String, + directives: Map + ): TestFile? = null companion object { fun findLightClass(allowFrontendExceptions: Boolean, environment: KotlinCoreEnvironment, fqname: String): PsiClass? { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt index d198a53c73b..88ee3f7494a 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt @@ -59,6 +59,7 @@ import org.jetbrains.kotlin.storage.ExceptionTracker import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.test.InTextDirectivesUtils +import org.jetbrains.kotlin.test.KotlinBaseTest import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.util.DescriptorValidator import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator @@ -191,7 +192,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { val actualText = StringBuilder() for (testFile in files) { - val module = testFile.module + val module: KotlinBaseTest.TestModule? = testFile.module val isCommonModule = modules[module]!!.platform.isCommon() val implementingModules = if (!isCommonModule) emptyList() diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt index efcd2b6be10..629eae63d64 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt @@ -53,6 +53,7 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.KotlinBaseTest import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF import org.jetbrains.kotlin.utils.addIfNotNull import org.junit.Assert @@ -74,26 +75,24 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava, + friends: List + ): TestModule = + TestModule(name, dependencies, friends) override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Map): TestFile = TestFile(module, fileName, text, directives) + override fun doMultiFileTest( - file: File, - modules: @JvmSuppressWildcards Map, - testFiles: List + wholeFile: File, + files: List ) { - for (moduleAndDependencies in modules.values) { - moduleAndDependencies.module.getDependencies().addAll(moduleAndDependencies.dependencies.map { name -> - modules[name]?.module ?: error("Dependency not found: $name for module ${moduleAndDependencies.module.name}") - }) - } + environment = createEnvironment(wholeFile) - environment = createEnvironment(file) - - analyzeAndCheck(file, testFiles) + analyzeAndCheck(wholeFile, files) } protected abstract fun analyzeAndCheck(testDataFile: File, files: List) @@ -122,16 +121,9 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava { + class TestModule(name: String, dependencies: List, friends: List) : + KotlinBaseTest.TestModule(name, dependencies, friends) { lateinit var languageVersionSettings: LanguageVersionSettings - - private val dependencies = ArrayList() - - fun getDependencies(): MutableList = dependencies - - override fun compareTo(other: TestModule): Int = name.compareTo(other.name) - - override fun toString(): String = name } inner class TestFile( @@ -139,7 +131,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava - ) { + ) : KotlinBaseTest.TestFile(fileName, textWithMarkers) { val diagnosedRanges: MutableList = mutableListOf() private val diagnosedRangesToDiagnosticNames: MutableMap> = mutableMapOf() val actualDiagnostics: MutableList = mutableListOf() diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java index e826babe227..3615e88c1eb 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java @@ -18,17 +18,16 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.parsing.KotlinParserDefinition; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.test.*; -import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase; +import org.jetbrains.kotlin.test.KotlinBaseTest; import java.io.File; import java.util.*; import static org.jetbrains.kotlin.script.ScriptTestUtilKt.loadScriptingPlugin; -public abstract class KotlinMultiFileTestWithJava extends KtUsefulTestCase { +public abstract class KotlinMultiFileTestWithJava extends KotlinBaseTest { protected File javaFilesDir; private File kotlinSourceRoot; - protected String coroutinesPackage; @Override public void setUp() throws Exception { @@ -38,7 +37,6 @@ public abstract class KotlinMultiFileTestWithJava extends KtUsefulTestCase if (isKotlinSourceRootNeeded()) { kotlinSourceRoot = KotlinTestUtils.tmpDir("kotlin-src"); } - coroutinesPackage = ""; } public class ModuleAndDependencies { @@ -54,10 +52,16 @@ public abstract class KotlinMultiFileTestWithJava extends KtUsefulTestCase } @NotNull - protected Boolean isScriptingNeeded(@NotNull File file) { + private static Boolean isScriptingNeeded(@NotNull File file) { return file.getName().endsWith(KotlinParserDefinition.STD_SCRIPT_EXT); } + @Override + @NotNull + public List createTestFilesFromFile(@NotNull File file, String expectedText) { + return createTestFiles(file, expectedText, new HashMap<>()); + } + @NotNull protected KotlinCoreEnvironment createEnvironment(@NotNull File file) { CompilerConfiguration configuration = KotlinTestUtils.newConfiguration( @@ -142,35 +146,20 @@ public abstract class KotlinMultiFileTestWithJava extends KtUsefulTestCase return new File(filePath); } - protected void doTest(String filePath) throws Exception { + @Override + protected void doTest(@NotNull String filePath) throws Exception { File file = createTestFileFromPath(filePath); String expectedText = KotlinTestUtils.doLoadFile(file); - + //TODO: move to proper tests if (InTextDirectivesUtils.isDirectiveDefined(expectedText, "// SKIP_JAVAC")) return; - Map modules = new HashMap<>(); - List testFiles = createTestFiles(file, expectedText, modules); - - doMultiFileTest(file, modules, testFiles); + super.doTest(file.getPath()); } - protected void doTestWithCoroutinesPackageReplacement(String filePath, String coroutinesPackage) throws Exception { - File file = new File(filePath); - String expectedText = KotlinTestUtils.doLoadFile(file); - expectedText = expectedText.replace("COROUTINES_PACKAGE", coroutinesPackage); - this.coroutinesPackage = coroutinesPackage; - Map modules = new HashMap<>(); - List testFiles = createTestFiles(file, expectedText, modules); - - doMultiFileTest(file, modules, testFiles); - } - - protected abstract M createTestModule(@NotNull String name); + protected abstract M createTestModule(@NotNull String name, List dependencies, List friends); protected abstract F createTestFile(M module, String fileName, String text, Map directives); - protected abstract void doMultiFileTest(File file, Map modules, List files) throws Exception; - protected List createTestFiles(File file, String expectedText, Map modules) { return TestFiles.createTestFiles(file.getName(), expectedText, new TestFiles.TestFileFactory() { @Override @@ -193,7 +182,7 @@ public abstract class KotlinMultiFileTestWithJava extends KtUsefulTestCase @Override public M createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends) { - M module = createTestModule(name); + M module = createTestModule(name, dependencies, friends); ModuleAndDependencies oldValue = modules.put(name, new ModuleAndDependencies(module, dependencies, friends)); assert oldValue == null : "Module " + name + " declared more than once"; diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxAgainstJavaCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxAgainstJavaCodegenTest.kt index df1978abae9..04a230b1c56 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxAgainstJavaCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxAgainstJavaCodegenTest.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration import java.io.File abstract class AbstractBlackBoxAgainstJavaCodegenTest : AbstractBlackBoxCodegenTest() { - override fun doMultiFileTest(wholeFile: File, files: MutableList) { + override fun doMultiFileTest(wholeFile: File, files: List) { javaClassesOutputDirectory = writeJavaFiles(files)!!.let { directory -> CodegenTestUtil.compileJava(CodegenTestUtil.findJavaSourcesInDirectory(directory), emptyList(), extractJavacOptions(files)) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java index 8cfcd2424e6..a5d4e04e506 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java @@ -59,9 +59,9 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { @Override protected void doMultiFileTest( @NotNull File wholeFile, - @NotNull List files + @NotNull List files ) throws Exception { - doMultiFileTest(wholeFile, files, false); + doMultiFileTest(wholeFile, (List)files, false); } private void doBytecodeListingTest(@NotNull File wholeFile) throws Exception { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java index 67de66e4253..821370f1d5f 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java @@ -49,9 +49,9 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest } @Override - protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List files) { + protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List files) { boolean isIgnored = InTextDirectivesUtils.isIgnoredTarget(getBackend(), wholeFile); - doTwoFileTest(files, !isIgnored); + doTwoFileTest((List) files, !isIgnored); } @NotNull diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractKapt3BuilderModeBytecodeShapeTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractKapt3BuilderModeBytecodeShapeTest.kt index 949c16af34e..0a81e531467 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractKapt3BuilderModeBytecodeShapeTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractKapt3BuilderModeBytecodeShapeTest.kt @@ -29,7 +29,7 @@ abstract class AbstractKapt3BuilderModeBytecodeShapeTest : CodegenTestCase() { } } - override fun doMultiFileTest(wholeFile: File, files: MutableList) { + override fun doMultiFileTest(wholeFile: File, files: List) { compile(files) val txtFile = File(wholeFile.parentFile, wholeFile.nameWithoutExtension + ".txt") KotlinTestUtils.assertEqualsToFile(txtFile, BytecodeListingTextCollectingVisitor.getText(classFileFactory)) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.kt index 5c736e561c1..4efbe3dd453 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.kt @@ -28,12 +28,9 @@ import kotlin.collections.ArrayList abstract class AbstractLineNumberTest : CodegenTestCase() { - override fun doMultiFileTest(wholeFile: File, files: MutableList) { + override fun doMultiFileTest(wholeFile: File, files: List) { val isCustomTest = wholeFile.parentFile.name.equals("custom", ignoreCase = true) - if (!isCustomTest) { - files.add(createLineNumberDeclaration()) - } - compile(files) + compile(if (!isCustomTest) files + createLineNumberDeclaration() else files) val psiFile = myFiles.psiFiles.single { file -> file.name == wholeFile.name } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java index 5137fb6e6c9..f9ae83794ef 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.TestsCompiletimeError; import org.jetbrains.kotlin.backend.common.output.OutputFile; import org.jetbrains.kotlin.backend.common.output.SimpleOutputFileCollection; import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings; +import org.jetbrains.kotlin.test.KotlinBaseTest; import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil; import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys; import org.jetbrains.kotlin.cli.common.output.OutputUtilsKt; @@ -41,7 +42,6 @@ import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider; import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationWrapper; import org.jetbrains.kotlin.test.*; import org.jetbrains.kotlin.test.clientserver.TestProxy; -import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import org.jetbrains.org.objectweb.asm.ClassReader; import org.jetbrains.org.objectweb.asm.tree.ClassNode; @@ -74,7 +74,7 @@ import static org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar; import static org.jetbrains.kotlin.test.clientserver.TestProcessServerKt.getBoxMethodOrNull; import static org.jetbrains.kotlin.test.clientserver.TestProcessServerKt.getGeneratedClass; -public abstract class CodegenTestCase extends KtUsefulTestCase { +public abstract class CodegenTestCase extends KotlinBaseTest { private static final String DEFAULT_TEST_FILE_NAME = "a_test"; private static final String DEFAULT_JVM_TARGET = System.getProperty("kotlin.test.default.jvm.target"); public static final String BOX_IN_SEPARATE_PROCESS_PORT = System.getProperty("kotlin.test.box.in.separate.process.port"); @@ -778,37 +778,8 @@ public abstract class CodegenTestCase extends KtUsefulTestCase { return TargetBackend.JVM; } - public static class TestFile implements Comparable { - public final String name; - public final String content; - - public TestFile(@NotNull String name, @NotNull String content) { - this.name = name; - this.content = content; - } - - @Override - public int compareTo(@NotNull TestFile o) { - return name.compareTo(o.name); - } - - @Override - public int hashCode() { - return name.hashCode(); - } - - @Override - public boolean equals(Object obj) { - return obj instanceof TestFile && ((TestFile) obj).name.equals(name); - } - - @Override - public String toString() { - return name; - } - } - - protected void doTest(String filePath) throws Exception { + @Override + protected void doTest(@NotNull String filePath) throws Exception { File file = new File(filePath); String expectedText = KotlinTestUtils.doLoadFile(file); @@ -816,18 +787,20 @@ public abstract class CodegenTestCase extends KtUsefulTestCase { expectedText = expectedText.replace("COROUTINES_PACKAGE", coroutinesPackage); } - List testFiles = createTestFiles(file, expectedText); + List testFiles = createTestFilesFromFile(file, expectedText); doMultiFileTest(file, testFiles); } - protected void doTestWithCoroutinesPackageReplacement(String filePath, String packageName) throws Exception { + @Override + protected void doTestWithCoroutinesPackageReplacement(@NotNull String filePath, @NotNull String packageName) throws Exception { this.coroutinesPackage = packageName; doTest(filePath); } + @Override @NotNull - private List createTestFiles(File file, String expectedText) { + protected List createTestFilesFromFile(File file, String expectedText) { List testFiles = TestFiles.createTestFiles(file.getName(), expectedText, new TestFiles.TestFileFactoryNoModules() { @NotNull @Override @@ -880,13 +853,6 @@ public abstract class CodegenTestCase extends KtUsefulTestCase { return dir; } - protected void doMultiFileTest( - @NotNull File wholeFile, - @NotNull List files - ) throws Exception { - throw new UnsupportedOperationException("Multi-file test cases are not supported in this test"); - } - protected void callBoxMethodAndCheckResult(URLClassLoader classLoader, String className) throws IOException, InvocationTargetException, IllegalAccessException { Class aClass = getGeneratedClass(classLoader, className); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/SMAPTestUtil.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/SMAPTestUtil.kt index 83cd250ede9..f3fb6a7a70e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/SMAPTestUtil.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/SMAPTestUtil.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.codegen.inline.GENERATE_SMAP import org.jetbrains.kotlin.codegen.inline.RangeMapping import org.jetbrains.kotlin.codegen.inline.SMAPParser import org.jetbrains.kotlin.codegen.inline.toRange +import org.jetbrains.kotlin.test.KotlinBaseTest import org.jetbrains.kotlin.utils.keysToMap import org.jetbrains.org.objectweb.asm.ClassReader import org.jetbrains.org.objectweb.asm.ClassVisitor @@ -45,7 +46,7 @@ object SMAPTestUtil { } } - private fun extractSmapFromTestDataFile(file: CodegenTestCase.TestFile, separateCompilation: Boolean): SMAPAndFile? { + private fun extractSmapFromTestDataFile(file: KotlinBaseTest.TestFile, separateCompilation: Boolean): SMAPAndFile? { if (!checkExtension(file, separateCompilation)) return null val content = buildString { @@ -60,13 +61,13 @@ object SMAPTestUtil { return SMAPAndFile(if (content.isNotEmpty()) content else null, SMAPAndFile.getPath(file.name), "NOT_SORTED") } - private fun checkExtension(file: CodegenTestCase.TestFile, separateCompilation: Boolean) = + private fun checkExtension(file: KotlinBaseTest.TestFile, separateCompilation: Boolean) = file.name.run { endsWith(".smap") || if (separateCompilation) endsWith(".smap-separate-compilation") else endsWith(".smap-nonseparate-compilation") } - fun checkSMAP(inputFiles: List, outputFiles: Iterable, separateCompilation: Boolean) { + fun checkSMAP(inputFiles: List, outputFiles: Iterable, separateCompilation: Boolean) { if (!GENERATE_SMAP) return val sourceData = inputFiles.mapNotNull { extractSmapFromTestDataFile(it, separateCompilation) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/defaultConstructor/AbstractDefaultArgumentsReflectionTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/defaultConstructor/AbstractDefaultArgumentsReflectionTest.java index 5a0d51be8cb..51c153c41bb 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/defaultConstructor/AbstractDefaultArgumentsReflectionTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/defaultConstructor/AbstractDefaultArgumentsReflectionTest.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.codegen.defaultConstructor; import com.intellij.openapi.util.io.FileUtil; +import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.codegen.CodegenTestCase; import org.jetbrains.kotlin.test.ConfigurationKind; @@ -35,7 +36,7 @@ public abstract class AbstractDefaultArgumentsReflectionTest extends CodegenTest } @Override - protected void doTest(String path) throws IOException { + protected void doTest(@NotNull String path) throws IOException { loadFileByFullPath(path); File file = new File(path); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java index 2feb5390d64..0a3ae183245 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java @@ -55,8 +55,8 @@ import static org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPref public abstract class AbstractWriteFlagsTest extends CodegenTestCase { @Override - protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List files) throws Exception { - compile(files); + protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List files) throws Exception { + compile((List)files); String fileText = FileUtil.loadFile(wholeFile, true); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt index c560bda1967..2ed4f85724b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt @@ -15,7 +15,7 @@ import java.util.* import java.util.regex.MatchResult abstract class AbstractWriteSignatureTest : CodegenTestCase() { - override fun doMultiFileTest(wholeFile: File, files: MutableList) { + override fun doMultiFileTest(wholeFile: File, files: List) { val isIgnored = InTextDirectivesUtils.isIgnoredTarget(backend, wholeFile) compile(files) try { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt new file mode 100644 index 00000000000..ba86e8073fa --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt @@ -0,0 +1,84 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test + +import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import java.io.File +import java.util.* + +abstract class KotlinBaseTest : KtUsefulTestCase() { + + @JvmField + protected var coroutinesPackage: String = "" + + @Throws(Exception::class) + override fun setUp() { + coroutinesPackage = "" + super.setUp() + } + + @Throws(java.lang.Exception::class) + protected open fun doTestWithCoroutinesPackageReplacement(filePath: String, coroutinesPackage: String) { + this.coroutinesPackage = coroutinesPackage + doTest(filePath) + } + + @Throws(java.lang.Exception::class) + protected open fun doTest(filePath: String) { + val file = File(filePath) + var expectedText = KotlinTestUtils.doLoadFile(file) + if (coroutinesPackage.isNotEmpty()) { + expectedText = expectedText.replace("COROUTINES_PACKAGE", coroutinesPackage) + } + doMultiFileTest(file, createTestFilesFromFile(file, expectedText)) + } + + protected abstract fun createTestFilesFromFile(file: File, expectedText: String?): List + + @Throws(java.lang.Exception::class) + protected open fun doMultiFileTest( + wholeFile: File, + files: List + ) { + throw UnsupportedOperationException("Multi-file test cases are not supported in this test") + } + + open class TestFile(@JvmField val name: String, @JvmField val content: String) : Comparable { + override operator fun compareTo(other: TestFile): Int { + return name.compareTo(other.name) + } + + override fun hashCode(): Int { + return name.hashCode() + } + + override fun equals(other: Any?): Boolean { + return other is TestFile && other.name == name + } + + override fun toString(): String { + return name + } + } + + open class TestModule( + @JvmField val name: String, + @JvmField val dependenciesSymbols: List, + @JvmField val friendsSymbols: List + ) : Comparable { + + private val dependencies = ArrayList() + private val friends = ArrayList() + + fun getDependencies(): MutableList = dependencies + + fun getFriends(): MutableList = friends + + override fun compareTo(other: TestModule): Int = name.compareTo(other.name) + + override fun toString(): String = name + } +} \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TestFiles.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/TestFiles.java index 9a20496eabb..744d395a3f9 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TestFiles.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/TestFiles.java @@ -11,10 +11,12 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.TestHelperGeneratorKt; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; +import java.util.stream.Collectors; import static org.jetbrains.kotlin.test.InTextDirectivesUtils.isDirectiveDefined; @@ -37,20 +39,20 @@ public class TestFiles { private static final Pattern LINE_SEPARATOR_PATTERN = Pattern.compile("\\r\\n|\\r|\\n"); @NotNull - public static List createTestFiles(@Nullable String testFileName, String expectedText, TestFileFactory factory) { + public static List createTestFiles(@Nullable String testFileName, String expectedText, TestFileFactory factory) { return createTestFiles(testFileName, expectedText, factory, false, ""); } @NotNull - public static List createTestFiles(@Nullable String testFileName, String expectedText, TestFileFactory factory, String coroutinesPackage) { + public static List createTestFiles(@Nullable String testFileName, String expectedText, TestFileFactory factory, String coroutinesPackage) { return createTestFiles(testFileName, expectedText, factory, false, coroutinesPackage); } @NotNull - public static List createTestFiles(String testFileName, String expectedText, TestFileFactory factory, + public static List createTestFiles(String testFileName, String expectedText, TestFileFactory factory, boolean preserveLocations, String coroutinesPackage) { Map directives = KotlinTestUtils.parseDirectives(expectedText); - + Map modules = new HashMap<>(); List testFiles = Lists.newArrayList(); Matcher matcher = FILE_OR_MODULE_PATTERN.matcher(expectedText); boolean hasModules = false; @@ -71,6 +73,8 @@ public class TestFiles { moduleName = moduleName.trim(); hasModules = true; module = factory.createModule(moduleName, parseModuleList(moduleDependencies), parseModuleList(moduleFriends)); + M oldValue = modules.put(moduleName, module); + assert oldValue == null : "Module with name " + moduleName + " already present in file"; } String fileName = matcher.group(4); @@ -101,6 +105,10 @@ public class TestFiles { if (isDirectiveDefined(expectedText, "WITH_COROUTINES")) { M supportModule = hasModules ? factory.createModule("support", Collections.emptyList(), Collections.emptyList()) : null; + if (supportModule != null) { + M oldValue = modules.put(supportModule.name, supportModule); + assert oldValue == null : "Module with name " + supportModule.name + " already present in file"; + } boolean isReleaseCoroutines = !coroutinesPackage.contains("experimental") && @@ -119,6 +127,23 @@ public class TestFiles { )); } + for (M module : modules.values()) { + if (module != null) { + module.getDependencies().addAll(module.dependenciesSymbols.stream().map(name -> { + M dep = modules.get(name); + assert dep != null : "Dependency not found:" + name + "for module " + module.name; + return dep; + }).collect(Collectors.toList())); + + module.getFriends().addAll(module.friendsSymbols.stream().map(name -> { + M dep = modules.get(name); + assert dep != null : "Dependency not found:" + name + "for module " + module.name; + return dep; + }).collect(Collectors.toList())); + } + } + + return testFiles; } @@ -152,10 +177,10 @@ public class TestFiles { M createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends); } - public static abstract class TestFileFactoryNoModules implements TestFileFactory { + public static abstract class TestFileFactoryNoModules implements TestFileFactory { @Override public final F createFile( - @Nullable Void module, + @Nullable KotlinBaseTest.TestModule module, @NotNull String fileName, @NotNull String text, @NotNull Map directives @@ -167,7 +192,7 @@ public class TestFiles { public abstract F create(@NotNull String fileName, @NotNull String text, @NotNull Map directives); @Override - public Void createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends) { + public KotlinBaseTest.TestModule createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends) { return null; } } diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/AbstractBlackBoxCodegenTestSpec.kt b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/AbstractBlackBoxCodegenTestSpec.kt index 28406467845..cf2d4fa95d7 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/AbstractBlackBoxCodegenTestSpec.kt +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/AbstractBlackBoxCodegenTestSpec.kt @@ -27,24 +27,22 @@ abstract class AbstractBlackBoxCodegenTestSpec : AbstractBlackBoxCodegenTest() { private fun addPackageDirectiveToHelperFile(helperContent: String, packageName: String?) = helperContent.replace(HELPERS_PACKAGE_VARIABLE, if (packageName == null) "" else "package $packageName") - private fun includeHelpers(wholeFile: File, files: MutableList, specTest: AbstractSpecTest) { - if (specTest.helpers == null) return + private fun includeHelpers(wholeFile: File, files: List, specTest: AbstractSpecTest): List { + if (specTest.helpers == null) return files val fileContent = FileUtil.loadFile(wholeFile, true) val packageName = packagePattern.matcher(fileContent).let { if (it.find()) it.group("packageName") else null } - specTest.helpers.forEach { + return files + specTest.helpers.map { val filename = "$it.kt" val helperContent = FileUtil.loadFile(File("$HELPERS_PATH/$filename"), true) - files.add( - TestFile(filename, addPackageDirectiveToHelperFile(helperContent, packageName)) - ) + TestFile(filename, addPackageDirectiveToHelperFile(helperContent, packageName)) } } - override fun doMultiFileTest(wholeFile: File, files: MutableList) { + override fun doMultiFileTest(wholeFile: File, files: List) { val (specTest, testLinkedType) = CommonParser.parseSpecTest( wholeFile.canonicalPath, mapOf("main.kt" to FileUtil.loadFile(wholeFile, true)) @@ -60,9 +58,9 @@ abstract class AbstractBlackBoxCodegenTestSpec : AbstractBlackBoxCodegenTest() { println(specTest) - includeHelpers(wholeFile, files, specTest) + val filesWithHelpers = includeHelpers(wholeFile, files, specTest) - val runTest = { super.doMultiFileTest(wholeFile, files, specTest.unexpectedBehavior) } + val runTest = { super.doMultiFileTest(wholeFile, filesWithHelpers, specTest.unexpectedBehavior) } if (specTest.exception == null) { runTest() diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt index 1e435777c84..1d538318f78 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt @@ -48,7 +48,7 @@ abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() { loadScriptingPlugin(configuration) } - override fun doMultiFileTest(wholeFile: File, files: MutableList) { + override fun doMultiFileTest(wholeFile: File, files: List) { if (files.size > 1) { throw UnsupportedOperationException("Multiple files are not yet supported in this test") } diff --git a/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt b/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt index 04cee40c061..94c95b04e74 100644 --- a/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt +++ b/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt @@ -5,20 +5,28 @@ package org.jetbrains.kotlin.visualizer +import org.jetbrains.kotlin.test.KotlinBaseTest import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.TestJdkKind import java.io.File -abstract class AbstractVisualizer : KotlinMultiFileTestWithJava() { +abstract class AbstractVisualizer : KotlinMultiFileTestWithJava() { lateinit var replacement: Pair - override fun createTestModule(name: String): Void? = null + override fun createTestModule( + name: String, + dependencies: MutableList, + friends: MutableList + ): TestModule? = null - override fun createTestFile(module: Void?, fileName: String?, text: String?, directives: MutableMap?): Void? = null - override fun doMultiFileTest(file: File, modules: MutableMap?, files: MutableList) { + override fun createTestFile(module: TestModule?, fileName: String?, text: String?, directives: MutableMap?): TestFile? = + null + + + override fun doMultiFileTest(file: File, files: List) { val environment = createEnvironment(file) doVisualizerTest(file, environment) } diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AbstractKotlinEvaluateExpressionTest.kt b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AbstractKotlinEvaluateExpressionTest.kt index 6394760f521..1ad89d4b2a9 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AbstractKotlinEvaluateExpressionTest.kt +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AbstractKotlinEvaluateExpressionTest.kt @@ -22,7 +22,6 @@ import com.sun.jdi.ObjectReference import org.jetbrains.eval4j.ObjectValue import org.jetbrains.eval4j.Value import org.jetbrains.eval4j.jdi.asValue -import org.jetbrains.kotlin.codegen.CodegenTestCase.TestFile import org.jetbrains.kotlin.idea.KotlinFileType import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinCodeFragmentFactory import org.jetbrains.kotlin.idea.debugger.test.preference.DebuggerPreferences @@ -32,6 +31,7 @@ import org.jetbrains.kotlin.idea.debugger.test.util.SteppingInstruction import org.jetbrains.kotlin.idea.util.application.runReadAction import org.jetbrains.kotlin.test.InTextDirectivesUtils.findLinesWithPrefixesRemoved import org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPrefixes +import org.jetbrains.kotlin.test.KotlinBaseTest import java.io.File import javax.swing.tree.TreeNode @@ -254,7 +254,7 @@ abstract class AbstractKotlinEvaluateExpressionTest : KotlinDescriptorTestCaseWi return this.toString() } - private fun loadExpressions(testFile: TestFile): List { + private fun loadExpressions(testFile: KotlinBaseTest.TestFile): List { val directives = findLinesWithPrefixesRemoved(testFile.content, "// EXPRESSION: ") val expected = findLinesWithPrefixesRemoved(testFile.content, "// RESULT: ") assert(directives.size == expected.size) { "Sizes of test directives are different" } @@ -276,7 +276,7 @@ abstract class AbstractKotlinEvaluateExpressionTest : KotlinDescriptorTestCaseWi return codeFragments } - private fun loadDebugLabels(testFile: TestFile): List { + private fun loadDebugLabels(testFile: KotlinBaseTest.TestFile): List { return findLinesWithPrefixesRemoved(testFile.content, "// DEBUG_LABEL: ") .map { text -> val labelParts = text.split("=") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/DebuggerTestCompilerFacility.kt b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/DebuggerTestCompilerFacility.kt index ef54acbc7ef..350102b29cd 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/DebuggerTestCompilerFacility.kt +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/DebuggerTestCompilerFacility.kt @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.caches.resolve.KotlinCacheService import org.jetbrains.kotlin.cli.common.output.writeAllTo import org.jetbrains.kotlin.cli.jvm.compiler.findMainClass import org.jetbrains.kotlin.codegen.ClassBuilderFactories -import org.jetbrains.kotlin.codegen.CodegenTestCase.TestFile import org.jetbrains.kotlin.codegen.CodegenTestUtil import org.jetbrains.kotlin.codegen.DefaultCodegenFactory import org.jetbrains.kotlin.codegen.KotlinCodegenFacade @@ -30,6 +29,7 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.KotlinBaseTest.TestFile import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase import java.io.File diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinDescriptorTestCase.kt b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinDescriptorTestCase.kt index 6109b86609e..de59bba44ce 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinDescriptorTestCase.kt +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinDescriptorTestCase.kt @@ -21,7 +21,6 @@ import com.intellij.openapi.vfs.VfsUtil import com.intellij.psi.PsiFile import com.intellij.testFramework.EdtTestUtil import com.intellij.xdebugger.XDebugSession -import org.jetbrains.kotlin.codegen.CodegenTestCase.TestFile import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinDebuggerCaches @@ -31,6 +30,7 @@ import org.jetbrains.kotlin.idea.debugger.test.util.KotlinOutputChecker import org.jetbrains.kotlin.idea.debugger.test.util.LogPropagator import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil import org.jetbrains.kotlin.idea.test.PluginTestCaseBase +import org.jetbrains.kotlin.test.KotlinBaseTest.TestFile import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestMetadata import org.jetbrains.kotlin.test.isIgnoredInDatabaseWithLog @@ -125,7 +125,7 @@ abstract class KotlinDescriptorTestCase : DescriptorTestCase() { } private fun createTestFiles(wholeFile: File, wholeFileContents: String): TestFiles { - val testFiles = org.jetbrains.kotlin.test.TestFiles.createTestFiles( + val testFiles = org.jetbrains.kotlin.test.TestFiles.createTestFiles( wholeFile.name, wholeFileContents, object : org.jetbrains.kotlin.test.TestFiles.TestFileFactoryNoModules() { diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/util/SteppingInstruction.kt b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/util/SteppingInstruction.kt index 6470e69adef..75c789fce01 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/util/SteppingInstruction.kt +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/util/SteppingInstruction.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.idea.debugger.test.util -import org.jetbrains.kotlin.codegen.CodegenTestCase +import org.jetbrains.kotlin.test.KotlinBaseTest.TestFile enum class SteppingInstructionKind(val directiveName: String) { StepInto("STEP_INTO"), @@ -19,11 +19,11 @@ enum class SteppingInstructionKind(val directiveName: String) { class SteppingInstruction(val kind: SteppingInstructionKind, val arg: Int) { companion object { - fun parse(file: CodegenTestCase.TestFile): List { + fun parse(file: TestFile): List { return parse(file, Companion::parseLine) } - fun parseSingle(file: CodegenTestCase.TestFile, kind: SteppingInstructionKind): SteppingInstruction? { + fun parseSingle(file: TestFile, kind: SteppingInstructionKind): SteppingInstruction? { val instructions = parse(file) { line -> parseKind(line, kind) } if (instructions.size > 1) { error("Several instructions found for kind $kind") @@ -32,7 +32,7 @@ class SteppingInstruction(val kind: SteppingInstructionKind, val arg: Int) { return instructions.singleOrNull() } - private fun parse(file: CodegenTestCase.TestFile, processor: (String) -> SteppingInstruction?): List { + private fun parse(file: TestFile, processor: (String) -> SteppingInstruction?): List { return file.content.lineSequence() .map { it.trimStart() } .filter { it.startsWith("// ") } diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt index 3466432e942..59fc38e3ed2 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.js.test.utils.LineOutputToStringVisitor import org.jetbrains.kotlin.js.util.TextOutputImpl import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.serialization.js.ModuleKind +import org.jetbrains.kotlin.test.KotlinBaseTest import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.KotlinTestWithEnvironment import org.jetbrains.kotlin.test.TestFiles @@ -51,7 +52,7 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() { .map { it.module }.distinct() .associateBy { it.name } - val orderedModules = DFS.topologicalOrder(modules.values) { module -> module.dependencies.mapNotNull { modules[it] } } + val orderedModules = DFS.topologicalOrder(modules.values) { module -> module.dependenciesSymbols.mapNotNull { modules[it] } } orderedModules.asReversed().forEach { module -> val baseOutputPath = module.outputFileName(file) @@ -110,7 +111,7 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() { KotlinCoreEnvironment.createForTests(testRootDisposable, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES) private fun createConfig(module: TestModule, inputFile: File, modules: Map): JsConfig { - val dependencies = module.dependencies + val dependencies = module.dependenciesSymbols .mapNotNull { modules[it]?.outputFileName(inputFile) } .map { "$it.meta.js" } @@ -137,7 +138,7 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() { private inner class TestFileFactoryImpl : TestFiles.TestFileFactory, Closeable { private val tmpDir = KotlinTestUtils.tmpDir("js-tests") - private val defaultModule = TestModule(BasicBoxTest.TEST_MODULE, emptyList()) + private val defaultModule = TestModule(BasicBoxTest.TEST_MODULE, emptyList(), emptyList()) override fun createFile(module: TestModule?, fileName: String, text: String, directives: Map): TestFile? { val currentModule = module ?: defaultModule @@ -146,11 +147,10 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() { KotlinTestUtils.mkdirs(temporaryFile.parentFile) temporaryFile.writeText(text, Charsets.UTF_8) - - return TestFile(temporaryFile.absolutePath, currentModule) + return TestFile(temporaryFile.absolutePath, text, currentModule) } - override fun createModule(name: String, dependencies: List, friends: List) = TestModule(name, dependencies) + override fun createModule(name: String, dependencies: List, friends: List) = TestModule(name, dependencies, friends) override fun close() { FileUtil.delete(tmpDir) @@ -158,14 +158,14 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() { } private class TestModule( - val name: String, - dependencies: List - ) { - val dependencies = dependencies.toMutableList() + name: String, + dependenciesSymbols: List, + friendsSymbols: List + ): KotlinBaseTest.TestModule(name, dependenciesSymbols, friendsSymbols) { val files = mutableListOf() } - private class TestFile(val fileName: String, val module: TestModule) { + private class TestFile(val fileName: String, content: String, val module: TestModule) : KotlinBaseTest.TestFile(fileName, content) { init { module.files += this } diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt index 6b44332fa1e..b05b0d58f4c 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt @@ -141,10 +141,10 @@ abstract class BasicBoxTest( .map { it.name to it }.toMap() fun TestModule.allTransitiveDependencies(): Set { - return dependencies.toSet() + dependencies.flatMap { modules[it]!!.allTransitiveDependencies() } + return dependenciesSymbols.toSet() + dependenciesSymbols.flatMap { modules[it]!!.allTransitiveDependencies() } } - val orderedModules = DFS.topologicalOrder(modules.values) { module -> module.dependencies.mapNotNull { modules[it] } } + val orderedModules = DFS.topologicalOrder(modules.values) { module -> module.dependenciesSymbols.mapNotNull { modules[it] } } val testPackage = if (runPlainBoxFunction) null else testFactory.testPackage @@ -159,9 +159,9 @@ abstract class BasicBoxTest( val mainModule = modules[mainModuleName] ?: error("No module with name \"$mainModuleName\"") val generatedJsFiles = orderedModules.asReversed().mapNotNull { module -> - val dependencies = module.dependencies.map { modules[it]?.outputFileName(outputDir) + ".meta.js" } + val dependencies = module.dependenciesSymbols.map { modules[it]?.outputFileName(outputDir) + ".meta.js" } val allDependencies = module.allTransitiveDependencies().map { modules[it]?.outputFileName(outputDir) + ".meta.js" } - val friends = module.friends.map { modules[it]?.outputFileName(outputDir) + ".meta.js" } + val friends = module.friendsSymbols.map { modules[it]?.outputFileName(outputDir) + ".meta.js" } val outputFileName = module.outputFileName(outputDir) + ".js" val dceOutputFileName = module.outputFileName(dceOutputDir) + ".js" @@ -863,12 +863,10 @@ abstract class BasicBoxTest( } private class TestModule( - val name: String, + name: String, dependencies: List, friends: List - ) { - val dependencies = dependencies.toMutableList() - val friends = friends.toMutableList() + ): KotlinBaseTest.TestModule(name, dependencies, friends) { var moduleKind = ModuleKind.PLAIN var inliningDisabled = false val files = mutableListOf() diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt index 540d149cf25..b813f6e1636 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt @@ -323,7 +323,7 @@ open class AbstractClassFileToSourceStubConverterTest : AbstractKotlinKapt3Test( } abstract class AbstractKotlinKaptContextTest : AbstractKotlinKapt3Test() { - override fun doTest(filePath: String?) { + override fun doTest(filePath: String) { kaptFlags.add(KaptFlag.CORRECT_ERROR_TYPES) kaptFlags.add(KaptFlag.STRICT) kaptFlags.add(KaptFlag.MAP_DIAGNOSTIC_LOCATIONS)