Migrate boxInline tests to new multi-file framework

compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java

@@ -42,7 +42,7 @@ public abstract class KotlinMultiFileTestWithJava<M, F> extends KotlinLiteFixtur
     private File javaFilesDir;
     private File kotlinSourceRoot;
 
-    protected class ModuleAndDependencies {
+    public class ModuleAndDependencies {
         final M module;
         final List<String> dependencies;
 

compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java

@@ -22,6 +22,7 @@ import com.intellij.util.Processor;
 import kotlin.io.FilesKt;
 import kotlin.text.Charsets;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
@@ -33,7 +34,10 @@ import org.jetbrains.kotlin.codegen.GeneratedClassLoader;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
+import org.jetbrains.kotlin.psi.KtDeclaration;
 import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtProperty;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
@@ -88,6 +92,11 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
 
     private void doTestMultiFile(@NotNull List<TestFile> files) {
         createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL);
+        loadMultiFiles(files);
+        blackBox();
+    }
+
+    protected void loadMultiFiles(@NotNull List<TestFile> files) {
         Collections.sort(files);
 
         List<KtFile> ktFiles = new ArrayList<KtFile>(files.size());
@@ -96,8 +105,6 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         }
 
         myFiles = CodegenTestFiles.create(ktFiles);
-
-        blackBox();
     }
 
     // NOTE: tests under fullJdk/ are run with FULL_JDK instead of MOCK_JDK
@@ -180,7 +187,8 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         // If there are many files, the first 'box(): String' function will be executed.
         GeneratedClassLoader generatedClassLoader = generateAndCreateClassLoader();
         for (KtFile firstFile : myFiles.getPsiFiles()) {
-            String className = JvmFileClassUtil.getFileClassInfoNoResolve(firstFile).getFacadeClassFqName().asString();
+            String className = getFacadeFqName(firstFile);
+            if (className == null) continue;
             Class<?> aClass = getGeneratedClass(generatedClassLoader, className);
             try {
                 Method method = getBoxMethodOrNull(aClass);
@@ -197,6 +205,16 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         }
     }
 
+    @Nullable
+    private static String getFacadeFqName(@NotNull KtFile firstFile) {
+        for (KtDeclaration declaration : firstFile.getDeclarations()) {
+            if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction) {
+                return JvmFileClassUtil.getFileClassInfoNoResolve(firstFile).getFacadeClassFqName().asString();
+            }
+        }
+        return null;
+    }
+
     private static Class<?> getGeneratedClass(GeneratedClassLoader generatedClassLoader, String className) {
         try {
             return generatedClassLoader.loadClass(className);

compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxInlineCodegenTest.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen.generated
 
+import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava
 import org.jetbrains.kotlin.codegen.InlineTestUtil
 import org.jetbrains.kotlin.codegen.filterClassFiles
 import org.jetbrains.kotlin.codegen.getClassFiles
@@ -24,12 +25,11 @@ import org.jetbrains.kotlin.test.ConfigurationKind
 import java.io.File
 
 abstract class AbstractBlackBoxInlineCodegenTest : AbstractBlackBoxCodegenTest(), AbstractSMAPBaseTest {
-    fun doTestMultiFileWithInlineCheck(firstFileName: String) {
-        val fileName = relativePath(File(firstFileName))
-        val inputFiles = listOf(fileName, fileName.substringBeforeLast("1.kt") + "2.kt")
-
+    override fun doMultiFileTest(
+            file: File, modules: Map<String, KotlinMultiFileTestWithJava<Void, TestFile>.ModuleAndDependencies>, files: List<TestFile>
+    ) {
         createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL)
-        loadFiles(*inputFiles.toTypedArray())
+        loadMultiFiles(files)
         blackBox()
 
         try {

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstInlineKotlinTest.kt

@@ -16,45 +16,33 @@
 
 package org.jetbrains.kotlin.jvm.compiler
 
+import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava
 import org.jetbrains.kotlin.codegen.ClassFileFactory
-import org.jetbrains.kotlin.codegen.CodegenTestCase
 import org.jetbrains.kotlin.codegen.InlineTestUtil
 import org.jetbrains.kotlin.codegen.filterClassFiles
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
 
 abstract class AbstractCompileKotlinAgainstInlineKotlinTest : AbstractCompileKotlinAgainstKotlinTest(), AbstractSMAPBaseTest {
-    protected fun doBoxTest(firstFileName: String): Pair<ClassFileFactory, ClassFileFactory> {
-        var files: List<CodegenTestCase.TestFile> = KotlinTestUtils.createTestFiles(
-                firstFileName, KotlinTestUtils.doLoadFile(File(firstFileName)),
-                object : KotlinTestUtils.TestFileFactory<Unit, CodegenTestCase.TestFile> {
-                    override fun createFile(
-                            module: Unit?, fileName: String, text: String, directives: Map<String, String>
-                    ): CodegenTestCase.TestFile {
-                        return CodegenTestCase.TestFile(fileName, text)
-                    }
-
-                    override fun createModule(name: String, dependencies: List<String>) {
-                        throw UnsupportedOperationException()
-                    }
-                })
-
-        // TODO: drop this (migrate codegen/box/inline/)
-        if (files.size == 1) {
-            val firstFile = files.iterator().next()
-            val secondFile = File(firstFileName.replace("1.kt", "2.kt"))
-            files = listOf(firstFile, CodegenTestCase.TestFile(secondFile.name, KotlinTestUtils.doLoadFile(secondFile)))
-        }
+    override fun doMultiFileTest(
+            file: File, modules: Map<String, KotlinMultiFileTestWithJava<Void, TestFile>.ModuleAndDependencies>, files: List<TestFile>
+    ) {
+        assert(files.size == 2) { "There should be exactly two files in this test" }
 
         var factory1: ClassFileFactory? = null
         var factory2: ClassFileFactory? = null
         try {
-            val fileA = files[1]
-            val fileB = files[0]
+            val fileA = files[0]
+            val fileB = files[1]
             factory1 = compileA(fileA.name, fileA.content)
             factory2 = compileB(fileB.name, fileB.content)
             invokeBox(PackagePartClassUtils.getFilePartShortName(File(fileB.name).name))
+
+            val allGeneratedFiles = factory1.asList() + factory2.asList()
+
+            val sourceFiles = factory1.inputFiles + factory2.inputFiles
+            InlineTestUtil.checkNoCallsToInline(allGeneratedFiles.filterClassFiles(), sourceFiles)
+            checkSMAP(sourceFiles, allGeneratedFiles.filterClassFiles())
         }
         catch (e: Throwable) {
             var result = ""
@@ -67,22 +55,5 @@ abstract class AbstractCompileKotlinAgainstInlineKotlinTest : AbstractCompileKot
             println(result)
             throw e
         }
-
-        return Pair(factory1, factory2)
-    }
-
-    fun doBoxTestWithInlineCheck(firstFileName: String) {
-        val (factory1, factory2) = doBoxTest(firstFileName)
-        val allGeneratedFiles = factory1.asList() + factory2.asList()
-
-        try {
-            val sourceFiles = factory1.inputFiles + factory2.inputFiles
-            InlineTestUtil.checkNoCallsToInline(allGeneratedFiles.filterClassFiles(), sourceFiles)
-            checkSMAP(sourceFiles, allGeneratedFiles.filterClassFiles())
-        }
-        catch (e: Throwable) {
-            System.out.println(factory1.createText() + "\n" + factory2.createText())
-            throw e
-        }
     }
 }