Add IR equivalent of the WriteFlags test

2019-04-08 16:41:05 +02:00
parent f2d513a39c
commit 3fdcf8376f
82 changed files with 1393 additions and 75 deletions
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
    fun foo() {}

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
    fun foo() {}

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
    val foo = ""

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
    val foo = ""

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR

 enum class BigEnum {
    ITEM1,
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
@Deprecated("") class MyClass() {
 }

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass {
    @Deprecated("") companion object {

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
@Deprecated("") enum class MyEnum {
    FIRST
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("") public class MyInnerClass() {}
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
@Deprecated("") public interface MyTrait {
 }

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 enum class MyClass() {
 }

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
  enum class MyClass() {
  }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 private enum class MyClass() {
 }

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 // NO_FLAGS because we put enum in companion object of foo. When it will be fixed - MyClass should have ACC_PRIVATE flag

 class Foo {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 public enum class MyClass() {
 }

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
  public enum class MyClass() {
  }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 enum class Foo {
    A, B, C
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
  fun a() {
    val s = object { }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("") val test = ""
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("") var test = ""
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    fun test(s: String = "") {}
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    companion object {
        fun test(s: String, x:Int = 10) {}
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
    @kotlin.internal.InlineOnly
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    inline fun <reified T> test(s: String = "") {}
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 fun test(s: String = "") {}

 // TESTED_OBJECT_KIND: function
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
    fun test() {}
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
    var test: Int
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
    var test: Int
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Introspector {
    inner class SchemaRetriever(val transaction: String) {
        inline fun inSchema(crossinline modifier: (String) -> Unit) =
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Introspector {

    class SchemaRetriever(val transaction: String) {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Introspector {
    fun test() {
        class SchemaRetriever(val transaction: String) {
@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: compatibility
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: compatibility
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: enable
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: enable
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: enable
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
    inline fun foo() = { }
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
    fun foo() = { }
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class My {
    lateinit var s: String
        private set
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    var prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    protected var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    public val prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    public var prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test(val prop: String) {

  companion object {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty

 public open class TestDelegate<T: Any>(private val initializer: () -> T) {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty

 public open class TestDelegate<T: Any>(private val initializer: () -> T) {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {

  public var prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty

 class TestDelegate() {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty

 class TestDelegate() {
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    internal const val prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    internal val prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    internal var prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    internal var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    private val prop = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    private var prop = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    protected const val prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    protected val prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    protected var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public const val prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public val prop: Int = 0;
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public val prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
  companion object {
    public var prop: Int = 0
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
    @Deprecated("") public val test: Int = 0
 }
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
@Deprecated("") val test: Int = 0

 // TESTED_OBJECT_KIND: property
@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
    annotation class Anno

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 open class Foo {
    annotation class Anno

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
    annotation class Anno

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
@Target(AnnotationTarget.TYPEALIAS)
 annotation class Anno

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
@Target(AnnotationTarget.TYPEALIAS)
 annotation class Anno

@@ -0,0 +1,17 @@
+/*
+ * 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.codegen.ir
+
+import org.jetbrains.kotlin.codegen.flags.AbstractWriteFlagsTest
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.test.TargetBackend
+
+abstract class AbstractIrWriteFlagsTest : AbstractWriteFlagsTest() {
+    override fun updateConfiguration(configuration: CompilerConfiguration) {
+        configuration.put(JVMConfigurationKeys.IR, true)
+    }
+}
@@ -22,11 +22,11 @@ import java.util.regex.Pattern;
@RunWith(JUnit3RunnerWithInners.class)
 public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    private void runTest(String testDataFilePath) throws Exception {
-        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
    }

    public void testAllFilesPresentInWriteFlags() throws Exception {
-        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
    }

    @TestMetadata("compiler/testData/writeFlags/callableReference")
@@ -34,11 +34,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class CallableReference extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInCallableReference() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/callableReference/visibility")
@@ -46,11 +46,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Visibility extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("functionReference.kt")
@@ -80,11 +80,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Class extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInClass() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/class/accessFlags")
@@ -92,11 +92,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class AccessFlags extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInAccessFlags() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("defaultImpls.kt")
@@ -150,11 +150,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class DeprecatedFlag extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInDeprecatedFlag() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("class.kt")
@@ -188,11 +188,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Visibility extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("compiler/testData/writeFlags/class/visibility/internal")
@@ -200,11 +200,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Internal extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInInternal() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("class.kt")
@@ -253,11 +253,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Packageprivate extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInPackageprivate() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("enumEntry.kt")
@@ -271,11 +271,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Private extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInPrivate() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("class.kt")
@@ -324,11 +324,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Public extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInPublic() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("class.kt")
@@ -379,11 +379,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class DelegatedProperty extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInDelegatedProperty() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/delegatedProperty/visibility")
@@ -391,11 +391,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Visibility extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("privateSet.kt")
@@ -410,11 +410,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Function extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInFunction() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/function/classObjectPrivate")
@@ -422,11 +422,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class ClassObjectPrivate extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInClassObjectPrivate() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("privateFun.kt")
@@ -450,11 +450,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Constructors extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInConstructors() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("classObject.kt")
@@ -488,11 +488,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class DeprecatedFlag extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInDeprecatedFlag() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("emptyGetter.kt")
@@ -561,11 +561,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class WithDefaultArguments extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInWithDefaultArguments() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("funInClass.kt")
@@ -600,11 +600,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Hidden extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInHidden() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("function.kt")
@@ -628,11 +628,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Inline extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInInline() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("lostInnerClass.kt")
@@ -656,11 +656,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class InnerClass extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInInnerClass() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/innerClass/visibility")
@@ -668,11 +668,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Visibility extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("internal.kt")
@@ -712,11 +712,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Jvm8 extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInJvm8() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("interfaceMethod.kt")
@@ -734,11 +734,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Defaults extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInDefaults() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("defaultMethod.kt")
@@ -761,11 +761,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Compatibility extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInCompatibility() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("propertyAccessors.kt")
@@ -786,11 +786,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Lambda extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInLambda() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("lambdaInInlineFunction.kt")
@@ -809,11 +809,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Lateinit extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInLateinit() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("lateinitGetter.kt")
@@ -837,11 +837,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Property extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInProperty() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/property/classObject")
@@ -849,11 +849,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class ClassObject extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInClassObject() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("compiler/testData/writeFlags/property/classObject/class")
@@ -861,11 +861,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Class extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("delegatedProtectedVar.kt")
@@ -959,11 +959,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Rename extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInRename() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("constructorAndClassObject.kt")
@@ -992,11 +992,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
            @RunWith(JUnit3RunnerWithInners.class)
            public static class Trait extends AbstractWriteFlagsTest {
                private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                }

                public void testAllFilesPresentInTrait() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                }

                @TestMetadata("delegatedProtectedVar.kt")
@@ -1106,11 +1106,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class DeprecatedFlag extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInDeprecatedFlag() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("propertyInClass.kt")
@@ -1129,11 +1129,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class SyntheticAnnotationsMethod extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("privateProperty.kt")
@@ -1157,11 +1157,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class Visibility extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("internal.kt")
@@ -1186,11 +1186,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
    @RunWith(JUnit3RunnerWithInners.class)
    public static class Typealias extends AbstractWriteFlagsTest {
        private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
        }

        public void testAllFilesPresentInTypealias() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
        }

        @TestMetadata("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod")
@@ -1198,11 +1198,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
        @RunWith(JUnit3RunnerWithInners.class)
        public static class SyntheticAnnotationsMethod extends AbstractWriteFlagsTest {
            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
            }

            public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
            }

            @TestMetadata("privateTypealias.kt")
@@ -221,7 +221,7 @@ fun main(args: Array<String>) {
        }

        testClass<AbstractWriteFlagsTest> {
-            model("writeFlags")
+            model("writeFlags", targetBackend = TargetBackend.JVM)
        }

        testClass<AbstractDefaultArgumentsReflectionTest> {
@@ -373,6 +373,10 @@ fun main(args: Array<String>) {
            model("checkLocalVariablesTable", targetBackend = TargetBackend.JVM_IR)
        }

+        testClass<AbstractIrWriteFlagsTest> {
+            model("writeFlags", targetBackend = TargetBackend.JVM_IR)
+        }
+
        testClass<AbstractIrLineNumberTest> {
            model("lineNumber", targetBackend = TargetBackend.JVM_IR)
        }