Add the IR version of CompileJavaAgainstKotlin tests

Only the WithoutJavac version for now, because the other one ignores
javac errors.

compiler/testData/compileJavaAgainstKotlin/class/ClassObject.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class WithClassObject {

compiler/testData/compileJavaAgainstKotlin/class/DefaultConstructor.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class A(val a: Int = 1)

compiler/testData/compileJavaAgainstKotlin/class/DefaultConstructorWithTwoArgs.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class A(val a: Int = 1, val b: String = "default")

compiler/testData/compileJavaAgainstKotlin/class/InnerClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class Outer {

compiler/testData/compileJavaAgainstKotlin/class/InnerClassConstructors.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class Outer {

compiler/testData/compileJavaAgainstKotlin/class/InnerClassOfGeneric.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class Outer<T> {

compiler/testData/compileJavaAgainstKotlin/method/TraitImpl.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 interface Trait {

compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass/InlineIntOverridesObject.kt

@@ -1,4 +1,5 @@
 // !LANGUAGE: +InlineClasses
+// IGNORE_BACKEND: JVM_IR
 
 package test
 

compiler/testData/compileJavaAgainstKotlin/method/throws/ClassMembers.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/method/throws/Constructor.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/method/throws/DefaultArgs.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/method/throws/Delegation.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/method/throws/GenericSubstitution.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/method/throws/TopLevel.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/method/throws/TraitMembers.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class E1: Exception()

compiler/testData/compileJavaAgainstKotlin/property/ConstVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @file:JvmName("ABC")
 package test;
 

compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 annotation class AString(val value: String)

compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 annotation class AString(val value: String)

compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 class KotlinClass {

compiler/testData/compileJavaAgainstKotlin/staticFields/staticTraitProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 package test
 
 interface Test {

compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.name.FqName
@@ -73,7 +74,7 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
             KotlinTestUtils.compileKotlinWithJava(
                 listOf(javaFile),
                 listOf(ktFile),
-                out, testRootDisposable, javaErrorFile
+                out, testRootDisposable, javaErrorFile, this::updateConfiguration
             )
         }
 
@@ -94,6 +95,8 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
         validateAndCompareDescriptorWithFile(packageView, CONFIGURATION, expectedFile)
     }
 
+    open fun updateConfiguration(configuration: CompilerConfiguration) {}
+
     @Throws(IOException::class)
     fun compileKotlinWithJava(
         javaFiles: List<File>,
@@ -107,6 +110,7 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
         environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true)
         environment.configuration.put(JVMConfigurationKeys.OUTPUT_DIRECTORY, outDir)
         environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
+        updateConfiguration(environment.configuration)
         environment.registerJavac(
             javaFiles = javaFiles,
             kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first()))
@@ -117,7 +121,6 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
             val mkdirs = outDir.mkdirs()
             assert(mkdirs) { "Not created: $outDir" }
         }
-
         return JavacWrapper.getInstance(environment.project).use { it.compile() }
     }
 

compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/ir/AbstractIrCompileJavaAgainstKotlinTest.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.jvm.compiler.ir
+
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.jvm.compiler.AbstractCompileJavaAgainstKotlinTest
+
+abstract class AbstractIrCompileJavaAgainstKotlinTest : AbstractCompileJavaAgainstKotlinTest() {
+    override fun updateConfiguration(configuration: CompilerConfiguration) = configuration.put(JVMConfigurationKeys.IR, true)
+}

compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java

@@ -28,6 +28,7 @@ import com.intellij.testFramework.TestDataFile;
 import com.intellij.util.PathUtil;
 import com.intellij.util.containers.ContainerUtil;
 import junit.framework.TestCase;
+import kotlin.Unit;
 import kotlin.collections.CollectionsKt;
 import kotlin.collections.SetsKt;
 import kotlin.jvm.functions.Function1;
@@ -708,10 +709,24 @@ public class KotlinTestUtils {
             @NotNull File outDir,
             @NotNull Disposable disposable,
             @Nullable File javaErrorFile
+    ) throws IOException {
+        return compileKotlinWithJava(javaFiles, ktFiles, outDir, disposable, javaErrorFile, null);
+    }
+
+    public static boolean compileKotlinWithJava(
+            @NotNull List<File> javaFiles,
+            @NotNull List<File> ktFiles,
+            @NotNull File outDir,
+            @NotNull Disposable disposable,
+            @Nullable File javaErrorFile,
+            @Nullable Function1<CompilerConfiguration, Unit> updateConfiguration
     ) throws IOException {
         if (!ktFiles.isEmpty()) {
             KotlinCoreEnvironment environment = createEnvironmentWithFullJdkAndIdeaAnnotations(disposable);
             CompilerTestLanguageVersionSettingsKt.setupLanguageVersionSettingsForMultifileCompilerTests(ktFiles, environment);
+            if (updateConfiguration != null) {
+                updateConfiguration.invoke(environment.getConfiguration());
+            }
             LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment);
         }
         else {

compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.ir.AbstractIrJsTextTestCase
 import org.jetbrains.kotlin.ir.AbstractIrSourceRangesTestCase
 import org.jetbrains.kotlin.ir.AbstractIrTextTestCase
 import org.jetbrains.kotlin.jvm.compiler.*
+import org.jetbrains.kotlin.jvm.compiler.ir.AbstractIrCompileJavaAgainstKotlinTest
 import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJavaUsingJavacTest
 import org.jetbrains.kotlin.lexer.kdoc.AbstractKDocLexerTest
 import org.jetbrains.kotlin.lexer.kotlin.AbstractKotlinLexerTest
@@ -263,8 +264,8 @@ fun main(args: Array<String>) {
         }
 
         testClass<AbstractCompileJavaAgainstKotlinTest> {
-            model("compileJavaAgainstKotlin", testClassName = "WithoutJavac", testMethod = "doTestWithoutJavac")
+            model("compileJavaAgainstKotlin", testClassName = "WithoutJavac", testMethod = "doTestWithoutJavac", targetBackend = TargetBackend.JVM)
-            model("compileJavaAgainstKotlin", testClassName = "WithJavac", testMethod = "doTestWithJavac")
+            model("compileJavaAgainstKotlin", testClassName = "WithJavac", testMethod = "doTestWithJavac", targetBackend = TargetBackend.JVM)
         }
 
         testClass<AbstractCompileKotlinAgainstJavaTest> {
@@ -365,6 +366,11 @@ fun main(args: Array<String>) {
             model("codegen/boxAgainstJava", targetBackend = TargetBackend.JVM_IR)
         }
 
+        testClass<AbstractIrCompileJavaAgainstKotlinTest> {
+            model("compileJavaAgainstKotlin", testClassName = "WithoutJavac", testMethod = "doTestWithoutJavac", targetBackend = TargetBackend.JVM_IR)
+            //model("compileJavaAgainstKotlin", testClassName = "WithJavac", testMethod = "doTestWithJavac", targetBackend = TargetBackend.JVM_IR)
+        }
+
         testClass<AbstractIrCompileKotlinAgainstKotlinTest> {
             model("compileKotlinAgainstKotlin", targetBackend = TargetBackend.JVM_IR)
         }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java

@@ -24,11 +24,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
     @RunWith(JUnit3RunnerWithInners.class)
     public static class WithoutJavac extends AbstractCompileJavaAgainstKotlinTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInWithoutJavac() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/compileJavaAgainstKotlin/callableReference")
@@ -36,11 +36,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CallableReference extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInCallableReference() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("GenericSignature.kt")
@@ -54,11 +54,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Class extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInClass() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("ClassObject.kt")
@@ -132,11 +132,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Enum extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInEnum() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("DefaultArgumentInEnumConstructor.kt")
@@ -150,11 +150,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class JvmStatic extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInJvmStatic() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("simpleCompanionObject.kt")
@@ -183,7 +183,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Method extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             @TestMetadata("AccessorGenericSignature.kt")
@@ -192,7 +192,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             }
 
             public void testAllFilesPresentInMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("Any.kt")
@@ -310,11 +310,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PlatformName extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPlatformName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("PlatformName.kt")
@@ -328,11 +328,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PrimitiveOverride extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPrimitiveOverride() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("ByteOverridesObject.kt")
@@ -396,11 +396,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PrimitiveOverrideWithInlineClass extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("InlineIntOverridesObject.kt")
@@ -414,11 +414,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Throws extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInThrows() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("ClassMembers.kt")
@@ -463,11 +463,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Property extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInProperty() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("ConstVal.kt")
@@ -490,11 +490,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PlatformName extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPlatformName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("PlatformName.kt")
@@ -509,11 +509,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Sealed extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInSealed() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("Derived.kt")
@@ -532,11 +532,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class StaticFields extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInStaticFields() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("AnnotationClass.kt")
@@ -570,11 +570,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Targets extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInTargets() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("annotation.kt")
@@ -649,11 +649,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
     @RunWith(JUnit3RunnerWithInners.class)
     public static class WithJavac extends AbstractCompileJavaAgainstKotlinTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInWithJavac() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/compileJavaAgainstKotlin/callableReference")
@@ -661,11 +661,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CallableReference extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInCallableReference() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("GenericSignature.kt")
@@ -679,11 +679,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Class extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInClass() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("ClassObject.kt")
@@ -757,11 +757,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Enum extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInEnum() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("DefaultArgumentInEnumConstructor.kt")
@@ -775,11 +775,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class JvmStatic extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInJvmStatic() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("simpleCompanionObject.kt")
@@ -808,7 +808,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Method extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             @TestMetadata("AccessorGenericSignature.kt")
@@ -817,7 +817,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             }
 
             public void testAllFilesPresentInMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("Any.kt")
@@ -935,11 +935,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PlatformName extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPlatformName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("PlatformName.kt")
@@ -953,11 +953,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PrimitiveOverride extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPrimitiveOverride() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("ByteOverridesObject.kt")
@@ -1021,11 +1021,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PrimitiveOverrideWithInlineClass extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("InlineIntOverridesObject.kt")
@@ -1039,11 +1039,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Throws extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInThrows() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("ClassMembers.kt")
@@ -1088,11 +1088,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Property extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInProperty() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("ConstVal.kt")
@@ -1115,11 +1115,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PlatformName extends AbstractCompileJavaAgainstKotlinTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPlatformName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("PlatformName.kt")
@@ -1134,11 +1134,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Sealed extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInSealed() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("Derived.kt")
@@ -1157,11 +1157,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class StaticFields extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInStaticFields() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("AnnotationClass.kt")
@@ -1195,11 +1195,11 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Targets extends AbstractCompileJavaAgainstKotlinTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTestWithJavac, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInTargets() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("annotation.kt")

compiler/tests/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileJavaAgainstKotlinTestGenerated.java

@@ -0,0 +1,643 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.jvm.compiler.ir;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.TargetBackend;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("compiler/testData/compileJavaAgainstKotlin")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJavaAgainstKotlinTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+    }
+
+    public void testAllFilesPresentInWithoutJavac() throws Exception {
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/callableReference")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class CallableReference extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInCallableReference() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("GenericSignature.kt")
+        public void testGenericSignature() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/callableReference/GenericSignature.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/class")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Class extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInClass() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("ClassObject.kt")
+        public void testClassObject() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/ClassObject.kt");
+        }
+
+        @TestMetadata("DefaultConstructor.kt")
+        public void testDefaultConstructor() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/DefaultConstructor.kt");
+        }
+
+        @TestMetadata("DefaultConstructorWithTwoArgs.kt")
+        public void testDefaultConstructorWithTwoArgs() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/DefaultConstructorWithTwoArgs.kt");
+        }
+
+        @TestMetadata("ExtendsAbstractListT.kt")
+        public void testExtendsAbstractListT() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/ExtendsAbstractListT.kt");
+        }
+
+        @TestMetadata("ImplementsListString.kt")
+        public void testImplementsListString() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/ImplementsListString.kt");
+        }
+
+        @TestMetadata("ImplementsMapPP.kt")
+        public void testImplementsMapPP() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/ImplementsMapPP.kt");
+        }
+
+        @TestMetadata("InnerClass.kt")
+        public void testInnerClass() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/InnerClass.kt");
+        }
+
+        @TestMetadata("InnerClassConstructors.kt")
+        public void testInnerClassConstructors() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/InnerClassConstructors.kt");
+        }
+
+        @TestMetadata("InnerClassOfGeneric.kt")
+        public void testInnerClassOfGeneric() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/InnerClassOfGeneric.kt");
+        }
+
+        @TestMetadata("kt3561.kt")
+        public void testKt3561() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/kt3561.kt");
+        }
+
+        @TestMetadata("kt4050.kt")
+        public void testKt4050() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/kt4050.kt");
+        }
+
+        @TestMetadata("Simple.kt")
+        public void testSimple() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/Simple.kt");
+        }
+
+        @TestMetadata("StarProjection.kt")
+        public void testStarProjection() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/class/StarProjection.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/enum")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Enum extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInEnum() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("DefaultArgumentInEnumConstructor.kt")
+        public void testDefaultArgumentInEnumConstructor() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/enum/DefaultArgumentInEnumConstructor.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/jvmStatic")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class JvmStatic extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInJvmStatic() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("simpleCompanionObject.kt")
+        public void testSimpleCompanionObject() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/jvmStatic/simpleCompanionObject.kt");
+        }
+
+        @TestMetadata("simpleCompanionObjectProperty.kt")
+        public void testSimpleCompanionObjectProperty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/jvmStatic/simpleCompanionObjectProperty.kt");
+        }
+
+        @TestMetadata("simpleObject.kt")
+        public void testSimpleObject() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/jvmStatic/simpleObject.kt");
+        }
+
+        @TestMetadata("simpleObjectProperty.kt")
+        public void testSimpleObjectProperty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/jvmStatic/simpleObjectProperty.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/method")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Method extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        @TestMetadata("AccessorGenericSignature.kt")
+        public void testAccessorGenericSignature() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/AccessorGenericSignature.kt");
+        }
+
+        public void testAllFilesPresentInMethod() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("Any.kt")
+        public void testAny() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Any.kt");
+        }
+
+        @TestMetadata("ArrayOfIntArray.kt")
+        public void testArrayOfIntArray() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/ArrayOfIntArray.kt");
+        }
+
+        @TestMetadata("ArrayOfIntegerArray.kt")
+        public void testArrayOfIntegerArray() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/ArrayOfIntegerArray.kt");
+        }
+
+        @TestMetadata("ClashingSignaturesWithoutReturnType.kt")
+        public void testClashingSignaturesWithoutReturnType() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/ClashingSignaturesWithoutReturnType.kt");
+        }
+
+        @TestMetadata("Delegation.kt")
+        public void testDelegation() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Delegation.kt");
+        }
+
+        @TestMetadata("Extensions.kt")
+        public void testExtensions() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Extensions.kt");
+        }
+
+        @TestMetadata("GenericArray.kt")
+        public void testGenericArray() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/GenericArray.kt");
+        }
+
+        @TestMetadata("Hello.kt")
+        public void testHello() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Hello.kt");
+        }
+
+        @TestMetadata("Int.kt")
+        public void testInt() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Int.kt");
+        }
+
+        @TestMetadata("IntArray.kt")
+        public void testIntArray() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/IntArray.kt");
+        }
+
+        @TestMetadata("IntWithDefault.kt")
+        public void testIntWithDefault() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/IntWithDefault.kt");
+        }
+
+        @TestMetadata("IntegerArray.kt")
+        public void testIntegerArray() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/IntegerArray.kt");
+        }
+
+        @TestMetadata("ListOfInt.kt")
+        public void testListOfInt() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/ListOfInt.kt");
+        }
+
+        @TestMetadata("ListOfString.kt")
+        public void testListOfString() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/ListOfString.kt");
+        }
+
+        @TestMetadata("ListOfT.kt")
+        public void testListOfT() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/ListOfT.kt");
+        }
+
+        @TestMetadata("MapOfKString.kt")
+        public void testMapOfKString() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/MapOfKString.kt");
+        }
+
+        @TestMetadata("MapOfStringIntQ.kt")
+        public void testMapOfStringIntQ() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/MapOfStringIntQ.kt");
+        }
+
+        @TestMetadata("QExtendsListString.kt")
+        public void testQExtendsListString() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/QExtendsListString.kt");
+        }
+
+        @TestMetadata("QExtendsString.kt")
+        public void testQExtendsString() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/QExtendsString.kt");
+        }
+
+        @TestMetadata("TraitImpl.kt")
+        public void testTraitImpl() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/TraitImpl.kt");
+        }
+
+        @TestMetadata("Vararg.kt")
+        public void testVararg() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Vararg.kt");
+        }
+
+        @TestMetadata("Void.kt")
+        public void testVoid() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/method/Void.kt");
+        }
+
+        @TestMetadata("compiler/testData/compileJavaAgainstKotlin/method/platformName")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class PlatformName extends AbstractIrCompileJavaAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInPlatformName() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("PlatformName.kt")
+            public void testPlatformName() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/platformName/PlatformName.kt");
+            }
+        }
+
+        @TestMetadata("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class PrimitiveOverride extends AbstractIrCompileJavaAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInPrimitiveOverride() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("ByteOverridesObject.kt")
+            public void testByteOverridesObject() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ByteOverridesObject.kt");
+            }
+
+            @TestMetadata("CallFinalNotInSubclass.kt")
+            public void testCallFinalNotInSubclass() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/CallFinalNotInSubclass.kt");
+            }
+
+            @TestMetadata("CallNotInSubclass.kt")
+            public void testCallNotInSubclass() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/CallNotInSubclass.kt");
+            }
+
+            @TestMetadata("CovariantReturnTypeOverride.kt")
+            public void testCovariantReturnTypeOverride() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/CovariantReturnTypeOverride.kt");
+            }
+
+            @TestMetadata("FinalOverride.kt")
+            public void testFinalOverride() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/FinalOverride.kt");
+            }
+
+            @TestMetadata("IntOverridesComparable.kt")
+            public void testIntOverridesComparable() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesComparable.kt");
+            }
+
+            @TestMetadata("IntOverridesNumber.kt")
+            public void testIntOverridesNumber() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesNumber.kt");
+            }
+
+            @TestMetadata("IntOverridesObject.kt")
+            public void testIntOverridesObject() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesObject.kt");
+            }
+
+            @TestMetadata("ManyClassesHierarchy.kt")
+            public void testManyClassesHierarchy() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ManyClassesHierarchy.kt");
+            }
+
+            @TestMetadata("NullableIntOverridesObject.kt")
+            public void testNullableIntOverridesObject() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/NullableIntOverridesObject.kt");
+            }
+
+            @TestMetadata("OverrideInJava.kt")
+            public void testOverrideInJava() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/OverrideInJava.kt");
+            }
+        }
+
+        @TestMetadata("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class PrimitiveOverrideWithInlineClass extends AbstractIrCompileJavaAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("InlineIntOverridesObject.kt")
+            public void testInlineIntOverridesObject() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass/InlineIntOverridesObject.kt");
+            }
+        }
+
+        @TestMetadata("compiler/testData/compileJavaAgainstKotlin/method/throws")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Throws extends AbstractIrCompileJavaAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInThrows() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("ClassMembers.kt")
+            public void testClassMembers() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/ClassMembers.kt");
+            }
+
+            @TestMetadata("Constructor.kt")
+            public void testConstructor() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/Constructor.kt");
+            }
+
+            @TestMetadata("DefaultArgs.kt")
+            public void testDefaultArgs() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/DefaultArgs.kt");
+            }
+
+            @TestMetadata("Delegation.kt")
+            public void testDelegation() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/Delegation.kt");
+            }
+
+            @TestMetadata("GenericSubstitution.kt")
+            public void testGenericSubstitution() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/GenericSubstitution.kt");
+            }
+
+            @TestMetadata("TopLevel.kt")
+            public void testTopLevel() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/TopLevel.kt");
+            }
+
+            @TestMetadata("TraitMembers.kt")
+            public void testTraitMembers() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/method/throws/TraitMembers.kt");
+            }
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/property")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Property extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInProperty() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("ConstVal.kt")
+        public void testConstVal() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/property/ConstVal.kt");
+        }
+
+        @TestMetadata("Extensions.kt")
+        public void testExtensions() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/property/Extensions.kt");
+        }
+
+        @TestMetadata("GenericProperty.kt")
+        public void testGenericProperty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/property/GenericProperty.kt");
+        }
+
+        @TestMetadata("compiler/testData/compileJavaAgainstKotlin/property/platformName")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class PlatformName extends AbstractIrCompileJavaAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInPlatformName() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("PlatformName.kt")
+            public void testPlatformName() throws Exception {
+                runTest("compiler/testData/compileJavaAgainstKotlin/property/platformName/PlatformName.kt");
+            }
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/sealed")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Sealed extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInSealed() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("Derived.kt")
+        public void testDerived() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/sealed/Derived.kt");
+        }
+
+        @TestMetadata("Instance.kt")
+        public void testInstance() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/sealed/Instance.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/staticFields")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class StaticFields extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInStaticFields() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("AnnotationClass.kt")
+        public void testAnnotationClass() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.kt");
+        }
+
+        @TestMetadata("AnnotationTrait.kt")
+        public void testAnnotationTrait() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.kt");
+        }
+
+        @TestMetadata("kt3698.kt")
+        public void testKt3698() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.kt");
+        }
+
+        @TestMetadata("staticClassProperty.kt")
+        public void testStaticClassProperty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/staticFields/staticClassProperty.kt");
+        }
+
+        @TestMetadata("staticTraitProperty.kt")
+        public void testStaticTraitProperty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/staticFields/staticTraitProperty.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/targets")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Targets extends AbstractIrCompileJavaAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavac, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTargets() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("annotation.kt")
+        public void testAnnotation() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/annotation.kt");
+        }
+
+        @TestMetadata("base.kt")
+        public void testBase() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/base.kt");
+        }
+
+        @TestMetadata("classifier.kt")
+        public void testClassifier() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/classifier.kt");
+        }
+
+        @TestMetadata("constructor.kt")
+        public void testConstructor() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/constructor.kt");
+        }
+
+        @TestMetadata("empty.kt")
+        public void testEmpty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/empty.kt");
+        }
+
+        @TestMetadata("field.kt")
+        public void testField() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/field.kt");
+        }
+
+        @TestMetadata("function.kt")
+        public void testFunction() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/function.kt");
+        }
+
+        @TestMetadata("getter.kt")
+        public void testGetter() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/getter.kt");
+        }
+
+        @TestMetadata("local.kt")
+        public void testLocal() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/local.kt");
+        }
+
+        @TestMetadata("multiple.kt")
+        public void testMultiple() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/multiple.kt");
+        }
+
+        @TestMetadata("parameter.kt")
+        public void testParameter() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/parameter.kt");
+        }
+
+        @TestMetadata("property.kt")
+        public void testProperty() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/property.kt");
+        }
+
+        @TestMetadata("setter.kt")
+        public void testSetter() throws Exception {
+            runTest("compiler/testData/compileJavaAgainstKotlin/targets/setter.kt");
+        }
+    }
+}