From 7040857d77c1e3ef13099c8724d4a22e3511ada2 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Tue, 25 Feb 2020 11:45:21 +0100 Subject: [PATCH] Convert KotlinMultiFileTestWithJava.java to Kotlin --- .../AbstractFirResolveTestCaseWithStdlib.kt | 2 +- .../asJava/AbstractCompilerLightClassTest.kt | 4 +- ...tractDiagnosticsWithModifiedMockJdkTest.kt | 28 +- ...ractDiagnosticsTestWithStdLibUsingJavac.kt | 2 +- .../AbstractJavacForeignAnnotationsTest.kt | 2 +- ...bstractJavacForeignJava8AnnotationsTest.kt | 2 +- .../AbstractDiagnosticsWithJdk9Test.kt | 26 +- .../AbstractForeignAnnotationsTest.kt | 2 +- .../checkers/KotlinMultiFileTestWithJava.kt | 265 ++++++++---------- .../AbstractDiagnosticsUsingJavacTest.kt | 2 +- .../javac/AbstractJavacDiagnosticsTest.kt | 4 +- .../javac/AbstractJavacFieldResolutionTest.kt | 2 +- .../jetbrains/kotlin/test/KotlinBaseTest.kt | 2 +- .../kotlin/visualizer/AbstractVisualizer.kt | 16 +- 14 files changed, 152 insertions(+), 207 deletions(-) diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt index 1ac167441a6..450395154f7 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt @@ -13,7 +13,7 @@ abstract class AbstractFirDiagnosticsWithStdlibTest : AbstractFirDiagnosticsTest return ConfigurationKind.ALL } - override fun getTestJdkKind(testFiles: MutableList): TestJdkKind { + override fun getTestJdkKind(files: List): TestJdkKind { return TestJdkKind.FULL_JDK } } \ No newline at end of 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 55eb88fc442..47626d379ad 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt @@ -50,8 +50,8 @@ abstract class AbstractCompilerLightClassTest : KotlinMultiFileTestWithJava, - friends: MutableList + dependencies: List, + friends: List ): TestModule? = null override fun createTestFile( diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt index b079385b083..5191cb9132e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt @@ -13,26 +13,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +package org.jetbrains.kotlin.cfg -package org.jetbrains.kotlin.cfg; +import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest +import org.jetbrains.kotlin.test.ConfigurationKind +import org.jetbrains.kotlin.test.TestJdkKind -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest; -import org.jetbrains.kotlin.test.ConfigurationKind; -import org.jetbrains.kotlin.test.TestJdkKind; - -import java.util.List; - -public abstract class AbstractDiagnosticsWithModifiedMockJdkTest extends AbstractDiagnosticsTest { - @NotNull - @Override - protected ConfigurationKind getConfigurationKind() { - return ConfigurationKind.ALL; +abstract class AbstractDiagnosticsWithModifiedMockJdkTest : AbstractDiagnosticsTest() { + override fun getConfigurationKind(): ConfigurationKind { + return ConfigurationKind.ALL } - @NotNull - @Override - protected TestJdkKind getTestJdkKind(@NotNull List testFiles) { - return TestJdkKind.MODIFIED_MOCK_JDK; + override fun getTestJdkKind(files: List): TestJdkKind { + return TestJdkKind.MODIFIED_MOCK_JDK } -} +} \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt index 688c21da794..91e03ca0ee8 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt @@ -30,7 +30,7 @@ abstract class AbstractDiagnosticsTestWithStdLibUsingJavac : AbstractDiagnostics return isJavacSkipTest(wholeFile, files) } - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList) { + override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { val testDataFileText = testDataFile.readText() val groupedByModule = files.groupBy(TestFile::module) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignAnnotationsTest.kt index af906e9e1a4..bb7700f0bbd 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignAnnotationsTest.kt @@ -23,7 +23,7 @@ import java.io.File abstract class AbstractJavacForeignAnnotationsTest : AbstractForeignAnnotationsTest() { - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList) { + override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { val groupedByModule = files.groupBy(TestFile::module) val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } environment.registerJavac(kotlinFiles = allKtFiles) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignJava8AnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignJava8AnnotationsTest.kt index b5d5a40d7c5..0b7641679c1 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignJava8AnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignJava8AnnotationsTest.kt @@ -28,7 +28,7 @@ abstract class AbstractJavacForeignJava8AnnotationsTest : AbstractForeignJava8An return isSkipJavacTest(wholeFile, files) } - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList) { + override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { val groupedByModule = files.groupBy(TestFile::module) val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } environment.registerJavac(kotlinFiles = allKtFiles) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt index 5fb622c0330..b8e37c15281 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt @@ -13,25 +13,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +package org.jetbrains.kotlin.checkers -package org.jetbrains.kotlin.checkers; +import org.jetbrains.kotlin.test.ConfigurationKind +import org.jetbrains.kotlin.test.TestJdkKind -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.test.ConfigurationKind; -import org.jetbrains.kotlin.test.TestJdkKind; +abstract class AbstractDiagnosticsWithJdk9Test : AbstractDiagnosticsTest() { + override fun getConfigurationKind(): ConfigurationKind = ConfigurationKind.ALL -import java.util.List; - -public abstract class AbstractDiagnosticsWithJdk9Test extends AbstractDiagnosticsTest { - @NotNull - @Override - protected ConfigurationKind getConfigurationKind() { - return ConfigurationKind.ALL; + override fun getTestJdkKind(files: List): TestJdkKind { + return TestJdkKind.FULL_JDK_9 } - - @NotNull - @Override - protected TestJdkKind getTestJdkKind(@NotNull List testFiles) { - return TestJdkKind.FULL_JDK_9; - } -} +} \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt index 73f6ddbd25b..0a6686952e9 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt @@ -54,7 +54,7 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { override fun getConfigurationKind(): ConfigurationKind = ConfigurationKind.ALL - override fun getTestJdkKind(testFiles: MutableList): TestJdkKind = TestJdkKind.FULL_JDK + override fun getTestJdkKind(testFiles: List): TestJdkKind = TestJdkKind.FULL_JDK open protected val annotationsPath: String get() = FOREIGN_ANNOTATIONS_SOURCES_PATH diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt index bf9abb61614..fdbeb97570d 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt @@ -2,203 +2,166 @@ * 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.checkers -package org.jetbrains.kotlin.checkers; +import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment.Companion.createForTests +import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.parsing.KotlinParserDefinition +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.script.loadScriptingPlugin +import org.jetbrains.kotlin.test.* +import org.jetbrains.kotlin.test.TestFiles.TestFileFactory +import java.io.File +import java.util.* -import kotlin.io.FilesKt; -import kotlin.text.Charsets; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.cli.common.config.ContentRootsKt; -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; -import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; -import org.jetbrains.kotlin.config.CompilerConfiguration; -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.KotlinBaseTest; +abstract class KotlinMultiFileTestWithJava : + KotlinBaseTest() { + protected lateinit var javaFilesDir: File + private var kotlinSourceRoot: File? = null -import java.io.File; -import java.util.*; - -import static org.jetbrains.kotlin.script.ScriptTestUtilKt.loadScriptingPlugin; - -public abstract class KotlinMultiFileTestWithJava extends KotlinBaseTest { - protected File javaFilesDir; - private File kotlinSourceRoot; - - @Override - public void setUp() throws Exception { - super.setUp(); + @Throws(Exception::class) + public override fun setUp() { + super.setUp() // TODO: do not create temporary directory for tests without Java sources - javaFilesDir = KotlinTestUtils.tmpDir("java-files"); + javaFilesDir = KotlinTestUtils.tmpDir("java-files") if (isKotlinSourceRootNeeded()) { - kotlinSourceRoot = KotlinTestUtils.tmpDir("kotlin-src"); + kotlinSourceRoot = KotlinTestUtils.tmpDir("kotlin-src") } } - public class ModuleAndDependencies { - final M module; - final List dependencies; - final List friends; + inner class ModuleAndDependencies internal constructor(val module: M?, val dependencies: List, val friends: List) - ModuleAndDependencies(M module, List dependencies, List friends) { - this.module = module; - this.dependencies = dependencies; - this.friends = friends; - } + override fun createTestFilesFromFile(file: File, expectedText: String): List { + return createTestFiles(file, expectedText, HashMap()) } - @NotNull - 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, - @NotNull List files - ) { - CompilerConfiguration configuration = KotlinTestUtils.newConfiguration( - getConfigurationKind(), - getTestJdkKind(files), - getClasspath(file), - isJavaSourceRootNeeded() ? Collections.singletonList(javaFilesDir) : Collections.emptyList() - ); + protected fun createEnvironment( + file: File, + files: List + ): KotlinCoreEnvironment { + val configuration = KotlinTestUtils.newConfiguration( + getConfigurationKind(), + getTestJdkKind(files), + getClasspath(file), + if (isJavaSourceRootNeeded()) listOf(javaFilesDir) else emptyList() + ) if (isScriptingNeeded(file)) { - loadScriptingPlugin(configuration); + loadScriptingPlugin(configuration) } if (isKotlinSourceRootNeeded()) { - ContentRootsKt.addKotlinSourceRoot(configuration, kotlinSourceRoot.getPath()); + configuration.addKotlinSourceRoot(kotlinSourceRoot!!.path) } // Currently, we're testing IDE behavior when generating the .txt files for comparison, but this can be changed. // The main difference is the fact that the new class file reading implementation doesn't load parameter names from JDK classes. - configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true); + configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true) - performCustomConfiguration(configuration); - return KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, getEnvironmentConfigFiles()); + performCustomConfiguration(configuration) + return createForTests(testRootDisposable, configuration, getEnvironmentConfigFiles()) } - protected boolean isJavaSourceRootNeeded() { - return true; + protected open fun isJavaSourceRootNeeded(): Boolean = true + + protected open fun performCustomConfiguration(configuration: CompilerConfiguration) {} + + protected open fun setupEnvironment(environment: KotlinCoreEnvironment) {} + + protected open fun setupEnvironment( + environment: KotlinCoreEnvironment, + testDataFile: File, + files: List + ) { + setupEnvironment(environment) } - protected void performCustomConfiguration(@NotNull CompilerConfiguration configuration) { - - } - - protected void setupEnvironment(@NotNull KotlinCoreEnvironment environment) { - - } - - protected void setupEnvironment(@NotNull KotlinCoreEnvironment environment,@NotNull File testDataFile, @NotNull List files) { - setupEnvironment(environment); - } - - @NotNull - protected ConfigurationKind getConfigurationKind() { - return ConfigurationKind.JDK_ONLY; - } - - private List getClasspath(File file) { - List result = new ArrayList<>(); - result.add(KotlinTestUtils.getAnnotationsJar()); - result.addAll(getExtraClasspath()); - - String fileText = FilesKt.readText(file, Charsets.UTF_8); + protected open fun getConfigurationKind() = ConfigurationKind.JDK_ONLY + private fun getClasspath(file: File): List { + val result: MutableList = ArrayList() + result.add(KotlinTestUtils.getAnnotationsJar()) + result.addAll(getExtraClasspath()) + val fileText = file.readText(Charsets.UTF_8) if (InTextDirectivesUtils.isDirectiveDefined(fileText, "ANDROID_ANNOTATIONS")) { - result.add(ForTestCompileRuntime.androidAnnotationsForTests()); + result.add(ForTestCompileRuntime.androidAnnotationsForTests()) } if (InTextDirectivesUtils.isDirectiveDefined(fileText, "STDLIB_JDK8")) { - result.add(ForTestCompileRuntime.runtimeJarForTestsWithJdk8()); + result.add(ForTestCompileRuntime.runtimeJarForTestsWithJdk8()) } - - if (DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString().equals(coroutinesPackage) || - fileText.contains(DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString())) { - result.add(ForTestCompileRuntime.coroutinesCompatForTests()); + if (DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString() == coroutinesPackage || + fileText.contains(DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString()) + ) { + result.add(ForTestCompileRuntime.coroutinesCompatForTests()) } - - return result; + return result } - @NotNull - protected List getExtraClasspath() { - return Collections.emptyList(); + protected open fun getExtraClasspath(): List = emptyList() + + protected open fun getEnvironmentConfigFiles(): EnvironmentConfigFiles = EnvironmentConfigFiles.JVM_CONFIG_FILES + + protected open fun isKotlinSourceRootNeeded(): Boolean = false + + protected open fun createTestFileFromPath(filePath: String): File { + return File(filePath) } - @NotNull - protected EnvironmentConfigFiles getEnvironmentConfigFiles() { - return EnvironmentConfigFiles.JVM_CONFIG_FILES; - } - - protected boolean isKotlinSourceRootNeeded() { - return false; - } - - @NotNull - protected File createTestFileFromPath(@NotNull String filePath) { - return new File(filePath); - } - - @Override - protected void doTest(@NotNull String filePath) throws Exception { - File file = createTestFileFromPath(filePath); - String expectedText = KotlinTestUtils.doLoadFile(file); + @Throws(Exception::class) + public override fun doTest(filePath: String) { + val file = createTestFileFromPath(filePath) + val expectedText = KotlinTestUtils.doLoadFile(file) //TODO: move to proper tests - if (InTextDirectivesUtils.isDirectiveDefined(expectedText, "// SKIP_JAVAC")) return; - - super.doTest(file.getPath()); + if (InTextDirectivesUtils.isDirectiveDefined(expectedText, "// SKIP_JAVAC")) return + super.doTest(file.path) } - protected abstract M createTestModule(@NotNull String name, List dependencies, List friends); + protected abstract fun createTestModule(name: String, dependencies: List, friends: List): M? - protected abstract F createTestFile(M module, String fileName, String text, Map directives); + protected abstract fun createTestFile(module: M?, fileName: String, text: String, directives: Map): F? - protected List createTestFiles(File file, String expectedText, Map modules) { - return TestFiles.createTestFiles(file.getName(), expectedText, new TestFiles.TestFileFactory() { - @Override - public F createFile( - @Nullable M module, - @NotNull String fileName, - @NotNull String text, - @NotNull Map directives - ) { + protected open fun createTestFiles( + file: File, + expectedText: String, + modules: MutableMap + ): List { + return TestFiles.createTestFiles(file.name, expectedText, object : TestFileFactory { + override fun createFile( + module: M?, + fileName: String, + text: String, + directives: Map + ): F? { if (fileName.endsWith(".java")) { - writeSourceFile(fileName, text, javaFilesDir); + writeSourceFile(fileName, text, javaFilesDir!!) } - if ((fileName.endsWith(".kt") || fileName.endsWith(".kts")) && kotlinSourceRoot != null) { - writeSourceFile(fileName, text, kotlinSourceRoot); + writeSourceFile(fileName, text, kotlinSourceRoot!!) } - - return createTestFile(module, fileName, text, directives); + return createTestFile(module, fileName, text, directives) } - @Override - public M createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends) { - 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"; - - return module; + override fun createModule(name: String, dependencies: List, friends: List): M? { + val module = createTestModule(name, dependencies, friends) + val oldValue = modules.put(name, ModuleAndDependencies(module, dependencies, friends)) + assert(oldValue == null) { "Module $name declared more than once" } + return module } - private void writeSourceFile(@NotNull String fileName, @NotNull String content, @NotNull File targetDir) { - File file = new File(targetDir, fileName); - KotlinTestUtils.mkdirs(file.getParentFile()); - FilesKt.writeText(file, content, Charsets.UTF_8); + private fun writeSourceFile(fileName: String, content: String, targetDir: File) { + val file = File(targetDir, fileName) + KotlinTestUtils.mkdirs(file.parentFile) + file.writeText(content, Charsets.UTF_8) } - }, coroutinesPackage); + }, coroutinesPackage) } -} + companion object { + private fun isScriptingNeeded(file: File): Boolean { + return file.name.endsWith(KotlinParserDefinition.STD_SCRIPT_EXT) + } + } +} \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt index bae50169ce1..71a0f720faa 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt @@ -29,7 +29,7 @@ abstract class AbstractDiagnosticsUsingJavacTest : AbstractDiagnosticsTest() { return isJavacSkipTest(wholeFile, files) } - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList) { + override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { val testDataFileText = testDataFile.readText() val groupedByModule = files.groupBy(TestFile::module) val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt index 55bad1044b3..c1266638252 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt @@ -26,7 +26,7 @@ abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() { private var useJavac = true - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList) { + override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { if (useJavac) { val groupedByModule = files.groupBy(TestFile::module) val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } @@ -46,7 +46,7 @@ abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() { return specialFile.takeIf { it.exists() } ?: super.getExpectedDiagnosticsFile(testDataFile) } - override fun createTestFiles(file: File, expectedText: String, modules: MutableMap?): List { + override fun createTestFiles(file: File, expectedText: String, modules: MutableMap): List { val specialFile = getExpectedDiagnosticsFile(file) if (file.path == specialFile.path) { return super.createTestFiles(file, expectedText, modules) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt index 1dfc628a457..a087059ce0e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt @@ -25,7 +25,7 @@ abstract class AbstractJavacFieldResolutionTest : AbstractDiagnosticsTest() { private var useJavac = true - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList) { + override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { if (useJavac) { val groupedByModule = files.groupBy(TestFile::module) val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt index ab7a6344aa3..09d86f48a92 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt @@ -36,7 +36,7 @@ abstract class KotlinBaseTest : KtUsefulTestCase() doMultiFileTest(file, createTestFilesFromFile(file, expectedText)) } - protected abstract fun createTestFilesFromFile(file: File, expectedText: String?): List + protected abstract fun createTestFilesFromFile(file: File, expectedText: String): List @Throws(java.lang.Exception::class) protected open fun doMultiFileTest( diff --git a/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt b/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt index dd20df03313..56a6a5f6cbd 100644 --- a/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt +++ b/compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt @@ -12,23 +12,23 @@ 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, - dependencies: MutableList, - friends: MutableList + dependencies: List, + friends: List ): TestModule? = null - override fun createTestFile(module: TestModule?, fileName: String?, text: String?, directives: MutableMap?): TestFile? = + override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Map): TestFile? = null - override fun doMultiFileTest(file: File, files: List) { - val environment = createEnvironment(file, files) - doVisualizerTest(file, environment) + override fun doMultiFileTest(wholeFile: File, files: List) { + val environment = createEnvironment(wholeFile, files) + doVisualizerTest(wholeFile, environment) } abstract fun doVisualizerTest(file: File, environment: KotlinCoreEnvironment) @@ -37,7 +37,7 @@ abstract class AbstractVisualizer : KotlinMultiFileTestWithJava): TestJdkKind { + override fun getTestJdkKind(files: List): TestJdkKind { return TestJdkKind.FULL_JDK }