Remove javaFilesDir parameter of CodegenTestCase.doMultiFileTest

Create TestFile instances for .java sources similarly to .kt sources, and write them to a temporary directory via writeJavaFiles in each test where this is needed
2026-04-14 00:21:27 +00:00 · 2019-04-03 16:34:25 +02:00
parent 7fdb9c990e
commit b602c08773
23 changed files with 89 additions and 115 deletions
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractAsmLikeInstructionListingTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractAsmLikeInstructionListingTest.kt
@@ -23,9 +23,9 @@ abstract class AbstractAsmLikeInstructionListingTest : CodegenTestCase() {
        val LOCAL_VARIABLE_TABLE_DIRECTIVE = "// LOCAL_VARIABLE_TABLE"
    }

-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
        val txtFile = File(wholeFile.parentFile, wholeFile.nameWithoutExtension + ".txt")
-        compile(files, javaFilesDir)
+        compile(files)

        val classes = classFileFactory
                .getClassFiles()
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxAgainstJavaCodegenTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxAgainstJavaCodegenTest.kt
@@ -22,12 +22,12 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import java.io.File

 abstract class AbstractBlackBoxAgainstJavaCodegenTest : AbstractBlackBoxCodegenTest() {
-    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>, javaFilesDir: File?) {
-        javaClassesOutputDirectory = javaFilesDir!!.let { directory ->
+    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>) {
+        javaClassesOutputDirectory = writeJavaFiles(files)!!.let { directory ->
            CodegenTestUtil.compileJava(CodegenTestUtil.findJavaSourcesInDirectory(directory), emptyList(), extractJavacOptions(files))
        }

-        super.doMultiFileTest(wholeFile, files, null)
+        super.doMultiFileTest(wholeFile, files)
    }

    override fun updateConfiguration(configuration: CompilerConfiguration) {
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java
@@ -32,14 +32,10 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
            Boolean.getBoolean("kotlin.suppress.expected.test.failures");

    @Override
-    protected void doMultiFileTest(
-            @NotNull File wholeFile,
-            @NotNull List<TestFile> files,
-            @Nullable File javaFilesDir
-    ) throws Exception {
+    protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List<TestFile> files) throws Exception {
        boolean isIgnored = IGNORE_EXPECTED_FAILURES && InTextDirectivesUtils.isIgnoredTarget(getBackend(), wholeFile);

-        compile(files, javaFilesDir, !isIgnored);
+        compile(files, !isIgnored);

        try {
            blackBox(!isIgnored);
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxInlineCodegenTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxInlineCodegenTest.kt
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.codegen
 import java.io.File

 abstract class AbstractBlackBoxInlineCodegenTest : AbstractBlackBoxCodegenTest() {
-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-        super.doMultiFileTest(wholeFile, files, javaFilesDir)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        super.doMultiFileTest(wholeFile, files)
        try {
            InlineTestUtil.checkNoCallsToInline(initializedClassLoader.allGeneratedFiles.filterClassFiles(), myFiles.psiFiles)
            SMAPTestUtil.checkSMAP(files, generateClassesInFile().getClassFiles(), false)
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt
@@ -14,9 +14,8 @@ import org.jetbrains.org.objectweb.asm.Opcodes.*
 import java.io.File

 abstract class AbstractBytecodeListingTest : CodegenTestCase() {
-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-
-        compile(files, javaFilesDir)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        compile(files)
        val actualTxt = BytecodeListingTextCollectingVisitor.getText(classFileFactory, withSignatures = isWithSignatures(wholeFile))

        val prefixes =
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.kt
@@ -16,12 +16,12 @@ import java.util.regex.Matcher
 import java.util.regex.Pattern

 abstract class AbstractBytecodeTextTest : CodegenTestCase() {
-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
        createEnvironmentWithMockJdkAndIdeaAnnotations(
            ConfigurationKind.ALL,
            files,
            TestJdkKind.MOCK_JDK,
-            *listOfNotNull(javaFilesDir).toTypedArray()
+            *listOfNotNull(writeJavaFiles(files)).toTypedArray()
        )
        loadMultiFiles(files)

--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.kt
@@ -20,7 +20,6 @@ import com.intellij.openapi.util.text.StringUtil
 import junit.framework.TestCase
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection
 import org.jetbrains.kotlin.test.KotlinTestUtils
-import org.jetbrains.kotlin.utils.rethrow
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
 import java.util.*
@@ -29,11 +28,9 @@ import java.util.regex.Pattern
 /**
 * Test correctness of written local variables in class file for specified method
 */
-
 abstract class AbstractCheckLocalVariablesTableTest : CodegenTestCase() {
-
-    override fun doMultiFileTest(wholeFile: File, files: List<CodegenTestCase.TestFile>, javaFilesDir: File?) {
-        compile(files, javaFilesDir)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        compile(files)

        try {
            val classAndMethod = parseClassAndMethodSignature(wholeFile)
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstInlineKotlinTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstInlineKotlinTest.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen
 import java.io.File

 abstract class AbstractCompileKotlinAgainstInlineKotlinTest : AbstractCompileKotlinAgainstKotlinTest() {
-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
        val (factory1, factory2) = doTwoFileTest(files.filter { it.name.endsWith(".kt") })
        try {
            val allGeneratedFiles = factory1.asList() + factory2.asList()
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java
@@ -11,7 +11,6 @@ import com.intellij.openapi.util.Disposer;
 import kotlin.Pair;
 import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.common.modules.ModuleBuilder;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -49,8 +48,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest
    }

    @Override
-    protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List<TestFile> files, @Nullable File javaFilesDir) {
-        assert javaFilesDir == null : ".java files are not supported yet in this test";
+    protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List<TestFile> files) {
        doTwoFileTest(files);
    }

--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractDumpDeclarationsTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractDumpDeclarationsTest.kt
@@ -15,10 +15,10 @@ abstract class AbstractDumpDeclarationsTest : CodegenTestCase() {

    private lateinit var dumpToFile: File

-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
        val expectedResult = KotlinTestUtils.replaceExtension(wholeFile, "json")
        dumpToFile = KotlinTestUtils.tmpDirForTest(this).resolve("$name.json")
-        compile(files, null)
+        compile(files)
        classFileFactory.generationState.destroy()
        KotlinTestUtils.assertEqualsToFile(expectedResult, dumpToFile.readText()) {
            it.replace("COROUTINES_PACKAGE", coroutinesPackage)
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractKapt3BuilderModeBytecodeShapeTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractKapt3BuilderModeBytecodeShapeTest.kt
@@ -29,9 +29,9 @@ abstract class AbstractKapt3BuilderModeBytecodeShapeTest : CodegenTestCase() {
        }
    }

-    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>) {
+        compile(files)
        val txtFile = File(wholeFile.parentFile, wholeFile.nameWithoutExtension + ".txt")
-        compile(files, javaFilesDir)
        KotlinTestUtils.assertEqualsToFile(txtFile, BytecodeListingTextCollectingVisitor.getText(classFileFactory))
    }

@@ -46,4 +46,4 @@ abstract class AbstractKapt3BuilderModeBytecodeShapeTest : CodegenTestCase() {
    override fun verifyWithDex(): Boolean {
        return false
    }
-}
+}
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt
@@ -26,17 +26,17 @@ abstract class AbstractLightAnalysisModeTest : CodegenTestCase() {
        }
    }

-    override fun doMultiFileTest(wholeFile: File, files: List<CodegenTestCase.TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
        for (file in files) {
            if (file.content.contains("// IGNORE_LIGHT_ANALYSIS")) {
                return
            }
        }

-        val fullTxt = compileWithFullAnalysis(files, javaFilesDir)
+        val fullTxt = compileWithFullAnalysis(files)
            .replace("final enum class", "enum class")

-        val liteTxt = compileWithLightAnalysis(wholeFile, files, javaFilesDir)
+        val liteTxt = compileWithLightAnalysis(wholeFile, files)
            .replace("@synthetic.kotlin.jvm.GeneratedByJvmOverloads ", "")

        assertEquals(fullTxt, liteTxt)
@@ -46,14 +46,14 @@ abstract class AbstractLightAnalysisModeTest : CodegenTestCase() {
        return false
    }

-    private fun compileWithLightAnalysis(wholeFile: File, files: List<CodegenTestCase.TestFile>, javaFilesDir: File?): String {
+    private fun compileWithLightAnalysis(wholeFile: File, files: List<TestFile>): String {
        val boxTestsDir = File("compiler/testData/codegen/box")
        val relativePath = wholeFile.toRelativeString(boxTestsDir)
        // Fail if this test is not under codegen/box
        assert(!relativePath.startsWith(".."))

        val configuration = createConfiguration(
-            configurationKind, getJdkKind(files), listOf(getAnnotationsJar()), javaFilesDir?.let(::listOf).orEmpty(), files
+            configurationKind, getJdkKind(files), listOf(getAnnotationsJar()), listOfNotNull(writeJavaFiles(files)), files
        )
        val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
        AnalysisHandlerExtension.registerExtension(environment.project, PartialAnalysisHandlerExtension())
@@ -64,11 +64,8 @@ abstract class AbstractLightAnalysisModeTest : CodegenTestCase() {
        return BytecodeListingTextCollectingVisitor.getText(classFileFactory, ListAnalysisFilter())
    }

-    protected fun compileWithFullAnalysis(
-        files: List<TestFile>,
-        javaSourceDir: File?
-    ): String {
-        compile(files, javaSourceDir)
+    private fun compileWithFullAnalysis(files: List<TestFile>): String {
+        compile(files)
        classFileFactory.getClassFiles()

        val classInternalNames = classFileFactory.generationState.bindingContext
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.kt
@@ -28,14 +28,12 @@ import kotlin.collections.ArrayList

 abstract class AbstractLineNumberTest : CodegenTestCase() {

-    override fun doMultiFileTest(
-        wholeFile: File, files: MutableList<TestFile>, javaFilesDir: File?
-    ) {
+    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>) {
        val isCustomTest = wholeFile.parentFile.name.equals("custom", ignoreCase = true)
        if (!isCustomTest) {
            files.add(createLineNumberDeclaration())
        }
-        compile(files, javaFilesDir)
+        compile(files)

        val psiFile = myFiles.psiFiles.single { file -> file.name == wholeFile.name }

--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.codegen;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.testFramework.TestDataFile;
 import kotlin.collections.ArraysKt;
@@ -636,18 +635,13 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
        }
    }

-    protected void compile(
-            @NotNull List<TestFile> files,
-            @Nullable File javaSourceDir
-    ) {
-        compile(files, javaSourceDir, true);
+    protected void compile(@NotNull List<TestFile> files) {
+        compile(files, true);
    }

-    protected void compile(
-            @NotNull List<TestFile> files,
-            @Nullable File javaSourceDir,
-            boolean reportProblems
-    ) {
+    protected void compile(@NotNull List<TestFile> files, boolean reportProblems) {
+        File javaSourceDir = writeJavaFiles(files);
+
        configurationKind = extractConfigurationKind(files);
        boolean loadAndroidAnnotations = files.stream().anyMatch(
                it -> InTextDirectivesUtils.isDirectiveDefined(it.content, "ANDROID_ANNOTATIONS")
@@ -677,7 +671,7 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {

        generateClassesInFile(reportProblems);

-        if (javaSourceDir != null) {
+        if (javaSourceDir != null && javaClassesOutputDirectory == null) {
            // If there are Java files, they should be compiled against the class files produced by Kotlin, so we dump them to the disk
            File kotlinOut;
            try {
@@ -771,16 +765,15 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {

    protected void doTest(String filePath) throws Exception {
        File file = new File(filePath);
-        Ref<File> javaFilesDir = Ref.create();

        String expectedText = KotlinTestUtils.doLoadFile(file);
        if (!coroutinesPackage.isEmpty()) {
            expectedText = expectedText.replace("COROUTINES_PACKAGE", coroutinesPackage);
        }

-        List<TestFile> testFiles = createTestFiles(file, expectedText, javaFilesDir, coroutinesPackage);
+        List<TestFile> testFiles = createTestFiles(file, expectedText, coroutinesPackage);

-        doMultiFileTest(file, testFiles, javaFilesDir.get());
+        doMultiFileTest(file, testFiles);
    }

    protected void doTestWithCoroutinesPackageReplacement(String filePath, String packageName) throws Exception {
@@ -789,38 +782,41 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
    }

    @NotNull
-    private static List<TestFile> createTestFiles(File file, String expectedText, Ref<File> javaFilesDir, String coroutinesPackage) {
+    private static List<TestFile> createTestFiles(File file, String expectedText, String coroutinesPackage) {
        return KotlinTestUtils.createTestFiles(file.getName(), expectedText, new KotlinTestUtils.TestFileFactoryNoModules<TestFile>() {
            @NotNull
            @Override
            public TestFile create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
-                if (fileName.endsWith(".java")) {
-                    if (javaFilesDir.isNull()) {
-                        try {
-                            javaFilesDir.set(KotlinTestUtils.tmpDir("java-files"));
-                        }
-                        catch (IOException e) {
-                            throw ExceptionUtilsKt.rethrow(e);
-                        }
-                    }
-                    writeSourceFile(fileName, text, javaFilesDir.get());
-                }
-
                return new TestFile(fileName, text);
            }
-
-            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);
-            }
        }, coroutinesPackage);
    }

+    @Nullable
+    protected static File writeJavaFiles(@NotNull List<TestFile> files) {
+        List<TestFile> javaFiles = CollectionsKt.filter(files, file -> file.name.endsWith(".java"));
+        if (javaFiles.isEmpty()) return null;
+
+        File dir;
+        try {
+            dir = KotlinTestUtils.tmpDir("java-files");
+        }
+        catch (IOException e) {
+            throw ExceptionUtilsKt.rethrow(e);
+        }
+
+        for (TestFile testFile : javaFiles) {
+            File file = new File(dir, testFile.name);
+            KotlinTestUtils.mkdirs(file.getParentFile());
+            FilesKt.writeText(file, testFile.content, Charsets.UTF_8);
+        }
+
+        return dir;
+    }
+
    protected void doMultiFileTest(
            @NotNull File wholeFile,
-            @NotNull List<TestFile> files,
-            @Nullable File javaFilesDir
+            @NotNull List<TestFile> files
    ) throws Exception {
        throw new UnsupportedOperationException("Multi-file test cases are not supported in this test");
    }
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.codegen.flags;

 import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.codegen.CodegenTestCase;
 import org.jetbrains.org.objectweb.asm.*;
@@ -51,10 +50,8 @@ import static org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPref
 public abstract class AbstractWriteFlagsTest extends CodegenTestCase {

    @Override
-    protected void doMultiFileTest(
-            @NotNull File wholeFile, @NotNull List<TestFile> files, @Nullable File javaFilesDir
-    ) throws Exception {
-        compile(files, null);
+    protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List<TestFile> files) throws Exception {
+        compile(files);

        String fileText = FileUtil.loadFile(wholeFile, true);

--- a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt
@@ -41,14 +41,14 @@ import java.io.PrintWriter
 import java.util.*

 abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-        setupEnvironment(files, javaFilesDir)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        setupEnvironment(files)

        loadMultiFiles(files)
        doTest(wholeFile, files)
    }

-    private fun setupEnvironment(files: List<TestFile>, javaFilesDir: File?) {
+    private fun setupEnvironment(files: List<TestFile>) {
        val jdkKind = getJdkKind(files)

        val javacOptions = ArrayList<String>(0)
@@ -74,7 +74,7 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
        val configuration = createConfiguration(
            configurationKind, jdkKind,
            listOf<File>(getAnnotationsJar()),
-            arrayOf(javaFilesDir).filterNotNull(),
+            listOfNotNull(writeJavaFiles(files)),
            files
        )

--- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt
@@ -14,10 +14,8 @@ import java.util.*
 import java.util.regex.MatchResult

 abstract class AbstractWriteSignatureTest : CodegenTestCase() {
-
-
-    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>, javaFilesDir: File?) {
-        compile(files, javaFilesDir)
+    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>) {
+        compile(files)
        try {
            parseExpectations(wholeFile).check()
        } catch (e: Throwable) {
--- a/compiler/tests-spec/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTestSpec.kt
+++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTestSpec.kt
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.spec.utils.GeneralConfiguration.TESTDATA_PATH
 import org.jetbrains.kotlin.spec.validators.BlackBoxTestTypeValidator
 import org.jetbrains.kotlin.spec.validators.SpecTestValidationException
 import org.junit.Assert
-import java.io.*
+import java.io.File

 abstract class AbstractBlackBoxCodegenTestSpec : AbstractBlackBoxCodegenTest() {
    companion object {
@@ -43,7 +43,7 @@ abstract class AbstractBlackBoxCodegenTestSpec : AbstractBlackBoxCodegenTest() {
        }
    }

-    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>) {
        val (specTest, testLinkedType) = CommonParser.parseSpecTest(
            wholeFile.canonicalPath,
            mapOf("main.kt" to FileUtil.loadFile(wholeFile, true))
@@ -62,10 +62,10 @@ abstract class AbstractBlackBoxCodegenTestSpec : AbstractBlackBoxCodegenTest() {
        includeHelpers(wholeFile, files, specTest)

        if (specTest.exception == null) {
-            super.doMultiFileTest(wholeFile, files, javaFilesDir)
+            super.doMultiFileTest(wholeFile, files)
        } else {
            TestExceptionsComparator(wholeFile).run(specTest.exception) {
-                super.doMultiFileTest(wholeFile, files, javaFilesDir)
+                super.doMultiFileTest(wholeFile, files)
            }
        }
    }
--- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt
@@ -45,7 +45,7 @@ abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() {
        loadScriptingPlugin(configuration)
    }

-    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>, javaFilesDir: File?) {
+    override fun doMultiFileTest(wholeFile: File, files: MutableList<TestFile>) {
        if (files.size > 1) {
            throw UnsupportedOperationException("Multiple files are not yet supported in this test")
        }
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/LowLevelDebuggerTestBase.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/LowLevelDebuggerTestBase.kt
@@ -26,9 +26,8 @@ abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
        private const val DEBUG_PORT = 5115
    }

-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-        val javaSources = javaFilesDir?.let { arrayOf(it) } ?: emptyArray()
-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *javaSources)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *listOfNotNull(writeJavaFiles(files)).toTypedArray())

        val options = wholeFile.readLines()
            .asSequence()
@@ -186,4 +185,4 @@ private object DebuggerMain {
            (lock as java.lang.Object).wait()
        }
    }
-}
+}
--- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelBoxTest.kt
+++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelBoxTest.kt
@@ -120,8 +120,8 @@ abstract class AbstractParcelBoxTest : CodegenTestCase() {
        return listOf(kotlinRuntimeJar) + layoutLibJars + robolectricJars + junitJar + androidExtensionsRuntimeJars
    }

-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-        compile(files + TestFile(LIBRARY_KT.name, LIBRARY_KT.readText()), javaFilesDir)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        compile(files + TestFile(LIBRARY_KT.name, LIBRARY_KT.readText()))

        val javaBin = File(System.getProperty("java.home").takeIf { it.isNotEmpty() } ?: error("JAVA_HOME is not set"), "bin")
        val javaExe = File(javaBin, "java.exe").takeIf { it.exists() } ?: File(javaBin, "java")
--- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3IntegrationTest.kt
+++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3IntegrationTest.kt
@@ -25,12 +25,14 @@ import org.jetbrains.kotlin.codegen.CodegenTestCase
 import org.jetbrains.kotlin.codegen.GenerationUtils
 import org.jetbrains.kotlin.codegen.OriginCollectingClassBuilderFactory
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.kapt3.*
+import org.jetbrains.kotlin.kapt3.AbstractKapt3Extension
+import org.jetbrains.kotlin.kapt3.KaptContextForStubGeneration
 import org.jetbrains.kotlin.kapt3.base.KaptContext
 import org.jetbrains.kotlin.kapt3.base.LoadedProcessors
 import org.jetbrains.kotlin.kapt3.base.incremental.DeclaredProcType
 import org.jetbrains.kotlin.kapt3.base.incremental.IncrementalProcessor
 import org.jetbrains.kotlin.kapt3.javac.KaptJavaFileObject
+import org.jetbrains.kotlin.kapt3.prettyPrint
 import org.jetbrains.kotlin.kapt3.stubs.ClassFileToSourceStubConverter
 import org.jetbrains.kotlin.kapt3.stubs.ClassFileToSourceStubConverter.KaptStub
 import org.jetbrains.kotlin.kapt3.util.MessageCollectorBackedKaptLogger
@@ -124,12 +126,11 @@ abstract class AbstractKotlinKapt3IntegrationTest : CodegenTestCase() {
        }
    }

-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-        val javaSources = javaFilesDir?.let { arrayOf(it) } ?: emptyArray()
-
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
        val txtFile = File(wholeFile.parentFile, wholeFile.nameWithoutExtension + ".it.txt")

-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *javaSources)
+        val javaSources = listOfNotNull(writeJavaFiles(files))
+        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *javaSources.toTypedArray())
        val project = myEnvironment.project

        val options = KaptOptions.Builder().apply {
--- 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
@@ -107,10 +107,8 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() {
        myFiles = CodegenTestFiles.create(ktFiles)
    }

-    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>, javaFilesDir: File?) {
-        val javaSources = javaFilesDir?.let { arrayOf(it) } ?: emptyArray()
-
-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *javaSources)
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *listOfNotNull(writeJavaFiles(files)).toTypedArray())
        addAnnotationProcessingRuntimeLibrary(myEnvironment)

        // Use light analysis mode in tests