Regenerate tests

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated.java

@@ -21,13 +21,16 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated extends AbstractIncrementalJsCompilerRunnerWithFriendModulesDisabledTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInFriendsModuleDisabled() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false);
     }
 
     @TestMetadata("internalInlineFunctionIsChanged")
     public void testInternalInlineFunctionIsChanged() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged/");
-        doTest(fileName);
+        runTest("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged/");
     }
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJsCompilerRunnerTestGenerated.java

@@ -21,19 +21,47 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class IncrementalMultiplatformJsCompilerRunnerTestGenerated extends AbstractIncrementalMultiplatformJsCompilerRunnerTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInMultiplatform() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("touchActual")
     public void testTouchActual() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/multiplatform/touchActual/");
-        doTest(fileName);
+        runTest("jps-plugin/testData/incremental/multiplatform/touchActual/");
     }
 
     @TestMetadata("touchExpect")
     public void testTouchExpect() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/multiplatform/touchExpect/");
-        doTest(fileName);
+        runTest("jps-plugin/testData/incremental/multiplatform/touchExpect/");
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/multiplatform/touchActual")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TouchActual extends AbstractIncrementalMultiplatformJsCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTouchActual() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/touchActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/multiplatform/touchExpect")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TouchExpect extends AbstractIncrementalMultiplatformJsCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTouchExpect() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/touchExpect"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
     }
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJvmCompilerRunnerTestGenerated.java

@@ -21,19 +21,47 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class IncrementalMultiplatformJvmCompilerRunnerTestGenerated extends AbstractIncrementalMultiplatformJvmCompilerRunnerTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInMultiplatform() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("touchActual")
     public void testTouchActual() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/multiplatform/touchActual/");
-        doTest(fileName);
+        runTest("jps-plugin/testData/incremental/multiplatform/touchActual/");
     }
 
     @TestMetadata("touchExpect")
     public void testTouchExpect() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/multiplatform/touchExpect/");
-        doTest(fileName);
+        runTest("jps-plugin/testData/incremental/multiplatform/touchExpect/");
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/multiplatform/touchActual")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TouchActual extends AbstractIncrementalMultiplatformJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTouchActual() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/touchActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/multiplatform/touchExpect")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TouchExpect extends AbstractIncrementalMultiplatformJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTouchExpect() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/touchExpect"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java

@@ -21,64 +21,64 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
     }
 
     @TestMetadata("typeUseOnObject.kt")
     public void testTypeUseOnObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAnnotationAppliedToType.kt")
         public void testDefaultAnnotationAppliedToType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
         }
 
         @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt")
         public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
         }
 
         @TestMetadata("springNullableWithTypeUse.kt")
         public void testSpringNullableWithTypeUse() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
         }
 
         @TestMetadata("typeArguments.kt")
         public void testTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
         }
 
         @TestMetadata("typeUseVsMethodConflict.kt")
         public void testTypeUseVsMethodConflict() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
         }
     }
 
@@ -86,50 +86,47 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeEnhancement extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeEnhancement() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotatedTypeArguments.kt")
         public void testAnnotatedTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
         }
 
         @TestMetadata("methodWithTypeParameter.kt")
         public void testMethodWithTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
         }
 
         @TestMetadata("notNullVarargsOverrides.kt")
         public void testNotNullVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
         }
 
         @TestMetadata("nullableVarargsOverrides.kt")
         public void testNullableVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
         }
 
         @TestMetadata("returnTypeDifferentConstructor.kt")
         public void testReturnTypeDifferentConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
         }
 
         @TestMetadata("returnTypeOverrideInKotlin.kt")
         public void testReturnTypeOverrideInKotlin() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java

@@ -21,64 +21,64 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
     }
 
     @TestMetadata("typeUseOnObject.kt")
     public void testTypeUseOnObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAnnotationAppliedToType.kt")
         public void testDefaultAnnotationAppliedToType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
         }
 
         @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt")
         public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
         }
 
         @TestMetadata("springNullableWithTypeUse.kt")
         public void testSpringNullableWithTypeUse() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
         }
 
         @TestMetadata("typeArguments.kt")
         public void testTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
         }
 
         @TestMetadata("typeUseVsMethodConflict.kt")
         public void testTypeUseVsMethodConflict() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
         }
     }
 
@@ -86,50 +86,47 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeEnhancement extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeEnhancement() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotatedTypeArguments.kt")
         public void testAnnotatedTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
         }
 
         @TestMetadata("methodWithTypeParameter.kt")
         public void testMethodWithTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
         }
 
         @TestMetadata("notNullVarargsOverrides.kt")
         public void testNotNullVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
         }
 
         @TestMetadata("nullableVarargsOverrides.kt")
         public void testNullableVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
         }
 
         @TestMetadata("returnTypeDifferentConstructor.kt")
         public void testReturnTypeDifferentConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
         }
 
         @TestMetadata("returnTypeOverrideInKotlin.kt")
         public void testReturnTypeOverrideInKotlin() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java

@@ -21,64 +21,64 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8AnnotationsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
     }
 
     @TestMetadata("typeUseOnObject.kt")
     public void testTypeUseOnObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractForeignJava8AnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAnnotationAppliedToType.kt")
         public void testDefaultAnnotationAppliedToType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
         }
 
         @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt")
         public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
         }
 
         @TestMetadata("springNullableWithTypeUse.kt")
         public void testSpringNullableWithTypeUse() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
         }
 
         @TestMetadata("typeArguments.kt")
         public void testTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
         }
 
         @TestMetadata("typeUseVsMethodConflict.kt")
         public void testTypeUseVsMethodConflict() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
         }
     }
 
@@ -86,50 +86,47 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeEnhancement extends AbstractForeignJava8AnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeEnhancement() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotatedTypeArguments.kt")
         public void testAnnotatedTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
         }
 
         @TestMetadata("methodWithTypeParameter.kt")
         public void testMethodWithTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
         }
 
         @TestMetadata("notNullVarargsOverrides.kt")
         public void testNotNullVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
         }
 
         @TestMetadata("nullableVarargsOverrides.kt")
         public void testNullableVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
         }
 
         @TestMetadata("returnTypeDifferentConstructor.kt")
         public void testReturnTypeDifferentConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
         }
 
         @TestMetadata("returnTypeOverrideInKotlin.kt")
         public void testReturnTypeOverrideInKotlin() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java

@@ -21,64 +21,64 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacForeignJava8AnnotationsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt");
     }
 
     @TestMetadata("typeUseOnObject.kt")
     public void testTypeUseOnObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotationsJava8/tests/typeUseOnObject.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractJavacForeignJava8AnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAnnotationAppliedToType.kt")
         public void testDefaultAnnotationAppliedToType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt");
         }
 
         @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt")
         public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt");
         }
 
         @TestMetadata("springNullableWithTypeUse.kt")
         public void testSpringNullableWithTypeUse() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt");
         }
 
         @TestMetadata("typeArguments.kt")
         public void testTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt");
         }
 
         @TestMetadata("typeUseVsMethodConflict.kt")
         public void testTypeUseVsMethodConflict() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeUseVsMethodConflict.kt");
         }
     }
 
@@ -86,50 +86,47 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeEnhancement extends AbstractJavacForeignJava8AnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeEnhancement() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotatedTypeArguments.kt")
         public void testAnnotatedTypeArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt");
         }
 
         @TestMetadata("methodWithTypeParameter.kt")
         public void testMethodWithTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt");
         }
 
         @TestMetadata("notNullVarargsOverrides.kt")
         public void testNotNullVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt");
         }
 
         @TestMetadata("nullableVarargsOverrides.kt")
         public void testNullableVarargsOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt");
         }
 
         @TestMetadata("returnTypeDifferentConstructor.kt")
         public void testReturnTypeDifferentConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt");
         }
 
         @TestMetadata("returnTypeOverrideInKotlin.kt")
         public void testReturnTypeOverrideInKotlin() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/codegen/BlackBoxWithJava8CodegenTestGenerated.java

@@ -21,130 +21,119 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodegenTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInBox() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("async.kt")
     public void testAsync() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/async.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/async.kt");
     }
 
     @TestMetadata("asyncException.kt")
     public void testAsyncException() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/asyncException.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/asyncException.kt");
     }
 
     @TestMetadata("capturedSuperCall.kt")
     public void testCapturedSuperCall() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/capturedSuperCall.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/capturedSuperCall.kt");
     }
 
     @TestMetadata("defaultMethodCallFromInterface.kt")
     public void testDefaultMethodCallFromInterface() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/defaultMethodCallFromInterface.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/defaultMethodCallFromInterface.kt");
     }
 
     @TestMetadata("defaultMethodCallViaClass.kt")
     public void testDefaultMethodCallViaClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/defaultMethodCallViaClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/defaultMethodCallViaClass.kt");
     }
 
     @TestMetadata("defaultMethodCallViaInterface.kt")
     public void testDefaultMethodCallViaInterface() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/defaultMethodCallViaInterface.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/defaultMethodCallViaInterface.kt");
     }
 
     @TestMetadata("defaultMethodOverride.kt")
     public void testDefaultMethodOverride() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/defaultMethodOverride.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/defaultMethodOverride.kt");
     }
 
     @TestMetadata("dontDelegateToDefaultMethods.kt")
     public void testDontDelegateToDefaultMethods() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/dontDelegateToDefaultMethods.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/dontDelegateToDefaultMethods.kt");
     }
 
     @TestMetadata("functionAssertion.kt")
     public void testFunctionAssertion() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/functionAssertion.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/functionAssertion.kt");
     }
 
     @TestMetadata("inheritKotlin.kt")
     public void testInheritKotlin() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/inheritKotlin.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/inheritKotlin.kt");
     }
 
     @TestMetadata("invokeDefaultViaSuper.kt")
     public void testInvokeDefaultViaSuper() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/invokeDefaultViaSuper.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/invokeDefaultViaSuper.kt");
     }
 
     @TestMetadata("invokeDefaultViaSuper_16.kt")
     public void testInvokeDefaultViaSuper_16() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/invokeDefaultViaSuper_16.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/invokeDefaultViaSuper_16.kt");
     }
 
     @TestMetadata("longChainOfKotlinExtendsFromJavaWithDefault.kt")
     public void testLongChainOfKotlinExtendsFromJavaWithDefault() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/longChainOfKotlinExtendsFromJavaWithDefault.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/longChainOfKotlinExtendsFromJavaWithDefault.kt");
     }
 
     @TestMetadata("removeIf.kt")
     public void testRemoveIf() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/removeIf.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/removeIf.kt");
     }
 
     @TestMetadata("samOnInterfaceWithDefaultMethod.kt")
     public void testSamOnInterfaceWithDefaultMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/samOnInterfaceWithDefaultMethod.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/samOnInterfaceWithDefaultMethod.kt");
     }
 
     @TestMetadata("stream.kt")
     public void testStream() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/stream.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/stream.kt");
     }
 
     @TestMetadata("streamBackwardCompatibility.kt")
     public void testStreamBackwardCompatibility() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/streamBackwardCompatibility.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/streamBackwardCompatibility.kt");
     }
 
     @TestMetadata("useStream.kt")
     public void testUseStream() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/useStream.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/box/useStream.kt");
     }
 
     @TestMetadata("compiler/testData/codegen/java8/box/builtinStubMethods")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class BuiltinStubMethods extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInBuiltinStubMethods() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("immutableRemove.kt")
         public void testImmutableRemove() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/builtinStubMethods/immutableRemove.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/builtinStubMethods/immutableRemove.kt");
         }
     }
 
@@ -152,62 +141,57 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DelegationBy extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDelegationBy() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/delegationBy"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("byMiddleInterface.kt")
         public void testByMiddleInterface() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/byMiddleInterface.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/byMiddleInterface.kt");
         }
 
         @TestMetadata("defaultOverride.kt")
         public void testDefaultOverride() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/defaultOverride.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/defaultOverride.kt");
         }
 
         @TestMetadata("delegationToMap.kt")
         public void testDelegationToMap() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/delegationToMap.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/delegationToMap.kt");
         }
 
         @TestMetadata("diamond.kt")
         public void testDiamond() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/diamond.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/diamond.kt");
         }
 
         @TestMetadata("diamond2.kt")
         public void testDiamond2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/diamond2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/diamond2.kt");
         }
 
         @TestMetadata("inClassDeclaration.kt")
         public void testInClassDeclaration() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/inClassDeclaration.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/inClassDeclaration.kt");
         }
 
         @TestMetadata("mixed.kt")
         public void testMixed() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/mixed.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/mixed.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/simple.kt");
         }
 
         @TestMetadata("simple1.0.kt")
         public void testSimple1_0() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/delegationBy/simple1.0.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/delegationBy/simple1.0.kt");
         }
     }
 
@@ -215,144 +199,130 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jvm8 extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJvm8() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("bridgeInClass.kt")
         public void testBridgeInClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/bridgeInClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/bridgeInClass.kt");
         }
 
         @TestMetadata("bridgeInInterface.kt")
         public void testBridgeInInterface() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/bridgeInInterface.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/bridgeInInterface.kt");
         }
 
         @TestMetadata("capturedSuperCall.kt")
         public void testCapturedSuperCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/capturedSuperCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/capturedSuperCall.kt");
         }
 
         @TestMetadata("defaultArgs.kt")
         public void testDefaultArgs() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaultArgs.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/defaultArgs.kt");
         }
 
         @TestMetadata("inlineFromAnotherFile.kt")
         public void testInlineFromAnotherFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/inlineFromAnotherFile.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/inlineFromAnotherFile.kt");
         }
 
         @TestMetadata("inlineFromStdlib.kt")
         public void testInlineFromStdlib() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/inlineFromStdlib.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/inlineFromStdlib.kt");
         }
 
         @TestMetadata("kt11969.kt")
         public void testKt11969() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt11969.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt11969.kt");
         }
 
         @TestMetadata("kt14243.kt")
         public void testKt14243() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt14243.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt14243.kt");
         }
 
         @TestMetadata("kt14243_2.kt")
         public void testKt14243_2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt14243_2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt14243_2.kt");
         }
 
         @TestMetadata("kt14243_prop.kt")
         public void testKt14243_prop() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt14243_prop.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt14243_prop.kt");
         }
 
         @TestMetadata("kt16581.kt")
         public void testKt16581() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt16581.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt16581.kt");
         }
 
         @TestMetadata("kt16581_2.kt")
         public void testKt16581_2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt16581_2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt16581_2.kt");
         }
 
         @TestMetadata("kt16588.kt")
         public void testKt16588() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt16588.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt16588.kt");
         }
 
         @TestMetadata("kt6301.kt")
         public void testKt6301() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt6301.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt6301.kt");
         }
 
         @TestMetadata("kt6301_2.kt")
         public void testKt6301_2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/kt6301_2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/kt6301_2.kt");
         }
 
         @TestMetadata("oneImplementation.kt")
         public void testOneImplementation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/oneImplementation.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/oneImplementation.kt");
         }
 
         @TestMetadata("oneImplementation2.kt")
         public void testOneImplementation2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/oneImplementation2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/oneImplementation2.kt");
         }
 
         @TestMetadata("simpleCall.kt")
         public void testSimpleCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/simpleCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/simpleCall.kt");
         }
 
         @TestMetadata("simpleProperty.kt")
         public void testSimpleProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/simpleProperty.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/jvm8/simpleProperty.kt");
         }
 
         @TestMetadata("compiler/testData/codegen/java8/box/jvm8/defaults")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Defaults extends AbstractBlackBoxCodegenTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             @TestMetadata("accessor.kt")
             public void testAccessor() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/accessor.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/accessor.kt");
             }
 
             @TestMetadata("accessorFromCompanion.kt")
             public void testAccessorFromCompanion() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/accessorFromCompanion.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/accessorFromCompanion.kt");
             }
 
             @TestMetadata("accessorsFromDefaultImpls.kt")
             public void testAccessorsFromDefaultImpls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/accessorsFromDefaultImpls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/accessorsFromDefaultImpls.kt");
             }
 
             public void testAllFilesPresentInDefaults() throws Exception {
@@ -361,160 +331,139 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
 
             @TestMetadata("bridgeInClass.kt")
             public void testBridgeInClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInClass.kt");
             }
 
             @TestMetadata("bridgeInInterface.kt")
             public void testBridgeInInterface() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterface.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterface.kt");
             }
 
             @TestMetadata("bridgeInInterface2.kt")
             public void testBridgeInInterface2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterface2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterface2.kt");
             }
 
             @TestMetadata("bridgeInInterfaceWithProperties.kt")
             public void testBridgeInInterfaceWithProperties() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterfaceWithProperties.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterfaceWithProperties.kt");
             }
 
             @TestMetadata("bridgeInInterfaceWithProperties2.kt")
             public void testBridgeInInterfaceWithProperties2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterfaceWithProperties2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeInInterfaceWithProperties2.kt");
             }
 
             @TestMetadata("bridgeWithJava.kt")
             public void testBridgeWithJava() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeWithJava.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/bridgeWithJava.kt");
             }
 
             @TestMetadata("callableReference.kt")
             public void testCallableReference() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/callableReference.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/callableReference.kt");
             }
 
             @TestMetadata("capturedSuperCall.kt")
             public void testCapturedSuperCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/capturedSuperCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/capturedSuperCall.kt");
             }
 
             @TestMetadata("defaultArgs.kt")
             public void testDefaultArgs() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/defaultArgs.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/defaultArgs.kt");
             }
 
             @TestMetadata("diamond.kt")
             public void testDiamond() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/diamond.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/diamond.kt");
             }
 
             @TestMetadata("inline.kt")
             public void testInline() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/inline.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/inline.kt");
             }
 
             @TestMetadata("inlineProperty.kt")
             public void testInlineProperty() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/inlineProperty.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/inlineProperty.kt");
             }
 
             @TestMetadata("kt11969.kt")
             public void testKt11969() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/kt11969.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/kt11969.kt");
             }
 
             @TestMetadata("kt14243.kt")
             public void testKt14243() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/kt14243.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/kt14243.kt");
             }
 
             @TestMetadata("kt14243_2.kt")
             public void testKt14243_2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/kt14243_2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/kt14243_2.kt");
             }
 
             @TestMetadata("kt14243_prop.kt")
             public void testKt14243_prop() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/kt14243_prop.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/kt14243_prop.kt");
             }
 
             @TestMetadata("oneImplementation.kt")
             public void testOneImplementation() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/oneImplementation.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/oneImplementation.kt");
             }
 
             @TestMetadata("oneImplementation2.kt")
             public void testOneImplementation2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/oneImplementation2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/oneImplementation2.kt");
             }
 
             @TestMetadata("privateDefaultFromDefaultImpl.kt")
             public void testPrivateDefaultFromDefaultImpl() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/privateDefaultFromDefaultImpl.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/privateDefaultFromDefaultImpl.kt");
             }
 
             @TestMetadata("privateInDefaultImpls.kt")
             public void testPrivateInDefaultImpls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/privateInDefaultImpls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/privateInDefaultImpls.kt");
             }
 
             @TestMetadata("simpleCall.kt")
             public void testSimpleCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/simpleCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/simpleCall.kt");
             }
 
             @TestMetadata("simpleProperty.kt")
             public void testSimpleProperty() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/simpleProperty.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/simpleProperty.kt");
             }
 
             @TestMetadata("superCall.kt")
             public void testSuperCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/superCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/defaults/superCall.kt");
             }
 
             @TestMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/delegationBy")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class DelegationBy extends AbstractBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInDelegationBy() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("simple.kt")
                 public void testSimple() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/delegationBy/simple.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/codegen/java8/box/jvm8/defaults/delegationBy/simple.kt");
                 }
 
                 @TestMetadata("simpleProperty.kt")
                 public void testSimpleProperty() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/delegationBy/simpleProperty.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/codegen/java8/box/jvm8/defaults/delegationBy/simpleProperty.kt");
                 }
             }
 
@@ -522,26 +471,27 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class NoDelegation extends AbstractBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInNoDelegation() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("noDelegationToDefaultMethodInClass.kt")
                 public void testNoDelegationToDefaultMethodInClass() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInClass.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInClass.kt");
                 }
 
                 @TestMetadata("noDelegationToDefaultMethodInInterface.kt")
                 public void testNoDelegationToDefaultMethodInInterface() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInInterface.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInInterface.kt");
                 }
 
                 @TestMetadata("noDelegationToDefaultMethodInInterface2.kt")
                 public void testNoDelegationToDefaultMethodInInterface2() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInInterface2.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/codegen/java8/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInInterface2.kt");
                 }
             }
 
@@ -549,14 +499,17 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Reflection extends AbstractBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInReflection() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("propertyAnnotations.kt")
                 public void testPropertyAnnotations() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/defaults/reflection/propertyAnnotations.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/codegen/java8/box/jvm8/defaults/reflection/propertyAnnotations.kt");
                 }
             }
         }
@@ -565,20 +518,22 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class InterfaceFlag extends AbstractBlackBoxCodegenTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInInterfaceFlag() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("superCall.kt")
             public void testSuperCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/interfaceFlag/superCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/interfaceFlag/superCall.kt");
             }
 
             @TestMetadata("superCallIndirect.kt")
             public void testSuperCallIndirect() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/interfaceFlag/superCallIndirect.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/interfaceFlag/superCallIndirect.kt");
             }
         }
 
@@ -586,14 +541,17 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Optimizations extends AbstractBlackBoxCodegenTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInOptimizations() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/jvm8/optimizations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("hashCode.kt")
             public void testHashCode() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/jvm8/optimizations/hashCode.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/jvm8/optimizations/hashCode.kt");
             }
         }
     }
@@ -602,26 +560,27 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class MapGetOrDefault extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInMapGetOrDefault() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("noTypeSafeBridge.kt")
         public void testNoTypeSafeBridge() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapGetOrDefault/noTypeSafeBridge.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapGetOrDefault/noTypeSafeBridge.kt");
         }
 
         @TestMetadata("typeSafeBridge.kt")
         public void testTypeSafeBridge() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapGetOrDefault/typeSafeBridge.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapGetOrDefault/typeSafeBridge.kt");
         }
 
         @TestMetadata("typeSafeBridgeNotNullAny.kt")
         public void testTypeSafeBridgeNotNullAny() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapGetOrDefault/typeSafeBridgeNotNullAny.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapGetOrDefault/typeSafeBridgeNotNullAny.kt");
         }
     }
 
@@ -629,32 +588,32 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class MapRemove extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInMapRemove() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/mapRemove"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("noDefaultImpls.kt")
         public void testNoDefaultImpls() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapRemove/noDefaultImpls.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapRemove/noDefaultImpls.kt");
         }
 
         @TestMetadata("readOnlyMap.kt")
         public void testReadOnlyMap() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapRemove/readOnlyMap.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapRemove/readOnlyMap.kt");
         }
 
         @TestMetadata("typeSafeBridge.kt")
         public void testTypeSafeBridge() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapRemove/typeSafeBridge.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapRemove/typeSafeBridge.kt");
         }
 
         @TestMetadata("typeSafeBridgeNotNullAny.kt")
         public void testTypeSafeBridgeNotNullAny() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/mapRemove/typeSafeBridgeNotNullAny.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/mapRemove/typeSafeBridgeNotNullAny.kt");
         }
     }
 
@@ -662,44 +621,42 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ParametersMetadata extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInParametersMetadata() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultImpls.kt")
         public void testDefaultImpls() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/parametersMetadata/defaultImpls.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/parametersMetadata/defaultImpls.kt");
         }
 
         @TestMetadata("enum.kt")
         public void testEnum() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/parametersMetadata/enum.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/parametersMetadata/enum.kt");
         }
 
         @TestMetadata("extensionFunction.kt")
         public void testExtensionFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/parametersMetadata/extensionFunction.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/parametersMetadata/extensionFunction.kt");
         }
 
         @TestMetadata("function.kt")
         public void testFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/parametersMetadata/function.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/parametersMetadata/function.kt");
         }
 
         @TestMetadata("innerClass.kt")
         public void testInnerClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/parametersMetadata/innerClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/parametersMetadata/innerClass.kt");
         }
 
         @TestMetadata("superParams.kt")
         public void testSuperParams() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/parametersMetadata/superParams.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/parametersMetadata/superParams.kt");
         }
     }
 
@@ -707,34 +664,39 @@ public class BlackBoxWithJava8CodegenTestGenerated extends AbstractBlackBoxCodeg
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Reflection extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInReflection() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/reflection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("realParameterNames.kt")
         public void testRealParameterNames() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/reflection/realParameterNames.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/reflection/realParameterNames.kt");
         }
 
         @TestMetadata("synthesizedParameterNames.kt")
         public void testSynthesizedParameterNames() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/reflection/synthesizedParameterNames.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/box/reflection/synthesizedParameterNames.kt");
         }
 
         @TestMetadata("compiler/testData/codegen/java8/box/reflection/parameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Parameters extends AbstractBlackBoxCodegenTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInParameters() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("javaParametersHaveDefaultNames.kt")
             public void testJavaParametersHaveDefaultNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/box/reflection/parameters/javaParametersHaveDefaultNames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/box/reflection/parameters/javaParametersHaveDefaultNames.kt");
             }
         }
     }

compiler/tests-java8/tests/org/jetbrains/kotlin/codegen/BytecodeTextJava8TestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class BytecodeTextJava8TestGenerated extends AbstractBytecodeTextTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInBytecodeText() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,20 +33,22 @@ public class BytecodeTextJava8TestGenerated extends AbstractBytecodeTextTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class HashCode extends AbstractBytecodeTextTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInHashCode() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("dataClass.kt")
         public void testDataClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/bytecodeText/hashCode/dataClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/bytecodeText/hashCode/dataClass.kt");
         }
 
         @TestMetadata("hashCode.kt")
         public void testHashCode() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/bytecodeText/hashCode/hashCode.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/bytecodeText/hashCode/hashCode.kt");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotlinAgainstKotlinTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,14 +33,17 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jvm6 extends AbstractCompileKotlinAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJvm6() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm6"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("jdk8Against6.kt")
         public void testJdk8Against6() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm6/jdk8Against6.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm6/jdk8Against6.kt");
         }
     }
 
@@ -44,6 +51,10 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jvm8 extends AbstractCompileKotlinAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJvm8() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -52,32 +63,32 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Defaults extends AbstractCompileKotlinAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInDefaults() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("superCall.kt")
             public void testSuperCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superCall.kt");
             }
 
             @TestMetadata("superCallFromInterface.kt")
             public void testSuperCallFromInterface() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface.kt");
             }
 
             @TestMetadata("superPropAccess.kt")
             public void testSuperPropAccess() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccess.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccess.kt");
             }
 
             @TestMetadata("superPropAccessFromInterface.kt")
             public void testSuperPropAccessFromInterface() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface.kt");
             }
         }
     }
@@ -86,64 +97,64 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jvm8against6 extends AbstractCompileKotlinAgainstKotlinTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJvm8against6() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("simpleCall.kt")
         public void testSimpleCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleCall.kt");
         }
 
         @TestMetadata("simpleCallWithBigHierarchy.kt")
         public void testSimpleCallWithBigHierarchy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleCallWithBigHierarchy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleCallWithBigHierarchy.kt");
         }
 
         @TestMetadata("simpleCallWithHierarchy.kt")
         public void testSimpleCallWithHierarchy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleCallWithHierarchy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleCallWithHierarchy.kt");
         }
 
         @TestMetadata("simpleProp.kt")
         public void testSimpleProp() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleProp.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simpleProp.kt");
         }
 
         @TestMetadata("simplePropWithHierarchy.kt")
         public void testSimplePropWithHierarchy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simplePropWithHierarchy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/simplePropWithHierarchy.kt");
         }
 
         @TestMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Delegation extends AbstractCompileKotlinAgainstKotlinTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInDelegation() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("diamond.kt")
             public void testDiamond() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation/diamond.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation/diamond.kt");
             }
 
             @TestMetadata("diamond2.kt")
             public void testDiamond2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation/diamond2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation/diamond2.kt");
             }
 
             @TestMetadata("diamond3.kt")
             public void testDiamond3() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation/diamond3.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/java8/compileKotlinAgainstKotlin/jvm8against6/delegation/diamond3.kt");
             }
         }
     }

compiler/tests-java8/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java

@@ -21,40 +21,44 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInWriteFlags() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/writeFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("interfaceMethod.kt")
     public void testInterfaceMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/writeFlags/interfaceMethod.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/writeFlags/interfaceMethod.kt");
     }
 
     @TestMetadata("interfaceProperty.kt")
     public void testInterfaceProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/writeFlags/interfaceProperty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/writeFlags/interfaceProperty.kt");
     }
 
     @TestMetadata("compiler/testData/codegen/java8/writeFlags/defaults")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Defaults extends AbstractWriteFlagsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDefaults() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/writeFlags/defaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultMethod.kt")
         public void testDefaultMethod() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/writeFlags/defaults/defaultMethod.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/writeFlags/defaults/defaultMethod.kt");
         }
 
         @TestMetadata("defaultProperty.kt")
         public void testDefaultProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/writeFlags/defaults/defaultProperty.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/java8/writeFlags/defaults/defaultProperty.kt");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/Java8WriteSignatureTestGenerated.java

@@ -21,13 +21,16 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class Java8WriteSignatureTestGenerated extends AbstractJava8WriteSignatureTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInWriteSignature() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/java8/writeSignature"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("mutableMapRemove.kt")
     public void testMutableMapRemove() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/java8/writeSignature/mutableMapRemove.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/java8/writeSignature/mutableMapRemove.kt");
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java

@@ -23,32 +23,32 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CompiledJava extends AbstractLoadJava8Test {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestCompiledJava, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCompiledJava() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("InnerClassTypeAnnotation.java")
         public void testInnerClassTypeAnnotation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
         }
 
         @TestMetadata("MapRemove.java")
         public void testMapRemove() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/MapRemove.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/MapRemove.java");
         }
 
         @TestMetadata("TypeAnnotations.java")
         public void testTypeAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
         }
 
         @TestMetadata("TypeParameterAnnotations.java")
         public void testTypeParameterAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
         }
     }
 
@@ -56,26 +56,27 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class SourceJava extends AbstractLoadJava8Test {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestSourceJava, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInSourceJava() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("MapRemove.java")
         public void testMapRemove() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/MapRemove.java");
-            doTestSourceJava(fileName);
+            runTest("compiler/testData/loadJava8/sourceJava/MapRemove.java");
         }
 
         @TestMetadata("TypeAnnotations.java")
         public void testTypeAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java");
-            doTestSourceJava(fileName);
+            runTest("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java");
         }
 
         @TestMetadata("TypeParameterAnnotations.java")
         public void testTypeParameterAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java");
-            doTestSourceJava(fileName);
+            runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithFastClassReadingTestGenerated.java

@@ -21,31 +21,31 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class LoadJava8WithFastClassReadingTestGenerated extends AbstractLoadJava8WithFastClassReadingTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTestCompiledJava, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInCompiledJava() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("InnerClassTypeAnnotation.java")
     public void testInnerClassTypeAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
-        doTestCompiledJava(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
     }
 
     @TestMetadata("MapRemove.java")
     public void testMapRemove() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/MapRemove.java");
-        doTestCompiledJava(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/MapRemove.java");
     }
 
     @TestMetadata("TypeAnnotations.java")
     public void testTypeAnnotations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
-        doTestCompiledJava(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
     }
 
     @TestMetadata("TypeParameterAnnotations.java")
     public void testTypeParameterAnnotations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
-        doTestCompiledJava(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java

@@ -23,32 +23,32 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CompiledJava extends AbstractLoadJava8UsingJavacTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestCompiledJava, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCompiledJava() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("InnerClassTypeAnnotation.java")
         public void testInnerClassTypeAnnotation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
         }
 
         @TestMetadata("MapRemove.java")
         public void testMapRemove() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/MapRemove.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/MapRemove.java");
         }
 
         @TestMetadata("TypeAnnotations.java")
         public void testTypeAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
         }
 
         @TestMetadata("TypeParameterAnnotations.java")
         public void testTypeParameterAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
-            doTestCompiledJava(fileName);
+            runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
         }
     }
 
@@ -56,26 +56,27 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class SourceJava extends AbstractLoadJava8UsingJavacTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestSourceJava, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInSourceJava() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("MapRemove.java")
         public void testMapRemove() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/MapRemove.java");
-            doTestSourceJava(fileName);
+            runTest("compiler/testData/loadJava8/sourceJava/MapRemove.java");
         }
 
         @TestMetadata("TypeAnnotations.java")
         public void testTypeAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java");
-            doTestSourceJava(fileName);
+            runTest("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java");
         }
 
         @TestMetadata("TypeParameterAnnotations.java")
         public void testTypeParameterAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java");
-            doTestSourceJava(fileName);
+            runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java");
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/resolve/calls/EnhancedSignaturesResolvedCallsTestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhancedSignaturesResolvedCallsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInEnhancedSignatures() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,26 +33,27 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Collection extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCollection() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/collection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("collectionRemoveIf.kt")
         public void testCollectionRemoveIf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/collection/collectionRemoveIf.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/collection/collectionRemoveIf.kt");
         }
 
         @TestMetadata("collectionSpliterator.kt")
         public void testCollectionSpliterator() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/collection/collectionSpliterator.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/collection/collectionSpliterator.kt");
         }
 
         @TestMetadata("collectionStream.kt")
         public void testCollectionStream() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/collection/collectionStream.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/collection/collectionStream.kt");
         }
     }
 
@@ -56,14 +61,17 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Iterable extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInIterable() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/iterable"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("iterableSpliterator.kt")
         public void testIterableSpliterator() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/iterable/iterableSpliterator.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/iterable/iterableSpliterator.kt");
         }
     }
 
@@ -71,14 +79,17 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Iterator extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInIterator() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/iterator"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("iteratorForEachRemaining.kt")
         public void testIteratorForEachRemaining() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/iterator/iteratorForEachRemaining.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/iterator/iteratorForEachRemaining.kt");
         }
     }
 
@@ -86,20 +97,22 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class List extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInList() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/list"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("listReplaceAll.kt")
         public void testListReplaceAll() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/list/listReplaceAll.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/list/listReplaceAll.kt");
         }
 
         @TestMetadata("listStream.kt")
         public void testListStream() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/list/listStream.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/list/listStream.kt");
         }
     }
 
@@ -107,50 +120,47 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Map extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInMap() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/map"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("mapCompute.kt")
         public void testMapCompute() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapCompute.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapCompute.kt");
         }
 
         @TestMetadata("mapComputeIfAbsent.kt")
         public void testMapComputeIfAbsent() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapComputeIfAbsent.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapComputeIfAbsent.kt");
         }
 
         @TestMetadata("mapComputeIfPresent.kt")
         public void testMapComputeIfPresent() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapComputeIfPresent.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapComputeIfPresent.kt");
         }
 
         @TestMetadata("mapForEach.kt")
         public void testMapForEach() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapForEach.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapForEach.kt");
         }
 
         @TestMetadata("mapMerge.kt")
         public void testMapMerge() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapMerge.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapMerge.kt");
         }
 
         @TestMetadata("mapPutIfAbsent.kt")
         public void testMapPutIfAbsent() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapPutIfAbsent.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapPutIfAbsent.kt");
         }
 
         @TestMetadata("mapReplace.kt")
         public void testMapReplace() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/map/mapReplace.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/map/mapReplace.kt");
         }
     }
 
@@ -158,32 +168,32 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Optional extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInOptional() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/optional"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("optionalEmpty.kt")
         public void testOptionalEmpty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalEmpty.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalEmpty.kt");
         }
 
         @TestMetadata("optionalGet.kt")
         public void testOptionalGet() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalGet.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalGet.kt");
         }
 
         @TestMetadata("optionalIfPresent.kt")
         public void testOptionalIfPresent() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalIfPresent.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalIfPresent.kt");
         }
 
         @TestMetadata("optionalOf.kt")
         public void testOptionalOf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalOf.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/optional/optionalOf.kt");
         }
     }
 
@@ -191,20 +201,22 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class References extends AbstractEnhancedSignaturesResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInReferences() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/references"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("softReference.kt")
         public void testSoftReference() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/references/softReference.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/references/softReference.kt");
         }
 
         @TestMetadata("weakReference.kt")
         public void testWeakReference() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/enhancedSignatures/references/weakReference.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/enhancedSignatures/references/weakReference.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java

@@ -21,150 +21,135 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInLightClasses() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true, "local", "ideRegression");
     }
 
     @TestMetadata("AnnotationClass.kt")
     public void testAnnotationClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
     }
 
     @TestMetadata("DataClassWithCustomImplementedMembers.kt")
     public void testDataClassWithCustomImplementedMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/DataClassWithCustomImplementedMembers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/DataClassWithCustomImplementedMembers.kt");
     }
 
     @TestMetadata("DelegatedNested.kt")
     public void testDelegatedNested() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/DelegatedNested.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/DelegatedNested.kt");
     }
 
     @TestMetadata("Delegation.kt")
     public void testDelegation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/Delegation.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/Delegation.kt");
     }
 
     @TestMetadata("DeprecatedEnumEntry.kt")
     public void testDeprecatedEnumEntry() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/DeprecatedEnumEntry.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/DeprecatedEnumEntry.kt");
     }
 
     @TestMetadata("DeprecatedNotHiddenInClass.kt")
     public void testDeprecatedNotHiddenInClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/DeprecatedNotHiddenInClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/DeprecatedNotHiddenInClass.kt");
     }
 
     @TestMetadata("DollarsInName.kt")
     public void testDollarsInName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/DollarsInName.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/DollarsInName.kt");
     }
 
     @TestMetadata("DollarsInNameNoPackage.kt")
     public void testDollarsInNameNoPackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
     }
 
     @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt")
     public void testExtendingInterfaceWithDefaultImpls() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/ExtendingInterfaceWithDefaultImpls.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/ExtendingInterfaceWithDefaultImpls.kt");
     }
 
     @TestMetadata("HiddenDeprecated.kt")
     public void testHiddenDeprecated() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/HiddenDeprecated.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/HiddenDeprecated.kt");
     }
 
     @TestMetadata("HiddenDeprecatedInClass.kt")
     public void testHiddenDeprecatedInClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/HiddenDeprecatedInClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/HiddenDeprecatedInClass.kt");
     }
 
     @TestMetadata("InheritingInterfaceDefaultImpls.kt")
     public void testInheritingInterfaceDefaultImpls() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/InheritingInterfaceDefaultImpls.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/InheritingInterfaceDefaultImpls.kt");
     }
 
     @TestMetadata("JvmNameOnMember.kt")
     public void testJvmNameOnMember() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/JvmNameOnMember.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/JvmNameOnMember.kt");
     }
 
     @TestMetadata("JvmStatic.kt")
     public void testJvmStatic() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/JvmStatic.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/JvmStatic.kt");
     }
 
     @TestMetadata("NestedObjects.kt")
     public void testNestedObjects() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/NestedObjects.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/NestedObjects.kt");
     }
 
     @TestMetadata("NonDataClassWithComponentFunctions.kt")
     public void testNonDataClassWithComponentFunctions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/NonDataClassWithComponentFunctions.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/NonDataClassWithComponentFunctions.kt");
     }
 
     @TestMetadata("PublishedApi.kt")
     public void testPublishedApi() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/PublishedApi.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/PublishedApi.kt");
     }
 
     @TestMetadata("SpecialAnnotationsOnAnnotationClass.kt")
     public void testSpecialAnnotationsOnAnnotationClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/SpecialAnnotationsOnAnnotationClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/SpecialAnnotationsOnAnnotationClass.kt");
     }
 
     @TestMetadata("StubOrderForOverloads.kt")
     public void testStubOrderForOverloads() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/StubOrderForOverloads.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/StubOrderForOverloads.kt");
     }
 
     @TestMetadata("VarArgs.kt")
     public void testVarArgs() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/VarArgs.kt");
-        doTest(fileName);
+        runTest("compiler/testData/asJava/lightClasses/VarArgs.kt");
     }
 
     @TestMetadata("compiler/testData/asJava/lightClasses/compilationErrors")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CompilationErrors extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         @TestMetadata("ActualClass.kt")
         public void testActualClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ActualClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ActualClass.kt");
         }
 
         @TestMetadata("ActualTypeAlias.kt")
         public void testActualTypeAlias() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAlias.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAlias.kt");
         }
 
         @TestMetadata("ActualTypeAliasCustomJvmPackageName.kt")
         public void testActualTypeAliasCustomJvmPackageName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt");
         }
 
         public void testAllFilesPresentInCompilationErrors() throws Exception {
@@ -173,80 +158,67 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
 
         @TestMetadata("AllInlineOnly.kt")
         public void testAllInlineOnly() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/AllInlineOnly.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/AllInlineOnly.kt");
         }
 
         @TestMetadata("AnnotationModifiers.kt")
         public void testAnnotationModifiers() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/AnnotationModifiers.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/AnnotationModifiers.kt");
         }
 
         @TestMetadata("ExpectClass.kt")
         public void testExpectClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ExpectClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ExpectClass.kt");
         }
 
         @TestMetadata("ExpectObject.kt")
         public void testExpectObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ExpectObject.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ExpectObject.kt");
         }
 
         @TestMetadata("ExpectedNestedClass.kt")
         public void testExpectedNestedClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ExpectedNestedClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ExpectedNestedClass.kt");
         }
 
         @TestMetadata("ExpectedNestedClassInObject.kt")
         public void testExpectedNestedClassInObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/ExpectedNestedClassInObject.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/ExpectedNestedClassInObject.kt");
         }
 
         @TestMetadata("JvmPackageName.kt")
         public void testJvmPackageName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/JvmPackageName.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/JvmPackageName.kt");
         }
 
         @TestMetadata("PrivateInTrait.kt")
         public void testPrivateInTrait() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/PrivateInTrait.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/PrivateInTrait.kt");
         }
 
         @TestMetadata("RepetableAnnotations.kt")
         public void testRepetableAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/RepetableAnnotations.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/RepetableAnnotations.kt");
         }
 
         @TestMetadata("SameName.kt")
         public void testSameName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/SameName.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/SameName.kt");
         }
 
         @TestMetadata("TopLevelDestructuring.kt")
         public void testTopLevelDestructuring() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/TopLevelDestructuring.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/TopLevelDestructuring.kt");
         }
 
         @TestMetadata("TraitClassObjectField.kt")
         public void testTraitClassObjectField() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/TraitClassObjectField.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/TraitClassObjectField.kt");
         }
 
         @TestMetadata("WrongAnnotations.kt")
         public void testWrongAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/compilationErrors/WrongAnnotations.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/compilationErrors/WrongAnnotations.kt");
         }
     }
 
@@ -254,20 +226,22 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Delegation extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDelegation() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("Function.kt")
         public void testFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/delegation/Function.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/delegation/Function.kt");
         }
 
         @TestMetadata("Property.kt")
         public void testProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/delegation/Property.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/delegation/Property.kt");
         }
     }
 
@@ -275,32 +249,32 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Facades extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInFacades() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("AllPrivate.kt")
         public void testAllPrivate() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/facades/AllPrivate.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/facades/AllPrivate.kt");
         }
 
         @TestMetadata("MultiFile.kt")
         public void testMultiFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/facades/MultiFile.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/facades/MultiFile.kt");
         }
 
         @TestMetadata("SingleFile.kt")
         public void testSingleFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/facades/SingleFile.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/facades/SingleFile.kt");
         }
 
         @TestMetadata("SingleJvmClassName.kt")
         public void testSingleJvmClassName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/facades/SingleJvmClassName.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/facades/SingleJvmClassName.kt");
         }
     }
 
@@ -308,116 +282,102 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class NullabilityAnnotations extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInNullabilityAnnotations() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("Class.kt")
         public void testClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Class.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Class.kt");
         }
 
         @TestMetadata("ClassObjectField.kt")
         public void testClassObjectField() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.kt");
         }
 
         @TestMetadata("ClassWithConstructor.kt")
         public void testClassWithConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassWithConstructor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassWithConstructor.kt");
         }
 
         @TestMetadata("ClassWithConstructorAndProperties.kt")
         public void testClassWithConstructorAndProperties() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassWithConstructorAndProperties.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassWithConstructorAndProperties.kt");
         }
 
         @TestMetadata("FileFacade.kt")
         public void testFileFacade() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/FileFacade.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/FileFacade.kt");
         }
 
         @TestMetadata("Generic.kt")
         public void testGeneric() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Generic.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Generic.kt");
         }
 
         @TestMetadata("IntOverridesAny.kt")
         public void testIntOverridesAny() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/IntOverridesAny.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/IntOverridesAny.kt");
         }
 
         @TestMetadata("JvmOverloads.kt")
         public void testJvmOverloads() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/JvmOverloads.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/JvmOverloads.kt");
         }
 
         @TestMetadata("NullableUnitReturn.kt")
         public void testNullableUnitReturn() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/NullableUnitReturn.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/NullableUnitReturn.kt");
         }
 
         @TestMetadata("OverrideAnyWithUnit.kt")
         public void testOverrideAnyWithUnit() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/OverrideAnyWithUnit.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/OverrideAnyWithUnit.kt");
         }
 
         @TestMetadata("PlatformTypes.kt")
         public void testPlatformTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/PlatformTypes.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/PlatformTypes.kt");
         }
 
         @TestMetadata("Primitives.kt")
         public void testPrimitives() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Primitives.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Primitives.kt");
         }
 
         @TestMetadata("PrivateInClass.kt")
         public void testPrivateInClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/PrivateInClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/PrivateInClass.kt");
         }
 
         @TestMetadata("Synthetic.kt")
         public void testSynthetic() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Synthetic.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Synthetic.kt");
         }
 
         @TestMetadata("Trait.kt")
         public void testTrait() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Trait.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/Trait.kt");
         }
 
         @TestMetadata("UnitAsGenericArgument.kt")
         public void testUnitAsGenericArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/UnitAsGenericArgument.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/UnitAsGenericArgument.kt");
         }
 
         @TestMetadata("UnitParameter.kt")
         public void testUnitParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/UnitParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/UnitParameter.kt");
         }
 
         @TestMetadata("VoidReturn.kt")
         public void testVoidReturn() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/nullabilityAnnotations/VoidReturn.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/nullabilityAnnotations/VoidReturn.kt");
         }
     }
 
@@ -425,14 +385,17 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Object extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInObject() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("SimpleObject.kt")
         public void testSimpleObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/object/SimpleObject.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/object/SimpleObject.kt");
         }
     }
 
@@ -440,20 +403,22 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class PublicField extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInPublicField() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("CompanionObject.kt")
         public void testCompanionObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt");
         }
 
         @TestMetadata("Simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/publicField/Simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/publicField/Simple.kt");
         }
     }
 
@@ -461,20 +426,22 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Script extends AbstractCompilerLightClassTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInScript() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("HelloWorld.kts")
         public void testHelloWorld() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/script/HelloWorld.kts");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/script/HelloWorld.kts");
         }
 
         @TestMetadata("InnerClasses.kts")
         public void testInnerClasses() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/script/InnerClasses.kts");
-            doTest(fileName);
+            runTest("compiler/testData/asJava/lightClasses/script/InnerClasses.kts");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/cfg/ControlFlowTestGenerated.java

@@ -23,6 +23,10 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Cfg extends AbstractControlFlowTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCfg() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -31,68 +35,62 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Arrays extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInArrays() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/arrays"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("ArrayAccess.kt")
             public void testArrayAccess() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/ArrayAccess.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/ArrayAccess.kt");
             }
 
             @TestMetadata("arrayAccessExpression.kt")
             public void testArrayAccessExpression() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arrayAccessExpression.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arrayAccessExpression.kt");
             }
 
             @TestMetadata("arrayInc.kt")
             public void testArrayInc() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arrayInc.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arrayInc.kt");
             }
 
             @TestMetadata("arrayIncUnresolved.kt")
             public void testArrayIncUnresolved() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arrayIncUnresolved.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arrayIncUnresolved.kt");
             }
 
             @TestMetadata("ArrayOfFunctions.kt")
             public void testArrayOfFunctions() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/ArrayOfFunctions.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/ArrayOfFunctions.kt");
             }
 
             @TestMetadata("arraySet.kt")
             public void testArraySet() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arraySet.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arraySet.kt");
             }
 
             @TestMetadata("arraySetNoRHS.kt")
             public void testArraySetNoRHS() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arraySetNoRHS.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arraySetNoRHS.kt");
             }
 
             @TestMetadata("arraySetPlusAssign.kt")
             public void testArraySetPlusAssign() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arraySetPlusAssign.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arraySetPlusAssign.kt");
             }
 
             @TestMetadata("arraySetPlusAssignUnresolved.kt")
             public void testArraySetPlusAssignUnresolved() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arraySetPlusAssignUnresolved.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arraySetPlusAssignUnresolved.kt");
             }
 
             @TestMetadata("arraySetUnresolved.kt")
             public void testArraySetUnresolved() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/arrays/arraySetUnresolved.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/arrays/arraySetUnresolved.kt");
             }
         }
 
@@ -100,26 +98,27 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Basic extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInBasic() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/basic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("Basic.kt")
             public void testBasic() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/basic/Basic.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/basic/Basic.kt");
             }
 
             @TestMetadata("EmptyFunction.kt")
             public void testEmptyFunction() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/basic/EmptyFunction.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/basic/EmptyFunction.kt");
             }
 
             @TestMetadata("ShortFunction.kt")
             public void testShortFunction() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/basic/ShortFunction.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/basic/ShortFunction.kt");
             }
         }
 
@@ -127,44 +126,42 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Bugs extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInBugs() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/bugs"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("functionalCallInEnumEntry.kt")
             public void testFunctionalCallInEnumEntry() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/bugs/functionalCallInEnumEntry.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/bugs/functionalCallInEnumEntry.kt");
             }
 
             @TestMetadata("jumpToOuterScope.kt")
             public void testJumpToOuterScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/bugs/jumpToOuterScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/bugs/jumpToOuterScope.kt");
             }
 
             @TestMetadata("kt10105.kt")
             public void testKt10105() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/bugs/kt10105.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/bugs/kt10105.kt");
             }
 
             @TestMetadata("kt7761.kt")
             public void testKt7761() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/bugs/kt7761.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/bugs/kt7761.kt");
             }
 
             @TestMetadata("setWithTypeMismatch.kt")
             public void testSetWithTypeMismatch() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/bugs/setWithTypeMismatch.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/bugs/setWithTypeMismatch.kt");
             }
 
             @TestMetadata("unresolvedInvokeOnResolvedVar.kt")
             public void testUnresolvedInvokeOnResolvedVar() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/bugs/unresolvedInvokeOnResolvedVar.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/bugs/unresolvedInvokeOnResolvedVar.kt");
             }
         }
 
@@ -172,110 +169,97 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ControlStructures extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInControlStructures() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/controlStructures"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("breakContinueInTryFinally.kt")
             public void testBreakContinueInTryFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/breakContinueInTryFinally.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/breakContinueInTryFinally.kt");
             }
 
             @TestMetadata("breakInsideLocal.kt")
             public void testBreakInsideLocal() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/breakInsideLocal.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/breakInsideLocal.kt");
             }
 
             @TestMetadata("continueInDoWhile.kt")
             public void testContinueInDoWhile() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/continueInDoWhile.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/continueInDoWhile.kt");
             }
 
             @TestMetadata("continueInFor.kt")
             public void testContinueInFor() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/continueInFor.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/continueInFor.kt");
             }
 
             @TestMetadata("continueInWhile.kt")
             public void testContinueInWhile() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/continueInWhile.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/continueInWhile.kt");
             }
 
             @TestMetadata("Finally.kt")
             public void testFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/Finally.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/Finally.kt");
             }
 
             @TestMetadata("FinallyTestCopy.kt")
             public void testFinallyTestCopy() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/FinallyTestCopy.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/FinallyTestCopy.kt");
             }
 
             @TestMetadata("For.kt")
             public void testFor() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/For.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/For.kt");
             }
 
             @TestMetadata("If.kt")
             public void testIf() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/If.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/If.kt");
             }
 
             @TestMetadata("incorrectIndex.kt")
             public void testIncorrectIndex() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/incorrectIndex.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/incorrectIndex.kt");
             }
 
             @TestMetadata("InfiniteLoops.kt")
             public void testInfiniteLoops() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/InfiniteLoops.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/InfiniteLoops.kt");
             }
 
             @TestMetadata("localAndNonlocalReturnsWithFinally.kt")
             public void testLocalAndNonlocalReturnsWithFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/localAndNonlocalReturnsWithFinally.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/localAndNonlocalReturnsWithFinally.kt");
             }
 
             @TestMetadata("localFunctionInFinally.kt")
             public void testLocalFunctionInFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/localFunctionInFinally.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/localFunctionInFinally.kt");
             }
 
             @TestMetadata("OnlyWhileInFunctionBody.kt")
             public void testOnlyWhileInFunctionBody() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.kt");
             }
 
             @TestMetadata("returnsInWhen.kt")
             public void testReturnsInWhen() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/returnsInWhen.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/returnsInWhen.kt");
             }
 
             @TestMetadata("whenConditions.kt")
             public void testWhenConditions() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/whenConditions.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/whenConditions.kt");
             }
 
             @TestMetadata("whenExhaustive.kt")
             public void testWhenExhaustive() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/controlStructures/whenExhaustive.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/controlStructures/whenExhaustive.kt");
             }
         }
 
@@ -283,38 +267,37 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Conventions extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInConventions() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("bothReceivers.kt")
             public void testBothReceivers() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/conventions/bothReceivers.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/conventions/bothReceivers.kt");
             }
 
             @TestMetadata("equals.kt")
             public void testEquals() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/conventions/equals.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/conventions/equals.kt");
             }
 
             @TestMetadata("incrementAtTheEnd.kt")
             public void testIncrementAtTheEnd() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/conventions/incrementAtTheEnd.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/conventions/incrementAtTheEnd.kt");
             }
 
             @TestMetadata("invoke.kt")
             public void testInvoke() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/conventions/invoke.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/conventions/invoke.kt");
             }
 
             @TestMetadata("notEqual.kt")
             public void testNotEqual() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/conventions/notEqual.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/conventions/notEqual.kt");
             }
         }
 
@@ -322,38 +305,37 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class DeadCode extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInDeadCode() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/deadCode"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("DeadCode.kt")
             public void testDeadCode() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/deadCode/DeadCode.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/deadCode/DeadCode.kt");
             }
 
             @TestMetadata("notLocalReturn.kt")
             public void testNotLocalReturn() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/deadCode/notLocalReturn.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/deadCode/notLocalReturn.kt");
             }
 
             @TestMetadata("returnInElvis.kt")
             public void testReturnInElvis() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/deadCode/returnInElvis.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/deadCode/returnInElvis.kt");
             }
 
             @TestMetadata("stringTemplate.kt")
             public void testStringTemplate() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/deadCode/stringTemplate.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/deadCode/stringTemplate.kt");
             }
 
             @TestMetadata("throwInLambda.kt")
             public void testThrowInLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/deadCode/throwInLambda.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/deadCode/throwInLambda.kt");
             }
         }
 
@@ -361,6 +343,10 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Declarations extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInDeclarations() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
@@ -369,44 +355,42 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ClassesAndObjects extends AbstractControlFlowTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInClassesAndObjects() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("AnonymousInitializers.kt")
                 public void testAnonymousInitializers() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.kt");
                 }
 
                 @TestMetadata("delegationByExpression.kt")
                 public void testDelegationByExpression() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt");
                 }
 
                 @TestMetadata("delegationBySuperCall.kt")
                 public void testDelegationBySuperCall() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt");
                 }
 
                 @TestMetadata("EnumEntryRefersCompanion.kt")
                 public void testEnumEntryRefersCompanion() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/EnumEntryRefersCompanion.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/classesAndObjects/EnumEntryRefersCompanion.kt");
                 }
 
                 @TestMetadata("ObjectEnumQualifiers.kt")
                 public void testObjectEnumQualifiers() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.kt");
                 }
 
                 @TestMetadata("QualifierReceiverWithOthers.kt")
                 public void testQualifierReceiverWithOthers() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.kt");
                 }
             }
 
@@ -414,14 +398,17 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class FunctionLiterals extends AbstractControlFlowTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInFunctionLiterals() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("unusedFunctionLiteral.kt")
                 public void testUnusedFunctionLiteral() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.kt");
                 }
             }
 
@@ -429,38 +416,37 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Functions extends AbstractControlFlowTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInFunctions() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations/functions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("anonymousFunctionInBlock.kt")
                 public void testAnonymousFunctionInBlock() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/functions/anonymousFunctionInBlock.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/functions/anonymousFunctionInBlock.kt");
                 }
 
                 @TestMetadata("FailFunction.kt")
                 public void testFailFunction() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/functions/FailFunction.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/functions/FailFunction.kt");
                 }
 
                 @TestMetadata("functionAsExpression.kt")
                 public void testFunctionAsExpression() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/functions/functionAsExpression.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/functions/functionAsExpression.kt");
                 }
 
                 @TestMetadata("namedFunctionInBlock.kt")
                 public void testNamedFunctionInBlock() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/functions/namedFunctionInBlock.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/functions/namedFunctionInBlock.kt");
                 }
 
                 @TestMetadata("typeParameter.kt")
                 public void testTypeParameter() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/functions/typeParameter.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/functions/typeParameter.kt");
                 }
             }
 
@@ -468,44 +454,42 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Local extends AbstractControlFlowTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInLocal() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations/local"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("localClass.kt")
                 public void testLocalClass() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/local/localClass.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/local/localClass.kt");
                 }
 
                 @TestMetadata("LocalDeclarations.kt")
                 public void testLocalDeclarations() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/local/LocalDeclarations.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/local/LocalDeclarations.kt");
                 }
 
                 @TestMetadata("localDelegatedVal.kt")
                 public void testLocalDelegatedVal() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/local/localDelegatedVal.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/local/localDelegatedVal.kt");
                 }
 
                 @TestMetadata("localFunction.kt")
                 public void testLocalFunction() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/local/localFunction.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/local/localFunction.kt");
                 }
 
                 @TestMetadata("localProperty.kt")
                 public void testLocalProperty() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/local/localProperty.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/local/localProperty.kt");
                 }
 
                 @TestMetadata("ObjectExpression.kt")
                 public void testObjectExpression() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/local/ObjectExpression.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/local/ObjectExpression.kt");
                 }
             }
 
@@ -513,20 +497,22 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultiDeclaration extends AbstractControlFlowTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInMultiDeclaration() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations/multiDeclaration"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("MultiDecl.kt")
                 public void testMultiDecl() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.kt");
                 }
 
                 @TestMetadata("multiDeclarationWithError.kt")
                 public void testMultiDeclarationWithError() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.kt");
                 }
             }
 
@@ -534,20 +520,22 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Properties extends AbstractControlFlowTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInProperties() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/declarations/properties"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("DelegatedProperty.kt")
                 public void testDelegatedProperty() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/properties/DelegatedProperty.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/properties/DelegatedProperty.kt");
                 }
 
                 @TestMetadata("unreachableDelegation.kt")
                 public void testUnreachableDelegation() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/properties/unreachableDelegation.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/cfg/declarations/properties/unreachableDelegation.kt");
                 }
             }
         }
@@ -556,146 +544,127 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Expressions extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInExpressions() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/expressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("assignmentToThis.kt")
             public void testAssignmentToThis() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/assignmentToThis.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/assignmentToThis.kt");
             }
 
             @TestMetadata("Assignments.kt")
             public void testAssignments() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/Assignments.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/Assignments.kt");
             }
 
             @TestMetadata("callableReferences.kt")
             public void testCallableReferences() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/callableReferences.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/callableReferences.kt");
             }
 
             @TestMetadata("casts.kt")
             public void testCasts() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/casts.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/casts.kt");
             }
 
             @TestMetadata("chainedQualifiedExpression.kt")
             public void testChainedQualifiedExpression() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/chainedQualifiedExpression.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/chainedQualifiedExpression.kt");
             }
 
             @TestMetadata("expressionAsFunction.kt")
             public void testExpressionAsFunction() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/expressionAsFunction.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/expressionAsFunction.kt");
             }
 
             @TestMetadata("incdec.kt")
             public void testIncdec() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/incdec.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/incdec.kt");
             }
 
             @TestMetadata("invalidVariableCall.kt")
             public void testInvalidVariableCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/invalidVariableCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/invalidVariableCall.kt");
             }
 
             @TestMetadata("labeledExpression.kt")
             public void testLabeledExpression() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/labeledExpression.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/labeledExpression.kt");
             }
 
             @TestMetadata("LazyBooleans.kt")
             public void testLazyBooleans() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/LazyBooleans.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/LazyBooleans.kt");
             }
 
             @TestMetadata("nothingExpr.kt")
             public void testNothingExpr() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/nothingExpr.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/nothingExpr.kt");
             }
 
             @TestMetadata("parenthesizedSelector.kt")
             public void testParenthesizedSelector() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/parenthesizedSelector.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/parenthesizedSelector.kt");
             }
 
             @TestMetadata("propertySafeCall.kt")
             public void testPropertySafeCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/propertySafeCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/propertySafeCall.kt");
             }
 
             @TestMetadata("qualifiedExpressionWithoutSelector.kt")
             public void testQualifiedExpressionWithoutSelector() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.kt");
             }
 
             @TestMetadata("ReturnFromExpression.kt")
             public void testReturnFromExpression() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/ReturnFromExpression.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/ReturnFromExpression.kt");
             }
 
             @TestMetadata("thisExpression.kt")
             public void testThisExpression() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/thisExpression.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/thisExpression.kt");
             }
 
             @TestMetadata("unresolvedCall.kt")
             public void testUnresolvedCall() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unresolvedCall.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unresolvedCall.kt");
             }
 
             @TestMetadata("unresolvedCalls.kt")
             public void testUnresolvedCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unresolvedCalls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unresolvedCalls.kt");
             }
 
             @TestMetadata("unresolvedCallsWithReceiver.kt")
             public void testUnresolvedCallsWithReceiver() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unresolvedCallsWithReceiver.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unresolvedCallsWithReceiver.kt");
             }
 
             @TestMetadata("unresolvedProperty.kt")
             public void testUnresolvedProperty() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unresolvedProperty.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unresolvedProperty.kt");
             }
 
             @TestMetadata("unresolvedWriteLHS.kt")
             public void testUnresolvedWriteLHS() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unresolvedWriteLHS.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unresolvedWriteLHS.kt");
             }
 
             @TestMetadata("unsupportedReturns.kt")
             public void testUnsupportedReturns() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unsupportedReturns.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unsupportedReturns.kt");
             }
 
             @TestMetadata("unusedExpressionSimpleName.kt")
             public void testUnusedExpressionSimpleName() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/expressions/unusedExpressionSimpleName.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/expressions/unusedExpressionSimpleName.kt");
             }
         }
 
@@ -703,20 +672,22 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Functions extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInFunctions() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/functions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("DefaultValuesForArguments.kt")
             public void testDefaultValuesForArguments() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/functions/DefaultValuesForArguments.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/functions/DefaultValuesForArguments.kt");
             }
 
             @TestMetadata("unmappedArgs.kt")
             public void testUnmappedArgs() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/functions/unmappedArgs.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/functions/unmappedArgs.kt");
             }
         }
 
@@ -724,38 +695,37 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class SecondaryConstructors extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInSecondaryConstructors() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("withPrimary.kt")
             public void testWithPrimary() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/secondaryConstructors/withPrimary.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/secondaryConstructors/withPrimary.kt");
             }
 
             @TestMetadata("withPrimarySuper.kt")
             public void testWithPrimarySuper() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/secondaryConstructors/withPrimarySuper.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/secondaryConstructors/withPrimarySuper.kt");
             }
 
             @TestMetadata("withReturn.kt")
             public void testWithReturn() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/secondaryConstructors/withReturn.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/secondaryConstructors/withReturn.kt");
             }
 
             @TestMetadata("withoutPrimary.kt")
             public void testWithoutPrimary() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/secondaryConstructors/withoutPrimary.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/secondaryConstructors/withoutPrimary.kt");
             }
 
             @TestMetadata("withoutPrimarySuper.kt")
             public void testWithoutPrimarySuper() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/secondaryConstructors/withoutPrimarySuper.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/secondaryConstructors/withoutPrimarySuper.kt");
             }
         }
 
@@ -763,38 +733,37 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TailCalls extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTailCalls() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg/tailCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("finally.kt")
             public void testFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/tailCalls/finally.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/tailCalls/finally.kt");
             }
 
             @TestMetadata("finallyWithReturn.kt")
             public void testFinallyWithReturn() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/tailCalls/finallyWithReturn.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/tailCalls/finallyWithReturn.kt");
             }
 
             @TestMetadata("sum.kt")
             public void testSum() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/tailCalls/sum.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/tailCalls/sum.kt");
             }
 
             @TestMetadata("try.kt")
             public void testTry() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/tailCalls/try.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/tailCalls/try.kt");
             }
 
             @TestMetadata("tryCatchFinally.kt")
             public void testTryCatchFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/tailCalls/tryCatchFinally.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg/tailCalls/tryCatchFinally.kt");
             }
         }
     }
@@ -803,6 +772,10 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CfgWithStdLib extends AbstractControlFlowTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithStdLib, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCfgWithStdLib() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfgWithStdLib"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -811,38 +784,37 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Contracts extends AbstractControlFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithStdLib, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInContracts() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfgWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("labeledReturns.kt")
             public void testLabeledReturns() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgWithStdLib/contracts/labeledReturns.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgWithStdLib/contracts/labeledReturns.kt");
             }
 
             @TestMetadata("nonReturningInlinedLambda.kt")
             public void testNonReturningInlinedLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgWithStdLib/contracts/nonReturningInlinedLambda.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgWithStdLib/contracts/nonReturningInlinedLambda.kt");
             }
 
             @TestMetadata("returnsAndCalls.kt")
             public void testReturnsAndCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgWithStdLib/contracts/returnsAndCalls.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgWithStdLib/contracts/returnsAndCalls.kt");
             }
 
             @TestMetadata("throwIfNotCalled.kt")
             public void testThrowIfNotCalled() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgWithStdLib/contracts/throwIfNotCalled.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgWithStdLib/contracts/throwIfNotCalled.kt");
             }
 
             @TestMetadata("tryCatchFinally.kt")
             public void testTryCatchFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgWithStdLib/contracts/tryCatchFinally.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgWithStdLib/contracts/tryCatchFinally.kt");
             }
         }
     }

compiler/tests/org/jetbrains/kotlin/cfg/DataFlowTestGenerated.java

@@ -23,6 +23,10 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Cfg_variables extends AbstractDataFlowTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCfg_variables() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg-variables"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -31,50 +35,47 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Basic extends AbstractDataFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInBasic() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg-variables/basic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("ExhaustiveInitialization.kt")
             public void testExhaustiveInitialization() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/ExhaustiveInitialization.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/ExhaustiveInitialization.kt");
             }
 
             @TestMetadata("IfWithUninitialized.kt")
             public void testIfWithUninitialized() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/IfWithUninitialized.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/IfWithUninitialized.kt");
             }
 
             @TestMetadata("InitializedNotDeclared.kt")
             public void testInitializedNotDeclared() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/InitializedNotDeclared.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/InitializedNotDeclared.kt");
             }
 
             @TestMetadata("UsageInFunctionLiteral.kt")
             public void testUsageInFunctionLiteral() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.kt");
             }
 
             @TestMetadata("UseUninitializedInLambda.kt")
             public void testUseUninitializedInLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/UseUninitializedInLambda.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/UseUninitializedInLambda.kt");
             }
 
             @TestMetadata("VariablesInitialization.kt")
             public void testVariablesInitialization() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/VariablesInitialization.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/VariablesInitialization.kt");
             }
 
             @TestMetadata("VariablesUsage.kt")
             public void testVariablesUsage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/basic/VariablesUsage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/basic/VariablesUsage.kt");
             }
         }
 
@@ -82,74 +83,67 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Bugs extends AbstractDataFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInBugs() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg-variables/bugs"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("doWhileAssignment.kt")
             public void testDoWhileAssignment() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/doWhileAssignment.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/doWhileAssignment.kt");
             }
 
             @TestMetadata("doWhileNotDefined.kt")
             public void testDoWhileNotDefined() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/doWhileNotDefined.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/doWhileNotDefined.kt");
             }
 
             @TestMetadata("initializationInLocalClass.kt")
             public void testInitializationInLocalClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/initializationInLocalClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/initializationInLocalClass.kt");
             }
 
             @TestMetadata("kt10243.kt")
             public void testKt10243() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/kt10243.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/kt10243.kt");
             }
 
             @TestMetadata("kt4764.kt")
             public void testKt4764() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/kt4764.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/kt4764.kt");
             }
 
             @TestMetadata("kt5469.kt")
             public void testKt5469() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/kt5469.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/kt5469.kt");
             }
 
             @TestMetadata("kt9825.kt")
             public void testKt9825() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/kt9825.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/kt9825.kt");
             }
 
             @TestMetadata("localObjectInConstructor.kt")
             public void testLocalObjectInConstructor() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/localObjectInConstructor.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/localObjectInConstructor.kt");
             }
 
             @TestMetadata("referenceToPropertyInitializer.kt")
             public void testReferenceToPropertyInitializer() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.kt");
             }
 
             @TestMetadata("varInitializationInIf.kt")
             public void testVarInitializationInIf() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/varInitializationInIf.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/varInitializationInIf.kt");
             }
 
             @TestMetadata("varInitializationInIfInCycle.kt")
             public void testVarInitializationInIfInCycle() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.kt");
             }
         }
 
@@ -157,80 +151,72 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class LexicalScopes extends AbstractDataFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInLexicalScopes() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfg-variables/lexicalScopes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("doWhileScope.kt")
             public void testDoWhileScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/doWhileScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/doWhileScope.kt");
             }
 
             @TestMetadata("forScope.kt")
             public void testForScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/forScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/forScope.kt");
             }
 
             @TestMetadata("functionLiteralScope.kt")
             public void testFunctionLiteralScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.kt");
             }
 
             @TestMetadata("ifScope.kt")
             public void testIfScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/ifScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/ifScope.kt");
             }
 
             @TestMetadata("localClass.kt")
             public void testLocalClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/localClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/localClass.kt");
             }
 
             @TestMetadata("localFunctionScope.kt")
             public void testLocalFunctionScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.kt");
             }
 
             @TestMetadata("localFunctionScopeWithoutBody.kt")
             public void testLocalFunctionScopeWithoutBody() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.kt");
             }
 
             @TestMetadata("localObject.kt")
             public void testLocalObject() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/localObject.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/localObject.kt");
             }
 
             @TestMetadata("objectLiteralScope.kt")
             public void testObjectLiteralScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.kt");
             }
 
             @TestMetadata("propertyAccessorScope.kt")
             public void testPropertyAccessorScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.kt");
             }
 
             @TestMetadata("tryScope.kt")
             public void testTryScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/tryScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/tryScope.kt");
             }
 
             @TestMetadata("whileScope.kt")
             public void testWhileScope() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg-variables/lexicalScopes/whileScope.kt");
-                doTest(fileName);
+                runTest("compiler/testData/cfg-variables/lexicalScopes/whileScope.kt");
             }
         }
     }
@@ -239,6 +225,10 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CfgVariablesWithStdLib extends AbstractDataFlowTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithStdLib, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCfgVariablesWithStdLib() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -247,68 +237,62 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Contracts extends AbstractDataFlowTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithStdLib, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInContracts() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("breakContinuesInInlinedLambda.kt")
             public void testBreakContinuesInInlinedLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/breakContinuesInInlinedLambda.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/breakContinuesInInlinedLambda.kt");
             }
 
             @TestMetadata("inlinedLambdaAlwaysThrows.kt")
             public void testInlinedLambdaAlwaysThrows() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/inlinedLambdaAlwaysThrows.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/inlinedLambdaAlwaysThrows.kt");
             }
 
             @TestMetadata("irrelevantUnknownClosure.kt")
             public void testIrrelevantUnknownClosure() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/irrelevantUnknownClosure.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/irrelevantUnknownClosure.kt");
             }
 
             @TestMetadata("nestedTryCatchFinally.kt")
             public void testNestedTryCatchFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/nestedTryCatchFinally.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/nestedTryCatchFinally.kt");
             }
 
             @TestMetadata("nestedTryCatchs.kt")
             public void testNestedTryCatchs() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/nestedTryCatchs.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/nestedTryCatchs.kt");
             }
 
             @TestMetadata("nonReturningInlinedLambda.kt")
             public void testNonReturningInlinedLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/nonReturningInlinedLambda.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/nonReturningInlinedLambda.kt");
             }
 
             @TestMetadata("returnsAndCalls.kt")
             public void testReturnsAndCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/returnsAndCalls.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/returnsAndCalls.kt");
             }
 
             @TestMetadata("throwIfNotCalled.kt")
             public void testThrowIfNotCalled() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/throwIfNotCalled.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/throwIfNotCalled.kt");
             }
 
             @TestMetadata("tryCatch.kt")
             public void testTryCatch() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/tryCatch.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/tryCatch.kt");
             }
 
             @TestMetadata("tryCatchFinally.kt")
             public void testTryCatchFinally() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfgVariablesWithStdLib/contracts/tryCatchFinally.kt");
-                doTestWithStdLib(fileName);
+                runTest("compiler/testData/cfgVariablesWithStdLib/contracts/tryCatchFinally.kt");
             }
         }
     }

compiler/tests/org/jetbrains/kotlin/cfg/DiagnosticsWithModifiedMockJdkTestGenerated.java

@@ -21,19 +21,21 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class DiagnosticsWithModifiedMockJdkTestGenerated extends AbstractDiagnosticsWithModifiedMockJdkTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testWithModifiedMockJdk"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("notConsideredMethod.kt")
     public void testNotConsideredMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.kt");
-        doTest(fileName);
+        runTest("compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.kt");
     }
 
     @TestMetadata("throwableConstructor.kt")
     public void testThrowableConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.kt");
     }
 }

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

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated extends AbstractDiagnosticsTestWithJsStdLibAndBackendCompilation {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTestsWithJsStdLibAndBackendCompilation() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,32 +33,32 @@ public class DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated extends A
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Inline extends AbstractDiagnosticsTestWithJsStdLibAndBackendCompilation {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInInline() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("recursionCycle.kt")
         public void testRecursionCycle() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycle.kt");
-            doTest(fileName);
+            runTest("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycle.kt");
         }
 
         @TestMetadata("recursionCycleLambda.kt")
         public void testRecursionCycleLambda() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleLambda.kt");
-            doTest(fileName);
+            runTest("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleLambda.kt");
         }
 
         @TestMetadata("recursionCycleWithPublicFun.kt")
         public void testRecursionCycleWithPublicFun() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithPublicFun.kt");
-            doTest(fileName);
+            runTest("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithPublicFun.kt");
         }
 
         @TestMetadata("recursionCycleWithStdlibCall.kt")
         public void testRecursionCycleWithStdlibCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithStdlibCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithStdlibCall.kt");
         }
     }
 
@@ -62,14 +66,17 @@ public class DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated extends A
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class UnsupportedFeatures extends AbstractDiagnosticsTestWithJsStdLibAndBackendCompilation {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInUnsupportedFeatures() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/unsupportedFeatures"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotations.kt")
         public void testAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/unsupportedFeatures/annotations.kt");
-            doTest(fileName);
+            runTest("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/unsupportedFeatures/annotations.kt");
         }
     }
 }

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

@@ -21,13 +21,16 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class DiagnosticsWithJdk9TestGenerated extends AbstractDiagnosticsWithJdk9Test {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTestsWithJava9() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava9"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("kt11167.kt")
     public void testKt11167() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJava9/kt11167.kt");
-        doTest(fileName);
+        runTest("compiler/testData/diagnostics/testsWithJava9/kt11167.kt");
     }
 }

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

@@ -21,108 +21,106 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("android_support.kt")
     public void testAndroid_support() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/android_support.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/android_support.kt");
     }
 
     @TestMetadata("androidx.kt")
     public void testAndroidx() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/androidx.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/androidx.kt");
     }
 
     @TestMetadata("aosp.kt")
     public void testAosp() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/aosp.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/aosp.kt");
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/eclipse.kt");
     }
 
     @TestMetadata("findBugsSimple.kt")
     public void testFindBugsSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
     }
 
     @TestMetadata("irrelevantQualifierNicknames.kt")
     public void testIrrelevantQualifierNicknames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
     }
 
     @TestMetadata("lombokSimple.kt")
     public void testLombokSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
     }
 
     @TestMetadata("rxjava.kt")
     public void testRxjava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/rxjava.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/rxjava.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("nonNullNever.kt")
         public void testNonNullNever() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
         }
 
         @TestMetadata("nullabilityNicknames.kt")
         public void testNullabilityNicknames() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
         }
 
         @TestMetadata("strange.kt")
         public void testStrange() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
         }
 
         @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Ignore extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInIgnore() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
             }
         }
 
@@ -130,178 +128,159 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class NullabilityWarnings extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInNullabilityWarnings() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("elvis.kt")
             public void testElvis() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
             }
 
             @TestMetadata("localInference.kt")
             public void testLocalInference() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
             }
 
             @TestMetadata("nullabilityGenerics.kt")
             public void testNullabilityGenerics() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
             }
 
             @TestMetadata("nullabilityNicknames.kt")
             public void testNullabilityNicknames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
             }
 
             @TestMetadata("safeCalls.kt")
             public void testSafeCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
             }
 
             @TestMetadata("simple.kt")
             public void testSimple() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
             }
 
             @TestMetadata("strange.kt")
             public void testStrange() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
             }
 
             @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class FromPlatformTypes extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInFromPlatformTypes() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("arithmetic.kt")
                 public void testArithmetic() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
                 }
 
                 @TestMetadata("array.kt")
                 public void testArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
                 }
 
                 @TestMetadata("assignToVar.kt")
                 public void testAssignToVar() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
                 }
 
                 @TestMetadata("conditions.kt")
                 public void testConditions() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
                 }
 
                 @TestMetadata("dataFlowInfo.kt")
                 public void testDataFlowInfo() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
                 }
 
                 @TestMetadata("defaultParameters.kt")
                 public void testDefaultParameters() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
                 }
 
                 @TestMetadata("delegatedProperties.kt")
                 public void testDelegatedProperties() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
                 }
 
                 @TestMetadata("delegation.kt")
                 public void testDelegation() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
                 }
 
                 @TestMetadata("derefenceExtension.kt")
                 public void testDerefenceExtension() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
                 }
 
                 @TestMetadata("derefenceMember.kt")
                 public void testDerefenceMember() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
                 }
 
                 @TestMetadata("expectedType.kt")
                 public void testExpectedType() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
                 }
 
                 @TestMetadata("for.kt")
                 public void testFor() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
                 }
 
                 @TestMetadata("functionArguments.kt")
                 public void testFunctionArguments() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
                 }
 
                 @TestMetadata("invoke.kt")
                 public void testInvoke() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
                 }
 
                 @TestMetadata("kt6829.kt")
                 public void testKt6829() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
                 }
 
                 @TestMetadata("multiDeclaration.kt")
                 public void testMultiDeclaration() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
                 }
 
                 @TestMetadata("passToJava.kt")
                 public void testPassToJava() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
                 }
 
                 @TestMetadata("primitiveArray.kt")
                 public void testPrimitiveArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
                 }
 
                 @TestMetadata("throw.kt")
                 public void testThrow() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
                 }
 
                 @TestMetadata("uselessElvisRightIsNull.kt")
                 public void testUselessElvisRightIsNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
                 }
             }
 
@@ -309,56 +288,52 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeQualifierDefault extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("equalsOnNonNull.kt")
                 public void testEqualsOnNonNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
                 }
 
                 @TestMetadata("fieldsAreNullable.kt")
                 public void testFieldsAreNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
                 }
 
                 @TestMetadata("nullabilityFromOverridden.kt")
                 public void testNullabilityFromOverridden() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
                 }
 
                 @TestMetadata("overridingDefaultQualifier.kt")
                 public void testOverridingDefaultQualifier() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefault.kt")
                 public void testParametersAreNonnullByDefault() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
                 public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
                 }
 
                 @TestMetadata("springNullable.kt")
                 public void testSpringNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
                 }
 
                 @TestMetadata("springNullablePackage.kt")
                 public void testSpringNullablePackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
                 }
             }
         }
@@ -367,62 +342,57 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeQualifierDefault extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("fieldsAreNullable.kt")
             public void testFieldsAreNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
             }
 
             @TestMetadata("forceFlexibility.kt")
             public void testForceFlexibility() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
             }
 
             @TestMetadata("forceFlexibleOverOverrides.kt")
             public void testForceFlexibleOverOverrides() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
             }
 
             @TestMetadata("nullabilityFromOverridden.kt")
             public void testNullabilityFromOverridden() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
             }
 
             @TestMetadata("overridingDefaultQualifier.kt")
             public void testOverridingDefaultQualifier() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
             public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
             }
 
             @TestMetadata("springNullable.kt")
             public void testSpringNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
             }
 
             @TestMetadata("springNullablePackage.kt")
             public void testSpringNullablePackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
             }
         }
     }
@@ -431,6 +401,10 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305NullabilityWarnings extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -439,62 +413,57 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Migration extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInMigration() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("customMigration.kt")
             public void testCustomMigration() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
             }
 
             @TestMetadata("globalIgnore.kt")
             public void testGlobalIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
             }
 
             @TestMetadata("globalWarningMigrationIgnore.kt")
             public void testGlobalWarningMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
             }
 
             @TestMetadata("migrationError.kt")
             public void testMigrationError() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
             }
 
             @TestMetadata("migrationIgnore.kt")
             public void testMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
             }
 
             @TestMetadata("migrationWarning.kt")
             public void testMigrationWarning() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
             }
 
             @TestMetadata("overrideConflicts.kt")
             public void testOverrideConflicts() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
             }
 
             @TestMetadata("specialCollision.kt")
             public void testSpecialCollision() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
             }
 
             @TestMetadata("stateRefinement.kt")
             public void testStateRefinement() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
             }
         }
     }
@@ -503,14 +472,17 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeQualifierDefault extends AbstractForeignAnnotationsNoAnnotationInClasspathTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAndNicknameMigrationPolicy.kt")
         public void testDefaultAndNicknameMigrationPolicy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
         }
     }
 }

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

@@ -21,108 +21,106 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("android_support.kt")
     public void testAndroid_support() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/android_support.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/android_support.kt");
     }
 
     @TestMetadata("androidx.kt")
     public void testAndroidx() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/androidx.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/androidx.kt");
     }
 
     @TestMetadata("aosp.kt")
     public void testAosp() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/aosp.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/aosp.kt");
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/eclipse.kt");
     }
 
     @TestMetadata("findBugsSimple.kt")
     public void testFindBugsSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
     }
 
     @TestMetadata("irrelevantQualifierNicknames.kt")
     public void testIrrelevantQualifierNicknames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
     }
 
     @TestMetadata("lombokSimple.kt")
     public void testLombokSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
     }
 
     @TestMetadata("rxjava.kt")
     public void testRxjava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/rxjava.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/rxjava.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("nonNullNever.kt")
         public void testNonNullNever() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
         }
 
         @TestMetadata("nullabilityNicknames.kt")
         public void testNullabilityNicknames() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
         }
 
         @TestMetadata("strange.kt")
         public void testStrange() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
         }
 
         @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Ignore extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInIgnore() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
             }
         }
 
@@ -130,178 +128,159 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGe
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class NullabilityWarnings extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInNullabilityWarnings() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("elvis.kt")
             public void testElvis() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
             }
 
             @TestMetadata("localInference.kt")
             public void testLocalInference() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
             }
 
             @TestMetadata("nullabilityGenerics.kt")
             public void testNullabilityGenerics() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
             }
 
             @TestMetadata("nullabilityNicknames.kt")
             public void testNullabilityNicknames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
             }
 
             @TestMetadata("safeCalls.kt")
             public void testSafeCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
             }
 
             @TestMetadata("simple.kt")
             public void testSimple() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
             }
 
             @TestMetadata("strange.kt")
             public void testStrange() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
             }
 
             @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class FromPlatformTypes extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInFromPlatformTypes() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("arithmetic.kt")
                 public void testArithmetic() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
                 }
 
                 @TestMetadata("array.kt")
                 public void testArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
                 }
 
                 @TestMetadata("assignToVar.kt")
                 public void testAssignToVar() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
                 }
 
                 @TestMetadata("conditions.kt")
                 public void testConditions() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
                 }
 
                 @TestMetadata("dataFlowInfo.kt")
                 public void testDataFlowInfo() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
                 }
 
                 @TestMetadata("defaultParameters.kt")
                 public void testDefaultParameters() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
                 }
 
                 @TestMetadata("delegatedProperties.kt")
                 public void testDelegatedProperties() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
                 }
 
                 @TestMetadata("delegation.kt")
                 public void testDelegation() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
                 }
 
                 @TestMetadata("derefenceExtension.kt")
                 public void testDerefenceExtension() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
                 }
 
                 @TestMetadata("derefenceMember.kt")
                 public void testDerefenceMember() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
                 }
 
                 @TestMetadata("expectedType.kt")
                 public void testExpectedType() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
                 }
 
                 @TestMetadata("for.kt")
                 public void testFor() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
                 }
 
                 @TestMetadata("functionArguments.kt")
                 public void testFunctionArguments() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
                 }
 
                 @TestMetadata("invoke.kt")
                 public void testInvoke() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
                 }
 
                 @TestMetadata("kt6829.kt")
                 public void testKt6829() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
                 }
 
                 @TestMetadata("multiDeclaration.kt")
                 public void testMultiDeclaration() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
                 }
 
                 @TestMetadata("passToJava.kt")
                 public void testPassToJava() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
                 }
 
                 @TestMetadata("primitiveArray.kt")
                 public void testPrimitiveArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
                 }
 
                 @TestMetadata("throw.kt")
                 public void testThrow() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
                 }
 
                 @TestMetadata("uselessElvisRightIsNull.kt")
                 public void testUselessElvisRightIsNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
                 }
             }
 
@@ -309,56 +288,52 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGe
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeQualifierDefault extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("equalsOnNonNull.kt")
                 public void testEqualsOnNonNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
                 }
 
                 @TestMetadata("fieldsAreNullable.kt")
                 public void testFieldsAreNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
                 }
 
                 @TestMetadata("nullabilityFromOverridden.kt")
                 public void testNullabilityFromOverridden() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
                 }
 
                 @TestMetadata("overridingDefaultQualifier.kt")
                 public void testOverridingDefaultQualifier() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefault.kt")
                 public void testParametersAreNonnullByDefault() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
                 public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
                 }
 
                 @TestMetadata("springNullable.kt")
                 public void testSpringNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
                 }
 
                 @TestMetadata("springNullablePackage.kt")
                 public void testSpringNullablePackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
                 }
             }
         }
@@ -367,62 +342,57 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGe
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeQualifierDefault extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("fieldsAreNullable.kt")
             public void testFieldsAreNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
             }
 
             @TestMetadata("forceFlexibility.kt")
             public void testForceFlexibility() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
             }
 
             @TestMetadata("forceFlexibleOverOverrides.kt")
             public void testForceFlexibleOverOverrides() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
             }
 
             @TestMetadata("nullabilityFromOverridden.kt")
             public void testNullabilityFromOverridden() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
             }
 
             @TestMetadata("overridingDefaultQualifier.kt")
             public void testOverridingDefaultQualifier() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
             public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
             }
 
             @TestMetadata("springNullable.kt")
             public void testSpringNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
             }
 
             @TestMetadata("springNullablePackage.kt")
             public void testSpringNullablePackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
             }
         }
     }
@@ -431,6 +401,10 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGe
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305NullabilityWarnings extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -439,62 +413,57 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGe
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Migration extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInMigration() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("customMigration.kt")
             public void testCustomMigration() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
             }
 
             @TestMetadata("globalIgnore.kt")
             public void testGlobalIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
             }
 
             @TestMetadata("globalWarningMigrationIgnore.kt")
             public void testGlobalWarningMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
             }
 
             @TestMetadata("migrationError.kt")
             public void testMigrationError() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
             }
 
             @TestMetadata("migrationIgnore.kt")
             public void testMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
             }
 
             @TestMetadata("migrationWarning.kt")
             public void testMigrationWarning() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
             }
 
             @TestMetadata("overrideConflicts.kt")
             public void testOverrideConflicts() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
             }
 
             @TestMetadata("specialCollision.kt")
             public void testSpecialCollision() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
             }
 
             @TestMetadata("stateRefinement.kt")
             public void testStateRefinement() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
             }
         }
     }
@@ -503,14 +472,17 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTestGe
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeQualifierDefault extends AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAndNicknameMigrationPolicy.kt")
         public void testDefaultAndNicknameMigrationPolicy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
         }
     }
 }

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

@@ -21,108 +21,106 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("android_support.kt")
     public void testAndroid_support() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/android_support.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/android_support.kt");
     }
 
     @TestMetadata("androidx.kt")
     public void testAndroidx() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/androidx.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/androidx.kt");
     }
 
     @TestMetadata("aosp.kt")
     public void testAosp() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/aosp.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/aosp.kt");
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/eclipse.kt");
     }
 
     @TestMetadata("findBugsSimple.kt")
     public void testFindBugsSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
     }
 
     @TestMetadata("irrelevantQualifierNicknames.kt")
     public void testIrrelevantQualifierNicknames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
     }
 
     @TestMetadata("lombokSimple.kt")
     public void testLombokSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
     }
 
     @TestMetadata("rxjava.kt")
     public void testRxjava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/rxjava.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/rxjava.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractForeignAnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("nonNullNever.kt")
         public void testNonNullNever() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
         }
 
         @TestMetadata("nullabilityNicknames.kt")
         public void testNullabilityNicknames() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
         }
 
         @TestMetadata("strange.kt")
         public void testStrange() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
         }
 
         @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Ignore extends AbstractForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInIgnore() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
             }
         }
 
@@ -130,178 +128,159 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class NullabilityWarnings extends AbstractForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInNullabilityWarnings() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("elvis.kt")
             public void testElvis() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
             }
 
             @TestMetadata("localInference.kt")
             public void testLocalInference() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
             }
 
             @TestMetadata("nullabilityGenerics.kt")
             public void testNullabilityGenerics() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
             }
 
             @TestMetadata("nullabilityNicknames.kt")
             public void testNullabilityNicknames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
             }
 
             @TestMetadata("safeCalls.kt")
             public void testSafeCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
             }
 
             @TestMetadata("simple.kt")
             public void testSimple() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
             }
 
             @TestMetadata("strange.kt")
             public void testStrange() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
             }
 
             @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class FromPlatformTypes extends AbstractForeignAnnotationsTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInFromPlatformTypes() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("arithmetic.kt")
                 public void testArithmetic() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
                 }
 
                 @TestMetadata("array.kt")
                 public void testArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
                 }
 
                 @TestMetadata("assignToVar.kt")
                 public void testAssignToVar() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
                 }
 
                 @TestMetadata("conditions.kt")
                 public void testConditions() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
                 }
 
                 @TestMetadata("dataFlowInfo.kt")
                 public void testDataFlowInfo() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
                 }
 
                 @TestMetadata("defaultParameters.kt")
                 public void testDefaultParameters() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
                 }
 
                 @TestMetadata("delegatedProperties.kt")
                 public void testDelegatedProperties() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
                 }
 
                 @TestMetadata("delegation.kt")
                 public void testDelegation() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
                 }
 
                 @TestMetadata("derefenceExtension.kt")
                 public void testDerefenceExtension() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
                 }
 
                 @TestMetadata("derefenceMember.kt")
                 public void testDerefenceMember() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
                 }
 
                 @TestMetadata("expectedType.kt")
                 public void testExpectedType() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
                 }
 
                 @TestMetadata("for.kt")
                 public void testFor() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
                 }
 
                 @TestMetadata("functionArguments.kt")
                 public void testFunctionArguments() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
                 }
 
                 @TestMetadata("invoke.kt")
                 public void testInvoke() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
                 }
 
                 @TestMetadata("kt6829.kt")
                 public void testKt6829() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
                 }
 
                 @TestMetadata("multiDeclaration.kt")
                 public void testMultiDeclaration() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
                 }
 
                 @TestMetadata("passToJava.kt")
                 public void testPassToJava() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
                 }
 
                 @TestMetadata("primitiveArray.kt")
                 public void testPrimitiveArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
                 }
 
                 @TestMetadata("throw.kt")
                 public void testThrow() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
                 }
 
                 @TestMetadata("uselessElvisRightIsNull.kt")
                 public void testUselessElvisRightIsNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
                 }
             }
 
@@ -309,56 +288,52 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeQualifierDefault extends AbstractForeignAnnotationsTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("equalsOnNonNull.kt")
                 public void testEqualsOnNonNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
                 }
 
                 @TestMetadata("fieldsAreNullable.kt")
                 public void testFieldsAreNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
                 }
 
                 @TestMetadata("nullabilityFromOverridden.kt")
                 public void testNullabilityFromOverridden() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
                 }
 
                 @TestMetadata("overridingDefaultQualifier.kt")
                 public void testOverridingDefaultQualifier() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefault.kt")
                 public void testParametersAreNonnullByDefault() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
                 public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
                 }
 
                 @TestMetadata("springNullable.kt")
                 public void testSpringNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
                 }
 
                 @TestMetadata("springNullablePackage.kt")
                 public void testSpringNullablePackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
                 }
             }
         }
@@ -367,62 +342,57 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeQualifierDefault extends AbstractForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("fieldsAreNullable.kt")
             public void testFieldsAreNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
             }
 
             @TestMetadata("forceFlexibility.kt")
             public void testForceFlexibility() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
             }
 
             @TestMetadata("forceFlexibleOverOverrides.kt")
             public void testForceFlexibleOverOverrides() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
             }
 
             @TestMetadata("nullabilityFromOverridden.kt")
             public void testNullabilityFromOverridden() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
             }
 
             @TestMetadata("overridingDefaultQualifier.kt")
             public void testOverridingDefaultQualifier() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
             public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
             }
 
             @TestMetadata("springNullable.kt")
             public void testSpringNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
             }
 
             @TestMetadata("springNullablePackage.kt")
             public void testSpringNullablePackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
             }
         }
     }
@@ -431,6 +401,10 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305NullabilityWarnings extends AbstractForeignAnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -439,62 +413,57 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Migration extends AbstractForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInMigration() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("customMigration.kt")
             public void testCustomMigration() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
             }
 
             @TestMetadata("globalIgnore.kt")
             public void testGlobalIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
             }
 
             @TestMetadata("globalWarningMigrationIgnore.kt")
             public void testGlobalWarningMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
             }
 
             @TestMetadata("migrationError.kt")
             public void testMigrationError() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
             }
 
             @TestMetadata("migrationIgnore.kt")
             public void testMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
             }
 
             @TestMetadata("migrationWarning.kt")
             public void testMigrationWarning() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
             }
 
             @TestMetadata("overrideConflicts.kt")
             public void testOverrideConflicts() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
             }
 
             @TestMetadata("specialCollision.kt")
             public void testSpecialCollision() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
             }
 
             @TestMetadata("stateRefinement.kt")
             public void testStateRefinement() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
             }
         }
     }
@@ -503,14 +472,17 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeQualifierDefault extends AbstractForeignAnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAndNicknameMigrationPolicy.kt")
         public void testDefaultAndNicknameMigrationPolicy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java

@@ -23,124 +23,114 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Tests extends AbstractJavacDiagnosticsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTests() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("Annotations.kt")
         public void testAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/Annotations.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/diagnostics/tests/Annotations.kt");
         }
 
         @TestMetadata("compiler/testData/javac/diagnostics/tests/imports")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Imports extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInImports() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("AllUnderImportsAmbiguity.kt")
             public void testAllUnderImportsAmbiguity() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt");
             }
 
             @TestMetadata("AllUnderImportsLessPriority.kt")
             public void testAllUnderImportsLessPriority() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt");
             }
 
             @TestMetadata("ClassImportsConflicting.kt")
             public void testClassImportsConflicting() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt");
             }
 
             @TestMetadata("CurrentPackageAndAllUnderImport.kt")
             public void testCurrentPackageAndAllUnderImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt");
             }
 
             @TestMetadata("CurrentPackageAndExplicitImport.kt")
             public void testCurrentPackageAndExplicitImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt");
             }
 
             @TestMetadata("CurrentPackageAndExplicitNestedImport.kt")
             public void testCurrentPackageAndExplicitNestedImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt");
             }
 
             @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt")
             public void testCurrentPackageAndNestedAsteriskImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt");
             }
 
             @TestMetadata("ImportGenericVsPackage.kt")
             public void testImportGenericVsPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt");
             }
 
             @TestMetadata("ImportProtectedClass.kt")
             public void testImportProtectedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt");
             }
 
             @TestMetadata("ImportTwoTimes.kt")
             public void testImportTwoTimes() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt");
             }
 
             @TestMetadata("ImportTwoTimesStar.kt")
             public void testImportTwoTimesStar() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt");
             }
 
             @TestMetadata("NestedAndTopLevelClassClash.kt")
             public void testNestedAndTopLevelClassClash() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt");
             }
 
             @TestMetadata("NestedClassClash.kt")
             public void testNestedClassClash() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt");
             }
 
             @TestMetadata("PackageExplicitAndStartImport.kt")
             public void testPackageExplicitAndStartImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt");
             }
 
             @TestMetadata("PackagePrivateAndPublicNested.kt")
             public void testPackagePrivateAndPublicNested() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt");
             }
 
             @TestMetadata("TopLevelClassVsPackage.kt")
             public void testTopLevelClassVsPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt");
             }
 
             @TestMetadata("TopLevelClassVsPackage2.kt")
             public void testTopLevelClassVsPackage2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt");
             }
         }
 
@@ -148,122 +138,107 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Inheritance extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInInheritance() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("IheritanceOfInner.kt")
             public void testIheritanceOfInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity.kt")
             public void testInheritanceAmbiguity() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity2.kt")
             public void testInheritanceAmbiguity2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity3.kt")
             public void testInheritanceAmbiguity3() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity4.kt")
             public void testInheritanceAmbiguity4() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt");
             }
 
             @TestMetadata("InheritanceWithKotlin.kt")
             public void testInheritanceWithKotlin() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt");
             }
 
             @TestMetadata("InheritanceWithKotlinClasses.kt")
             public void testInheritanceWithKotlinClasses() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt");
             }
 
             @TestMetadata("InheritedInner.kt")
             public void testInheritedInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt");
             }
 
             @TestMetadata("InheritedInner2.kt")
             public void testInheritedInner2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt");
             }
 
             @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt")
             public void testInheritedInnerAndSupertypeWithSameName() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt");
             }
 
             @TestMetadata("InheritedInnerUsageInInner.kt")
             public void testInheritedInnerUsageInInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt");
             }
 
             @TestMetadata("InheritedKotlinInner.kt")
             public void testInheritedKotlinInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt");
             }
 
             @TestMetadata("InnerAndInheritedInner.kt")
             public void testInnerAndInheritedInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt");
             }
 
             @TestMetadata("ManyInheritedClasses.kt")
             public void testManyInheritedClasses() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt");
             }
 
             @TestMetadata("NoAmbiguity.kt")
             public void testNoAmbiguity() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt");
             }
 
             @TestMetadata("NoAmbiguity2.kt")
             public void testNoAmbiguity2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt");
             }
 
             @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt")
             public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt");
             }
 
             @TestMetadata("SuperTypeWithSameInner.kt")
             public void testSuperTypeWithSameInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt");
             }
 
             @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt")
             public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt");
             }
         }
 
@@ -271,50 +246,47 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Inners extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInInners() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inners"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("ComplexCase.kt")
             public void testComplexCase() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt");
             }
 
             @TestMetadata("ComplexCase2.kt")
             public void testComplexCase2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt");
             }
 
             @TestMetadata("CurrentPackageAndInner.kt")
             public void testCurrentPackageAndInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt");
             }
 
             @TestMetadata("ImportThriceNestedClass.kt")
             public void testImportThriceNestedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt");
             }
 
             @TestMetadata("InnerInInner.kt")
             public void testInnerInInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt");
             }
 
             @TestMetadata("Nested.kt")
             public void testNested() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/Nested.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/Nested.kt");
             }
 
             @TestMetadata("ThriceNestedClass.kt")
             public void testThriceNestedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt");
             }
         }
 
@@ -322,38 +294,37 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class QualifiedExpression extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInQualifiedExpression() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("GenericClassVsPackage.kt")
             public void testGenericClassVsPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt");
             }
 
             @TestMetadata("PackageVsClass.kt")
             public void testPackageVsClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt");
             }
 
             @TestMetadata("PackageVsClass2.kt")
             public void testPackageVsClass2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt");
             }
 
             @TestMetadata("PackageVsRootClass.kt")
             public void testPackageVsRootClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt");
             }
 
             @TestMetadata("visibleClassVsQualifiedClass.kt")
             public void testVisibleClassVsQualifiedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt");
             }
         }
 
@@ -361,50 +332,47 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeParameters extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTypeParameters() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("Clash.kt")
             public void testClash() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt");
             }
 
             @TestMetadata("ComplexCase.kt")
             public void testComplexCase() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt");
             }
 
             @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt")
             public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt");
             }
 
             @TestMetadata("InnerWithTypeParameter.kt")
             public void testInnerWithTypeParameter() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt");
             }
 
             @TestMetadata("NestedWithInner.kt")
             public void testNestedWithInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt");
             }
 
             @TestMetadata("SeveralInnersWithTypeParameters.kt")
             public void testSeveralInnersWithTypeParameters() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt");
             }
 
             @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt")
             public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt");
             }
         }
     }
@@ -413,124 +381,114 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TestsWithoutJavac extends AbstractJavacDiagnosticsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTestsWithoutJavac() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("Annotations.kt")
         public void testAnnotations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/Annotations.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/diagnostics/tests/Annotations.kt");
         }
 
         @TestMetadata("compiler/testData/javac/diagnostics/tests/imports")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Imports extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInImports() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("AllUnderImportsAmbiguity.kt")
             public void testAllUnderImportsAmbiguity() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt");
             }
 
             @TestMetadata("AllUnderImportsLessPriority.kt")
             public void testAllUnderImportsLessPriority() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt");
             }
 
             @TestMetadata("ClassImportsConflicting.kt")
             public void testClassImportsConflicting() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt");
             }
 
             @TestMetadata("CurrentPackageAndAllUnderImport.kt")
             public void testCurrentPackageAndAllUnderImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt");
             }
 
             @TestMetadata("CurrentPackageAndExplicitImport.kt")
             public void testCurrentPackageAndExplicitImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt");
             }
 
             @TestMetadata("CurrentPackageAndExplicitNestedImport.kt")
             public void testCurrentPackageAndExplicitNestedImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt");
             }
 
             @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt")
             public void testCurrentPackageAndNestedAsteriskImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt");
             }
 
             @TestMetadata("ImportGenericVsPackage.kt")
             public void testImportGenericVsPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt");
             }
 
             @TestMetadata("ImportProtectedClass.kt")
             public void testImportProtectedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt");
             }
 
             @TestMetadata("ImportTwoTimes.kt")
             public void testImportTwoTimes() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt");
             }
 
             @TestMetadata("ImportTwoTimesStar.kt")
             public void testImportTwoTimesStar() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt");
             }
 
             @TestMetadata("NestedAndTopLevelClassClash.kt")
             public void testNestedAndTopLevelClassClash() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt");
             }
 
             @TestMetadata("NestedClassClash.kt")
             public void testNestedClassClash() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt");
             }
 
             @TestMetadata("PackageExplicitAndStartImport.kt")
             public void testPackageExplicitAndStartImport() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt");
             }
 
             @TestMetadata("PackagePrivateAndPublicNested.kt")
             public void testPackagePrivateAndPublicNested() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt");
             }
 
             @TestMetadata("TopLevelClassVsPackage.kt")
             public void testTopLevelClassVsPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt");
             }
 
             @TestMetadata("TopLevelClassVsPackage2.kt")
             public void testTopLevelClassVsPackage2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt");
             }
         }
 
@@ -538,122 +496,107 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Inheritance extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInInheritance() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("IheritanceOfInner.kt")
             public void testIheritanceOfInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity.kt")
             public void testInheritanceAmbiguity() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity2.kt")
             public void testInheritanceAmbiguity2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity3.kt")
             public void testInheritanceAmbiguity3() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt");
             }
 
             @TestMetadata("InheritanceAmbiguity4.kt")
             public void testInheritanceAmbiguity4() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt");
             }
 
             @TestMetadata("InheritanceWithKotlin.kt")
             public void testInheritanceWithKotlin() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt");
             }
 
             @TestMetadata("InheritanceWithKotlinClasses.kt")
             public void testInheritanceWithKotlinClasses() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt");
             }
 
             @TestMetadata("InheritedInner.kt")
             public void testInheritedInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt");
             }
 
             @TestMetadata("InheritedInner2.kt")
             public void testInheritedInner2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt");
             }
 
             @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt")
             public void testInheritedInnerAndSupertypeWithSameName() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt");
             }
 
             @TestMetadata("InheritedInnerUsageInInner.kt")
             public void testInheritedInnerUsageInInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt");
             }
 
             @TestMetadata("InheritedKotlinInner.kt")
             public void testInheritedKotlinInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt");
             }
 
             @TestMetadata("InnerAndInheritedInner.kt")
             public void testInnerAndInheritedInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt");
             }
 
             @TestMetadata("ManyInheritedClasses.kt")
             public void testManyInheritedClasses() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt");
             }
 
             @TestMetadata("NoAmbiguity.kt")
             public void testNoAmbiguity() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt");
             }
 
             @TestMetadata("NoAmbiguity2.kt")
             public void testNoAmbiguity2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt");
             }
 
             @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt")
             public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt");
             }
 
             @TestMetadata("SuperTypeWithSameInner.kt")
             public void testSuperTypeWithSameInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt");
             }
 
             @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt")
             public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt");
             }
         }
 
@@ -661,50 +604,47 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Inners extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInInners() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inners"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("ComplexCase.kt")
             public void testComplexCase() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt");
             }
 
             @TestMetadata("ComplexCase2.kt")
             public void testComplexCase2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt");
             }
 
             @TestMetadata("CurrentPackageAndInner.kt")
             public void testCurrentPackageAndInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt");
             }
 
             @TestMetadata("ImportThriceNestedClass.kt")
             public void testImportThriceNestedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt");
             }
 
             @TestMetadata("InnerInInner.kt")
             public void testInnerInInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt");
             }
 
             @TestMetadata("Nested.kt")
             public void testNested() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/Nested.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/Nested.kt");
             }
 
             @TestMetadata("ThriceNestedClass.kt")
             public void testThriceNestedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt");
             }
         }
 
@@ -712,38 +652,37 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class QualifiedExpression extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInQualifiedExpression() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("GenericClassVsPackage.kt")
             public void testGenericClassVsPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt");
             }
 
             @TestMetadata("PackageVsClass.kt")
             public void testPackageVsClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt");
             }
 
             @TestMetadata("PackageVsClass2.kt")
             public void testPackageVsClass2() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt");
             }
 
             @TestMetadata("PackageVsRootClass.kt")
             public void testPackageVsRootClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt");
             }
 
             @TestMetadata("visibleClassVsQualifiedClass.kt")
             public void testVisibleClassVsQualifiedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt");
             }
         }
 
@@ -751,50 +690,47 @@ public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeParameters extends AbstractJavacDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTypeParameters() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("Clash.kt")
             public void testClash() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt");
             }
 
             @TestMetadata("ComplexCase.kt")
             public void testComplexCase() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt");
             }
 
             @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt")
             public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt");
             }
 
             @TestMetadata("InnerWithTypeParameter.kt")
             public void testInnerWithTypeParameter() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt");
             }
 
             @TestMetadata("NestedWithInner.kt")
             public void testNestedWithInner() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt");
             }
 
             @TestMetadata("SeveralInnersWithTypeParameters.kt")
             public void testSeveralInnersWithTypeParameters() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt");
             }
 
             @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt")
             public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt");
-                doTestWithoutJavacWrapper(fileName);
+                runTest("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt");
             }
         }
     }

compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacFieldResolutionTestGenerated.java

@@ -23,80 +23,72 @@ public class JavacFieldResolutionTestGenerated extends AbstractJavacFieldResolut
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Tests extends AbstractJavacFieldResolutionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTests() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/fieldsResolution/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("AsteriskStaticImportsAmbiguity.kt")
         public void testAsteriskStaticImportsAmbiguity() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt");
         }
 
         @TestMetadata("BinaryInitializers.kt")
         public void testBinaryInitializers() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt");
         }
 
         @TestMetadata("ConstantByFqName.kt")
         public void testConstantByFqName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt");
         }
 
         @TestMetadata("ConstantValues.kt")
         public void testConstantValues() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt");
         }
 
         @TestMetadata("ConstantValuesFromKtFile.kt")
         public void testConstantValuesFromKtFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt");
         }
 
         @TestMetadata("FieldFromOuterClass.kt")
         public void testFieldFromOuterClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt");
         }
 
         @TestMetadata("InheritedField.kt")
         public void testInheritedField() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/InheritedField.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/InheritedField.kt");
         }
 
         @TestMetadata("MultipleOuters.kt")
         public void testMultipleOuters() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt");
         }
 
         @TestMetadata("ResolutionPriority.kt")
         public void testResolutionPriority() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt");
         }
 
         @TestMetadata("SameFieldInSupertypes.kt")
         public void testSameFieldInSupertypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt");
         }
 
         @TestMetadata("StaticImport.kt")
         public void testStaticImport() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/StaticImport.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/StaticImport.kt");
         }
 
         @TestMetadata("StaticImportsAmbiguity.kt")
         public void testStaticImportsAmbiguity() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt");
-            doTest(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt");
         }
     }
 
@@ -104,80 +96,72 @@ public class JavacFieldResolutionTestGenerated extends AbstractJavacFieldResolut
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TestsWithoutJavac extends AbstractJavacFieldResolutionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTestsWithoutJavac() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/fieldsResolution/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("AsteriskStaticImportsAmbiguity.kt")
         public void testAsteriskStaticImportsAmbiguity() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt");
         }
 
         @TestMetadata("BinaryInitializers.kt")
         public void testBinaryInitializers() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt");
         }
 
         @TestMetadata("ConstantByFqName.kt")
         public void testConstantByFqName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt");
         }
 
         @TestMetadata("ConstantValues.kt")
         public void testConstantValues() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt");
         }
 
         @TestMetadata("ConstantValuesFromKtFile.kt")
         public void testConstantValuesFromKtFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt");
         }
 
         @TestMetadata("FieldFromOuterClass.kt")
         public void testFieldFromOuterClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt");
         }
 
         @TestMetadata("InheritedField.kt")
         public void testInheritedField() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/InheritedField.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/InheritedField.kt");
         }
 
         @TestMetadata("MultipleOuters.kt")
         public void testMultipleOuters() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt");
         }
 
         @TestMetadata("ResolutionPriority.kt")
         public void testResolutionPriority() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt");
         }
 
         @TestMetadata("SameFieldInSupertypes.kt")
         public void testSameFieldInSupertypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt");
         }
 
         @TestMetadata("StaticImport.kt")
         public void testStaticImport() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/StaticImport.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/StaticImport.kt");
         }
 
         @TestMetadata("StaticImportsAmbiguity.kt")
         public void testStaticImportsAmbiguity() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt");
-            doTestWithoutJavacWrapper(fileName);
+            runTest("compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java

@@ -21,108 +21,106 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAnnotationsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTests() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("android_support.kt")
     public void testAndroid_support() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/android_support.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/android_support.kt");
     }
 
     @TestMetadata("androidx.kt")
     public void testAndroidx() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/androidx.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/androidx.kt");
     }
 
     @TestMetadata("aosp.kt")
     public void testAosp() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/aosp.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/aosp.kt");
     }
 
     @TestMetadata("checkerFramework.kt")
     public void testCheckerFramework() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/checkerFramework.kt");
     }
 
     @TestMetadata("eclipse.kt")
     public void testEclipse() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/eclipse.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/eclipse.kt");
     }
 
     @TestMetadata("findBugsSimple.kt")
     public void testFindBugsSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt");
     }
 
     @TestMetadata("irrelevantQualifierNicknames.kt")
     public void testIrrelevantQualifierNicknames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/irrelevantQualifierNicknames.kt");
     }
 
     @TestMetadata("lombokSimple.kt")
     public void testLombokSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/lombokSimple.kt");
     }
 
     @TestMetadata("rxjava.kt")
     public void testRxjava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/rxjava.kt");
-        doTest(fileName);
+        runTest("compiler/testData/foreignAnnotations/tests/rxjava.kt");
     }
 
     @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305 extends AbstractJavacForeignAnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("nonNullNever.kt")
         public void testNonNullNever() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nonNullNever.kt");
         }
 
         @TestMetadata("nullabilityNicknames.kt")
         public void testNullabilityNicknames() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityNicknames.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/simple.kt");
         }
 
         @TestMetadata("strange.kt")
         public void testStrange() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/jsr305/strange.kt");
         }
 
         @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Ignore extends AbstractJavacForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInIgnore() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/ignore/parametersAreNonnullByDefault.kt");
             }
         }
 
@@ -130,178 +128,159 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class NullabilityWarnings extends AbstractJavacForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInNullabilityWarnings() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("elvis.kt")
             public void testElvis() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/elvis.kt");
             }
 
             @TestMetadata("localInference.kt")
             public void testLocalInference() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/localInference.kt");
             }
 
             @TestMetadata("nullabilityGenerics.kt")
             public void testNullabilityGenerics() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityGenerics.kt");
             }
 
             @TestMetadata("nullabilityNicknames.kt")
             public void testNullabilityNicknames() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/nullabilityNicknames.kt");
             }
 
             @TestMetadata("safeCalls.kt")
             public void testSafeCalls() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/safeCalls.kt");
             }
 
             @TestMetadata("simple.kt")
             public void testSimple() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/simple.kt");
             }
 
             @TestMetadata("strange.kt")
             public void testStrange() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/strange.kt");
             }
 
             @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class FromPlatformTypes extends AbstractJavacForeignAnnotationsTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInFromPlatformTypes() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("arithmetic.kt")
                 public void testArithmetic() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.kt");
                 }
 
                 @TestMetadata("array.kt")
                 public void testArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.kt");
                 }
 
                 @TestMetadata("assignToVar.kt")
                 public void testAssignToVar() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.kt");
                 }
 
                 @TestMetadata("conditions.kt")
                 public void testConditions() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.kt");
                 }
 
                 @TestMetadata("dataFlowInfo.kt")
                 public void testDataFlowInfo() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.kt");
                 }
 
                 @TestMetadata("defaultParameters.kt")
                 public void testDefaultParameters() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.kt");
                 }
 
                 @TestMetadata("delegatedProperties.kt")
                 public void testDelegatedProperties() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.kt");
                 }
 
                 @TestMetadata("delegation.kt")
                 public void testDelegation() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.kt");
                 }
 
                 @TestMetadata("derefenceExtension.kt")
                 public void testDerefenceExtension() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.kt");
                 }
 
                 @TestMetadata("derefenceMember.kt")
                 public void testDerefenceMember() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.kt");
                 }
 
                 @TestMetadata("expectedType.kt")
                 public void testExpectedType() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.kt");
                 }
 
                 @TestMetadata("for.kt")
                 public void testFor() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/for.kt");
                 }
 
                 @TestMetadata("functionArguments.kt")
                 public void testFunctionArguments() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/functionArguments.kt");
                 }
 
                 @TestMetadata("invoke.kt")
                 public void testInvoke() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/invoke.kt");
                 }
 
                 @TestMetadata("kt6829.kt")
                 public void testKt6829() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/kt6829.kt");
                 }
 
                 @TestMetadata("multiDeclaration.kt")
                 public void testMultiDeclaration() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/multiDeclaration.kt");
                 }
 
                 @TestMetadata("passToJava.kt")
                 public void testPassToJava() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/passToJava.kt");
                 }
 
                 @TestMetadata("primitiveArray.kt")
                 public void testPrimitiveArray() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/primitiveArray.kt");
                 }
 
                 @TestMetadata("throw.kt")
                 public void testThrow() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/throw.kt");
                 }
 
                 @TestMetadata("uselessElvisRightIsNull.kt")
                 public void testUselessElvisRightIsNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes/uselessElvisRightIsNull.kt");
                 }
             }
 
@@ -309,56 +288,52 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeQualifierDefault extends AbstractJavacForeignAnnotationsTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                }
+
                 public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                     KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
                 }
 
                 @TestMetadata("equalsOnNonNull.kt")
                 public void testEqualsOnNonNull() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/equalsOnNonNull.kt");
                 }
 
                 @TestMetadata("fieldsAreNullable.kt")
                 public void testFieldsAreNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/fieldsAreNullable.kt");
                 }
 
                 @TestMetadata("nullabilityFromOverridden.kt")
                 public void testNullabilityFromOverridden() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/nullabilityFromOverridden.kt");
                 }
 
                 @TestMetadata("overridingDefaultQualifier.kt")
                 public void testOverridingDefaultQualifier() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/overridingDefaultQualifier.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefault.kt")
                 public void testParametersAreNonnullByDefault() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefault.kt");
                 }
 
                 @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
                 public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
                 }
 
                 @TestMetadata("springNullable.kt")
                 public void testSpringNullable() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullable.kt");
                 }
 
                 @TestMetadata("springNullablePackage.kt")
                 public void testSpringNullablePackage() throws Exception {
-                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
-                    doTest(fileName);
+                    runTest("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault/springNullablePackage.kt");
                 }
             }
         }
@@ -367,62 +342,57 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeQualifierDefault extends AbstractJavacForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("fieldsAreNullable.kt")
             public void testFieldsAreNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/fieldsAreNullable.kt");
             }
 
             @TestMetadata("forceFlexibility.kt")
             public void testForceFlexibility() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibility.kt");
             }
 
             @TestMetadata("forceFlexibleOverOverrides.kt")
             public void testForceFlexibleOverOverrides() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/forceFlexibleOverOverrides.kt");
             }
 
             @TestMetadata("nullabilityFromOverridden.kt")
             public void testNullabilityFromOverridden() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/nullabilityFromOverridden.kt");
             }
 
             @TestMetadata("overridingDefaultQualifier.kt")
             public void testOverridingDefaultQualifier() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/overridingDefaultQualifier.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefault.kt")
             public void testParametersAreNonnullByDefault() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefault.kt");
             }
 
             @TestMetadata("parametersAreNonnullByDefaultPackage.kt")
             public void testParametersAreNonnullByDefaultPackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt");
             }
 
             @TestMetadata("springNullable.kt")
             public void testSpringNullable() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullable.kt");
             }
 
             @TestMetadata("springNullablePackage.kt")
             public void testSpringNullablePackage() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault/springNullablePackage.kt");
             }
         }
     }
@@ -431,6 +401,10 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jsr305NullabilityWarnings extends AbstractJavacForeignAnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -439,62 +413,57 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Migration extends AbstractJavacForeignAnnotationsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInMigration() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("customMigration.kt")
             public void testCustomMigration() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/customMigration.kt");
             }
 
             @TestMetadata("globalIgnore.kt")
             public void testGlobalIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalIgnore.kt");
             }
 
             @TestMetadata("globalWarningMigrationIgnore.kt")
             public void testGlobalWarningMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/globalWarningMigrationIgnore.kt");
             }
 
             @TestMetadata("migrationError.kt")
             public void testMigrationError() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationError.kt");
             }
 
             @TestMetadata("migrationIgnore.kt")
             public void testMigrationIgnore() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationIgnore.kt");
             }
 
             @TestMetadata("migrationWarning.kt")
             public void testMigrationWarning() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/migrationWarning.kt");
             }
 
             @TestMetadata("overrideConflicts.kt")
             public void testOverrideConflicts() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/overrideConflicts.kt");
             }
 
             @TestMetadata("specialCollision.kt")
             public void testSpecialCollision() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/specialCollision.kt");
             }
 
             @TestMetadata("stateRefinement.kt")
             public void testStateRefinement() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
-                doTest(fileName);
+                runTest("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration/stateRefinement.kt");
             }
         }
     }
@@ -503,14 +472,17 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TypeQualifierDefault extends AbstractJavacForeignAnnotationsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTypeQualifierDefault() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultAndNicknameMigrationPolicy.kt")
         public void testDefaultAndNicknameMigrationPolicy() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
-            doTest(fileName);
+            runTest("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/defaultAndNicknameMigrationPolicy.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java

@@ -21,202 +21,179 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInBytecodeListing() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("callableNameIntrinsic.kt")
     public void testCallableNameIntrinsic() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/callableNameIntrinsic.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/callableNameIntrinsic.kt");
     }
 
     @TestMetadata("coroutineContextIntrinsic.kt")
     public void testCoroutineContextIntrinsic() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/coroutineContextIntrinsic.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/coroutineContextIntrinsic.kt");
     }
 
     @TestMetadata("coroutineFields.kt")
     public void testCoroutineFields() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/coroutineFields.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/coroutineFields.kt");
     }
 
     @TestMetadata("defaultImpls.kt")
     public void testDefaultImpls() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/defaultImpls.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/defaultImpls.kt");
     }
 
     @TestMetadata("emptyMultifileFacade.kt")
     public void testEmptyMultifileFacade() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/emptyMultifileFacade.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/emptyMultifileFacade.kt");
     }
 
     @TestMetadata("immutableCollection.kt")
     public void testImmutableCollection() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/immutableCollection.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/immutableCollection.kt");
     }
 
     @TestMetadata("inlineOnly.kt")
     public void testInlineOnly() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineOnly.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/inlineOnly.kt");
     }
 
     @TestMetadata("InlineOnlyMultifile.kt")
     public void testInlineOnlyMultifile() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/InlineOnlyMultifile.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/InlineOnlyMultifile.kt");
     }
 
     @TestMetadata("inlineOnlyProperty.kt")
     public void testInlineOnlyProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineOnlyProperty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/inlineOnlyProperty.kt");
     }
 
     @TestMetadata("InlineOnlyPropertyMultifile.kt")
     public void testInlineOnlyPropertyMultifile() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/InlineOnlyPropertyMultifile.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/InlineOnlyPropertyMultifile.kt");
     }
 
     @TestMetadata("invisibleCompanionObject.kt")
     public void testInvisibleCompanionObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/invisibleCompanionObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/invisibleCompanionObject.kt");
     }
 
     @TestMetadata("invisibleCompanionObject_lv11.kt")
     public void testInvisibleCompanionObject_lv11() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/invisibleCompanionObject_lv11.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/invisibleCompanionObject_lv11.kt");
     }
 
     @TestMetadata("invisibleCompanionObject_lv12.kt")
     public void testInvisibleCompanionObject_lv12() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/invisibleCompanionObject_lv12.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/invisibleCompanionObject_lv12.kt");
     }
 
     @TestMetadata("jvmOverloadsAndParametersAnnotations.kt")
     public void testJvmOverloadsAndParametersAnnotations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.kt");
     }
 
     @TestMetadata("noCollectionStubMethodsInInterface.kt")
     public void testNoCollectionStubMethodsInInterface() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/noCollectionStubMethodsInInterface.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/noCollectionStubMethodsInInterface.kt");
     }
 
     @TestMetadata("noDelegationsToPrivateInterfaceMembers.kt")
     public void testNoDelegationsToPrivateInterfaceMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/noDelegationsToPrivateInterfaceMembers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/noDelegationsToPrivateInterfaceMembers.kt");
     }
 
     @TestMetadata("noReceiverInCallableReferenceClasses.kt")
     public void testNoReceiverInCallableReferenceClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/noReceiverInCallableReferenceClasses.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/noReceiverInCallableReferenceClasses.kt");
     }
 
     @TestMetadata("noRemoveAtInReadOnly.kt")
     public void testNoRemoveAtInReadOnly() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/noRemoveAtInReadOnly.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/noRemoveAtInReadOnly.kt");
     }
 
     @TestMetadata("noToArrayInJava.kt")
     public void testNoToArrayInJava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/noToArrayInJava.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/noToArrayInJava.kt");
     }
 
     @TestMetadata("oomInReturnUnit.kt")
     public void testOomInReturnUnit() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/oomInReturnUnit.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/oomInReturnUnit.kt");
     }
 
     @TestMetadata("privateSuspendFun.kt")
     public void testPrivateSuspendFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/privateSuspendFun.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/privateSuspendFun.kt");
     }
 
     @TestMetadata("releaseCoroutines.kt")
     public void testReleaseCoroutines() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/releaseCoroutines.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/releaseCoroutines.kt");
     }
 
     @TestMetadata("samAdapterAndInlinedOne.kt")
     public void testSamAdapterAndInlinedOne() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/samAdapterAndInlinedOne.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/samAdapterAndInlinedOne.kt");
     }
 
     @TestMetadata("suspendReifiedFun.kt")
     public void testSuspendReifiedFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/suspendReifiedFun.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/bytecodeListing/suspendReifiedFun.kt");
     }
 
     @TestMetadata("compiler/testData/codegen/bytecodeListing/annotations")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Annotations extends AbstractBytecodeListingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInAnnotations() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("defaultTargets.kt")
         public void testDefaultTargets() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/defaultTargets.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/defaultTargets.kt");
         }
 
         @TestMetadata("deprecatedJvmOverloads.kt")
         public void testDeprecatedJvmOverloads() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/deprecatedJvmOverloads.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/deprecatedJvmOverloads.kt");
         }
 
         @TestMetadata("JvmSynthetic.kt")
         public void testJvmSynthetic() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/JvmSynthetic.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/JvmSynthetic.kt");
         }
 
         @TestMetadata("kt9320.kt")
         public void testKt9320() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/kt9320.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/kt9320.kt");
         }
 
         @TestMetadata("literals.kt")
         public void testLiterals() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/literals.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/literals.kt");
         }
 
         @TestMetadata("onProperties.kt")
         public void testOnProperties() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/onProperties.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/onProperties.kt");
         }
 
         @TestMetadata("onReceiver.kt")
         public void testOnReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/annotations/onReceiver.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/annotations/onReceiver.kt");
         }
     }
 
@@ -224,26 +201,27 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CollectionStubs extends AbstractBytecodeListingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCollectionStubs() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("noStubsInJavaSuperClass.kt")
         public void testNoStubsInJavaSuperClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/collectionStubs/noStubsInJavaSuperClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/collectionStubs/noStubsInJavaSuperClass.kt");
         }
 
         @TestMetadata("stubsFromSuperclass.kt")
         public void testStubsFromSuperclass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/collectionStubs/stubsFromSuperclass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/collectionStubs/stubsFromSuperclass.kt");
         }
 
         @TestMetadata("stubsFromSuperclassNoBridges.kt")
         public void testStubsFromSuperclassNoBridges() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/collectionStubs/stubsFromSuperclassNoBridges.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/collectionStubs/stubsFromSuperclassNoBridges.kt");
         }
     }
 
@@ -251,38 +229,37 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class InlineClasses extends AbstractBytecodeListingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInInlineClasses() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("companionObjectInsideInlineClass.kt")
         public void testCompanionObjectInsideInlineClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineClasses/companionObjectInsideInlineClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/companionObjectInsideInlineClass.kt");
         }
 
         @TestMetadata("computablePropertiesInsideInlineClass.kt")
         public void testComputablePropertiesInsideInlineClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineClasses/computablePropertiesInsideInlineClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/computablePropertiesInsideInlineClass.kt");
         }
 
         @TestMetadata("noBridgesForErasedInlineClass.kt")
         public void testNoBridgesForErasedInlineClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineClasses/noBridgesForErasedInlineClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/noBridgesForErasedInlineClass.kt");
         }
 
         @TestMetadata("shapeOfInlineClassWithPrimitive.kt")
         public void testShapeOfInlineClassWithPrimitive() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineClasses/shapeOfInlineClassWithPrimitive.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/shapeOfInlineClassWithPrimitive.kt");
         }
 
         @TestMetadata("shapeOfInlineClassWithPrivateConstructor.kt")
         public void testShapeOfInlineClassWithPrivateConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/inlineClasses/shapeOfInlineClassWithPrivateConstructor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/shapeOfInlineClassWithPrivateConstructor.kt");
         }
     }
 
@@ -290,58 +267,59 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class SpecialBridges extends AbstractBytecodeListingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInSpecialBridges() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("contains.kt")
         public void testContains() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/contains.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/specialBridges/contains.kt");
         }
 
         @TestMetadata("noSpecialBridgeIfPresentInSuperClass.kt")
         public void testNoSpecialBridgeIfPresentInSuperClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/noSpecialBridgeIfPresentInSuperClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/specialBridges/noSpecialBridgeIfPresentInSuperClass.kt");
         }
 
         @TestMetadata("redundantStubForSize.kt")
         public void testRedundantStubForSize() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/redundantStubForSize.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/specialBridges/redundantStubForSize.kt");
         }
 
         @TestMetadata("removeAtTwoSpecialBridges.kt")
         public void testRemoveAtTwoSpecialBridges() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/removeAtTwoSpecialBridges.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/specialBridges/removeAtTwoSpecialBridges.kt");
         }
 
         @TestMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/signatures")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Signatures extends AbstractBytecodeListingTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInSignatures() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges/signatures"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("genericClass.kt")
             public void testGenericClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/signatures/genericClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/bytecodeListing/specialBridges/signatures/genericClass.kt");
             }
 
             @TestMetadata("nonGenericClass.kt")
             public void testNonGenericClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/signatures/nonGenericClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/bytecodeListing/specialBridges/signatures/nonGenericClass.kt");
             }
 
             @TestMetadata("partiallySpecializedClass.kt")
             public void testPartiallySpecializedClass() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/specialBridges/signatures/partiallySpecializedClass.kt");
-                doTest(fileName);
+                runTest("compiler/testData/codegen/bytecodeListing/specialBridges/signatures/partiallySpecializedClass.kt");
             }
         }
     }
@@ -350,38 +328,37 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Tailcall extends AbstractBytecodeListingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTailcall() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/tailcall"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("tailCallIntrinsics.kt")
         public void testTailCallIntrinsics() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt");
         }
 
         @TestMetadata("tailSuspendUnitFun.kt")
         public void testTailSuspendUnitFun() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt");
         }
 
         @TestMetadata("tryCatchTailCall.kt")
         public void testTryCatchTailCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt");
         }
 
         @TestMetadata("unreachable.kt")
         public void testUnreachable() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt");
         }
 
         @TestMetadata("whenUnit.kt")
         public void testWhenUnit() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt");
-            doTest(fileName);
+            runTest("compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/CheckLocalVariablesTableTestGenerated.java

@@ -21,103 +21,91 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CheckLocalVariablesTableTestGenerated extends AbstractCheckLocalVariablesTableTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInCheckLocalVariablesTable() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/checkLocalVariablesTable"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("catchClause.kt")
     public void testCatchClause() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/catchClause.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/catchClause.kt");
     }
 
     @TestMetadata("copyFunction.kt")
     public void testCopyFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/copyFunction.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/copyFunction.kt");
     }
 
     @TestMetadata("destructuringInLambdas.kt")
     public void testDestructuringInLambdas() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/destructuringInLambdas.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/destructuringInLambdas.kt");
     }
 
     @TestMetadata("destructuringInlineLambda.kt")
     public void testDestructuringInlineLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/destructuringInlineLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/destructuringInlineLambda.kt");
     }
 
     @TestMetadata("inlineLambdaWithItParam.kt")
     public void testInlineLambdaWithItParam() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/inlineLambdaWithItParam.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/inlineLambdaWithItParam.kt");
     }
 
     @TestMetadata("inlineLambdaWithParam.kt")
     public void testInlineLambdaWithParam() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/inlineLambdaWithParam.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/inlineLambdaWithParam.kt");
     }
 
     @TestMetadata("inlineProperty.kt")
     public void testInlineProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/inlineProperty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/inlineProperty.kt");
     }
 
     @TestMetadata("inlineSimple.kt")
     public void testInlineSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/inlineSimple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/inlineSimple.kt");
     }
 
     @TestMetadata("inlineSimpleChain.kt")
     public void testInlineSimpleChain() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/inlineSimpleChain.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/inlineSimpleChain.kt");
     }
 
     @TestMetadata("itInLambda.kt")
     public void testItInLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/itInLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/itInLambda.kt");
     }
 
     @TestMetadata("itInReturnedLambda.kt")
     public void testItInReturnedLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/itInReturnedLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/itInReturnedLambda.kt");
     }
 
     @TestMetadata("jvmOverloads.kt")
     public void testJvmOverloads() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/jvmOverloads.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/jvmOverloads.kt");
     }
 
     @TestMetadata("kt11117.kt")
     public void testKt11117() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/kt11117.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/kt11117.kt");
     }
 
     @TestMetadata("lambdaAsVar.kt")
     public void testLambdaAsVar() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/lambdaAsVar.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/lambdaAsVar.kt");
     }
 
     @TestMetadata("localFun.kt")
     public void testLocalFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/localFun.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/localFun.kt");
     }
 
     @TestMetadata("underscoreNames.kt")
     public void testUnderscoreNames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/checkLocalVariablesTable/underscoreNames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/checkLocalVariablesTable/underscoreNames.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java

@@ -21,271 +21,231 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotlinAgainstKotlinTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("annotationInInterface.kt")
     public void testAnnotationInInterface() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/annotationInInterface.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/annotationInInterface.kt");
     }
 
     @TestMetadata("annotationsOnTypeAliases.kt")
     public void testAnnotationsOnTypeAliases() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/annotationsOnTypeAliases.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/annotationsOnTypeAliases.kt");
     }
 
     @TestMetadata("callsToMultifileClassFromOtherPackage.kt")
     public void testCallsToMultifileClassFromOtherPackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt");
     }
 
     @TestMetadata("classInObject.kt")
     public void testClassInObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt");
     }
 
     @TestMetadata("companionObjectInEnum.kt")
     public void testCompanionObjectInEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/companionObjectInEnum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/companionObjectInEnum.kt");
     }
 
     @TestMetadata("companionObjectMember.kt")
     public void testCompanionObjectMember() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/companionObjectMember.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/companionObjectMember.kt");
     }
 
     @TestMetadata("constPropertyReferenceFromMultifileClass.kt")
     public void testConstPropertyReferenceFromMultifileClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/constPropertyReferenceFromMultifileClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/constPropertyReferenceFromMultifileClass.kt");
     }
 
     @TestMetadata("constructorVararg.kt")
     public void testConstructorVararg() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/constructorVararg.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/constructorVararg.kt");
     }
 
     @TestMetadata("copySamOnInline.kt")
     public void testCopySamOnInline() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline.kt");
     }
 
     @TestMetadata("copySamOnInline2.kt")
     public void testCopySamOnInline2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline2.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline2.kt");
     }
 
     @TestMetadata("coroutinesBinary.kt")
     public void testCoroutinesBinary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/coroutinesBinary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/coroutinesBinary.kt");
     }
 
     @TestMetadata("defaultConstructor.kt")
     public void testDefaultConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/defaultConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/defaultConstructor.kt");
     }
 
     @TestMetadata("defaultLambdaRegeneration.kt")
     public void testDefaultLambdaRegeneration() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration.kt");
     }
 
     @TestMetadata("defaultLambdaRegeneration2.kt")
     public void testDefaultLambdaRegeneration2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration2.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration2.kt");
     }
 
     @TestMetadata("doublyNestedClass.kt")
     public void testDoublyNestedClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/doublyNestedClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/doublyNestedClass.kt");
     }
 
     @TestMetadata("enum.kt")
     public void testEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/enum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/enum.kt");
     }
 
     @TestMetadata("inlinedConstants.kt")
     public void testInlinedConstants() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/inlinedConstants.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/inlinedConstants.kt");
     }
 
     @TestMetadata("innerClassConstructor.kt")
     public void testInnerClassConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/innerClassConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/innerClassConstructor.kt");
     }
 
     @TestMetadata("internalSetterOverridden.kt")
     public void testInternalSetterOverridden() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/internalSetterOverridden.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/internalSetterOverridden.kt");
     }
 
     @TestMetadata("jvmField.kt")
     public void testJvmField() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmField.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmField.kt");
     }
 
     @TestMetadata("jvmFieldInConstructor.kt")
     public void testJvmFieldInConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInConstructor.kt");
     }
 
     @TestMetadata("jvmNames.kt")
     public void testJvmNames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt");
     }
 
     @TestMetadata("jvmPackageName.kt")
     public void testJvmPackageName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmPackageName.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageName.kt");
     }
 
     @TestMetadata("jvmPackageNameInRootPackage.kt")
     public void testJvmPackageNameInRootPackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameInRootPackage.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameInRootPackage.kt");
     }
 
     @TestMetadata("jvmPackageNameWithJvmName.kt")
     public void testJvmPackageNameWithJvmName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameWithJvmName.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameWithJvmName.kt");
     }
 
     @TestMetadata("jvmStaticInObject.kt")
     public void testJvmStaticInObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/jvmStaticInObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/jvmStaticInObject.kt");
     }
 
     @TestMetadata("kotlinPropertyAsAnnotationParameter.kt")
     public void testKotlinPropertyAsAnnotationParameter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/kotlinPropertyAsAnnotationParameter.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/kotlinPropertyAsAnnotationParameter.kt");
     }
 
     @TestMetadata("kt14012.kt")
     public void testKt14012() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/kt14012.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/kt14012.kt");
     }
 
     @TestMetadata("kt14012_multi.kt")
     public void testKt14012_multi() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/kt14012_multi.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/kt14012_multi.kt");
     }
 
     @TestMetadata("multifileClassInlineFunctionAccessingProperty.kt")
     public void testMultifileClassInlineFunctionAccessingProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/multifileClassInlineFunctionAccessingProperty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/multifileClassInlineFunctionAccessingProperty.kt");
     }
 
     @TestMetadata("multifileClassWithTypealias.kt")
     public void testMultifileClassWithTypealias() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/multifileClassWithTypealias.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/multifileClassWithTypealias.kt");
     }
 
     @TestMetadata("nestedClass.kt")
     public void testNestedClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/nestedClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/nestedClass.kt");
     }
 
     @TestMetadata("nestedEnum.kt")
     public void testNestedEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/nestedEnum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/nestedEnum.kt");
     }
 
     @TestMetadata("nestedObject.kt")
     public void testNestedObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/nestedObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/nestedObject.kt");
     }
 
     @TestMetadata("platformTypes.kt")
     public void testPlatformTypes() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/platformTypes.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/platformTypes.kt");
     }
 
     @TestMetadata("propertyReference.kt")
     public void testPropertyReference() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/propertyReference.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/propertyReference.kt");
     }
 
     @TestMetadata("recursiveGeneric.kt")
     public void testRecursiveGeneric() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/recursiveGeneric.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/recursiveGeneric.kt");
     }
 
     @TestMetadata("sealedClass.kt")
     public void testSealedClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/sealedClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/sealedClass.kt");
     }
 
     @TestMetadata("secondaryConstructors.kt")
     public void testSecondaryConstructors() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/secondaryConstructors.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/secondaryConstructors.kt");
     }
 
     @TestMetadata("simple.kt")
     public void testSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/simple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/simple.kt");
     }
 
     @TestMetadata("simpleValAnonymousObject.kt")
     public void testSimpleValAnonymousObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/simpleValAnonymousObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/simpleValAnonymousObject.kt");
     }
 
     @TestMetadata("starImportEnum.kt")
     public void testStarImportEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/starImportEnum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/starImportEnum.kt");
     }
 
     @TestMetadata("targetedJvmName.kt")
     public void testTargetedJvmName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/targetedJvmName.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/targetedJvmName.kt");
     }
 
     @TestMetadata("typeAliasesKt13181.kt")
     public void testTypeAliasesKt13181() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstKotlin/typeAliasesKt13181.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstKotlin/typeAliasesKt13181.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/DumpDeclarationsTestGenerated.java

@@ -21,32 +21,32 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class DumpDeclarationsTestGenerated extends AbstractDumpDeclarationsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInDumpDeclarations() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/dumpDeclarations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("annotation.kt")
     public void testAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/annotation.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/annotation.kt");
     }
 
     @TestMetadata("classMembers.kt")
     public void testClassMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/classMembers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/classMembers.kt");
     }
 
     @TestMetadata("classes.kt")
     public void testClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/classes.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/classes.kt");
     }
 
     @TestMetadata("interfaces.kt")
     public void testInterfaces() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/interfaces.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/interfaces.kt");
     }
 
     @TestMetadata("intermediateAbstractSuspendFunction.kt")
@@ -57,31 +57,26 @@ public class DumpDeclarationsTestGenerated extends AbstractDumpDeclarationsTest
 
     @TestMetadata("localClasses.kt")
     public void testLocalClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/localClasses.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/localClasses.kt");
     }
 
     @TestMetadata("multifileFacadeMembers.kt")
     public void testMultifileFacadeMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/multifileFacadeMembers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/multifileFacadeMembers.kt");
     }
 
     @TestMetadata("suspendLambda.kt")
     public void testSuspendLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/suspendLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/suspendLambda.kt");
     }
 
     @TestMetadata("suspendOverride.kt")
     public void testSuspendOverride() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/suspendOverride.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/suspendOverride.kt");
     }
 
     @TestMetadata("topLevelMembers.kt")
     public void testTopLevelMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/dumpDeclarations/topLevelMembers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/dumpDeclarations/topLevelMembers.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/Kapt3BuilderModeBytecodeShapeTestGenerated.java

@@ -21,49 +21,46 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class Kapt3BuilderModeBytecodeShapeTestGenerated extends AbstractKapt3BuilderModeBytecodeShapeTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+    }
+
     public void testAllFilesPresentInKapt() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/kapt"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
     }
 
     @TestMetadata("dataClass.kt")
     public void testDataClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/dataClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/dataClass.kt");
     }
 
     @TestMetadata("errorTypes.kt")
     public void testErrorTypes() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/errorTypes.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/errorTypes.kt");
     }
 
     @TestMetadata("innerClasses.kt")
     public void testInnerClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/innerClasses.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/innerClasses.kt");
     }
 
     @TestMetadata("interfaceImpls.kt")
     public void testInterfaceImpls() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/interfaceImpls.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/interfaceImpls.kt");
     }
 
     @TestMetadata("jvmOverloads.kt")
     public void testJvmOverloads() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/jvmOverloads.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/jvmOverloads.kt");
     }
 
     @TestMetadata("lambdas.kt")
     public void testLambdas() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/lambdas.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/lambdas.kt");
     }
 
     @TestMetadata("simple.kt")
     public void testSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/kapt/simple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/kapt/simple.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/LineNumberTestGenerated.java

@@ -23,110 +23,97 @@ public class LineNumberTestGenerated extends AbstractLineNumberTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class LineNumber extends AbstractLineNumberTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInLineNumber() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/lineNumber"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, false);
         }
 
         @TestMetadata("anonymousFunction.kt")
         public void testAnonymousFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/anonymousFunction.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/anonymousFunction.kt");
         }
 
         @TestMetadata("class.kt")
         public void testClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/class.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/class.kt");
         }
 
         @TestMetadata("classObject.kt")
         public void testClassObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/classObject.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/classObject.kt");
         }
 
         @TestMetadata("defaultParameter.kt")
         public void testDefaultParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/defaultParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/defaultParameter.kt");
         }
 
         @TestMetadata("enum.kt")
         public void testEnum() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/enum.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/enum.kt");
         }
 
         @TestMetadata("for.kt")
         public void testFor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/for.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/for.kt");
         }
 
         @TestMetadata("if.kt")
         public void testIf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/if.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/if.kt");
         }
 
         @TestMetadata("inlineSimpleCall.kt")
         public void testInlineSimpleCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/inlineSimpleCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/inlineSimpleCall.kt");
         }
 
         @TestMetadata("localFunction.kt")
         public void testLocalFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/localFunction.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/localFunction.kt");
         }
 
         @TestMetadata("object.kt")
         public void testObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/object.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/object.kt");
         }
 
         @TestMetadata("propertyAccessor.kt")
         public void testPropertyAccessor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/propertyAccessor.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/propertyAccessor.kt");
         }
 
         @TestMetadata("psvm.kt")
         public void testPsvm() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/psvm.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/psvm.kt");
         }
 
         @TestMetadata("simpleSmap.kt")
         public void testSimpleSmap() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/simpleSmap.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/simpleSmap.kt");
         }
 
         @TestMetadata("topLevel.kt")
         public void testTopLevel() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/topLevel.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/topLevel.kt");
         }
 
         @TestMetadata("trait.kt")
         public void testTrait() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/trait.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/trait.kt");
         }
 
         @TestMetadata("tryCatch.kt")
         public void testTryCatch() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/tryCatch.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/tryCatch.kt");
         }
 
         @TestMetadata("while.kt")
         public void testWhile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/while.kt");
-            doTest(fileName);
+            runTest("compiler/testData/lineNumber/while.kt");
         }
     }
 
@@ -134,146 +121,127 @@ public class LineNumberTestGenerated extends AbstractLineNumberTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Custom extends AbstractLineNumberTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestCustom, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCustom() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/lineNumber/custom"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("beforeGotoToWhileStart.kt")
         public void testBeforeGotoToWhileStart() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/beforeGotoToWhileStart.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/beforeGotoToWhileStart.kt");
         }
 
         @TestMetadata("callWithCallInArguments.kt")
         public void testCallWithCallInArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/callWithCallInArguments.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/callWithCallInArguments.kt");
         }
 
         @TestMetadata("callWithReceiver.kt")
         public void testCallWithReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/callWithReceiver.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/callWithReceiver.kt");
         }
 
         @TestMetadata("chainCall.kt")
         public void testChainCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/chainCall.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/chainCall.kt");
         }
 
         @TestMetadata("compileTimeConstant.kt")
         public void testCompileTimeConstant() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/compileTimeConstant.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/compileTimeConstant.kt");
         }
 
         @TestMetadata("functionCallWithDefault.kt")
         public void testFunctionCallWithDefault() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/functionCallWithDefault.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/functionCallWithDefault.kt");
         }
 
         @TestMetadata("functionCallWithInlinedLambdaParam.kt")
         public void testFunctionCallWithInlinedLambdaParam() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/functionCallWithInlinedLambdaParam.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/functionCallWithInlinedLambdaParam.kt");
         }
 
         @TestMetadata("functionCallWithLambdaParam.kt")
         public void testFunctionCallWithLambdaParam() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/functionCallWithLambdaParam.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/functionCallWithLambdaParam.kt");
         }
 
         @TestMetadata("ifThen.kt")
         public void testIfThen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/ifThen.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/ifThen.kt");
         }
 
         @TestMetadata("ifThenElse.kt")
         public void testIfThenElse() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/ifThenElse.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/ifThenElse.kt");
         }
 
         @TestMetadata("inTheEndOfLambdaArgumentOfInlineCall.kt")
         public void testInTheEndOfLambdaArgumentOfInlineCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/inTheEndOfLambdaArgumentOfInlineCall.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/inTheEndOfLambdaArgumentOfInlineCall.kt");
         }
 
         @TestMetadata("multilineFunctionCall.kt")
         public void testMultilineFunctionCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/multilineFunctionCall.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/multilineFunctionCall.kt");
         }
 
         @TestMetadata("multilineInfixCall.kt")
         public void testMultilineInfixCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/multilineInfixCall.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/multilineInfixCall.kt");
         }
 
         @TestMetadata("noParametersArgumentCallInExpression.kt")
         public void testNoParametersArgumentCallInExpression() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/noParametersArgumentCallInExpression.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/noParametersArgumentCallInExpression.kt");
         }
 
         @TestMetadata("smapInlineAsArgument.kt")
         public void testSmapInlineAsArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/smapInlineAsArgument.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/smapInlineAsArgument.kt");
         }
 
         @TestMetadata("smapInlineAsInfixArgument.kt")
         public void testSmapInlineAsInfixArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/smapInlineAsInfixArgument.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/smapInlineAsInfixArgument.kt");
         }
 
         @TestMetadata("smapInlineAsInlineArgument.kt")
         public void testSmapInlineAsInlineArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/smapInlineAsInlineArgument.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/smapInlineAsInlineArgument.kt");
         }
 
         @TestMetadata("smapInlineInIntrinsicArgument.kt")
         public void testSmapInlineInIntrinsicArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/smapInlineInIntrinsicArgument.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/smapInlineInIntrinsicArgument.kt");
         }
 
         @TestMetadata("tryCatchExpression.kt")
         public void testTryCatchExpression() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/tryCatchExpression.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/tryCatchExpression.kt");
         }
 
         @TestMetadata("tryCatchFinally.kt")
         public void testTryCatchFinally() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/tryCatchFinally.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/tryCatchFinally.kt");
         }
 
         @TestMetadata("tryFinally.kt")
         public void testTryFinally() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/tryFinally.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/tryFinally.kt");
         }
 
         @TestMetadata("when.kt")
         public void testWhen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/when.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/when.kt");
         }
 
         @TestMetadata("whenSubject.kt")
         public void testWhenSubject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/lineNumber/custom/whenSubject.kt");
-            doTestCustom(fileName);
+            runTest("compiler/testData/lineNumber/custom/whenSubject.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/ScriptCodegenTestGenerated.java

@@ -21,10 +21,13 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ScriptCodegenTestGenerated extends AbstractScriptCodegenTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     @TestMetadata("adder.kts")
     public void testAdder() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/adder.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/adder.kts");
     }
 
     public void testAllFilesPresentInScript() throws Exception {
@@ -33,169 +36,141 @@ public class ScriptCodegenTestGenerated extends AbstractScriptCodegenTest {
 
     @TestMetadata("classLiteralInsideFunction.kts")
     public void testClassLiteralInsideFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/classLiteralInsideFunction.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/classLiteralInsideFunction.kts");
     }
 
     @TestMetadata("destructuringDeclaration.kts")
     public void testDestructuringDeclaration() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/destructuringDeclaration.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/destructuringDeclaration.kts");
     }
 
     @TestMetadata("destructuringDeclarationUnderscore.kts")
     public void testDestructuringDeclarationUnderscore() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/destructuringDeclarationUnderscore.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/destructuringDeclarationUnderscore.kts");
     }
 
     @TestMetadata("empty.kts")
     public void testEmpty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/empty.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/empty.kts");
     }
 
     @TestMetadata("helloWorld.kts")
     public void testHelloWorld() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/helloWorld.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/helloWorld.kts");
     }
 
     @TestMetadata("inline.kts")
     public void testInline() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/inline.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/inline.kts");
     }
 
     @TestMetadata("kt20707.kts")
     public void testKt20707() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/kt20707.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/kt20707.kts");
     }
 
     @TestMetadata("kt22029.kts")
     public void testKt22029() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/kt22029.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/kt22029.kts");
     }
 
     @TestMetadata("localDelegatedProperty.kts")
     public void testLocalDelegatedProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/localDelegatedProperty.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/localDelegatedProperty.kts");
     }
 
     @TestMetadata("localDelegatedPropertyNoExplicitType.kts")
     public void testLocalDelegatedPropertyNoExplicitType() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/localDelegatedPropertyNoExplicitType.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/localDelegatedPropertyNoExplicitType.kts");
     }
 
     @TestMetadata("localFunction.kts")
     public void testLocalFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/localFunction.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/localFunction.kts");
     }
 
     @TestMetadata("outerCapture.kts")
     public void testOuterCapture() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/outerCapture.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/outerCapture.kts");
     }
 
     @TestMetadata("parameter.kts")
     public void testParameter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/parameter.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/parameter.kts");
     }
 
     @TestMetadata("parameterArray.kts")
     public void testParameterArray() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/parameterArray.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/parameterArray.kts");
     }
 
     @TestMetadata("parameterClosure.kts")
     public void testParameterClosure() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/parameterClosure.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/parameterClosure.kts");
     }
 
     @TestMetadata("parameterLong.kts")
     public void testParameterLong() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/parameterLong.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/parameterLong.kts");
     }
 
     @TestMetadata("secondLevelFunction.kts")
     public void testSecondLevelFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/secondLevelFunction.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/secondLevelFunction.kts");
     }
 
     @TestMetadata("secondLevelFunctionClosure.kts")
     public void testSecondLevelFunctionClosure() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/secondLevelFunctionClosure.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/secondLevelFunctionClosure.kts");
     }
 
     @TestMetadata("secondLevelVal.kts")
     public void testSecondLevelVal() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/secondLevelVal.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/secondLevelVal.kts");
     }
 
     @TestMetadata("simpleClass.kts")
     public void testSimpleClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/simpleClass.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/simpleClass.kts");
     }
 
     @TestMetadata("string.kts")
     public void testString() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/string.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/string.kts");
     }
 
     @TestMetadata("topLevelFunction.kts")
     public void testTopLevelFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelFunction.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelFunction.kts");
     }
 
     @TestMetadata("topLevelFunctionClosure.kts")
     public void testTopLevelFunctionClosure() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelFunctionClosure.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelFunctionClosure.kts");
     }
 
     @TestMetadata("topLevelLocalDelegatedProperty.kts")
     public void testTopLevelLocalDelegatedProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelLocalDelegatedProperty.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelLocalDelegatedProperty.kts");
     }
 
     @TestMetadata("topLevelPropertiesWithGetSet.kts")
     public void testTopLevelPropertiesWithGetSet() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelPropertiesWithGetSet.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelPropertiesWithGetSet.kts");
     }
 
     @TestMetadata("topLevelProperty.kts")
     public void testTopLevelProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelProperty.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelProperty.kts");
     }
 
     @TestMetadata("topLevelPropertyWithProvideDelegate.kts")
     public void testTopLevelPropertyWithProvideDelegate() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelPropertyWithProvideDelegate.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelPropertyWithProvideDelegate.kts");
     }
 
     @TestMetadata("topLevelTypealias.kts")
     public void testTopLevelTypealias() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/script/topLevelTypealias.kts");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/script/topLevelTypealias.kts");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/TopLevelMembersInvocationTestGenerated.java

@@ -21,49 +21,46 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class TopLevelMembersInvocationTestGenerated extends AbstractTopLevelMembersInvocationTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInTopLevelMemberInvocation() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/topLevelMemberInvocation"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false);
     }
 
     @TestMetadata("extensionFunction")
     public void testExtensionFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/extensionFunction/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/extensionFunction/");
     }
 
     @TestMetadata("functionDifferentPackage")
     public void testFunctionDifferentPackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/functionDifferentPackage/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/functionDifferentPackage/");
     }
 
     @TestMetadata("functionInMultiFilePackage")
     public void testFunctionInMultiFilePackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/functionInMultiFilePackage/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/functionInMultiFilePackage/");
     }
 
     @TestMetadata("functionSamePackage")
     public void testFunctionSamePackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/functionSamePackage/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/functionSamePackage/");
     }
 
     @TestMetadata("property")
     public void testProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/property/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/property/");
     }
 
     @TestMetadata("propertyWithGetter")
     public void testPropertyWithGetter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/propertyWithGetter/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/propertyWithGetter/");
     }
 
     @TestMetadata("twoModules")
     public void testTwoModules() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/topLevelMemberInvocation/twoModules/");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/topLevelMemberInvocation/twoModules/");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/defaultConstructor/DefaultArgumentsReflectionTestGenerated.java

@@ -21,79 +21,71 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class DefaultArgumentsReflectionTestGenerated extends AbstractDefaultArgumentsReflectionTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInReflection() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/defaultArguments/reflection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("classInClassObject.kt")
     public void testClassInClassObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/classInClassObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/classInClassObject.kt");
     }
 
     @TestMetadata("classInObject.kt")
     public void testClassInObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/classInObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/classInObject.kt");
     }
 
     @TestMetadata("classWithTwoDefaultArgs.kt")
     public void testClassWithTwoDefaultArgs() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/classWithTwoDefaultArgs.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/classWithTwoDefaultArgs.kt");
     }
 
     @TestMetadata("classWithVararg.kt")
     public void testClassWithVararg() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/classWithVararg.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/classWithVararg.kt");
     }
 
     @TestMetadata("enum.kt")
     public void testEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/enum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/enum.kt");
     }
 
     @TestMetadata("internalClass.kt")
     public void testInternalClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/internalClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/internalClass.kt");
     }
 
     @TestMetadata("privateClass.kt")
     public void testPrivateClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/privateClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/privateClass.kt");
     }
 
     @TestMetadata("privateConstructor.kt")
     public void testPrivateConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/privateConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/privateConstructor.kt");
     }
 
     @TestMetadata("publicClass.kt")
     public void testPublicClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/publicClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/publicClass.kt");
     }
 
     @TestMetadata("publicClassWoDefArgs.kt")
     public void testPublicClassWoDefArgs() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/publicClassWoDefArgs.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/publicClassWoDefArgs.kt");
     }
 
     @TestMetadata("publicInnerClass.kt")
     public void testPublicInnerClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/publicInnerClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/publicInnerClass.kt");
     }
 
     @TestMetadata("publicInnerClassInPrivateClass.kt")
     public void testPublicInnerClassInPrivateClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/defaultArguments/reflection/publicInnerClassInPrivateClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/codegen/defaultArguments/reflection/publicInnerClassInPrivateClass.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/codegen/ir/IrOnlyBoxCodegenTestGenerated.java

@@ -21,106 +21,99 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class IrOnlyBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+    }
+
     public void testAllFilesPresentInBox() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/box"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
     }
 
     @TestMetadata("classInitializers.kt")
     public void testClassInitializers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/classInitializers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/classInitializers.kt");
     }
 
     @TestMetadata("enumClass.kt")
     public void testEnumClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/enumClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/enumClass.kt");
     }
 
     @TestMetadata("enumClass2.kt")
     public void testEnumClass2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/enumClass2.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/enumClass2.kt");
     }
 
     @TestMetadata("enumClass3.kt")
     public void testEnumClass3() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/enumClass3.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/enumClass3.kt");
     }
 
     @TestMetadata("fileClassInitializers.kt")
     public void testFileClassInitializers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/fileClassInitializers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/fileClassInitializers.kt");
     }
 
     @TestMetadata("objectClass.kt")
     public void testObjectClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/objectClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/objectClass.kt");
     }
 
     @TestMetadata("simple.kt")
     public void testSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/simple.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/box/simple.kt");
     }
 
     @TestMetadata("compiler/testData/ir/box/closureConversion")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ClosureConversion extends AbstractIrBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+        }
+
         public void testAllFilesPresentInClosureConversion() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/box/closureConversion"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("closureConversion1.kt")
         public void testClosureConversion1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/closureConversion1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/closureConversion1.kt");
         }
 
         @TestMetadata("closureConversion2.kt")
         public void testClosureConversion2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/closureConversion2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/closureConversion2.kt");
         }
 
         @TestMetadata("closureConversion3.kt")
         public void testClosureConversion3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/closureConversion3.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/closureConversion3.kt");
         }
 
         @TestMetadata("closureConversion4.kt")
         public void testClosureConversion4() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/closureConversion4.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/closureConversion4.kt");
         }
 
         @TestMetadata("innerClass1.kt")
         public void testInnerClass1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/innerClass1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/innerClass1.kt");
         }
 
         @TestMetadata("innerClass2.kt")
         public void testInnerClass2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/innerClass2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/innerClass2.kt");
         }
 
         @TestMetadata("mutable1.kt")
         public void testMutable1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/mutable1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/mutable1.kt");
         }
 
         @TestMetadata("mutablePrimitives.kt")
         public void testMutablePrimitives() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/closureConversion/mutablePrimitives.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/closureConversion/mutablePrimitives.kt");
         }
     }
 
@@ -128,32 +121,32 @@ public class IrOnlyBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class PrimitiveNumberComparisons extends AbstractIrBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+        }
+
         public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/box/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("comparableToDouble.kt")
         public void testComparableToDouble() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/primitiveNumberComparisons/comparableToDouble.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/primitiveNumberComparisons/comparableToDouble.kt");
         }
 
         @TestMetadata("doubleEqeq.kt")
         public void testDoubleEqeq() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/primitiveNumberComparisons/doubleEqeq.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/primitiveNumberComparisons/doubleEqeq.kt");
         }
 
         @TestMetadata("floatEqeq.kt")
         public void testFloatEqeq() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/primitiveNumberComparisons/floatEqeq.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/primitiveNumberComparisons/floatEqeq.kt");
         }
 
         @TestMetadata("mixedNumberTypes.kt")
         public void testMixedNumberTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/box/primitiveNumberComparisons/mixedNumberTypes.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/box/primitiveNumberComparisons/mixedNumberTypes.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java

@@ -21,10 +21,13 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AntTaskTestGenerated extends AbstractAntTaskTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     @TestMetadata("additionalArguments")
     public void testAdditionalArguments() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/additionalArguments/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/additionalArguments/");
     }
 
     public void testAllFilesPresentInJvm() throws Exception {
@@ -33,145 +36,121 @@ public class AntTaskTestGenerated extends AbstractAntTaskTest {
 
     @TestMetadata("doNotFailOnError")
     public void testDoNotFailOnError() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/doNotFailOnError/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/doNotFailOnError/");
     }
 
     @TestMetadata("failOnErrorByDefault")
     public void testFailOnErrorByDefault() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/failOnErrorByDefault/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/failOnErrorByDefault/");
     }
 
     @TestMetadata("helloWorld")
     public void testHelloWorld() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/helloWorld/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/helloWorld/");
     }
 
     @TestMetadata("internalMembers")
     public void testInternalMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/internalMembers/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/internalMembers/");
     }
 
     @TestMetadata("jvmClasspath")
     public void testJvmClasspath() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/jvmClasspath/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/jvmClasspath/");
     }
 
     @TestMetadata("kt11995")
     public void testKt11995() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/kt11995/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/kt11995/");
     }
 
     @TestMetadata("languageVersion")
     public void testLanguageVersion() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/languageVersion/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/languageVersion/");
     }
 
     @TestMetadata("mainInFiles")
     public void testMainInFiles() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/mainInFiles/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/mainInFiles/");
     }
 
     @TestMetadata("moduleName")
     public void testModuleName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/moduleName/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/moduleName/");
     }
 
     @TestMetadata("moduleNameDefault")
     public void testModuleNameDefault() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/moduleNameDefault/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/moduleNameDefault/");
     }
 
     @TestMetadata("moduleNameWithKotlin")
     public void testModuleNameWithKotlin() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/moduleNameWithKotlin/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/moduleNameWithKotlin/");
     }
 
     @TestMetadata("noReflectForJavac")
     public void testNoReflectForJavac() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/noReflectForJavac/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/noReflectForJavac/");
     }
 
     @TestMetadata("noStdlibForJavac")
     public void testNoStdlibForJavac() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/noStdlibForJavac/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/noStdlibForJavac/");
     }
 
     @TestMetadata("overloadResolutionOnCollectionLiteral")
     public void testOverloadResolutionOnCollectionLiteral() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/overloadResolutionOnCollectionLiteral/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/overloadResolutionOnCollectionLiteral/");
     }
 
     @TestMetadata("stdlibForJavacWithNoKotlin")
     public void testStdlibForJavacWithNoKotlin() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/stdlibForJavacWithNoKotlin/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/stdlibForJavacWithNoKotlin/");
     }
 
     @TestMetadata("stdlibJre78AndStdlibJdk78")
     public void testStdlibJre78AndStdlibJdk78() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/stdlibJre78AndStdlibJdk78/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/stdlibJre78AndStdlibJdk78/");
     }
 
     @TestMetadata("suppressWarnings")
     public void testSuppressWarnings() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/suppressWarnings/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/suppressWarnings/");
     }
 
     @TestMetadata("twoStdlibForCollectionLiterals")
     public void testTwoStdlibForCollectionLiterals() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/twoStdlibForCollectionLiterals/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/twoStdlibForCollectionLiterals/");
     }
 
     @TestMetadata("valWithInvoke")
     public void testValWithInvoke() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/valWithInvoke/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/valWithInvoke/");
     }
 
     @TestMetadata("verbose")
     public void testVerbose() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/verbose/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/verbose/");
     }
 
     @TestMetadata("version")
     public void testVersion() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/version/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/version/");
     }
 
     @TestMetadata("withKotlinFork")
     public void testWithKotlinFork() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/withKotlinFork/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/withKotlinFork/");
     }
 
     @TestMetadata("withKotlinNoJavaSources")
     public void testWithKotlinNoJavaSources() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/withKotlinNoJavaSources/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/withKotlinNoJavaSources/");
     }
 
     @TestMetadata("wrongCallForCollectionLiteral")
     public void testWrongCallForCollectionLiteral() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/wrongCallForCollectionLiteral/");
-        doTest(fileName);
+        runTest("compiler/testData/integration/ant/jvm/wrongCallForCollectionLiteral/");
     }
 }

compiler/tests/org/jetbrains/kotlin/ir/IrCfgTestCaseGenerated.java

@@ -21,70 +21,69 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class IrCfgTestCaseGenerated extends AbstractIrCfgTestCase {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInIrCfg() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irCfg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("expressionFun.kt")
     public void testExpressionFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/expressionFun.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/irCfg/expressionFun.kt");
     }
 
     @TestMetadata("expressionUnit.kt")
     public void testExpressionUnit() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/expressionUnit.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/irCfg/expressionUnit.kt");
     }
 
     @TestMetadata("returnUnit.kt")
     public void testReturnUnit() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/returnUnit.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/irCfg/returnUnit.kt");
     }
 
     @TestMetadata("sequentialFun.kt")
     public void testSequentialFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/sequentialFun.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/irCfg/sequentialFun.kt");
     }
 
     @TestMetadata("simpleFun.kt")
     public void testSimpleFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/simpleFun.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/irCfg/simpleFun.kt");
     }
 
     @TestMetadata("simpleReturn.kt")
     public void testSimpleReturn() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/simpleReturn.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/irCfg/simpleReturn.kt");
     }
 
     @TestMetadata("compiler/testData/ir/irCfg/loop")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Loop extends AbstractIrCfgTestCase {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInLoop() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irCfg/loop"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("digitCount.kt")
         public void testDigitCount() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/loop/digitCount.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/loop/digitCount.kt");
         }
 
         @TestMetadata("factorial.kt")
         public void testFactorial() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/loop/factorial.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/loop/factorial.kt");
         }
 
         @TestMetadata("isPerfect.kt")
         public void testIsPerfect() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/loop/isPerfect.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/loop/isPerfect.kt");
         }
     }
 
@@ -92,38 +91,37 @@ public class IrCfgTestCaseGenerated extends AbstractIrCfgTestCase {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class When extends AbstractIrCfgTestCase {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInWhen() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irCfg/when"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("cascadeIf.kt")
         public void testCascadeIf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/when/cascadeIf.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/when/cascadeIf.kt");
         }
 
         @TestMetadata("emptyWhen.kt")
         public void testEmptyWhen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/when/emptyWhen.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/when/emptyWhen.kt");
         }
 
         @TestMetadata("expressionIf.kt")
         public void testExpressionIf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/when/expressionIf.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/when/expressionIf.kt");
         }
 
         @TestMetadata("ifChain.kt")
         public void testIfChain() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/when/ifChain.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/when/ifChain.kt");
         }
 
         @TestMetadata("whenReturn.kt")
         public void testWhenReturn() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irCfg/when/whenReturn.kt");
-            doTest(fileName);
+            runTest("compiler/testData/ir/irCfg/when/whenReturn.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/ir/IrSourceRangesTestCaseGenerated.java

@@ -21,25 +21,26 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class IrSourceRangesTestCaseGenerated extends AbstractIrSourceRangesTestCase {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInSourceRanges() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/sourceRanges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("augmentedAssignmentWithExpression.kt")
     public void testAugmentedAssignmentWithExpression() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/sourceRanges/augmentedAssignmentWithExpression.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/sourceRanges/augmentedAssignmentWithExpression.kt");
     }
 
     @TestMetadata("kt17108.kt")
     public void testKt17108() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/sourceRanges/kt17108.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/sourceRanges/kt17108.kt");
     }
 
     @TestMetadata("synthesizedDataClassMembers.kt")
     public void testSynthesizedDataClassMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/sourceRanges/synthesizedDataClassMembers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/ir/sourceRanges/synthesizedDataClassMembers.kt");
     }
 }

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

@@ -21,16 +21,18 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlinAgainstJavaTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     @TestMetadata("AbstractClass.kt")
     public void testAbstractClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/AbstractClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/AbstractClass.kt");
     }
 
     @TestMetadata("AbstractEnum.kt")
     public void testAbstractEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/AbstractEnum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/AbstractEnum.kt");
     }
 
     public void testAllFilesPresentInCompileKotlinAgainstJava() throws Exception {
@@ -39,313 +41,261 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin
 
     @TestMetadata("AnnotationWithArguments.kt")
     public void testAnnotationWithArguments() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/AnnotationWithArguments.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/AnnotationWithArguments.kt");
     }
 
     @TestMetadata("AnnotationWithField.kt")
     public void testAnnotationWithField() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/AnnotationWithField.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/AnnotationWithField.kt");
     }
 
     @TestMetadata("AsteriskInImport.kt")
     public void testAsteriskInImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/AsteriskInImport.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/AsteriskInImport.kt");
     }
 
     @TestMetadata("CheckKotlinStub.kt")
     public void testCheckKotlinStub() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/CheckKotlinStub.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/CheckKotlinStub.kt");
     }
 
     @TestMetadata("CheckNotNull.kt")
     public void testCheckNotNull() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/CheckNotNull.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/CheckNotNull.kt");
     }
 
     @TestMetadata("Class.kt")
     public void testClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Class.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Class.kt");
     }
 
     @TestMetadata("ClassWithNestedEnum.kt")
     public void testClassWithNestedEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.kt");
     }
 
     @TestMetadata("ClassWithTypeParameter.kt")
     public void testClassWithTypeParameter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ClassWithTypeParameter.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ClassWithTypeParameter.kt");
     }
 
     @TestMetadata("CyclicDependencies.kt")
     public void testCyclicDependencies() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/CyclicDependencies.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/CyclicDependencies.kt");
     }
 
     @TestMetadata("DefaultModifier.kt")
     public void testDefaultModifier() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/DefaultModifier.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/DefaultModifier.kt");
     }
 
     @TestMetadata("EnclosingClassInner.kt")
     public void testEnclosingClassInner() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.kt");
     }
 
     @TestMetadata("Enum.kt")
     public void testEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Enum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Enum.kt");
     }
 
     @TestMetadata("EnumName.kt")
     public void testEnumName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/EnumName.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/EnumName.kt");
     }
 
     @TestMetadata("EnumValues.kt")
     public void testEnumValues() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/EnumValues.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/EnumValues.kt");
     }
 
     @TestMetadata("Inheritance.kt")
     public void testInheritance() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Inheritance.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Inheritance.kt");
     }
 
     @TestMetadata("InheritedInner.kt")
     public void testInheritedInner() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InheritedInner.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InheritedInner.kt");
     }
 
     @TestMetadata("InnerCanonicalName.kt")
     public void testInnerCanonicalName() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InnerCanonicalName.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InnerCanonicalName.kt");
     }
 
     @TestMetadata("InnerClass.kt")
     public void testInnerClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InnerClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InnerClass.kt");
     }
 
     @TestMetadata("InnerClassFromAsteriskImport.kt")
     public void testInnerClassFromAsteriskImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InnerClassFromAsteriskImport.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InnerClassFromAsteriskImport.kt");
     }
 
     @TestMetadata("InnerClassFromImport.kt")
     public void testInnerClassFromImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InnerClassFromImport.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InnerClassFromImport.kt");
     }
 
     @TestMetadata("InnerWithGenericOuter.kt")
     public void testInnerWithGenericOuter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.kt");
     }
 
     @TestMetadata("Interface.kt")
     public void testInterface() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Interface.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Interface.kt");
     }
 
     @TestMetadata("InterfaceField.kt")
     public void testInterfaceField() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InterfaceField.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InterfaceField.kt");
     }
 
     @TestMetadata("InterfaceMemberClass.kt")
     public void testInterfaceMemberClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InterfaceMemberClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InterfaceMemberClass.kt");
     }
 
     @TestMetadata("InterfaceWithDefault.kt")
     public void testInterfaceWithDefault() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InterfaceWithDefault.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/InterfaceWithDefault.kt");
     }
 
     @TestMetadata("JavaLangClass.kt")
     public void testJavaLangClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/JavaLangClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/JavaLangClass.kt");
     }
 
     @TestMetadata("ListImpl.kt")
     public void testListImpl() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ListImpl.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ListImpl.kt");
     }
 
     @TestMetadata("MapExample.kt")
     public void testMapExample() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/MapExample.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/MapExample.kt");
     }
 
     @TestMetadata("Method.kt")
     public void testMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Method.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Method.kt");
     }
 
     @TestMetadata("MethodWithArgument.kt")
     public void testMethodWithArgument() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/MethodWithArgument.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/MethodWithArgument.kt");
     }
 
     @TestMetadata("MethodWithSeveralTypeParameters.kt")
     public void testMethodWithSeveralTypeParameters() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/MethodWithSeveralTypeParameters.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/MethodWithSeveralTypeParameters.kt");
     }
 
     @TestMetadata("MethodWithTypeParameter.kt")
     public void testMethodWithTypeParameter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/MethodWithTypeParameter.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/MethodWithTypeParameter.kt");
     }
 
     @TestMetadata("MethodWithWildcard.kt")
     public void testMethodWithWildcard() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/MethodWithWildcard.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/MethodWithWildcard.kt");
     }
 
     @TestMetadata("Nesting.kt")
     public void testNesting() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Nesting.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Nesting.kt");
     }
 
     @TestMetadata("RawReturnType.kt")
     public void testRawReturnType() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/RawReturnType.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/RawReturnType.kt");
     }
 
     @TestMetadata("ReturnEnum.kt")
     public void testReturnEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnEnum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnEnum.kt");
     }
 
     @TestMetadata("ReturnInnerClass.kt")
     public void testReturnInnerClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnInnerClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnInnerClass.kt");
     }
 
     @TestMetadata("ReturnInnerInInner.kt")
     public void testReturnInnerInInner() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnInnerInInner.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnInnerInInner.kt");
     }
 
     @TestMetadata("ReturnInnerInner.kt")
     public void testReturnInnerInner() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnInnerInner.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnInnerInner.kt");
     }
 
     @TestMetadata("ReturnNested.kt")
     public void testReturnNested() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnNested.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnNested.kt");
     }
 
     @TestMetadata("ReturnNestedFQ.kt")
     public void testReturnNestedFQ() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnNestedFQ.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnNestedFQ.kt");
     }
 
     @TestMetadata("ReturnType.kt")
     public void testReturnType() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnType.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnType.kt");
     }
 
     @TestMetadata("ReturnTypeResolution.kt")
     public void testReturnTypeResolution() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ReturnTypeResolution.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/ReturnTypeResolution.kt");
     }
 
     @TestMetadata("SeveralInnerClasses.kt")
     public void testSeveralInnerClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/SeveralInnerClasses.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/SeveralInnerClasses.kt");
     }
 
     @TestMetadata("SimpleAnnotation.kt")
     public void testSimpleAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/SimpleAnnotation.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/SimpleAnnotation.kt");
     }
 
     @TestMetadata("SimpleWildcard.kt")
     public void testSimpleWildcard() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/SimpleWildcard.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/SimpleWildcard.kt");
     }
 
     @TestMetadata("Singleton.kt")
     public void testSingleton() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Singleton.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Singleton.kt");
     }
 
     @TestMetadata("StaticNestedClass.kt")
     public void testStaticNestedClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/StaticNestedClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/StaticNestedClass.kt");
     }
 
     @TestMetadata("TypeArgumentInSuperType.kt")
     public void testTypeArgumentInSuperType() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/TypeArgumentInSuperType.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/TypeArgumentInSuperType.kt");
     }
 
     @TestMetadata("TypeParameter.kt")
     public void testTypeParameter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/TypeParameter.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/TypeParameter.kt");
     }
 
     @TestMetadata("UseKtClass.kt")
     public void testUseKtClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/UseKtClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/UseKtClass.kt");
     }
 
     @TestMetadata("Vararg.kt")
     public void testVararg() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Vararg.kt");
-        doTest(fileName);
+        runTest("compiler/testData/compileKotlinAgainstJava/Vararg.kt");
     }
 }

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

@@ -21,172 +21,154 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInWriteSignature() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("ArrayOfCharSequence.kt")
     public void testArrayOfCharSequence() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/ArrayOfCharSequence.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/ArrayOfCharSequence.kt");
     }
 
     @TestMetadata("ArrayOfInt.kt")
     public void testArrayOfInt() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/ArrayOfInt.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/ArrayOfInt.kt");
     }
 
     @TestMetadata("backingFieldForGenericDelegated.kt")
     public void testBackingFieldForGenericDelegated() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/backingFieldForGenericDelegated.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/backingFieldForGenericDelegated.kt");
     }
 
     @TestMetadata("Comparable.kt")
     public void testComparable() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/Comparable.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/Comparable.kt");
     }
 
     @TestMetadata("DeepGenericInnerClass.kt")
     public void testDeepGenericInnerClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/DeepGenericInnerClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/DeepGenericInnerClass.kt");
     }
 
     @TestMetadata("GenericInnerClass.kt")
     public void testGenericInnerClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/GenericInnerClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/GenericInnerClass.kt");
     }
 
     @TestMetadata("GenericInnerClassWithSimpleOuter.kt")
     public void testGenericInnerClassWithSimpleOuter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt");
     }
 
     @TestMetadata("Int.kt")
     public void testInt() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/Int.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/Int.kt");
     }
 
     @TestMetadata("IntArray.kt")
     public void testIntArray() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/IntArray.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/IntArray.kt");
     }
 
     @TestMetadata("IntQ.kt")
     public void testIntQ() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/IntQ.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/IntQ.kt");
     }
 
     @TestMetadata("jlString.kt")
     public void testJlString() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/jlString.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/jlString.kt");
     }
 
     @TestMetadata("ListOfCharSequence.kt")
     public void testListOfCharSequence() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/ListOfCharSequence.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/ListOfCharSequence.kt");
     }
 
     @TestMetadata("ListOfStar.kt")
     public void testListOfStar() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/ListOfStar.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/ListOfStar.kt");
     }
 
     @TestMetadata("MapEntry.kt")
     public void testMapEntry() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/MapEntry.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/MapEntry.kt");
     }
 
     @TestMetadata("MutableMapEntry.kt")
     public void testMutableMapEntry() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/MutableMapEntry.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/MutableMapEntry.kt");
     }
 
     @TestMetadata("NonGeneric.kt")
     public void testNonGeneric() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/NonGeneric.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/NonGeneric.kt");
     }
 
     @TestMetadata("StarProjectionInClass.kt")
     public void testStarProjectionInClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/StarProjectionInClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/StarProjectionInClass.kt");
     }
 
     @TestMetadata("StarProjectionInSuper.kt")
     public void testStarProjectionInSuper() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/StarProjectionInSuper.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/StarProjectionInSuper.kt");
     }
 
     @TestMetadata("StarProjectionOutsideClass.kt")
     public void testStarProjectionOutsideClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/StarProjectionOutsideClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/StarProjectionOutsideClass.kt");
     }
 
     @TestMetadata("syntheticAccessorForGeneric.kt")
     public void testSyntheticAccessorForGeneric() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/syntheticAccessorForGeneric.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/syntheticAccessorForGeneric.kt");
     }
 
     @TestMetadata("VarargCharSequence.kt")
     public void testVarargCharSequence() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/VarargCharSequence.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/VarargCharSequence.kt");
     }
 
     @TestMetadata("VarargGeneric.kt")
     public void testVarargGeneric() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/VarargGeneric.kt");
-        doTest(fileName);
+        runTest("compiler/testData/writeSignature/VarargGeneric.kt");
     }
 
     @TestMetadata("compiler/testData/writeSignature/annotations")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Annotations extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInAnnotations() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("kArrayClassOfJClass.kt")
         public void testKArrayClassOfJClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/annotations/kArrayClassOfJClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/annotations/kArrayClassOfJClass.kt");
         }
 
         @TestMetadata("kArrayClassOfKClass.kt")
         public void testKArrayClassOfKClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/annotations/kArrayClassOfKClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/annotations/kArrayClassOfKClass.kt");
         }
 
         @TestMetadata("kClassBasic.kt")
         public void testKClassBasic() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/annotations/kClassBasic.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/annotations/kClassBasic.kt");
         }
 
         @TestMetadata("kClassInt.kt")
         public void testKClassInt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/annotations/kClassInt.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/annotations/kClassInt.kt");
         }
     }
 
@@ -194,26 +176,27 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CallableReference extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCallableReference() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("constructorReferenceInReturnType.kt")
         public void testConstructorReferenceInReturnType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/callableReference/constructorReferenceInReturnType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/callableReference/constructorReferenceInReturnType.kt");
         }
 
         @TestMetadata("functionReferenceInvoke.kt")
         public void testFunctionReferenceInvoke() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/callableReference/functionReferenceInvoke.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/callableReference/functionReferenceInvoke.kt");
         }
 
         @TestMetadata("propertyReferenceGet.kt")
         public void testPropertyReferenceGet() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/callableReference/propertyReferenceGet.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/callableReference/propertyReferenceGet.kt");
         }
     }
 
@@ -221,32 +204,32 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Constructor extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInConstructor() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/constructor"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("Constructor0.kt")
         public void testConstructor0() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/constructor/Constructor0.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/constructor/Constructor0.kt");
         }
 
         @TestMetadata("ConstructorCollectionParameter.kt")
         public void testConstructorCollectionParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/constructor/ConstructorCollectionParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/constructor/ConstructorCollectionParameter.kt");
         }
 
         @TestMetadata("ConstructorWithTypeParameter.kt")
         public void testConstructorWithTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/constructor/ConstructorWithTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/constructor/ConstructorWithTypeParameter.kt");
         }
 
         @TestMetadata("ConstructorWithTypeParameterAndValueParameterP.kt")
         public void testConstructorWithTypeParameterAndValueParameterP() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/constructor/ConstructorWithTypeParameterAndValueParameterP.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/constructor/ConstructorWithTypeParameterAndValueParameterP.kt");
         }
     }
 
@@ -254,196 +237,174 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DeclarationSiteVariance extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDeclarationSiteVariance() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("FunctionTwoTypeParameters.kt")
         public void testFunctionTwoTypeParameters() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/FunctionTwoTypeParameters.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/FunctionTwoTypeParameters.kt");
         }
 
         @TestMetadata("GenericOverrides.kt")
         public void testGenericOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt");
         }
 
         @TestMetadata("InInInPosition.kt")
         public void testInInInPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InInInPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/InInInPosition.kt");
         }
 
         @TestMetadata("InInOutPosition.kt")
         public void testInInOutPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InInOutPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/InInOutPosition.kt");
         }
 
         @TestMetadata("InOfInInInPosition.kt")
         public void testInOfInInInPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InOfInInInPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/InOfInInInPosition.kt");
         }
 
         @TestMetadata("InOfInInOutPosition.kt")
         public void testInOfInInOutPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InOfInInOutPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/InOfInInOutPosition.kt");
         }
 
         @TestMetadata("InOfOutInInPosition.kt")
         public void testInOfOutInInPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InOfOutInInPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/InOfOutInInPosition.kt");
         }
 
         @TestMetadata("InOfOutInOutPosition.kt")
         public void testInOfOutInOutPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InOfOutInOutPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/InOfOutInOutPosition.kt");
         }
 
         @TestMetadata("MappedSupertypeWithVariance.kt")
         public void testMappedSupertypeWithVariance() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/MappedSupertypeWithVariance.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/MappedSupertypeWithVariance.kt");
         }
 
         @TestMetadata("OpenMembersReturnType.kt")
         public void testOpenMembersReturnType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt");
         }
 
         @TestMetadata("OpenMembersValueParameter.kt")
         public void testOpenMembersValueParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt");
         }
 
         @TestMetadata("OutInField.kt")
         public void testOutInField() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutInField.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutInField.kt");
         }
 
         @TestMetadata("OutInInPosition.kt")
         public void testOutInInPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutInInPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutInInPosition.kt");
         }
 
         @TestMetadata("OutInOutPosition.kt")
         public void testOutInOutPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutInOutPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutInOutPosition.kt");
         }
 
         @TestMetadata("OutOfInInInPosition.kt")
         public void testOutOfInInInPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutOfInInInPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutOfInInInPosition.kt");
         }
 
         @TestMetadata("OutOfInInOutPosition.kt")
         public void testOutOfInInOutPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutOfInInOutPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutOfInInOutPosition.kt");
         }
 
         @TestMetadata("OutOfOutInInPosition.kt")
         public void testOutOfOutInInPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInInPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInInPosition.kt");
         }
 
         @TestMetadata("OutOfOutInOutPosition.kt")
         public void testOutOfOutInOutPosition() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInOutPosition.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInOutPosition.kt");
         }
 
         @TestMetadata("PropertyGetterIn.kt")
         public void testPropertyGetterIn() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/PropertyGetterIn.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/PropertyGetterIn.kt");
         }
 
         @TestMetadata("PropertyGetterOut.kt")
         public void testPropertyGetterOut() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/PropertyGetterOut.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/PropertyGetterOut.kt");
         }
 
         @TestMetadata("PropertyGetterTwoParams.kt")
         public void testPropertyGetterTwoParams() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/PropertyGetterTwoParams.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/PropertyGetterTwoParams.kt");
         }
 
         @TestMetadata("PropertySetterIn.kt")
         public void testPropertySetterIn() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/PropertySetterIn.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/PropertySetterIn.kt");
         }
 
         @TestMetadata("PropertySetterOut.kt")
         public void testPropertySetterOut() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/PropertySetterOut.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/PropertySetterOut.kt");
         }
 
         @TestMetadata("RedundantProjections.kt")
         public void testRedundantProjections() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/RedundantProjections.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/RedundantProjections.kt");
         }
 
         @TestMetadata("SuperClassWithVariance.kt")
         public void testSuperClassWithVariance() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/SuperClassWithVariance.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/SuperClassWithVariance.kt");
         }
 
         @TestMetadata("SuperTraitWithVariance.kt")
         public void testSuperTraitWithVariance() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/SuperTraitWithVariance.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/SuperTraitWithVariance.kt");
         }
 
         @TestMetadata("SuperTypeWithVarianceInArguments.kt")
         public void testSuperTypeWithVarianceInArguments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/SuperTypeWithVarianceInArguments.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/declarationSiteVariance/SuperTypeWithVarianceInArguments.kt");
         }
 
         @TestMetadata("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class JvmWildcardAnnotations extends AbstractWriteSignatureTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInJvmWildcardAnnotations() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("onFunction.kt")
             public void testOnFunction() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations/onFunction.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations/onFunction.kt");
             }
 
             @TestMetadata("onTypes.kt")
             public void testOnTypes() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations/onTypes.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations/onTypes.kt");
             }
 
             @TestMetadata("primitiveTypes.kt")
             public void testPrimitiveTypes() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations/primitiveTypes.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations/primitiveTypes.kt");
             }
         }
 
@@ -451,74 +412,67 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class WildcardOptimization extends AbstractWriteSignatureTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInWildcardOptimization() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("argumentOverridability.kt")
             public void testArgumentOverridability() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt");
             }
 
             @TestMetadata("arrays.kt")
             public void testArrays() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt");
             }
 
             @TestMetadata("complicatedInBounds.kt")
             public void testComplicatedInBounds() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt");
             }
 
             @TestMetadata("deepOut.kt")
             public void testDeepOut() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt");
             }
 
             @TestMetadata("fields.kt")
             public void testFields() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/fields.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/fields.kt");
             }
 
             @TestMetadata("finalReturnType.kt")
             public void testFinalReturnType() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt");
             }
 
             @TestMetadata("outIn.kt")
             public void testOutIn() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt");
             }
 
             @TestMetadata("outInv.kt")
             public void testOutInv() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt");
             }
 
             @TestMetadata("topLevelIn.kt")
             public void testTopLevelIn() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt");
             }
 
             @TestMetadata("topLevelInv.kt")
             public void testTopLevelInv() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt");
             }
 
             @TestMetadata("typeParameter.kt")
             public void testTypeParameter() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt");
-                doTest(fileName);
+                runTest("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt");
             }
         }
     }
@@ -527,26 +481,27 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DefaultImpls extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDefaultImpls() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/defaultImpls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("functionTypeParameterClash.kt")
         public void testFunctionTypeParameterClash() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/defaultImpls/functionTypeParameterClash.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/defaultImpls/functionTypeParameterClash.kt");
         }
 
         @TestMetadata("functionTypeParameterClashWith_I.kt")
         public void testFunctionTypeParameterClashWith_I() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/defaultImpls/functionTypeParameterClashWith_I.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/defaultImpls/functionTypeParameterClashWith_I.kt");
         }
 
         @TestMetadata("propertyTypeParameterClash.kt")
         public void testPropertyTypeParameterClash() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/defaultImpls/propertyTypeParameterClash.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/defaultImpls/propertyTypeParameterClash.kt");
         }
     }
 
@@ -554,74 +509,67 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class InlineClasses extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInInlineClasses() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("basicInlineClassDeclarationCodegen.kt")
         public void testBasicInlineClassDeclarationCodegen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/basicInlineClassDeclarationCodegen.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/basicInlineClassDeclarationCodegen.kt");
         }
 
         @TestMetadata("genericInlineClassBasedOnGenericType.kt")
         public void testGenericInlineClassBasedOnGenericType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/genericInlineClassBasedOnGenericType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/genericInlineClassBasedOnGenericType.kt");
         }
 
         @TestMetadata("genericInlineClassWithDefaultTypeParameter.kt")
         public void testGenericInlineClassWithDefaultTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/genericInlineClassWithDefaultTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/genericInlineClassWithDefaultTypeParameter.kt");
         }
 
         @TestMetadata("genericInlineClassWithNotNullTypeParameter.kt")
         public void testGenericInlineClassWithNotNullTypeParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/genericInlineClassWithNotNullTypeParameter.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/genericInlineClassWithNotNullTypeParameter.kt");
         }
 
         @TestMetadata("inlineClassAsGenericArgument.kt")
         public void testInlineClassAsGenericArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/inlineClassAsGenericArgument.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/inlineClassAsGenericArgument.kt");
         }
 
         @TestMetadata("inlineClassBasedOnOtherInlineClass.kt")
         public void testInlineClassBasedOnOtherInlineClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/inlineClassBasedOnOtherInlineClass.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/inlineClassBasedOnOtherInlineClass.kt");
         }
 
         @TestMetadata("inlineClassWithComplexSubstitutedType.kt")
         public void testInlineClassWithComplexSubstitutedType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/inlineClassWithComplexSubstitutedType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/inlineClassWithComplexSubstitutedType.kt");
         }
 
         @TestMetadata("inlineClassesInsideFunctionalTypes.kt")
         public void testInlineClassesInsideFunctionalTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/inlineClassesInsideFunctionalTypes.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/inlineClassesInsideFunctionalTypes.kt");
         }
 
         @TestMetadata("nullableInlineClassType.kt")
         public void testNullableInlineClassType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/nullableInlineClassType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/nullableInlineClassType.kt");
         }
 
         @TestMetadata("simpleSignatureWithInlineClassTypesAsPrimitive.kt")
         public void testSimpleSignatureWithInlineClassTypesAsPrimitive() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/simpleSignatureWithInlineClassTypesAsPrimitive.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/simpleSignatureWithInlineClassTypesAsPrimitive.kt");
         }
 
         @TestMetadata("simpleSignatureWithInlineClassTypesAsReference.kt")
         public void testSimpleSignatureWithInlineClassTypesAsReference() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/inlineClasses/simpleSignatureWithInlineClassTypesAsReference.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/inlineClasses/simpleSignatureWithInlineClassTypesAsReference.kt");
         }
     }
 
@@ -629,20 +577,22 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Nothing extends AbstractWriteSignatureTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInNothing() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/nothing"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("nothing.kt")
         public void testNothing() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/nothing/nothing.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/nothing/nothing.kt");
         }
 
         @TestMetadata("nullableNothing.kt")
         public void testNullableNothing() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/nothing/nullableNothing.kt");
-            doTest(fileName);
+            runTest("compiler/testData/writeSignature/nothing/nullableNothing.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/kdoc/KDocLexerTestGenerated.java

@@ -21,13 +21,16 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class KDocLexerTestGenerated extends AbstractKDocLexerTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInLexer() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/kdoc/lexer"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("codeBlocks.kt")
     public void testCodeBlocks() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/kdoc/lexer/codeBlocks.kt");
-        doTest(fileName);
+        runTest("compiler/testData/kdoc/lexer/codeBlocks.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/modules/xml/ModuleXmlParserTestGenerated.java

@@ -21,55 +21,51 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ModuleXmlParserTestGenerated extends AbstractModuleXmlParserTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInModules_xml() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/modules.xml"), Pattern.compile("^(.+)\\.xml$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("allOnce.xml")
     public void testAllOnce() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/allOnce.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/allOnce.xml");
     }
 
     @TestMetadata("comments.xml")
     public void testComments() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/comments.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/comments.xml");
     }
 
     @TestMetadata("empty.xml")
     public void testEmpty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/empty.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/empty.xml");
     }
 
     @TestMetadata("emptyModule.xml")
     public void testEmptyModule() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/emptyModule.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/emptyModule.xml");
     }
 
     @TestMetadata("manyTimes.xml")
     public void testManyTimes() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/manyTimes.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/manyTimes.xml");
     }
 
     @TestMetadata("onlySources.xml")
     public void testOnlySources() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/onlySources.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/onlySources.xml");
     }
 
     @TestMetadata("twoModules.xml")
     public void testTwoModules() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/twoModules.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/twoModules.xml");
     }
 
     @TestMetadata("typeTestModule.xml")
     public void testTypeTestModule() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/modules.xml/typeTestModule.xml");
-        doTest(fileName);
+        runTest("compiler/testData/modules.xml/typeTestModule.xml");
     }
 }

compiler/tests/org/jetbrains/kotlin/multiplatform/MultiPlatformIntegrationTestGenerated.java

@@ -21,172 +21,310 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatformIntegrationTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInMultiplatform() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("compatibleProperties")
     public void testCompatibleProperties() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/compatibleProperties/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/compatibleProperties/");
     }
 
     @TestMetadata("compilerArguments")
     public void testCompilerArguments() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/compilerArguments/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/compilerArguments/");
     }
 
     @TestMetadata("createImplClassInPlatformModule")
     public void testCreateImplClassInPlatformModule() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/createImplClassInPlatformModule/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/createImplClassInPlatformModule/");
     }
 
     @TestMetadata("explicitActualOnOverrideOfAbstractMethod")
     public void testExplicitActualOnOverrideOfAbstractMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/");
     }
 
     @TestMetadata("genericDeclarations")
     public void testGenericDeclarations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/genericDeclarations/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/genericDeclarations/");
     }
 
     @TestMetadata("incompatibleCallables")
     public void testIncompatibleCallables() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/incompatibleCallables/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/incompatibleCallables/");
     }
 
     @TestMetadata("incompatibleClasses")
     public void testIncompatibleClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/incompatibleClasses/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/incompatibleClasses/");
     }
 
     @TestMetadata("incompatibleFunctions")
     public void testIncompatibleFunctions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/incompatibleFunctions/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/incompatibleFunctions/");
     }
 
     @TestMetadata("incompatibleNestedClasses")
     public void testIncompatibleNestedClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/incompatibleNestedClasses/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/incompatibleNestedClasses/");
     }
 
     @TestMetadata("incompatibleProperties")
     public void testIncompatibleProperties() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/incompatibleProperties/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/incompatibleProperties/");
     }
 
     @TestMetadata("incorrectImplInClass")
     public void testIncorrectImplInClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/incorrectImplInClass/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/incorrectImplInClass/");
     }
 
     @TestMetadata("jsNameClash")
     public void testJsNameClash() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/jsNameClash/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/jsNameClash/");
     }
 
     @TestMetadata("jvmMultifileClass")
     public void testJvmMultifileClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/jvmMultifileClass/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/jvmMultifileClass/");
     }
 
     @TestMetadata("missingOverload")
     public void testMissingOverload() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/missingOverload/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/missingOverload/");
     }
 
     @TestMetadata("simple")
     public void testSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/simple/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/simple/");
     }
 
     @TestMetadata("simpleNoImplKeywordOnTopLevelFunction")
     public void testSimpleNoImplKeywordOnTopLevelFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/simpleNoImplKeywordOnTopLevelFunction/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/simpleNoImplKeywordOnTopLevelFunction/");
     }
 
     @TestMetadata("weakIncompatibilityWithoutActualModifier")
     public void testWeakIncompatibilityWithoutActualModifier() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/");
-        doTest(fileName);
+        runTest("compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/");
     }
 
     @TestMetadata("compiler/testData/multiplatform/classScopes")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ClassScopes extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInClassScopes() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("constructorIncorrectSignature")
         public void testConstructorIncorrectSignature() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/");
         }
 
         @TestMetadata("enumsWithDifferentEntries")
         public void testEnumsWithDifferentEntries() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/");
         }
 
         @TestMetadata("fakeOverrides")
         public void testFakeOverrides() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/fakeOverrides/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/fakeOverrides/");
         }
 
         @TestMetadata("functionAndPropertyWithSameName")
         public void testFunctionAndPropertyWithSameName() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/");
         }
 
         @TestMetadata("functionIncorrectSignature")
         public void testFunctionIncorrectSignature() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/functionIncorrectSignature/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/functionIncorrectSignature/");
         }
 
         @TestMetadata("functionIncorrectSignatureFromSuperclass")
         public void testFunctionIncorrectSignatureFromSuperclass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/");
         }
 
         @TestMetadata("missingConstructor")
         public void testMissingConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/missingConstructor/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/missingConstructor/");
         }
 
         @TestMetadata("missingFunction")
         public void testMissingFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/missingFunction/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/missingFunction/");
         }
 
         @TestMetadata("simple")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/classScopes/simple/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/classScopes/simple/");
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/constructorIncorrectSignature")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ConstructorIncorrectSignature extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInConstructorIncorrectSignature() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/constructorIncorrectSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class EnumsWithDifferentEntries extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInEnumsWithDifferentEntries() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/fakeOverrides")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class FakeOverrides extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInFakeOverrides() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/fakeOverrides"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class FunctionAndPropertyWithSameName extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInFunctionAndPropertyWithSameName() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/functionIncorrectSignature")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class FunctionIncorrectSignature extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInFunctionIncorrectSignature() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionIncorrectSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class FunctionIncorrectSignatureFromSuperclass extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInFunctionIncorrectSignatureFromSuperclass() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/missingConstructor")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class MissingConstructor extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInMissingConstructor() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/missingConstructor"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/missingFunction")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class MissingFunction extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInMissingFunction() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/missingFunction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/classScopes/simple")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Simple extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInSimple() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/classScopes/simple"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/compatibleProperties")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class CompatibleProperties extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInCompatibleProperties() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/compatibleProperties"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/compilerArguments")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class CompilerArguments extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInCompilerArguments() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/compilerArguments"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/createImplClassInPlatformModule")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class CreateImplClassInPlatformModule extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInCreateImplClassInPlatformModule() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/createImplClassInPlatformModule"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
     }
 
@@ -194,14 +332,56 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DefaultArguments extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDefaultArguments() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/defaultArguments"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("useDefaultArgumentsInDependency")
         public void testUseDefaultArgumentsInDependency() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/");
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class UseDefaultArgumentsInDependency extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInUseDefaultArgumentsInDependency() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class ExplicitActualOnOverrideOfAbstractMethod extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInExplicitActualOnOverrideOfAbstractMethod() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/genericDeclarations")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class GenericDeclarations extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInGenericDeclarations() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/genericDeclarations"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
     }
 
@@ -209,26 +389,183 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ImplTypeAlias extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInImplTypeAlias() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("discriminateHeaderClassInFavorOfTypeAlias")
         public void testDiscriminateHeaderClassInFavorOfTypeAlias() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/");
         }
 
         @TestMetadata("generic")
         public void testGeneric() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/implTypeAlias/generic/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/implTypeAlias/generic/");
         }
 
         @TestMetadata("nestedClassesViaTypeAlias")
         public void testNestedClassesViaTypeAlias() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/");
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class DiscriminateHeaderClassInFavorOfTypeAlias extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInDiscriminateHeaderClassInFavorOfTypeAlias() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/implTypeAlias/generic")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Generic extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInGeneric() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/generic"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class NestedClassesViaTypeAlias extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInNestedClassesViaTypeAlias() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/incompatibleCallables")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncompatibleCallables extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInIncompatibleCallables() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/incompatibleCallables"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/incompatibleClasses")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncompatibleClasses extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInIncompatibleClasses() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/incompatibleClasses"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/incompatibleFunctions")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncompatibleFunctions extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInIncompatibleFunctions() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/incompatibleFunctions"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/incompatibleNestedClasses")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncompatibleNestedClasses extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInIncompatibleNestedClasses() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/incompatibleNestedClasses"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/incompatibleProperties")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncompatibleProperties extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInIncompatibleProperties() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/incompatibleProperties"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/incorrectImplInClass")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncorrectImplInClass extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInIncorrectImplInClass() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/incorrectImplInClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/jsNameClash")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class JsNameClash extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInJsNameClash() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/jsNameClash"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/jvmMultifileClass")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class JvmMultifileClass extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInJvmMultifileClass() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/jvmMultifileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/missingOverload")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class MissingOverload extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInMissingOverload() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/missingOverload"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
     }
 
@@ -236,20 +573,87 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Regressions extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRegressions() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/regressions"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("incompatibleClassScopesWithImplTypeAlias")
         public void testIncompatibleClassScopesWithImplTypeAlias() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/");
         }
 
         @TestMetadata("kt17001")
         public void testKt17001() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/multiplatform/regressions/kt17001/");
-            doTest(fileName);
+            runTest("compiler/testData/multiplatform/regressions/kt17001/");
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class IncompatibleClassScopesWithImplTypeAlias extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInIncompatibleClassScopesWithImplTypeAlias() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("compiler/testData/multiplatform/regressions/kt17001")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Kt17001 extends AbstractMultiPlatformIntegrationTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInKt17001() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/regressions/kt17001"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            }
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/simple")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Simple extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInSimple() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/simple"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/simpleNoImplKeywordOnTopLevelFunction")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class SimpleNoImplKeywordOnTopLevelFunction extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInSimpleNoImplKeywordOnTopLevelFunction() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/simpleNoImplKeywordOnTopLevelFunction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+        }
+    }
+
+    @TestMetadata("compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class WeakIncompatibilityWithoutActualModifier extends AbstractMultiPlatformIntegrationTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInWeakIncompatibilityWithoutActualModifier() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/renderer/DescriptorRendererTestGenerated.java

@@ -21,91 +21,81 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class DescriptorRendererTestGenerated extends AbstractDescriptorRendererTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInRenderer() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/renderer"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("Classes.kt")
     public void testClasses() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/Classes.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/Classes.kt");
     }
 
     @TestMetadata("Enum.kt")
     public void testEnum() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/Enum.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/Enum.kt");
     }
 
     @TestMetadata("ErrorType.kt")
     public void testErrorType() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/ErrorType.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/ErrorType.kt");
     }
 
     @TestMetadata("FunctionTypes.kt")
     public void testFunctionTypes() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/FunctionTypes.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/FunctionTypes.kt");
     }
 
     @TestMetadata("FunctionTypesInSignature.kt")
     public void testFunctionTypesInSignature() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/FunctionTypesInSignature.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/FunctionTypesInSignature.kt");
     }
 
     @TestMetadata("GlobalFunctions.kt")
     public void testGlobalFunctions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/GlobalFunctions.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/GlobalFunctions.kt");
     }
 
     @TestMetadata("GlobalProperties.kt")
     public void testGlobalProperties() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/GlobalProperties.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/GlobalProperties.kt");
     }
 
     @TestMetadata("InheritedMembersVisibility.kt")
     public void testInheritedMembersVisibility() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/InheritedMembersVisibility.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/InheritedMembersVisibility.kt");
     }
 
     @TestMetadata("KeywordsInNames.kt")
     public void testKeywordsInNames() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/KeywordsInNames.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/KeywordsInNames.kt");
     }
 
     @TestMetadata("ObjectWithConstructor.kt")
     public void testObjectWithConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/ObjectWithConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/ObjectWithConstructor.kt");
     }
 
     @TestMetadata("StarProjection.kt")
     public void testStarProjection() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/StarProjection.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/StarProjection.kt");
     }
 
     @TestMetadata("TraitWithConstructor.kt")
     public void testTraitWithConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/TraitWithConstructor.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/TraitWithConstructor.kt");
     }
 
     @TestMetadata("TypeAnnotations.kt")
     public void testTypeAnnotations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/TypeAnnotations.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/TypeAnnotations.kt");
     }
 
     @TestMetadata("UnitType.kt")
     public void testUnitType() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderer/UnitType.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderer/UnitType.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/renderer/FunctionDescriptorInExpressionRendererTestGenerated.java

@@ -21,43 +21,41 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class FunctionDescriptorInExpressionRendererTestGenerated extends AbstractFunctionDescriptorInExpressionRendererTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInRenderFunctionDescriptorInExpression() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/renderFunctionDescriptorInExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("basicFunExpr.kt")
     public void testBasicFunExpr() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderFunctionDescriptorInExpression/basicFunExpr.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderFunctionDescriptorInExpression/basicFunExpr.kt");
     }
 
     @TestMetadata("basicFunExprArgs.kt")
     public void testBasicFunExprArgs() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderFunctionDescriptorInExpression/basicFunExprArgs.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderFunctionDescriptorInExpression/basicFunExprArgs.kt");
     }
 
     @TestMetadata("basicLambda.kt")
     public void testBasicLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderFunctionDescriptorInExpression/basicLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderFunctionDescriptorInExpression/basicLambda.kt");
     }
 
     @TestMetadata("labeledLambda.kt")
     public void testLabeledLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderFunctionDescriptorInExpression/labeledLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderFunctionDescriptorInExpression/labeledLambda.kt");
     }
 
     @TestMetadata("parenthesizedFunExpr.kt")
     public void testParenthesizedFunExpr() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderFunctionDescriptorInExpression/parenthesizedFunExpr.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderFunctionDescriptorInExpression/parenthesizedFunExpr.kt");
     }
 
     @TestMetadata("parenthesizedLambda.kt")
     public void testParenthesizedLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/renderFunctionDescriptorInExpression/parenthesizedLambda.kt");
-        doTest(fileName);
+        runTest("compiler/testData/renderFunctionDescriptorInExpression/parenthesizedLambda.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java

@@ -21,190 +21,169 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInRepl() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("analyzeErrors.repl")
     public void testAnalyzeErrors() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/analyzeErrors.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/analyzeErrors.repl");
     }
 
     @TestMetadata("constants.repl")
     public void testConstants() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/constants.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/constants.repl");
     }
 
     @TestMetadata("destructuringDeclaration.repl")
     public void testDestructuringDeclaration() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/destructuringDeclaration.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/destructuringDeclaration.repl");
     }
 
     @TestMetadata("empty.repl")
     public void testEmpty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/empty.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/empty.repl");
     }
 
     @TestMetadata("evaluationErrors.repl")
     public void testEvaluationErrors() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/evaluationErrors.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/evaluationErrors.repl");
     }
 
     @TestMetadata("exceptionInValueToString.repl")
     public void testExceptionInValueToString() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/exceptionInValueToString.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/exceptionInValueToString.repl");
     }
 
     @TestMetadata("exceptionInVariableInitializer.repl")
     public void testExceptionInVariableInitializer() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/exceptionInVariableInitializer.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/exceptionInVariableInitializer.repl");
     }
 
     @TestMetadata("function.repl")
     public void testFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/function.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/function.repl");
     }
 
     @TestMetadata("functionOverloadResolution.repl")
     public void testFunctionOverloadResolution() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/functionOverloadResolution.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/functionOverloadResolution.repl");
     }
 
     @TestMetadata("functionOverloadResolutionAnyBeatsString.repl")
     public void testFunctionOverloadResolutionAnyBeatsString() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/functionOverloadResolutionAnyBeatsString.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/functionOverloadResolutionAnyBeatsString.repl");
     }
 
     @TestMetadata("functionReferencesPrev.repl")
     public void testFunctionReferencesPrev() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/functionReferencesPrev.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/functionReferencesPrev.repl");
     }
 
     @TestMetadata("imports.repl")
     public void testImports() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/imports.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/imports.repl");
     }
 
     @TestMetadata("multipleImports.repl")
     public void testMultipleImports() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/multipleImports.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/multipleImports.repl");
     }
 
     @TestMetadata("noWarningsWithErrors.repl")
     public void testNoWarningsWithErrors() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/noWarningsWithErrors.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/noWarningsWithErrors.repl");
     }
 
     @TestMetadata("simple.repl")
     public void testSimple() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/simple.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/simple.repl");
     }
 
     @TestMetadata("simpleTwoVals.repl")
     public void testSimpleTwoVals() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/simpleTwoVals.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/simpleTwoVals.repl");
     }
 
     @TestMetadata("syntaxErrors.repl")
     public void testSyntaxErrors() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/syntaxErrors.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/syntaxErrors.repl");
     }
 
     @TestMetadata("topLevelLocalDelegatedProperty.repl")
     public void testTopLevelLocalDelegatedProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/topLevelLocalDelegatedProperty.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/topLevelLocalDelegatedProperty.repl");
     }
 
     @TestMetadata("twoClosures.repl")
     public void testTwoClosures() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/twoClosures.repl");
-        doTest(fileName);
+        runTest("compiler/testData/repl/twoClosures.repl");
     }
 
     @TestMetadata("compiler/testData/repl/classes")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Classes extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInClasses() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/classes"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("classInheritance.repl")
         public void testClassInheritance() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/classInheritance.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/classInheritance.repl");
         }
 
         @TestMetadata("classRedeclaration.repl")
         public void testClassRedeclaration() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/classRedeclaration.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/classRedeclaration.repl");
         }
 
         @TestMetadata("classReferencesVal.repl")
         public void testClassReferencesVal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/classReferencesVal.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/classReferencesVal.repl");
         }
 
         @TestMetadata("emptyClass.repl")
         public void testEmptyClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/emptyClass.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/emptyClass.repl");
         }
 
         @TestMetadata("emptyClassRedeclaration.repl")
         public void testEmptyClassRedeclaration() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/emptyClassRedeclaration.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/emptyClassRedeclaration.repl");
         }
 
         @TestMetadata("enumEntrySubclass.repl")
         public void testEnumEntrySubclass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/enumEntrySubclass.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/enumEntrySubclass.repl");
         }
 
         @TestMetadata("import.repl")
         public void testImport() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/import.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/import.repl");
         }
 
         @TestMetadata("simpleClass.repl")
         public void testSimpleClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/simpleClass.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/simpleClass.repl");
         }
 
         @TestMetadata("simpleEnum.repl")
         public void testSimpleEnum() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/simpleEnum.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/simpleEnum.repl");
         }
 
         @TestMetadata("simpleTrait.repl")
         public void testSimpleTrait() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/classes/simpleTrait.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/classes/simpleTrait.repl");
         }
     }
 
@@ -212,50 +191,47 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ControlFlow extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInControlFlow() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/controlFlow"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("functionWithoutReturn.repl")
         public void testFunctionWithoutReturn() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/functionWithoutReturn.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/functionWithoutReturn.repl");
         }
 
         @TestMetadata("incompleteIf.repl")
         public void testIncompleteIf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/incompleteIf.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/incompleteIf.repl");
         }
 
         @TestMetadata("incompleteWhen.repl")
         public void testIncompleteWhen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/incompleteWhen.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/incompleteWhen.repl");
         }
 
         @TestMetadata("kt15407.repl")
         public void testKt15407() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/kt15407.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/kt15407.repl");
         }
 
         @TestMetadata("loopWithWrongLabel.repl")
         public void testLoopWithWrongLabel() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/loopWithWrongLabel.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/loopWithWrongLabel.repl");
         }
 
         @TestMetadata("mutateVal.repl")
         public void testMutateVal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/mutateVal.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/mutateVal.repl");
         }
 
         @TestMetadata("useUninitializedVal.repl")
         public void testUseUninitializedVal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/controlFlow/useUninitializedVal.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/controlFlow/useUninitializedVal.repl");
         }
     }
 
@@ -263,14 +239,17 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Modules extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInModules() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/modules"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("kt10001.repl")
         public void testKt10001() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/modules/kt10001.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/modules/kt10001.repl");
         }
     }
 
@@ -278,38 +257,37 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Multiline extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInMultiline() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/multiline"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("blankLinesAndComments.repl")
         public void testBlankLinesAndComments() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/multiline/blankLinesAndComments.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/multiline/blankLinesAndComments.repl");
         }
 
         @TestMetadata("functionOnSeveralLines.repl")
         public void testFunctionOnSeveralLines() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/multiline/functionOnSeveralLines.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/multiline/functionOnSeveralLines.repl");
         }
 
         @TestMetadata("multilineFunctionInvocation.repl")
         public void testMultilineFunctionInvocation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/multiline/multilineFunctionInvocation.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/multiline/multilineFunctionInvocation.repl");
         }
 
         @TestMetadata("openParenthesisIncomplete.repl")
         public void testOpenParenthesisIncomplete() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/multiline/openParenthesisIncomplete.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/multiline/openParenthesisIncomplete.repl");
         }
 
         @TestMetadata("simpleFunctionBodyOnNextLine.repl")
         public void testSimpleFunctionBodyOnNextLine() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/multiline/simpleFunctionBodyOnNextLine.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/multiline/simpleFunctionBodyOnNextLine.repl");
         }
     }
 
@@ -317,26 +295,27 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Objects extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInObjects() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/objects"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("emptyObject.repl")
         public void testEmptyObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/objects/emptyObject.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/objects/emptyObject.repl");
         }
 
         @TestMetadata("localObject.repl")
         public void testLocalObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/objects/localObject.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/objects/localObject.repl");
         }
 
         @TestMetadata("simpleObjectDeclaration.repl")
         public void testSimpleObjectDeclaration() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/objects/simpleObjectDeclaration.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/objects/simpleObjectDeclaration.repl");
         }
     }
 
@@ -344,20 +323,22 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class PrimitiveTypes extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInPrimitiveTypes() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/primitiveTypes"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("arrayOfBoxed.repl")
         public void testArrayOfBoxed() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/primitiveTypes/arrayOfBoxed.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/primitiveTypes/arrayOfBoxed.repl");
         }
 
         @TestMetadata("boxingOnPurpose.repl")
         public void testBoxingOnPurpose() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/primitiveTypes/boxingOnPurpose.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/primitiveTypes/boxingOnPurpose.repl");
         }
     }
 
@@ -365,14 +346,17 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Regressions extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRegressions() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/regressions"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("kt6843.repl")
         public void testKt6843() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/regressions/kt6843.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/regressions/kt6843.repl");
         }
     }
 
@@ -380,14 +364,17 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class UseJava extends AbstractReplInterpreterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInUseJava() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/useJava"), Pattern.compile("^(.+)\\.repl$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("syntheticProperty.repl")
         public void testSyntheticProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/repl/useJava/syntheticProperty.repl");
-            doTest(fileName);
+            runTest("compiler/testData/repl/useJava/syntheticProperty.repl");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/ResolveTestGenerated.java

@@ -21,286 +21,249 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ResolveTestGenerated extends AbstractResolveTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInResolve() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("Basic.resolve")
     public void testBasic() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/Basic.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/Basic.resolve");
     }
 
     @TestMetadata("ClassObjects.resolve")
     public void testClassObjects() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ClassObjects.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ClassObjects.resolve");
     }
 
     @TestMetadata("Classifiers.resolve")
     public void testClassifiers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/Classifiers.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/Classifiers.resolve");
     }
 
     @TestMetadata("DefaultParamsOfLocalFunctions.resolve")
     public void testDefaultParamsOfLocalFunctions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/DefaultParamsOfLocalFunctions.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/DefaultParamsOfLocalFunctions.resolve");
     }
 
     @TestMetadata("ErrorSupertype.resolve")
     public void testErrorSupertype() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ErrorSupertype.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ErrorSupertype.resolve");
     }
 
     @TestMetadata("ExtensionFunctions.resolve")
     public void testExtensionFunctions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ExtensionFunctions.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ExtensionFunctions.resolve");
     }
 
     @TestMetadata("FunctionVariable.resolve")
     public void testFunctionVariable() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/FunctionVariable.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/FunctionVariable.resolve");
     }
 
     @TestMetadata("ImportFromRootScope.resolve")
     public void testImportFromRootScope() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ImportFromRootScope.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ImportFromRootScope.resolve");
     }
 
     @TestMetadata("ImportingRootScopeWhenProcessingImports.resolve")
     public void testImportingRootScopeWhenProcessingImports() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ImportingRootScopeWhenProcessingImports.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ImportingRootScopeWhenProcessingImports.resolve");
     }
 
     @TestMetadata("kt304.resolve")
     public void testKt304() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/kt304.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/kt304.resolve");
     }
 
     @TestMetadata("LocalObjects.resolve")
     public void testLocalObjects() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/LocalObjects.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/LocalObjects.resolve");
     }
 
     @TestMetadata("NestedObjects.resolve")
     public void testNestedObjects() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/NestedObjects.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/NestedObjects.resolve");
     }
 
     @TestMetadata("NoReferenceForErrorAnnotation.resolve")
     public void testNoReferenceForErrorAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/NoReferenceForErrorAnnotation.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/NoReferenceForErrorAnnotation.resolve");
     }
 
     @TestMetadata("Objects.resolve")
     public void testObjects() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/Objects.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/Objects.resolve");
     }
 
     @TestMetadata("Packages.resolve")
     public void testPackages() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/Packages.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/Packages.resolve");
     }
 
     @TestMetadata("PrimaryConstructorParameters.resolve")
     public void testPrimaryConstructorParameters() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/PrimaryConstructorParameters.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/PrimaryConstructorParameters.resolve");
     }
 
     @TestMetadata("PrimaryConstructors.resolve")
     public void testPrimaryConstructors() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/PrimaryConstructors.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/PrimaryConstructors.resolve");
     }
 
     @TestMetadata("Projections.resolve")
     public void testProjections() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/Projections.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/Projections.resolve");
     }
 
     @TestMetadata("PropertyAndFunctionNameClash.resolve")
     public void testPropertyAndFunctionNameClash() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/PropertyAndFunctionNameClash.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/PropertyAndFunctionNameClash.resolve");
     }
 
     @TestMetadata("ResolveOfInfixExpressions.resolve")
     public void testResolveOfInfixExpressions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ResolveOfInfixExpressions.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ResolveOfInfixExpressions.resolve");
     }
 
     @TestMetadata("ResolveToJava.resolve")
     public void testResolveToJava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ResolveToJava.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ResolveToJava.resolve");
     }
 
     @TestMetadata("ResolveToJava2.resolve")
     public void testResolveToJava2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ResolveToJava2.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ResolveToJava2.resolve");
     }
 
     @TestMetadata("ResolveToJava3.resolve")
     public void testResolveToJava3() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ResolveToJava3.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ResolveToJava3.resolve");
     }
 
     @TestMetadata("ResolveToJavaTypeTransform.resolve")
     public void testResolveToJavaTypeTransform() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ResolveToJavaTypeTransform.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ResolveToJavaTypeTransform.resolve");
     }
 
     @TestMetadata("ScopeInteraction.resolve")
     public void testScopeInteraction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/ScopeInteraction.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/ScopeInteraction.resolve");
     }
 
     @TestMetadata("StringTemplates.resolve")
     public void testStringTemplates() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/StringTemplates.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/StringTemplates.resolve");
     }
 
     @TestMetadata("Super.resolve")
     public void testSuper() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/Super.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/Super.resolve");
     }
 
     @TestMetadata("TryCatch.resolve")
     public void testTryCatch() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/TryCatch.resolve");
-        doTest(fileName);
+        runTest("compiler/testData/resolve/TryCatch.resolve");
     }
 
     @TestMetadata("compiler/testData/resolve/candidatesPriority")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CandidatesPriority extends AbstractResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInCandidatesPriority() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve/candidatesPriority"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("classObjectOuterResolve.resolve")
         public void testClassObjectOuterResolve() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve");
         }
 
         @TestMetadata("closerReceiver1.resolve")
         public void testCloserReceiver1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/closerReceiver1.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/closerReceiver1.resolve");
         }
 
         @TestMetadata("closerReceiver2.resolve")
         public void testCloserReceiver2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/closerReceiver2.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/closerReceiver2.resolve");
         }
 
         @TestMetadata("closerReceiver3.resolve")
         public void testCloserReceiver3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/closerReceiver3.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/closerReceiver3.resolve");
         }
 
         @TestMetadata("closerScope.resolve")
         public void testCloserScope() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/closerScope.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/closerScope.resolve");
         }
 
         @TestMetadata("dispatchReceiverVsExtensionReceiver.resolve")
         public void testDispatchReceiverVsExtensionReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/dispatchReceiverVsExtensionReceiver.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/dispatchReceiverVsExtensionReceiver.resolve");
         }
 
         @TestMetadata("dispatchReceiverVsExtensionReceiver2.resolve")
         public void testDispatchReceiverVsExtensionReceiver2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/dispatchReceiverVsExtensionReceiver2.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/dispatchReceiverVsExtensionReceiver2.resolve");
         }
 
         @TestMetadata("extensionToCloserReceiverVsMember.resolve")
         public void testExtensionToCloserReceiverVsMember() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/extensionToCloserReceiverVsMember.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/extensionToCloserReceiverVsMember.resolve");
         }
 
         @TestMetadata("implicitThisVsNoReceiver.resolve")
         public void testImplicitThisVsNoReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/implicitThisVsNoReceiver.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/implicitThisVsNoReceiver.resolve");
         }
 
         @TestMetadata("implicitThisVsNoReceiver2.resolve")
         public void testImplicitThisVsNoReceiver2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/implicitThisVsNoReceiver2.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/implicitThisVsNoReceiver2.resolve");
         }
 
         @TestMetadata("localVsImplicitThis.resolve")
         public void testLocalVsImplicitThis() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/localVsImplicitThis.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/localVsImplicitThis.resolve");
         }
 
         @TestMetadata("memberVsExtension1.resolve")
         public void testMemberVsExtension1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/memberVsExtension1.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/memberVsExtension1.resolve");
         }
 
         @TestMetadata("memberVsExtension2.resolve")
         public void testMemberVsExtension2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/memberVsExtension2.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/memberVsExtension2.resolve");
         }
 
         @TestMetadata("memberVsExtension3.resolve")
         public void testMemberVsExtension3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/memberVsExtension3.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/memberVsExtension3.resolve");
         }
 
         @TestMetadata("memberVsLocalExtension.resolve")
         public void testMemberVsLocalExtension() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/memberVsLocalExtension.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/memberVsLocalExtension.resolve");
         }
 
         @TestMetadata("memberWithInvokeVsNonLocal.resolve")
         public void testMemberWithInvokeVsNonLocal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/memberWithInvokeVsNonLocal.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/memberWithInvokeVsNonLocal.resolve");
         }
 
         @TestMetadata("wrongReceiverVsOtherError.resolve")
         public void testWrongReceiverVsOtherError() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/candidatesPriority/wrongReceiverVsOtherError.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/candidatesPriority/wrongReceiverVsOtherError.resolve");
         }
     }
 
@@ -308,50 +271,47 @@ public class ResolveTestGenerated extends AbstractResolveTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DelegatedProperty extends AbstractResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDelegatedProperty() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve/delegatedProperty"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("delegationByCall.resolve")
         public void testDelegationByCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/delegationByCall.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/delegationByCall.resolve");
         }
 
         @TestMetadata("delegationByConstructor.resolve")
         public void testDelegationByConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/delegationByConstructor.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/delegationByConstructor.resolve");
         }
 
         @TestMetadata("delegationByFun.resolve")
         public void testDelegationByFun() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/delegationByFun.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/delegationByFun.resolve");
         }
 
         @TestMetadata("delegationByObject.resolve")
         public void testDelegationByObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/delegationByObject.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/delegationByObject.resolve");
         }
 
         @TestMetadata("delegationByProperty.resolve")
         public void testDelegationByProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/delegationByProperty.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/delegationByProperty.resolve");
         }
 
         @TestMetadata("delegationInClass.resolve")
         public void testDelegationInClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/delegationInClass.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/delegationInClass.resolve");
         }
 
         @TestMetadata("localDelegation.resolve")
         public void testLocalDelegation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/delegatedProperty/localDelegation.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/delegatedProperty/localDelegation.resolve");
         }
     }
 
@@ -359,80 +319,72 @@ public class ResolveTestGenerated extends AbstractResolveTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Imports extends AbstractResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInImports() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve/imports"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("ImportConflictAllPackage.resolve")
         public void testImportConflictAllPackage() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictAllPackage.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictAllPackage.resolve");
         }
 
         @TestMetadata("ImportConflictBetweenImportedAndRootPackage.resolve")
         public void testImportConflictBetweenImportedAndRootPackage() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve");
         }
 
         @TestMetadata("ImportConflictBetweenImportedAndSamePackage.resolve")
         public void testImportConflictBetweenImportedAndSamePackage() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve");
         }
 
         @TestMetadata("ImportConflictForFunctions.resolve")
         public void testImportConflictForFunctions() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictForFunctions.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictForFunctions.resolve");
         }
 
         @TestMetadata("ImportConflictPackageAndClass.resolve")
         public void testImportConflictPackageAndClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve");
         }
 
         @TestMetadata("ImportConflictSameNameClass.resolve")
         public void testImportConflictSameNameClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve");
         }
 
         @TestMetadata("ImportConflictWithClassObject.resolve")
         public void testImportConflictWithClassObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve");
         }
 
         @TestMetadata("ImportConflictWithInFileClass.resolve")
         public void testImportConflictWithInFileClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve");
         }
 
         @TestMetadata("ImportConflictWithInnerClass.resolve")
         public void testImportConflictWithInnerClass() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve");
         }
 
         @TestMetadata("ImportConflictsWithMappedToJava.resolve")
         public void testImportConflictsWithMappedToJava() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve");
         }
 
         @TestMetadata("ImportNonBlockingAnalysis.resolve")
         public void testImportNonBlockingAnalysis() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve");
         }
 
         @TestMetadata("ImportResolveOrderStable.resolve")
         public void testImportResolveOrderStable() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/imports/ImportResolveOrderStable.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/imports/ImportResolveOrderStable.resolve");
         }
     }
 
@@ -440,20 +392,22 @@ public class ResolveTestGenerated extends AbstractResolveTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Labels extends AbstractResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInLabels() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve/labels"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("labelForPropertyInGetter.resolve")
         public void testLabelForPropertyInGetter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/labels/labelForPropertyInGetter.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/labels/labelForPropertyInGetter.resolve");
         }
 
         @TestMetadata("labelForPropertyInSetter.resolve")
         public void testLabelForPropertyInSetter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/labels/labelForPropertyInSetter.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/labels/labelForPropertyInSetter.resolve");
         }
     }
 
@@ -461,20 +415,22 @@ public class ResolveTestGenerated extends AbstractResolveTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Regressions extends AbstractResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRegressions() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve/regressions"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("kt300.resolve")
         public void testKt300() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/regressions/kt300.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/regressions/kt300.resolve");
         }
 
         @TestMetadata("objectInsideFun.resolve")
         public void testObjectInsideFun() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/regressions/objectInsideFun.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/regressions/objectInsideFun.resolve");
         }
     }
 
@@ -482,26 +438,27 @@ public class ResolveTestGenerated extends AbstractResolveTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Varargs extends AbstractResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInVarargs() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolve/varargs"), Pattern.compile("^(.+)\\.resolve$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("MoreSpecificVarargsOfEqualLength.resolve")
         public void testMoreSpecificVarargsOfEqualLength() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/varargs/MoreSpecificVarargsOfEqualLength.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/varargs/MoreSpecificVarargsOfEqualLength.resolve");
         }
 
         @TestMetadata("NilaryVsVararg.resolve")
         public void testNilaryVsVararg() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/varargs/NilaryVsVararg.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/varargs/NilaryVsVararg.resolve");
         }
 
         @TestMetadata("UnaryVsVararg.resolve")
         public void testUnaryVsVararg() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolve/varargs/UnaryVsVararg.resolve");
-            doTest(fileName);
+            runTest("compiler/testData/resolve/varargs/UnaryVsVararg.resolve");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationParameterTestGenerated.java

@@ -21,262 +21,229 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AnnotationParameterTestGenerated extends AbstractAnnotationParameterTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInParameters() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolveAnnotations/parameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("byte.kt")
     public void testByte() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/byte.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/byte.kt");
     }
 
     @TestMetadata("char.kt")
     public void testChar() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/char.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/char.kt");
     }
 
     @TestMetadata("double.kt")
     public void testDouble() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/double.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/double.kt");
     }
 
     @TestMetadata("float.kt")
     public void testFloat() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/float.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/float.kt");
     }
 
     @TestMetadata("int.kt")
     public void testInt() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/int.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/int.kt");
     }
 
     @TestMetadata("long.kt")
     public void testLong() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/long.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/long.kt");
     }
 
     @TestMetadata("short.kt")
     public void testShort() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/short.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveAnnotations/parameters/short.kt");
     }
 
     @TestMetadata("compiler/testData/resolveAnnotations/parameters/expressions")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Expressions extends AbstractAnnotationParameterTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInExpressions() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolveAnnotations/parameters/expressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("andAnd.kt")
         public void testAndAnd() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/andAnd.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/andAnd.kt");
         }
 
         @TestMetadata("boolean.kt")
         public void testBoolean() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/boolean.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/boolean.kt");
         }
 
         @TestMetadata("char.kt")
         public void testChar() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/char.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/char.kt");
         }
 
         @TestMetadata("compositeCallBinary.kt")
         public void testCompositeCallBinary() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/compositeCallBinary.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/compositeCallBinary.kt");
         }
 
         @TestMetadata("divide.kt")
         public void testDivide() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/divide.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/divide.kt");
         }
 
         @TestMetadata("double.kt")
         public void testDouble() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/double.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/double.kt");
         }
 
         @TestMetadata("eqeq.kt")
         public void testEqeq() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/eqeq.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/eqeq.kt");
         }
 
         @TestMetadata("escapedString.kt")
         public void testEscapedString() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/escapedString.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/escapedString.kt");
         }
 
         @TestMetadata("float.kt")
         public void testFloat() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/float.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/float.kt");
         }
 
         @TestMetadata("gt.kt")
         public void testGt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/gt.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/gt.kt");
         }
 
         @TestMetadata("gteq.kt")
         public void testGteq() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/gteq.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/gteq.kt");
         }
 
         @TestMetadata("intrincics.kt")
         public void testIntrincics() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/intrincics.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/intrincics.kt");
         }
 
         @TestMetadata("labeled.kt")
         public void testLabeled() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/labeled.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/labeled.kt");
         }
 
         @TestMetadata("long.kt")
         public void testLong() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/long.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/long.kt");
         }
 
         @TestMetadata("lt.kt")
         public void testLt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/lt.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/lt.kt");
         }
 
         @TestMetadata("lteq.kt")
         public void testLteq() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/lteq.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/lteq.kt");
         }
 
         @TestMetadata("maxValue.kt")
         public void testMaxValue() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/maxValue.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/maxValue.kt");
         }
 
         @TestMetadata("maxValueByte.kt")
         public void testMaxValueByte() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/maxValueByte.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/maxValueByte.kt");
         }
 
         @TestMetadata("maxValueInt.kt")
         public void testMaxValueInt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/maxValueInt.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/maxValueInt.kt");
         }
 
         @TestMetadata("miltiply.kt")
         public void testMiltiply() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/miltiply.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/miltiply.kt");
         }
 
         @TestMetadata("minus.kt")
         public void testMinus() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/minus.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/minus.kt");
         }
 
         @TestMetadata("mod.kt")
         public void testMod() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/mod.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/mod.kt");
         }
 
         @TestMetadata("multilineString.kt")
         public void testMultilineString() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/multilineString.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/multilineString.kt");
         }
 
         @TestMetadata("not.kt")
         public void testNot() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/not.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/not.kt");
         }
 
         @TestMetadata("noteq.kt")
         public void testNoteq() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/noteq.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/noteq.kt");
         }
 
         @TestMetadata("orOr.kt")
         public void testOrOr() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/orOr.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/orOr.kt");
         }
 
         @TestMetadata("paranthesized.kt")
         public void testParanthesized() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/paranthesized.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/paranthesized.kt");
         }
 
         @TestMetadata("plus.kt")
         public void testPlus() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/plus.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/plus.kt");
         }
 
         @TestMetadata("simpleCallBinary.kt")
         public void testSimpleCallBinary() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/simpleCallBinary.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/simpleCallBinary.kt");
         }
 
         @TestMetadata("stringPlusInt.kt")
         public void testStringPlusInt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/stringPlusInt.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/stringPlusInt.kt");
         }
 
         @TestMetadata("stringTemplate.kt")
         public void testStringTemplate() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/stringTemplate.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/stringTemplate.kt");
         }
 
         @TestMetadata("strings.kt")
         public void testStrings() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/strings.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/strings.kt");
         }
 
         @TestMetadata("unaryMinus.kt")
         public void testUnaryMinus() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/unaryMinus.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/unaryMinus.kt");
         }
 
         @TestMetadata("unaryPlus.kt")
         public void testUnaryPlus() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveAnnotations/parameters/expressions/unaryPlus.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolveAnnotations/parameters/expressions/unaryPlus.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/calls/ResolvedCallsTestGenerated.java

@@ -21,62 +21,62 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInResolvedCalls() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true, "enhancedSignatures");
     }
 
     @TestMetadata("explicitReceiverIsDispatchReceiver.kt")
     public void testExplicitReceiverIsDispatchReceiver() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/explicitReceiverIsDispatchReceiver.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/explicitReceiverIsDispatchReceiver.kt");
     }
 
     @TestMetadata("explicitReceiverIsExtensionReceiver.kt")
     public void testExplicitReceiverIsExtensionReceiver() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/explicitReceiverIsExtensionReceiver.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/explicitReceiverIsExtensionReceiver.kt");
     }
 
     @TestMetadata("hasBothDispatchAndExtensionReceivers.kt")
     public void testHasBothDispatchAndExtensionReceivers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceivers.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceivers.kt");
     }
 
     @TestMetadata("hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt")
     public void testHasBothDispatchAndExtensionReceiversWithoutExplicitReceiver() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt");
     }
 
     @TestMetadata("implicitReceiverIsDispatchReceiver.kt")
     public void testImplicitReceiverIsDispatchReceiver() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/implicitReceiverIsDispatchReceiver.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/implicitReceiverIsDispatchReceiver.kt");
     }
 
     @TestMetadata("implicitReceiverIsExtensionReceiver.kt")
     public void testImplicitReceiverIsExtensionReceiver() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/implicitReceiverIsExtensionReceiver.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/implicitReceiverIsExtensionReceiver.kt");
     }
 
     @TestMetadata("impliedThisNoExplicitReceiver.kt")
     public void testImpliedThisNoExplicitReceiver() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/impliedThisNoExplicitReceiver.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/impliedThisNoExplicitReceiver.kt");
     }
 
     @TestMetadata("simpleCall.kt")
     public void testSimpleCall() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/simpleCall.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolvedCalls/simpleCall.kt");
     }
 
     @TestMetadata("compiler/testData/resolvedCalls/arguments")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Arguments extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInArguments() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
@@ -85,44 +85,42 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class FunctionLiterals extends AbstractResolvedCallsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInFunctionLiterals() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("chainedLambdas.kt")
             public void testChainedLambdas() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals/chainedLambdas.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/functionLiterals/chainedLambdas.kt");
             }
 
             @TestMetadata("notInferredLambdaReturnType.kt")
             public void testNotInferredLambdaReturnType() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaReturnType.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaReturnType.kt");
             }
 
             @TestMetadata("notInferredLambdaType.kt")
             public void testNotInferredLambdaType() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaType.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaType.kt");
             }
 
             @TestMetadata("simpleGenericLambda.kt")
             public void testSimpleGenericLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals/simpleGenericLambda.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/functionLiterals/simpleGenericLambda.kt");
             }
 
             @TestMetadata("simpleLambda.kt")
             public void testSimpleLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals/simpleLambda.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/functionLiterals/simpleLambda.kt");
             }
 
             @TestMetadata("unmappedLambda.kt")
             public void testUnmappedLambda() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals/unmappedLambda.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/functionLiterals/unmappedLambda.kt");
             }
         }
 
@@ -130,32 +128,32 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class GenericCalls extends AbstractResolvedCallsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInGenericCalls() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/genericCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("inferredParameter.kt")
             public void testInferredParameter() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/genericCalls/inferredParameter.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/genericCalls/inferredParameter.kt");
             }
 
             @TestMetadata("simpleGeneric.kt")
             public void testSimpleGeneric() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/genericCalls/simpleGeneric.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/genericCalls/simpleGeneric.kt");
             }
 
             @TestMetadata("uninferredParameter.kt")
             public void testUninferredParameter() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameter.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameter.kt");
             }
 
             @TestMetadata("uninferredParameterTypeMismatch.kt")
             public void testUninferredParameterTypeMismatch() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameterTypeMismatch.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameterTypeMismatch.kt");
             }
         }
 
@@ -163,20 +161,22 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class NamedArguments extends AbstractResolvedCallsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInNamedArguments() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/namedArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("positionedAfterNamed.kt")
             public void testPositionedAfterNamed() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/namedArguments/positionedAfterNamed.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/namedArguments/positionedAfterNamed.kt");
             }
 
             @TestMetadata("shiftedArgsMatch.kt")
             public void testShiftedArgsMatch() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/namedArguments/shiftedArgsMatch.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/namedArguments/shiftedArgsMatch.kt");
             }
         }
 
@@ -184,32 +184,32 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class OneArgument extends AbstractResolvedCallsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInOneArgument() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/oneArgument"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("argumentHasNoType.kt")
             public void testArgumentHasNoType() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/oneArgument/argumentHasNoType.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/oneArgument/argumentHasNoType.kt");
             }
 
             @TestMetadata("simpleMatch.kt")
             public void testSimpleMatch() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/oneArgument/simpleMatch.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/oneArgument/simpleMatch.kt");
             }
 
             @TestMetadata("typeMismatch.kt")
             public void testTypeMismatch() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/oneArgument/typeMismatch.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/oneArgument/typeMismatch.kt");
             }
 
             @TestMetadata("unmappedArgument.kt")
             public void testUnmappedArgument() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/oneArgument/unmappedArgument.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/oneArgument/unmappedArgument.kt");
             }
         }
 
@@ -217,20 +217,22 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class RealExamples extends AbstractResolvedCallsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInRealExamples() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/realExamples"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("emptyList.kt")
             public void testEmptyList() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/realExamples/emptyList.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/realExamples/emptyList.kt");
             }
 
             @TestMetadata("emptyMutableList.kt")
             public void testEmptyMutableList() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.kt");
             }
         }
 
@@ -238,14 +240,17 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class SeveralCandidates extends AbstractResolvedCallsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInSeveralCandidates() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/severalCandidates"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("mostSpecific.kt")
             public void testMostSpecific() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/arguments/severalCandidates/mostSpecific.kt");
-                doTest(fileName);
+                runTest("compiler/testData/resolvedCalls/arguments/severalCandidates/mostSpecific.kt");
             }
         }
     }
@@ -254,26 +259,27 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DifferentCallElements extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDifferentCallElements() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/differentCallElements"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotationCall.kt")
         public void testAnnotationCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/differentCallElements/annotationCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/differentCallElements/annotationCall.kt");
         }
 
         @TestMetadata("delegatorToSuperCall.kt")
         public void testDelegatorToSuperCall() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/differentCallElements/delegatorToSuperCall.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/differentCallElements/delegatorToSuperCall.kt");
         }
 
         @TestMetadata("simpleArrayAccess.kt")
         public void testSimpleArrayAccess() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/differentCallElements/simpleArrayAccess.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/differentCallElements/simpleArrayAccess.kt");
         }
     }
 
@@ -281,44 +287,42 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Dynamic extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInDynamic() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/dynamic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("explicitReceiverIsDispatchReceiver.kt")
         public void testExplicitReceiverIsDispatchReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/dynamic/explicitReceiverIsDispatchReceiver.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/dynamic/explicitReceiverIsDispatchReceiver.kt");
         }
 
         @TestMetadata("explicitReceiverIsExtensionReceiver.kt")
         public void testExplicitReceiverIsExtensionReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/dynamic/explicitReceiverIsExtensionReceiver.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/dynamic/explicitReceiverIsExtensionReceiver.kt");
         }
 
         @TestMetadata("hasBothDispatchAndExtensionReceivers.kt")
         public void testHasBothDispatchAndExtensionReceivers() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/dynamic/hasBothDispatchAndExtensionReceivers.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/dynamic/hasBothDispatchAndExtensionReceivers.kt");
         }
 
         @TestMetadata("hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt")
         public void testHasBothDispatchAndExtensionReceiversWithoutExplicitReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/dynamic/hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/dynamic/hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt");
         }
 
         @TestMetadata("implicitReceiverIsDispatchReceiver.kt")
         public void testImplicitReceiverIsDispatchReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/dynamic/implicitReceiverIsDispatchReceiver.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/dynamic/implicitReceiverIsDispatchReceiver.kt");
         }
 
         @TestMetadata("implicitReceiverIsExtensionReceiver.kt")
         public void testImplicitReceiverIsExtensionReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/dynamic/implicitReceiverIsExtensionReceiver.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/dynamic/implicitReceiverIsExtensionReceiver.kt");
         }
     }
 
@@ -326,44 +330,42 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class FunctionTypes extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInFunctionTypes() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/functionTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("invokeForExtensionFunctionType.kt")
         public void testInvokeForExtensionFunctionType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/functionTypes/invokeForExtensionFunctionType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/functionTypes/invokeForExtensionFunctionType.kt");
         }
 
         @TestMetadata("invokeForFunctionType.kt")
         public void testInvokeForFunctionType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/functionTypes/invokeForFunctionType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/functionTypes/invokeForFunctionType.kt");
         }
 
         @TestMetadata("valOfExtensionFunctionType.kt")
         public void testValOfExtensionFunctionType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/functionTypes/valOfExtensionFunctionType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/functionTypes/valOfExtensionFunctionType.kt");
         }
 
         @TestMetadata("valOfExtensionFunctionTypeInvoke.kt")
         public void testValOfExtensionFunctionTypeInvoke() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/functionTypes/valOfExtensionFunctionTypeInvoke.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/functionTypes/valOfExtensionFunctionTypeInvoke.kt");
         }
 
         @TestMetadata("valOfFunctionType.kt")
         public void testValOfFunctionType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/functionTypes/valOfFunctionType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/functionTypes/valOfFunctionType.kt");
         }
 
         @TestMetadata("valOfFunctionTypeInvoke.kt")
         public void testValOfFunctionTypeInvoke() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/functionTypes/valOfFunctionTypeInvoke.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/functionTypes/valOfFunctionTypeInvoke.kt");
         }
     }
 
@@ -371,68 +373,62 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Invoke extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInInvoke() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/invoke"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("bothReceivers.kt")
         public void testBothReceivers() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/bothReceivers.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/bothReceivers.kt");
         }
 
         @TestMetadata("dispatchReceiverAsReceiverForInvoke.kt")
         public void testDispatchReceiverAsReceiverForInvoke() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/dispatchReceiverAsReceiverForInvoke.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/dispatchReceiverAsReceiverForInvoke.kt");
         }
 
         @TestMetadata("extensionReceiverAsReceiverForInvoke.kt")
         public void testExtensionReceiverAsReceiverForInvoke() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/extensionReceiverAsReceiverForInvoke.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/extensionReceiverAsReceiverForInvoke.kt");
         }
 
         @TestMetadata("implicitReceiverForInvoke.kt")
         public void testImplicitReceiverForInvoke() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/implicitReceiverForInvoke.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/implicitReceiverForInvoke.kt");
         }
 
         @TestMetadata("invokeOnClassObject1.kt")
         public void testInvokeOnClassObject1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/invokeOnClassObject1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/invokeOnClassObject1.kt");
         }
 
         @TestMetadata("invokeOnClassObject2.kt")
         public void testInvokeOnClassObject2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/invokeOnClassObject2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/invokeOnClassObject2.kt");
         }
 
         @TestMetadata("invokeOnEnumEntry1.kt")
         public void testInvokeOnEnumEntry1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/invokeOnEnumEntry1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/invokeOnEnumEntry1.kt");
         }
 
         @TestMetadata("invokeOnEnumEntry2.kt")
         public void testInvokeOnEnumEntry2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/invokeOnEnumEntry2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/invokeOnEnumEntry2.kt");
         }
 
         @TestMetadata("invokeOnObject1.kt")
         public void testInvokeOnObject1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/invokeOnObject1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/invokeOnObject1.kt");
         }
 
         @TestMetadata("invokeOnObject2.kt")
         public void testInvokeOnObject2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/invoke/invokeOnObject2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/invoke/invokeOnObject2.kt");
         }
     }
 
@@ -440,26 +436,27 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ObjectsAndClassObjects extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInObjectsAndClassObjects() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/objectsAndClassObjects"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("classObject.kt")
         public void testClassObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/objectsAndClassObjects/classObject.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/objectsAndClassObjects/classObject.kt");
         }
 
         @TestMetadata("kt5308IntRangeConstant.kt")
         public void testKt5308IntRangeConstant() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/objectsAndClassObjects/kt5308IntRangeConstant.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/objectsAndClassObjects/kt5308IntRangeConstant.kt");
         }
 
         @TestMetadata("object.kt")
         public void testObject() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/objectsAndClassObjects/object.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/objectsAndClassObjects/object.kt");
         }
     }
 
@@ -467,14 +464,17 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class RealExamples extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRealExamples() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/realExamples"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("stringPlusInBuilders.kt")
         public void testStringPlusInBuilders() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/realExamples/stringPlusInBuilders.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/realExamples/stringPlusInBuilders.kt");
         }
     }
 
@@ -482,20 +482,22 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Resolve extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInResolve() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/resolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("mostSpecificUninferredParam.kt")
         public void testMostSpecificUninferredParam() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/resolve/mostSpecificUninferredParam.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/resolve/mostSpecificUninferredParam.kt");
         }
 
         @TestMetadata("mostSpecificWithLambda.kt")
         public void testMostSpecificWithLambda() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/resolve/mostSpecificWithLambda.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/resolve/mostSpecificWithLambda.kt");
         }
     }
 
@@ -503,92 +505,82 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class SecondaryConstructors extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInSecondaryConstructors() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("classWithGenerics.kt")
         public void testClassWithGenerics() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics.kt");
         }
 
         @TestMetadata("classWithGenerics2.kt")
         public void testClassWithGenerics2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics2.kt");
         }
 
         @TestMetadata("classWithGenerics3.kt")
         public void testClassWithGenerics3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics3.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics3.kt");
         }
 
         @TestMetadata("explicitPrimaryArgs.kt")
         public void testExplicitPrimaryArgs() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryArgs.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryArgs.kt");
         }
 
         @TestMetadata("explicitPrimaryCallSecondary.kt")
         public void testExplicitPrimaryCallSecondary() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryCallSecondary.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryCallSecondary.kt");
         }
 
         @TestMetadata("explicitPrimaryNoArgs.kt")
         public void testExplicitPrimaryNoArgs() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryNoArgs.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryNoArgs.kt");
         }
 
         @TestMetadata("implicitPrimary.kt")
         public void testImplicitPrimary() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/implicitPrimary.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/implicitPrimary.kt");
         }
 
         @TestMetadata("overload1.kt")
         public void testOverload1() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overload1.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/overload1.kt");
         }
 
         @TestMetadata("overload2.kt")
         public void testOverload2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overload2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/overload2.kt");
         }
 
         @TestMetadata("overload3.kt")
         public void testOverload3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overload3.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/overload3.kt");
         }
 
         @TestMetadata("overloadDefault.kt")
         public void testOverloadDefault() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overloadDefault.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/overloadDefault.kt");
         }
 
         @TestMetadata("overloadNamed.kt")
         public void testOverloadNamed() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overloadNamed.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/overloadNamed.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/simple.kt");
         }
 
         @TestMetadata("varargs.kt")
         public void testVarargs() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/varargs.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/secondaryConstructors/varargs.kt");
         }
     }
 
@@ -596,38 +588,37 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ThisOrSuper extends AbstractResolvedCallsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInThisOrSuper() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/thisOrSuper"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("labeledSuper.kt")
         public void testLabeledSuper() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/thisOrSuper/labeledSuper.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/thisOrSuper/labeledSuper.kt");
         }
 
         @TestMetadata("labeledThis.kt")
         public void testLabeledThis() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/thisOrSuper/labeledThis.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/thisOrSuper/labeledThis.kt");
         }
 
         @TestMetadata("simpleSuper.kt")
         public void testSimpleSuper() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/thisOrSuper/simpleSuper.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/thisOrSuper/simpleSuper.kt");
         }
 
         @TestMetadata("simpleThis.kt")
         public void testSimpleThis() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/thisOrSuper/simpleThis.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/thisOrSuper/simpleThis.kt");
         }
 
         @TestMetadata("thisInExtensionFunction.kt")
         public void testThisInExtensionFunction() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolvedCalls/thisOrSuper/thisInExtensionFunction.kt");
-            doTest(fileName);
+            runTest("compiler/testData/resolvedCalls/thisOrSuper/thisInExtensionFunction.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/calls/ResolvedConstructorDelegationCallsTestsGenerated.java

@@ -21,133 +21,116 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class ResolvedConstructorDelegationCallsTestsGenerated extends AbstractResolvedConstructorDelegationCallsTests {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInResolveConstructorDelegationCalls() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolveConstructorDelegationCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("classWithGenerics.kt")
     public void testClassWithGenerics() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/classWithGenerics.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/classWithGenerics.kt");
     }
 
     @TestMetadata("generics2.kt")
     public void testGenerics2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/generics2.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/generics2.kt");
     }
 
     @TestMetadata("generics3.kt")
     public void testGenerics3() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/generics3.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/generics3.kt");
     }
 
     @TestMetadata("generics4.kt")
     public void testGenerics4() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/generics4.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/generics4.kt");
     }
 
     @TestMetadata("generics5.kt")
     public void testGenerics5() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/generics5.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/generics5.kt");
     }
 
     @TestMetadata("inheritanceWithGeneric.kt")
     public void testInheritanceWithGeneric() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/inheritanceWithGeneric.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/inheritanceWithGeneric.kt");
     }
 
     @TestMetadata("innerClassDelegatingPrimary.kt")
     public void testInnerClassDelegatingPrimary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/innerClassDelegatingPrimary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/innerClassDelegatingPrimary.kt");
     }
 
     @TestMetadata("innerClassDelegatingSecondary.kt")
     public void testInnerClassDelegatingSecondary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/innerClassDelegatingSecondary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/innerClassDelegatingSecondary.kt");
     }
 
     @TestMetadata("superAnyEmpty.kt")
     public void testSuperAnyEmpty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superAnyEmpty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superAnyEmpty.kt");
     }
 
     @TestMetadata("superAnyImplicit.kt")
     public void testSuperAnyImplicit() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superAnyImplicit.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superAnyImplicit.kt");
     }
 
     @TestMetadata("superPrimary.kt")
     public void testSuperPrimary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superPrimary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superPrimary.kt");
     }
 
     @TestMetadata("superPrimaryEmpty.kt")
     public void testSuperPrimaryEmpty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superPrimaryEmpty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superPrimaryEmpty.kt");
     }
 
     @TestMetadata("superPrimaryImplicit.kt")
     public void testSuperPrimaryImplicit() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superPrimaryImplicit.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superPrimaryImplicit.kt");
     }
 
     @TestMetadata("superSecondary.kt")
     public void testSuperSecondary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superSecondary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superSecondary.kt");
     }
 
     @TestMetadata("superSecondaryImplicit.kt")
     public void testSuperSecondaryImplicit() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superSecondaryImplicit.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superSecondaryImplicit.kt");
     }
 
     @TestMetadata("superSecondaryOverload.kt")
     public void testSuperSecondaryOverload() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/superSecondaryOverload.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/superSecondaryOverload.kt");
     }
 
     @TestMetadata("thisPrimary.kt")
     public void testThisPrimary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/thisPrimary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/thisPrimary.kt");
     }
 
     @TestMetadata("thisPrimaryEmpty.kt")
     public void testThisPrimaryEmpty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/thisPrimaryEmpty.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/thisPrimaryEmpty.kt");
     }
 
     @TestMetadata("thisSecondary.kt")
     public void testThisSecondary() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/thisSecondary.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/thisSecondary.kt");
     }
 
     @TestMetadata("thisSecondaryOverload.kt")
     public void testThisSecondaryOverload() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/thisSecondaryOverload.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/thisSecondaryOverload.kt");
     }
 
     @TestMetadata("varargs.kt")
     public void testVarargs() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/resolveConstructorDelegationCalls/varargs.kt");
-        doTest(fileName);
+        runTest("compiler/testData/resolveConstructorDelegationCalls/varargs.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/CompileTimeConstantEvaluatorTestGenerated.java

@@ -23,134 +23,117 @@ public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Constant extends AbstractCompileTimeConstantEvaluatorTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doConstantTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInConstant() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/evaluate/constant"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("classObjectProperty.kt")
         public void testClassObjectProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/classObjectProperty.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/classObjectProperty.kt");
         }
 
         @TestMetadata("compareTo.kt")
         public void testCompareTo() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/compareTo.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/compareTo.kt");
         }
 
         @TestMetadata("differentTypes.kt")
         public void testDifferentTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/differentTypes.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/differentTypes.kt");
         }
 
         @TestMetadata("divideByZero.kt")
         public void testDivideByZero() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/divideByZero.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/divideByZero.kt");
         }
 
         @TestMetadata("equals.kt")
         public void testEquals() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/equals.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/equals.kt");
         }
 
         @TestMetadata("exceptionWhenEvaluate.kt")
         public void testExceptionWhenEvaluate() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/exceptionWhenEvaluate.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/exceptionWhenEvaluate.kt");
         }
 
         @TestMetadata("finalProperty.kt")
         public void testFinalProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/finalProperty.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/finalProperty.kt");
         }
 
         @TestMetadata("float.kt")
         public void testFloat() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/float.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/float.kt");
         }
 
         @TestMetadata("floatsAndDoubles.kt")
         public void testFloatsAndDoubles() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/floatsAndDoubles.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/floatsAndDoubles.kt");
         }
 
         @TestMetadata("integer.kt")
         public void testInteger() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/integer.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/integer.kt");
         }
 
         @TestMetadata("integerOperations.kt")
         public void testIntegerOperations() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/integerOperations.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/integerOperations.kt");
         }
 
         @TestMetadata("integers.kt")
         public void testIntegers() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/integers.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/integers.kt");
         }
 
         @TestMetadata("localVal.kt")
         public void testLocalVal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/localVal.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/localVal.kt");
         }
 
         @TestMetadata("localVar.kt")
         public void testLocalVar() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/localVar.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/localVar.kt");
         }
 
         @TestMetadata("nonFinalProperty.kt")
         public void testNonFinalProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/nonFinalProperty.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/nonFinalProperty.kt");
         }
 
         @TestMetadata("objectProperty.kt")
         public void testObjectProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/objectProperty.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/objectProperty.kt");
         }
 
         @TestMetadata("strings.kt")
         public void testStrings() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/strings.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/strings.kt");
         }
 
         @TestMetadata("topLevelVal.kt")
         public void testTopLevelVal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/topLevelVal.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/topLevelVal.kt");
         }
 
         @TestMetadata("topLevelVar.kt")
         public void testTopLevelVar() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/topLevelVar.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/topLevelVar.kt");
         }
 
         @TestMetadata("unaryMinusIndepWoExpType.kt")
         public void testUnaryMinusIndepWoExpType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/unaryMinusIndepWoExpType.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/unaryMinusIndepWoExpType.kt");
         }
 
         @TestMetadata("unaryMinusIndependentExpType.kt")
         public void testUnaryMinusIndependentExpType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/constant/unaryMinusIndependentExpType.kt");
-            doConstantTest(fileName);
+            runTest("compiler/testData/evaluate/constant/unaryMinusIndependentExpType.kt");
         }
     }
 
@@ -158,38 +141,37 @@ public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class IsPure extends AbstractCompileTimeConstantEvaluatorTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doIsPureTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInIsPure() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/evaluate/isPure"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("innerToType.kt")
         public void testInnerToType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/isPure/innerToType.kt");
-            doIsPureTest(fileName);
+            runTest("compiler/testData/evaluate/isPure/innerToType.kt");
         }
 
         @TestMetadata("namedConstants.kt")
         public void testNamedConstants() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/isPure/namedConstants.kt");
-            doIsPureTest(fileName);
+            runTest("compiler/testData/evaluate/isPure/namedConstants.kt");
         }
 
         @TestMetadata("toType.kt")
         public void testToType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/isPure/toType.kt");
-            doIsPureTest(fileName);
+            runTest("compiler/testData/evaluate/isPure/toType.kt");
         }
 
         @TestMetadata("unaryMinusIndepWoExpType.kt")
         public void testUnaryMinusIndepWoExpType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/isPure/unaryMinusIndepWoExpType.kt");
-            doIsPureTest(fileName);
+            runTest("compiler/testData/evaluate/isPure/unaryMinusIndepWoExpType.kt");
         }
 
         @TestMetadata("unaryMinusIndependentExpType.kt")
         public void testUnaryMinusIndependentExpType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/isPure/unaryMinusIndependentExpType.kt");
-            doIsPureTest(fileName);
+            runTest("compiler/testData/evaluate/isPure/unaryMinusIndependentExpType.kt");
         }
     }
 
@@ -197,32 +179,32 @@ public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class UsesVariableAsConstant extends AbstractCompileTimeConstantEvaluatorTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doUsesVariableAsConstantTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInUsesVariableAsConstant() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/evaluate/usesVariableAsConstant"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("binaryTypes.kt")
         public void testBinaryTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/usesVariableAsConstant/binaryTypes.kt");
-            doUsesVariableAsConstantTest(fileName);
+            runTest("compiler/testData/evaluate/usesVariableAsConstant/binaryTypes.kt");
         }
 
         @TestMetadata("NamedConstants.kt")
         public void testNamedConstants() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/usesVariableAsConstant/NamedConstants.kt");
-            doUsesVariableAsConstantTest(fileName);
+            runTest("compiler/testData/evaluate/usesVariableAsConstant/NamedConstants.kt");
         }
 
         @TestMetadata("OtherTypes.kt")
         public void testOtherTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/usesVariableAsConstant/OtherTypes.kt");
-            doUsesVariableAsConstantTest(fileName);
+            runTest("compiler/testData/evaluate/usesVariableAsConstant/OtherTypes.kt");
         }
 
         @TestMetadata("simpleTypes.kt")
         public void testSimpleTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/evaluate/usesVariableAsConstant/simpleTypes.kt");
-            doUsesVariableAsConstantTest(fileName);
+            runTest("compiler/testData/evaluate/usesVariableAsConstant/simpleTypes.kt");
         }
     }
 }

compiler/tests/org/jetbrains/kotlin/serialization/LocalClassProtoTestGenerated.java

@@ -21,49 +21,46 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class LocalClassProtoTestGenerated extends AbstractLocalClassProtoTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInLocal() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/serialization/local"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("annotationsInLocalClass.kt")
     public void testAnnotationsInLocalClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/annotationsInLocalClass.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/annotationsInLocalClass.kt");
     }
 
     @TestMetadata("anonymousObject.kt")
     public void testAnonymousObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/anonymousObject.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/anonymousObject.kt");
     }
 
     @TestMetadata("deepInnerChain.kt")
     public void testDeepInnerChain() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/deepInnerChain.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/deepInnerChain.kt");
     }
 
     @TestMetadata("innerOfLocal.kt")
     public void testInnerOfLocal() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/innerOfLocal.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/innerOfLocal.kt");
     }
 
     @TestMetadata("localClassInSignature.kt")
     public void testLocalClassInSignature() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/localClassInSignature.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/localClassInSignature.kt");
     }
 
     @TestMetadata("simpleInMemberFunction.kt")
     public void testSimpleInMemberFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/simpleInMemberFunction.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/simpleInMemberFunction.kt");
     }
 
     @TestMetadata("simpleInTopLevelFunction.kt")
     public void testSimpleInTopLevelFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/serialization/local/simpleInTopLevelFunction.kt");
-        doTest(fileName);
+        runTest("compiler/testData/serialization/local/simpleInTopLevelFunction.kt");
     }
 }

compiler/tests/org/jetbrains/kotlin/types/TypeBindingTestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class TypeBindingTestGenerated extends AbstractTypeBindingTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInBinding() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/type/binding"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,116 +33,102 @@ public class TypeBindingTestGenerated extends AbstractTypeBindingTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Explicit extends AbstractTypeBindingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInExplicit() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/type/binding/explicit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("conflictingProjection.kt")
         public void testConflictingProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/conflictingProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/conflictingProjection.kt");
         }
 
         @TestMetadata("conflictingProjection2.kt")
         public void testConflictingProjection2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/conflictingProjection2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/conflictingProjection2.kt");
         }
 
         @TestMetadata("errorPair.kt")
         public void testErrorPair() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/errorPair.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/errorPair.kt");
         }
 
         @TestMetadata("errorWithProjection.kt")
         public void testErrorWithProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/errorWithProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/errorWithProjection.kt");
         }
 
         @TestMetadata("functionType.kt")
         public void testFunctionType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/functionType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/functionType.kt");
         }
 
         @TestMetadata("functionType2.kt")
         public void testFunctionType2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/functionType2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/functionType2.kt");
         }
 
         @TestMetadata("functionType3.kt")
         public void testFunctionType3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/functionType3.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/functionType3.kt");
         }
 
         @TestMetadata("inProjection.kt")
         public void testInProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/inProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/inProjection.kt");
         }
 
         @TestMetadata("int.kt")
         public void testInt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/int.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/int.kt");
         }
 
         @TestMetadata("list0.kt")
         public void testList0() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/list0.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/list0.kt");
         }
 
         @TestMetadata("list2.kt")
         public void testList2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/list2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/list2.kt");
         }
 
         @TestMetadata("nullableType.kt")
         public void testNullableType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/nullableType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/nullableType.kt");
         }
 
         @TestMetadata("outProjection.kt")
         public void testOutProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/outProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/outProjection.kt");
         }
 
         @TestMetadata("pair.kt")
         public void testPair() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/pair.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/pair.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/simple.kt");
         }
 
         @TestMetadata("star.kt")
         public void testStar() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/star.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/star.kt");
         }
 
         @TestMetadata("typeWithBracket.kt")
         public void testTypeWithBracket() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/typeWithBracket.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/typeWithBracket.kt");
         }
 
         @TestMetadata("unresolvedType.kt")
         public void testUnresolvedType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/explicit/unresolvedType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/explicit/unresolvedType.kt");
         }
     }
 
@@ -146,116 +136,102 @@ public class TypeBindingTestGenerated extends AbstractTypeBindingTest {
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Implicit extends AbstractTypeBindingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInImplicit() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/type/binding/implicit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("conflictingProjection.kt")
         public void testConflictingProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/conflictingProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/conflictingProjection.kt");
         }
 
         @TestMetadata("conflictingProjection2.kt")
         public void testConflictingProjection2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/conflictingProjection2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/conflictingProjection2.kt");
         }
 
         @TestMetadata("errorPair.kt")
         public void testErrorPair() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/errorPair.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/errorPair.kt");
         }
 
         @TestMetadata("errorWithProjection.kt")
         public void testErrorWithProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/errorWithProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/errorWithProjection.kt");
         }
 
         @TestMetadata("functionType.kt")
         public void testFunctionType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/functionType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/functionType.kt");
         }
 
         @TestMetadata("functionType2.kt")
         public void testFunctionType2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/functionType2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/functionType2.kt");
         }
 
         @TestMetadata("functionType3.kt")
         public void testFunctionType3() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/functionType3.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/functionType3.kt");
         }
 
         @TestMetadata("inProjection.kt")
         public void testInProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/inProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/inProjection.kt");
         }
 
         @TestMetadata("int.kt")
         public void testInt() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/int.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/int.kt");
         }
 
         @TestMetadata("list0.kt")
         public void testList0() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/list0.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/list0.kt");
         }
 
         @TestMetadata("list2.kt")
         public void testList2() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/list2.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/list2.kt");
         }
 
         @TestMetadata("nullableType.kt")
         public void testNullableType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/nullableType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/nullableType.kt");
         }
 
         @TestMetadata("outProjection.kt")
         public void testOutProjection() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/outProjection.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/outProjection.kt");
         }
 
         @TestMetadata("pair.kt")
         public void testPair() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/pair.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/pair.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/simple.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/simple.kt");
         }
 
         @TestMetadata("star.kt")
         public void testStar() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/star.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/star.kt");
         }
 
         @TestMetadata("typeWithBracket.kt")
         public void testTypeWithBracket() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/typeWithBracket.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/typeWithBracket.kt");
         }
 
         @TestMetadata("unresolvedType.kt")
         public void testUnresolvedType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/type/binding/implicit/unresolvedType.kt");
-            doTest(fileName);
+            runTest("compiler/testData/type/binding/implicit/unresolvedType.kt");
         }
     }
 }

core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java

@@ -21,31 +21,31 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8RuntimeDescriptorLoaderTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInCompiledJava() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("InnerClassTypeAnnotation.java")
     public void testInnerClassTypeAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
-        doTest(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java");
     }
 
     @TestMetadata("MapRemove.java")
     public void testMapRemove() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/MapRemove.java");
-        doTest(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/MapRemove.java");
     }
 
     @TestMetadata("TypeAnnotations.java")
     public void testTypeAnnotations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
-        doTest(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
     }
 
     @TestMetadata("TypeParameterAnnotations.java")
     public void testTypeParameterAnnotations() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
-        doTest(fileName);
+        runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/annotator/AndroidGutterIconTestGenerated.java

@@ -21,52 +21,106 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInGutterIcon() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("color.kt")
     public void testColor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/gutterIcon/color.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/gutterIcon/color.kt");
     }
 
     @TestMetadata("drawable.kt")
     public void testDrawable() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/gutterIcon/drawable.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/gutterIcon/drawable.kt");
     }
 
     @TestMetadata("mipmap.kt")
     public void testMipmap() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/gutterIcon/mipmap.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/gutterIcon/mipmap.kt");
     }
 
     @TestMetadata("relatedFiles.kt")
     public void testRelatedFiles() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/gutterIcon/relatedFiles.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/gutterIcon/relatedFiles.kt");
     }
 
     @TestMetadata("systemColor.kt")
     public void testSystemColor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/gutterIcon/systemColor.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/gutterIcon/systemColor.kt");
     }
 
     @TestMetadata("systemDrawable.kt")
     public void testSystemDrawable() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/gutterIcon/systemDrawable.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/gutterIcon/systemDrawable.kt");
     }
 
     @TestMetadata("idea/testData/android/gutterIcon/res")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Res extends AbstractAndroidGutterIconTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRes() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
         }
+
+        @TestMetadata("idea/testData/android/gutterIcon/res/drawable")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Drawable extends AbstractAndroidGutterIconTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInDrawable() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/drawable"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("idea/testData/android/gutterIcon/res/layout")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Layout extends AbstractAndroidGutterIconTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInLayout() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/layout"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("idea/testData/android/gutterIcon/res/mipmap-mdpi")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Mipmap_mdpi extends AbstractAndroidGutterIconTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInMipmap_mdpi() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/mipmap-mdpi"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            }
+        }
+
+        @TestMetadata("idea/testData/android/gutterIcon/res/values")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Values extends AbstractAndroidGutterIconTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInValues() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/values"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            }
+        }
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/configure/ConfigureProjectTestGenerated.java

@@ -23,136 +23,124 @@ public class ConfigureProjectTestGenerated extends AbstractConfigureProjectTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Android_gradle extends AbstractConfigureProjectTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestAndroidGradle, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInAndroid_gradle() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gradle"), Pattern.compile("(\\w+)_before\\.gradle$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("androidStudioDefault_before.gradle")
         public void testAndroidStudioDefault() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/androidStudioDefault_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/androidStudioDefault_before.gradle");
         }
 
         @TestMetadata("androidStudioDefaultShapshot_before.gradle")
         public void testAndroidStudioDefaultShapshot() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/androidStudioDefaultShapshot_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/androidStudioDefaultShapshot_before.gradle");
         }
 
         @TestMetadata("buildConfigs_before.gradle")
         public void testBuildConfigs() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/buildConfigs_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/buildConfigs_before.gradle");
         }
 
         @TestMetadata("emptyDependencyList_before.gradle")
         public void testEmptyDependencyList() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/emptyDependencyList_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/emptyDependencyList_before.gradle");
         }
 
         @TestMetadata("emptyFile_before.gradle")
         public void testEmptyFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/emptyFile_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/emptyFile_before.gradle");
         }
 
         @TestMetadata("helloWorld_before.gradle")
         public void testHelloWorld() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/helloWorld_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/helloWorld_before.gradle");
         }
 
         @TestMetadata("libraryFile_before.gradle")
         public void testLibraryFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/libraryFile_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/libraryFile_before.gradle");
         }
 
         @TestMetadata("missedApplyAndroidStatement_before.gradle")
         public void testMissedApplyAndroidStatement() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/missedApplyAndroidStatement_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/missedApplyAndroidStatement_before.gradle");
         }
 
         @TestMetadata("missedBuildscriptBlock_before.gradle")
         public void testMissedBuildscriptBlock() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/missedBuildscriptBlock_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/missedBuildscriptBlock_before.gradle");
         }
 
         @TestMetadata("missedRepositoriesInBuildscriptBlock_before.gradle")
         public void testMissedRepositoriesInBuildscriptBlock() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/missedRepositoriesInBuildscriptBlock_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/missedRepositoriesInBuildscriptBlock_before.gradle");
         }
 
         @TestMetadata("productFlavor_before.gradle")
         public void testProductFlavor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/productFlavor_before.gradle");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gradle/productFlavor_before.gradle");
         }
 
         @TestMetadata("idea/testData/configuration/android-gradle/gradleExamples")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class GradleExamples extends AbstractConfigureProjectTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestAndroidGradle, TargetBackend.ANY, testDataFilePath);
+            }
+
             public void testAllFilesPresentInGradleExamples() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gradle/gradleExamples"), Pattern.compile("(\\w+)_before\\.gradle$"), TargetBackend.ANY, true);
             }
 
             @TestMetadata("gradleExample0_before.gradle")
             public void testGradleExample0() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample0_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample0_before.gradle");
             }
 
             @TestMetadata("gradleExample18_before.gradle")
             public void testGradleExample18() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample18_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample18_before.gradle");
             }
 
             @TestMetadata("gradleExample22_before.gradle")
             public void testGradleExample22() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample22_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample22_before.gradle");
             }
 
             @TestMetadata("gradleExample44_before.gradle")
             public void testGradleExample44() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample44_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample44_before.gradle");
             }
 
             @TestMetadata("gradleExample5_before.gradle")
             public void testGradleExample5() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample5_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample5_before.gradle");
             }
 
             @TestMetadata("gradleExample50_before.gradle")
             public void testGradleExample50() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample50_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample50_before.gradle");
             }
 
             @TestMetadata("gradleExample58_before.gradle")
             public void testGradleExample58() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample58_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample58_before.gradle");
             }
 
             @TestMetadata("gradleExample65_before.gradle")
             public void testGradleExample65() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample65_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample65_before.gradle");
             }
 
             @TestMetadata("gradleExample8_before.gradle")
             public void testGradleExample8() throws Exception {
-                String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gradle/gradleExamples/gradleExample8_before.gradle");
-                doTestAndroidGradle(fileName);
+                runTest("idea/testData/configuration/android-gradle/gradleExamples/gradleExample8_before.gradle");
             }
         }
     }
@@ -161,20 +149,22 @@ public class ConfigureProjectTestGenerated extends AbstractConfigureProjectTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Android_gsk extends AbstractConfigureProjectTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestAndroidGradle, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInAndroid_gsk() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gsk"), Pattern.compile("(\\w+)_before\\.gradle.kts$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("emptyFile_before.gradle.kts")
         public void testEmptyFile() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gsk/emptyFile_before.gradle.kts");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gsk/emptyFile_before.gradle.kts");
         }
 
         @TestMetadata("helloWorld_before.gradle.kts")
         public void testHelloWorld() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/configuration/android-gsk/helloWorld_before.gradle.kts");
-            doTestAndroidGradle(fileName);
+            runTest("idea/testData/configuration/android-gsk/helloWorld_before.gradle.kts");
         }
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/folding/AndroidResourceFoldingTestGenerated.java

@@ -21,25 +21,26 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AndroidResourceFoldingTestGenerated extends AbstractAndroidResourceFoldingTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInFolding() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/folding"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("dimensions.kt")
     public void testDimensions() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/folding/dimensions.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/folding/dimensions.kt");
     }
 
     @TestMetadata("getString.kt")
     public void testGetString() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/folding/getString.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/folding/getString.kt");
     }
 
     @TestMetadata("plurals.kt")
     public void testPlurals() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/folding/plurals.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/folding/plurals.kt");
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidIntentionTestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInIntention() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,10 +33,13 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class AddActivityToManifest extends AbstractAndroidIntentionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         @TestMetadata("abstract.kt")
         public void testAbstract() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/abstract.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/abstract.kt");
         }
 
         public void testAllFilesPresentInAddActivityToManifest() throws Exception {
@@ -41,56 +48,47 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
 
         @TestMetadata("alreadyExists.kt")
         public void testAlreadyExists() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/alreadyExists.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/alreadyExists.kt");
         }
 
         @TestMetadata("inner.kt")
         public void testInner() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/inner.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/inner.kt");
         }
 
         @TestMetadata("insideBody.kt")
         public void testInsideBody() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/insideBody.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/insideBody.kt");
         }
 
         @TestMetadata("local.kt")
         public void testLocal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/local.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/local.kt");
         }
 
         @TestMetadata("nested.kt")
         public void testNested() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/nested.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/nested.kt");
         }
 
         @TestMetadata("notActivity.kt")
         public void testNotActivity() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/notActivity.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/notActivity.kt");
         }
 
         @TestMetadata("private.kt")
         public void testPrivate() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/private.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/private.kt");
         }
 
         @TestMetadata("protected.kt")
         public void testProtected() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/protected.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/protected.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addActivityToManifest/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addActivityToManifest/simple.kt");
         }
     }
 
@@ -98,10 +96,13 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class AddBroadcastReceiverToManifest extends AbstractAndroidIntentionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         @TestMetadata("abstract.kt")
         public void testAbstract() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/abstract.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/abstract.kt");
         }
 
         public void testAllFilesPresentInAddBroadcastReceiverToManifest() throws Exception {
@@ -110,56 +111,47 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
 
         @TestMetadata("alreadyExists.kt")
         public void testAlreadyExists() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/alreadyExists.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/alreadyExists.kt");
         }
 
         @TestMetadata("inner.kt")
         public void testInner() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/inner.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/inner.kt");
         }
 
         @TestMetadata("insideBody.kt")
         public void testInsideBody() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/insideBody.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/insideBody.kt");
         }
 
         @TestMetadata("local.kt")
         public void testLocal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/local.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/local.kt");
         }
 
         @TestMetadata("nested.kt")
         public void testNested() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/nested.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/nested.kt");
         }
 
         @TestMetadata("notReceiver.kt")
         public void testNotReceiver() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/notReceiver.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/notReceiver.kt");
         }
 
         @TestMetadata("private.kt")
         public void testPrivate() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/private.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/private.kt");
         }
 
         @TestMetadata("protected.kt")
         public void testProtected() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/protected.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/protected.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addBroadcastReceiverToManifest/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addBroadcastReceiverToManifest/simple.kt");
         }
     }
 
@@ -167,10 +159,13 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class AddServiceToManifest extends AbstractAndroidIntentionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         @TestMetadata("abstract.kt")
         public void testAbstract() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/abstract.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/abstract.kt");
         }
 
         public void testAllFilesPresentInAddServiceToManifest() throws Exception {
@@ -179,56 +174,47 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
 
         @TestMetadata("alreadyExists.kt")
         public void testAlreadyExists() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/alreadyExists.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/alreadyExists.kt");
         }
 
         @TestMetadata("inner.kt")
         public void testInner() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/inner.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/inner.kt");
         }
 
         @TestMetadata("insideBody.kt")
         public void testInsideBody() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/insideBody.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/insideBody.kt");
         }
 
         @TestMetadata("local.kt")
         public void testLocal() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/local.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/local.kt");
         }
 
         @TestMetadata("nested.kt")
         public void testNested() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/nested.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/nested.kt");
         }
 
         @TestMetadata("notService.kt")
         public void testNotService() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/notService.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/notService.kt");
         }
 
         @TestMetadata("private.kt")
         public void testPrivate() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/private.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/private.kt");
         }
 
         @TestMetadata("protected.kt")
         public void testProtected() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/protected.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/protected.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/addServiceToManifest/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/addServiceToManifest/simple.kt");
         }
     }
 
@@ -236,68 +222,62 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ImplementParcelable extends AbstractAndroidIntentionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInImplementParcelable() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/implementParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("allNullableTypes.kt")
         public void testAllNullableTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/allNullableTypes.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/allNullableTypes.kt");
         }
 
         @TestMetadata("allTypes.kt")
         public void testAllTypes() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/allTypes.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/allTypes.kt");
         }
 
         @TestMetadata("alreadyImplemented.kt")
         public void testAlreadyImplemented() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/alreadyImplemented.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/alreadyImplemented.kt");
         }
 
         @TestMetadata("constructorProperties.kt")
         public void testConstructorProperties() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/constructorProperties.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/constructorProperties.kt");
         }
 
         @TestMetadata("constructorPropertiesWithParameters.kt")
         public void testConstructorPropertiesWithParameters() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/constructorPropertiesWithParameters.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/constructorPropertiesWithParameters.kt");
         }
 
         @TestMetadata("missingConstructor.kt")
         public void testMissingConstructor() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/missingConstructor.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/missingConstructor.kt");
         }
 
         @TestMetadata("missingDescribeContents.kt")
         public void testMissingDescribeContents() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/missingDescribeContents.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/missingDescribeContents.kt");
         }
 
         @TestMetadata("missingWriteToParcel.kt")
         public void testMissingWriteToParcel() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/missingWriteToParcel.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/missingWriteToParcel.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/simple.kt");
         }
 
         @TestMetadata("withTransient.kt")
         public void testWithTransient() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/implementParcelable/withTransient.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/implementParcelable/withTransient.kt");
         }
     }
 
@@ -305,56 +285,52 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class RedoParcelable extends AbstractAndroidIntentionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRedoParcelable() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/redoParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("indirectParcelable.kt")
         public void testIndirectParcelable() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/indirectParcelable.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/indirectParcelable.kt");
         }
 
         @TestMetadata("init.kt")
         public void testInit() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/init.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/init.kt");
         }
 
         @TestMetadata("initWithExtraStatements.kt")
         public void testInitWithExtraStatements() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/initWithExtraStatements.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/initWithExtraStatements.kt");
         }
 
         @TestMetadata("noParcelable.kt")
         public void testNoParcelable() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/noParcelable.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/noParcelable.kt");
         }
 
         @TestMetadata("oldField.kt")
         public void testOldField() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/oldField.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/oldField.kt");
         }
 
         @TestMetadata("oldFieldSecondary.kt")
         public void testOldFieldSecondary() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/oldFieldSecondary.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/oldFieldSecondary.kt");
         }
 
         @TestMetadata("parcelize.kt")
         public void testParcelize() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/parcelize.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/parcelize.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/redoParcelable/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/redoParcelable/simple.kt");
         }
     }
 
@@ -362,44 +338,42 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class RemoveParcelable extends AbstractAndroidIntentionTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRemoveParcelable() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/removeParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("inderectParcelable.kt")
         public void testInderectParcelable() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/removeParcelable/inderectParcelable.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/removeParcelable/inderectParcelable.kt");
         }
 
         @TestMetadata("init.kt")
         public void testInit() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/removeParcelable/init.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/removeParcelable/init.kt");
         }
 
         @TestMetadata("initWithExtraStatements.kt")
         public void testInitWithExtraStatements() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/removeParcelable/initWithExtraStatements.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/removeParcelable/initWithExtraStatements.kt");
         }
 
         @TestMetadata("noParcelable.kt")
         public void testNoParcelable() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/removeParcelable/noParcelable.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/removeParcelable/noParcelable.kt");
         }
 
         @TestMetadata("parcelize.kt")
         public void testParcelize() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/removeParcelable/parcelize.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/removeParcelable/parcelize.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/intention/removeParcelable/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/intention/removeParcelable/simple.kt");
         }
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidResourceIntentionTestGenerated.java

@@ -21,127 +21,111 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AndroidResourceIntentionTestGenerated extends AbstractAndroidResourceIntentionTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInResourceIntention() throws Exception {
         KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClass(this.getClass(), new File("idea/testData/android/resourceIntention"), Pattern.compile("^(.+)\\.test$"), TargetBackend.ANY);
     }
 
     @TestMetadata("createColorValueResource/alreadyExists/alreadyExists.test")
     public void testCreateColorValueResource_alreadyExists_AlreadyExists() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/createColorValueResource/alreadyExists/alreadyExists.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/createColorValueResource/alreadyExists/alreadyExists.test");
     }
 
     @TestMetadata("createColorValueResource/simpleFunction/simpleFunction.test")
     public void testCreateColorValueResource_simpleFunction_SimpleFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/createColorValueResource/simpleFunction/simpleFunction.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/createColorValueResource/simpleFunction/simpleFunction.test");
     }
 
     @TestMetadata("createLayoutResourceFile/alreadyExists/alreadyExists.test")
     public void testCreateLayoutResourceFile_alreadyExists_AlreadyExists() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/createLayoutResourceFile/alreadyExists/alreadyExists.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/createLayoutResourceFile/alreadyExists/alreadyExists.test");
     }
 
     @TestMetadata("createLayoutResourceFile/simpleFunction/simpleFunction.test")
     public void testCreateLayoutResourceFile_simpleFunction_SimpleFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/createLayoutResourceFile/simpleFunction/simpleFunction.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/createLayoutResourceFile/simpleFunction/simpleFunction.test");
     }
 
     @TestMetadata("createStringValueResource/alreadyExists/alreadyExists.test")
     public void testCreateStringValueResource_alreadyExists_AlreadyExists() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/createStringValueResource/alreadyExists/alreadyExists.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/createStringValueResource/alreadyExists/alreadyExists.test");
     }
 
     @TestMetadata("createStringValueResource/simpleFunction/simpleFunction.test")
     public void testCreateStringValueResource_simpleFunction_SimpleFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/createStringValueResource/simpleFunction/simpleFunction.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/createStringValueResource/simpleFunction/simpleFunction.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/activityExtension/activityExtension.test")
     public void testKotlinAndroidAddStringResource_activityExtension_ActivityExtension() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/activityExtension/activityExtension.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/activityExtension/activityExtension.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/activityMethod/activityMethod.test")
     public void testKotlinAndroidAddStringResource_activityMethod_ActivityMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/activityMethod/activityMethod.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/activityMethod/activityMethod.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/classInActivity/classInActivity.test")
     public void testKotlinAndroidAddStringResource_classInActivity_ClassInActivity() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/classInActivity/classInActivity.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/classInActivity/classInActivity.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/extensionLambda/extensionLambda.test")
     public void testKotlinAndroidAddStringResource_extensionLambda_ExtensionLambda() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/extensionLambda/extensionLambda.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/extensionLambda/extensionLambda.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/function/function.test")
     public void testKotlinAndroidAddStringResource_function_Function() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/function/function.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/function/function.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/genericContextExtensionFunction/genericContextExtensionFunction.test")
     public void testKotlinAndroidAddStringResource_genericContextExtensionFunction_GenericContextExtensionFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/genericContextExtensionFunction/genericContextExtensionFunction.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/genericContextExtensionFunction/genericContextExtensionFunction.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/innerClassInActivity/innerClassInActivity.test")
     public void testKotlinAndroidAddStringResource_innerClassInActivity_InnerClassInActivity() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/innerClassInActivity/innerClassInActivity.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/innerClassInActivity/innerClassInActivity.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/innerViewInActivity/innerViewInActivity.test")
     public void testKotlinAndroidAddStringResource_innerViewInActivity_InnerViewInActivity() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/innerViewInActivity/innerViewInActivity.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/innerViewInActivity/innerViewInActivity.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/objectInActivity/objectInActivity.test")
     public void testKotlinAndroidAddStringResource_objectInActivity_ObjectInActivity() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/objectInActivity/objectInActivity.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/objectInActivity/objectInActivity.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/objectInActivityMethod/objectInActivityMethod.test")
     public void testKotlinAndroidAddStringResource_objectInActivityMethod_ObjectInActivityMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/objectInActivityMethod/objectInActivityMethod.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/objectInActivityMethod/objectInActivityMethod.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/objectInFunction/objectInFunction.test")
     public void testKotlinAndroidAddStringResource_objectInFunction_ObjectInFunction() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/objectInFunction/objectInFunction.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/objectInFunction/objectInFunction.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/stringTemplate/stringTemplate.test")
     public void testKotlinAndroidAddStringResource_stringTemplate_StringTemplate() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/stringTemplate/stringTemplate.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/stringTemplate/stringTemplate.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/viewExtensionActivityMethod/viewExtensionActivityMethod.test")
     public void testKotlinAndroidAddStringResource_viewExtensionActivityMethod_ViewExtensionActivityMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/viewExtensionActivityMethod/viewExtensionActivityMethod.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/viewExtensionActivityMethod/viewExtensionActivityMethod.test");
     }
 
     @TestMetadata("kotlinAndroidAddStringResource/viewMethod/viewMethod.test")
     public void testKotlinAndroidAddStringResource_viewMethod_ViewMethod() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/viewMethod/viewMethod.test");
-        doTest(fileName);
+        runTest("idea/testData/android/resourceIntention/kotlinAndroidAddStringResource/viewMethod/viewMethod.test");
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/lint/KotlinLintTestGenerated.java

@@ -21,10 +21,13 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class KotlinLintTestGenerated extends AbstractKotlinLintTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     @TestMetadata("alarm.kt")
     public void testAlarm() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/alarm.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/alarm.kt");
     }
 
     public void testAllFilesPresentInLint() throws Exception {
@@ -33,163 +36,136 @@ public class KotlinLintTestGenerated extends AbstractKotlinLintTest {
 
     @TestMetadata("apiCheck.kt")
     public void testApiCheck() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/apiCheck.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/apiCheck.kt");
     }
 
     @TestMetadata("callSuper.kt")
     public void testCallSuper() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/callSuper.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/callSuper.kt");
     }
 
     @TestMetadata("closeCursor.kt")
     public void testCloseCursor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/closeCursor.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/closeCursor.kt");
     }
 
     @TestMetadata("commitFragment.kt")
     public void testCommitFragment() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/commitFragment.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/commitFragment.kt");
     }
 
     @TestMetadata("findViewById.kt")
     public void testFindViewById() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/findViewById.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/findViewById.kt");
     }
 
     @TestMetadata("javaPerformance.kt")
     public void testJavaPerformance() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/javaPerformance.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/javaPerformance.kt");
     }
 
     @TestMetadata("javaScriptInterface.kt")
     public void testJavaScriptInterface() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/javaScriptInterface.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/javaScriptInterface.kt");
     }
 
     @TestMetadata("layoutInflation.kt")
     public void testLayoutInflation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/layoutInflation.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/layoutInflation.kt");
     }
 
     @TestMetadata("log.kt")
     public void testLog() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/log.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/log.kt");
     }
 
     @TestMetadata("noInternationalSms.kt")
     public void testNoInternationalSms() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/noInternationalSms.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/noInternationalSms.kt");
     }
 
     @TestMetadata("overrideConcrete.kt")
     public void testOverrideConcrete() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/overrideConcrete.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/overrideConcrete.kt");
     }
 
     @TestMetadata("parcel.kt")
     public void testParcel() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/parcel.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/parcel.kt");
     }
 
     @TestMetadata("sdCardTest.kt")
     public void testSdCardTest() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/sdCardTest.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/sdCardTest.kt");
     }
 
     @TestMetadata("setJavaScriptEnabled.kt")
     public void testSetJavaScriptEnabled() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/setJavaScriptEnabled.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/setJavaScriptEnabled.kt");
     }
 
     @TestMetadata("sharedPrefs.kt")
     public void testSharedPrefs() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/sharedPrefs.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/sharedPrefs.kt");
     }
 
     @TestMetadata("showDiagnosticsWhenFileIsRed.kt")
     public void testShowDiagnosticsWhenFileIsRed() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/showDiagnosticsWhenFileIsRed.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/showDiagnosticsWhenFileIsRed.kt");
     }
 
     @TestMetadata("sqlite.kt")
     public void testSqlite() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/sqlite.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/sqlite.kt");
     }
 
     @TestMetadata("supportAnnotation.kt")
     public void testSupportAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/supportAnnotation.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/supportAnnotation.kt");
     }
 
     @TestMetadata("systemServices.kt")
     public void testSystemServices() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/systemServices.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/systemServices.kt");
     }
 
     @TestMetadata("toast.kt")
     public void testToast() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/toast.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/toast.kt");
     }
 
     @TestMetadata("valueOf.kt")
     public void testValueOf() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/valueOf.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/valueOf.kt");
     }
 
     @TestMetadata("velocityTrackerRecycle.kt")
     public void testVelocityTrackerRecycle() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/velocityTrackerRecycle.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/velocityTrackerRecycle.kt");
     }
 
     @TestMetadata("viewConstructor.kt")
     public void testViewConstructor() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/viewConstructor.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/viewConstructor.kt");
     }
 
     @TestMetadata("viewHolder.kt")
     public void testViewHolder() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/viewHolder.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/viewHolder.kt");
     }
 
     @TestMetadata("wrongAnnotation.kt")
     public void testWrongAnnotation() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/wrongAnnotation.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/wrongAnnotation.kt");
     }
 
     @TestMetadata("wrongImport.kt")
     public void testWrongImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/wrongImport.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/wrongImport.kt");
     }
 
     @TestMetadata("wrongViewCall.kt")
     public void testWrongViewCall() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lint/wrongViewCall.kt");
-        doTest(fileName);
+        runTest("idea/testData/android/lint/wrongViewCall.kt");
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidLintQuickfixTestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfixTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInLintQuickfix() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
     }
@@ -29,20 +33,22 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class FindViewById extends AbstractAndroidLintQuickfixTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInFindViewById() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/findViewById"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("nullableType.kt")
         public void testNullableType() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/findViewById/nullableType.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/findViewById/nullableType.kt");
         }
 
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/findViewById/simple.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/findViewById/simple.kt");
         }
     }
 
@@ -50,20 +56,22 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Parcelable extends AbstractAndroidLintQuickfixTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInParcelable() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/parcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("missingCreator.kt")
         public void testMissingCreator() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/parcelable/missingCreator.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/parcelable/missingCreator.kt");
         }
 
         @TestMetadata("noImplementation.kt")
         public void testNoImplementation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/parcelable/noImplementation.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/parcelable/noImplementation.kt");
         }
     }
 
@@ -71,68 +79,62 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class RequiresApi extends AbstractAndroidLintQuickfixTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInRequiresApi() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/requiresApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotation.kt")
         public void testAnnotation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/annotation.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/annotation.kt");
         }
 
         @TestMetadata("companion.kt")
         public void testCompanion() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/companion.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/companion.kt");
         }
 
         @TestMetadata("defaultParameter.kt")
         public void testDefaultParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/defaultParameter.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/defaultParameter.kt");
         }
 
         @TestMetadata("extend.kt")
         public void testExtend() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/extend.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/extend.kt");
         }
 
         @TestMetadata("functionLiteral.kt")
         public void testFunctionLiteral() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/functionLiteral.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/functionLiteral.kt");
         }
 
         @TestMetadata("inlinedConstant.kt")
         public void testInlinedConstant() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/inlinedConstant.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/inlinedConstant.kt");
         }
 
         @TestMetadata("method.kt")
         public void testMethod() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/method.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/method.kt");
         }
 
         @TestMetadata("property.kt")
         public void testProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/property.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/property.kt");
         }
 
         @TestMetadata("topLevelProperty.kt")
         public void testTopLevelProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/topLevelProperty.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/topLevelProperty.kt");
         }
 
         @TestMetadata("when.kt")
         public void testWhen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/requiresApi/when.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/requiresApi/when.kt");
         }
     }
 
@@ -140,16 +142,18 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class SuppressLint extends AbstractAndroidLintQuickfixTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         @TestMetadata("activityMethod.kt")
         public void testActivityMethod() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/activityMethod.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/activityMethod.kt");
         }
 
         @TestMetadata("addToExistingAnnotation.kt")
         public void testAddToExistingAnnotation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/addToExistingAnnotation.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/addToExistingAnnotation.kt");
         }
 
         public void testAllFilesPresentInSuppressLint() throws Exception {
@@ -158,44 +162,37 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
 
         @TestMetadata("constructorParameter.kt")
         public void testConstructorParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/constructorParameter.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/constructorParameter.kt");
         }
 
         @TestMetadata("destructuringDeclaration.kt")
         public void testDestructuringDeclaration() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/destructuringDeclaration.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/destructuringDeclaration.kt");
         }
 
         @TestMetadata("lambdaArgument.kt")
         public void testLambdaArgument() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/lambdaArgument.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/lambdaArgument.kt");
         }
 
         @TestMetadata("lambdaArgumentProperty.kt")
         public void testLambdaArgumentProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/lambdaArgumentProperty.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/lambdaArgumentProperty.kt");
         }
 
         @TestMetadata("methodParameter.kt")
         public void testMethodParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/methodParameter.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/methodParameter.kt");
         }
 
         @TestMetadata("propertyWithLambda.kt")
         public void testPropertyWithLambda() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/propertyWithLambda.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/propertyWithLambda.kt");
         }
 
         @TestMetadata("simpleProperty.kt")
         public void testSimpleProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/suppressLint/simpleProperty.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/suppressLint/simpleProperty.kt");
         }
     }
 
@@ -203,68 +200,62 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TargetApi extends AbstractAndroidLintQuickfixTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTargetApi() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/targetApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotation.kt")
         public void testAnnotation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/annotation.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/annotation.kt");
         }
 
         @TestMetadata("companion.kt")
         public void testCompanion() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/companion.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/companion.kt");
         }
 
         @TestMetadata("defaultParameter.kt")
         public void testDefaultParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/defaultParameter.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/defaultParameter.kt");
         }
 
         @TestMetadata("extend.kt")
         public void testExtend() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/extend.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/extend.kt");
         }
 
         @TestMetadata("functionLiteral.kt")
         public void testFunctionLiteral() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/functionLiteral.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/functionLiteral.kt");
         }
 
         @TestMetadata("inlinedConstant.kt")
         public void testInlinedConstant() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/inlinedConstant.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/inlinedConstant.kt");
         }
 
         @TestMetadata("method.kt")
         public void testMethod() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/method.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/method.kt");
         }
 
         @TestMetadata("property.kt")
         public void testProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/property.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/property.kt");
         }
 
         @TestMetadata("topLevelProperty.kt")
         public void testTopLevelProperty() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/topLevelProperty.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/topLevelProperty.kt");
         }
 
         @TestMetadata("when.kt")
         public void testWhen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetApi/when.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetApi/when.kt");
         }
     }
 
@@ -272,74 +263,67 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class TargetVersionCheck extends AbstractAndroidLintQuickfixTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInTargetVersionCheck() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/targetVersionCheck"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("annotation.kt")
         public void testAnnotation() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/annotation.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/annotation.kt");
         }
 
         @TestMetadata("defaultParameter.kt")
         public void testDefaultParameter() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/defaultParameter.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/defaultParameter.kt");
         }
 
         @TestMetadata("destructuringDeclaration.kt")
         public void testDestructuringDeclaration() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/destructuringDeclaration.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/destructuringDeclaration.kt");
         }
 
         @TestMetadata("expressionBody.kt")
         public void testExpressionBody() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/expressionBody.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/expressionBody.kt");
         }
 
         @TestMetadata("functionLiteral.kt")
         public void testFunctionLiteral() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/functionLiteral.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/functionLiteral.kt");
         }
 
         @TestMetadata("getterWIthExpressionBody.kt")
         public void testGetterWIthExpressionBody() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/getterWIthExpressionBody.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/getterWIthExpressionBody.kt");
         }
 
         @TestMetadata("if.kt")
         public void testIf() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/if.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/if.kt");
         }
 
         @TestMetadata("ifWithBlock.kt")
         public void testIfWithBlock() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/ifWithBlock.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/ifWithBlock.kt");
         }
 
         @TestMetadata("inlinedConstant.kt")
         public void testInlinedConstant() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/inlinedConstant.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/inlinedConstant.kt");
         }
 
         @TestMetadata("method.kt")
         public void testMethod() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/method.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/method.kt");
         }
 
         @TestMetadata("when.kt")
         public void testWhen() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/lintQuickfix/targetVersionCheck/when.kt");
-            doTest(fileName);
+            runTest("idea/testData/android/lintQuickfix/targetVersionCheck/when.kt");
         }
     }
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidQuickFixMultiFileTestGenerated.java

@@ -21,6 +21,10 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class AndroidQuickFixMultiFileTestGenerated extends AbstractAndroidQuickFixMultiFileTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTestWithExtraFile, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInQuickfix() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true);
     }
@@ -29,14 +33,17 @@ public class AndroidQuickFixMultiFileTestGenerated extends AbstractAndroidQuickF
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class AutoImports extends AbstractAndroidQuickFixMultiFileTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithExtraFile, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInAutoImports() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix/autoImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("androidRImport.before.Main.kt")
         public void testAndroidRImport() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/quickfix/autoImports/androidRImport.before.Main.kt");
-            doTestWithExtraFile(fileName);
+            runTest("idea/testData/android/quickfix/autoImports/androidRImport.before.Main.kt");
         }
     }
 
@@ -44,20 +51,22 @@ public class AndroidQuickFixMultiFileTestGenerated extends AbstractAndroidQuickF
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ViewConstructor extends AbstractAndroidQuickFixMultiFileTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestWithExtraFile, TargetBackend.ANY, testDataFilePath);
+        }
+
         public void testAllFilesPresentInViewConstructor() throws Exception {
             KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix/viewConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true);
         }
 
         @TestMetadata("indirect.before.Main.kt")
         public void testIndirect() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/quickfix/viewConstructor/indirect.before.Main.kt");
-            doTestWithExtraFile(fileName);
+            runTest("idea/testData/android/quickfix/viewConstructor/indirect.before.Main.kt");
         }
 
         @TestMetadata("simple.before.Main.kt")
         public void testSimple() throws Exception {
-            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/android/quickfix/viewConstructor/simple.before.Main.kt");
-            doTestWithExtraFile(fileName);
+            runTest("idea/testData/android/quickfix/viewConstructor/simple.before.Main.kt");
         }
     }
 }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompiledKotlinInJavaCompletionTestGenerated.java

@@ -21,181 +21,156 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CompiledKotlinInJavaCompletionTestGenerated extends AbstractCompiledKotlinInJavaCompletionTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInInjava() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/injava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, false);
     }
 
     @TestMetadata("AnnotationParameter.java")
     public void testAnnotationParameter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/AnnotationParameter.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/AnnotationParameter.java");
     }
 
     @TestMetadata("Class.java")
     public void testClass() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/Class.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/Class.java");
     }
 
     @TestMetadata("ClassMembers.java")
     public void testClassMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/ClassMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/ClassMembers.java");
     }
 
     @TestMetadata("ClassObject.java")
     public void testClassObject() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/ClassObject.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/ClassObject.java");
     }
 
     @TestMetadata("ClassObjectField.java")
     public void testClassObjectField() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/ClassObjectField.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/ClassObjectField.java");
     }
 
     @TestMetadata("ClassesFromNamespace.java")
     public void testClassesFromNamespace() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/ClassesFromNamespace.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/ClassesFromNamespace.java");
     }
 
     @TestMetadata("EnumConstants.java")
     public void testEnumConstants() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/EnumConstants.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/EnumConstants.java");
     }
 
     @TestMetadata("InterfaceDefaultImpl.java")
     public void testInterfaceDefaultImpl() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/InterfaceDefaultImpl.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/InterfaceDefaultImpl.java");
     }
 
     @TestMetadata("InterfaceDefaultImplImportedMembers.java")
     public void testInterfaceDefaultImplImportedMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/InterfaceDefaultImplImportedMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/InterfaceDefaultImplImportedMembers.java");
     }
 
     @TestMetadata("InterfaceDefaultImplMembers.java")
     public void testInterfaceDefaultImplMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/InterfaceDefaultImplMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/InterfaceDefaultImplMembers.java");
     }
 
     @TestMetadata("InterfaceDefaultImplStaticImportedMembers.java")
     public void testInterfaceDefaultImplStaticImportedMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/InterfaceDefaultImplStaticImportedMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/InterfaceDefaultImplStaticImportedMembers.java");
     }
 
     @TestMetadata("InterfaceDefaultImplsNonImported.java")
     public void testInterfaceDefaultImplsNonImported() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/InterfaceDefaultImplsNonImported.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/InterfaceDefaultImplsNonImported.java");
     }
 
     @TestMetadata("MultiFileFacade.java")
     public void testMultiFileFacade() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/MultiFileFacade.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/MultiFileFacade.java");
     }
 
     @TestMetadata("MultiFileFacadeMembers.java")
     public void testMultiFileFacadeMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/MultiFileFacadeMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/MultiFileFacadeMembers.java");
     }
 
     @TestMetadata("MultiFileFacadeNoImport.java")
     public void testMultiFileFacadeNoImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/MultiFileFacadeNoImport.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/MultiFileFacadeNoImport.java");
     }
 
     @TestMetadata("Nested.java")
     public void testNested() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/Nested.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/Nested.java");
     }
 
     @TestMetadata("NestedClassMembers.java")
     public void testNestedClassMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/NestedClassMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/NestedClassMembers.java");
     }
 
     @TestMetadata("NestedClassMembers2.java")
     public void testNestedClassMembers2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/NestedClassMembers2.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/NestedClassMembers2.java");
     }
 
     @TestMetadata("NestedNoImport.java")
     public void testNestedNoImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/NestedNoImport.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/NestedNoImport.java");
     }
 
     @TestMetadata("NestedObjectInstance.java")
     public void testNestedObjectInstance() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/NestedObjectInstance.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/NestedObjectInstance.java");
     }
 
     @TestMetadata("ObjectInClassObjects.java")
     public void testObjectInClassObjects() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/ObjectInClassObjects.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/ObjectInClassObjects.java");
     }
 
     @TestMetadata("ObjectInstance.java")
     public void testObjectInstance() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/ObjectInstance.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/ObjectInstance.java");
     }
 
     @TestMetadata("RenamedFacade.java")
     public void testRenamedFacade() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/RenamedFacade.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/RenamedFacade.java");
     }
 
     @TestMetadata("SingleFileFacade.java")
     public void testSingleFileFacade() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/SingleFileFacade.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/SingleFileFacade.java");
     }
 
     @TestMetadata("SingleFileFacadeMembers.java")
     public void testSingleFileFacadeMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/SingleFileFacadeMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/SingleFileFacadeMembers.java");
     }
 
     @TestMetadata("SingleFileFacadeNoImport.java")
     public void testSingleFileFacadeNoImport() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/SingleFileFacadeNoImport.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/SingleFileFacadeNoImport.java");
     }
 
     @TestMetadata("Subpackage.java")
     public void testSubpackage() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/Subpackage.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/Subpackage.java");
     }
 
     @TestMetadata("TopLevelMembers.java")
     public void testTopLevelMembers() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/TopLevelMembers.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/TopLevelMembers.java");
     }
 
     @TestMetadata("TraitMember.java")
     public void testTraitMember() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/injava/TraitMember.java");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/injava/TraitMember.java");
     }
 }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompletionIncrementalResolveTestGenerated.java

@@ -21,67 +21,61 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class CompletionIncrementalResolveTestGenerated extends AbstractCompletionIncrementalResolveTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInIncrementalResolve() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/incrementalResolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("codeAboveChanged.kt")
     public void testCodeAboveChanged() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/codeAboveChanged.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/codeAboveChanged.kt");
     }
 
     @TestMetadata("codeAboveChanged2.kt")
     public void testCodeAboveChanged2() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/codeAboveChanged2.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/codeAboveChanged2.kt");
     }
 
     @TestMetadata("dataFlowInfoFromPrevStatement.kt")
     public void testDataFlowInfoFromPrevStatement() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/dataFlowInfoFromPrevStatement.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/dataFlowInfoFromPrevStatement.kt");
     }
 
     @TestMetadata("dataFlowInfoFromSameStatement.kt")
     public void testDataFlowInfoFromSameStatement() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/dataFlowInfoFromSameStatement.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/dataFlowInfoFromSameStatement.kt");
     }
 
     @TestMetadata("doNotAnalyzeComplexStatement.kt")
     public void testDoNotAnalyzeComplexStatement() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/doNotAnalyzeComplexStatement.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/doNotAnalyzeComplexStatement.kt");
     }
 
     @TestMetadata("noDataFlowFromOldStatement.kt")
     public void testNoDataFlowFromOldStatement() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/noDataFlowFromOldStatement.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/noDataFlowFromOldStatement.kt");
     }
 
     @TestMetadata("noPrevStatement.kt")
     public void testNoPrevStatement() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/noPrevStatement.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/noPrevStatement.kt");
     }
 
     @TestMetadata("outOfBlockModification.kt")
     public void testOutOfBlockModification() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/outOfBlockModification.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/outOfBlockModification.kt");
     }
 
     @TestMetadata("prevStatementNotResolved.kt")
     public void testPrevStatementNotResolved() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/prevStatementNotResolved.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/prevStatementNotResolved.kt");
     }
 
     @TestMetadata("sameStatement.kt")
     public void testSameStatement() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/incrementalResolve/sameStatement.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/incrementalResolve/sameStatement.kt");
     }
 }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/Java8BasicCompletionTestGenerated.java

@@ -21,19 +21,21 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class Java8BasicCompletionTestGenerated extends AbstractJava8BasicCompletionTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInJava8() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/java8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
     @TestMetadata("CollectionMethods.kt")
     public void testCollectionMethods() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/java8/CollectionMethods.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/java8/CollectionMethods.kt");
     }
 
     @TestMetadata("StreamMethods.kt")
     public void testStreamMethods() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/java8/StreamMethods.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/java8/StreamMethods.kt");
     }
 }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmWithLibBasicCompletionTestGenerated.java

@@ -21,55 +21,51 @@ import java.util.regex.Pattern;
 @TestDataPath("$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners.class)
 public class JvmWithLibBasicCompletionTestGenerated extends AbstractJvmWithLibBasicCompletionTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+    }
+
     public void testAllFilesPresentInWithLib() throws Exception {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/withLib"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, false);
     }
 
     @TestMetadata("NamedArgumentsJava.kt")
     public void testNamedArgumentsJava() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/NamedArgumentsJava.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/NamedArgumentsJava.kt");
     }
 
     @TestMetadata("NamedArgumentsKotlin.kt")
     public void testNamedArgumentsKotlin() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/NamedArgumentsKotlin.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/NamedArgumentsKotlin.kt");
     }
 
     @TestMetadata("SamAdapter.kt")
     public void testSamAdapter() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/SamAdapter.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/SamAdapter.kt");
     }
 
     @TestMetadata("SamAdapterAndGenerics.kt")
     public void testSamAdapterAndGenerics() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/SamAdapterAndGenerics.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/SamAdapterAndGenerics.kt");
     }
 
     @TestMetadata("TopLevelNonImportedExtFun.kt")
     public void testTopLevelNonImportedExtFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedExtFun.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedExtFun.kt");
     }
 
     @TestMetadata("TopLevelNonImportedExtProp.kt")
     public void testTopLevelNonImportedExtProp() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedExtProp.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedExtProp.kt");
     }
 
     @TestMetadata("TopLevelNonImportedFun.kt")
     public void testTopLevelNonImportedFun() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedFun.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedFun.kt");
     }
 
     @TestMetadata("TopLevelNonImportedProperty.kt")
     public void testTopLevelNonImportedProperty() throws Exception {
-        String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedProperty.kt");
-        doTest(fileName);
+        runTest("idea/idea-completion/testData/basic/withLib/TopLevelNonImportedProperty.kt");
     }
 }