Split 'analyzeAndCheck' into 'shouldSkipTest' and 'setupEnvironment'

compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.checkers.javac
 
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTestWithStdLib
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils.getHomeDirectory
@@ -24,24 +25,24 @@ import java.io.File
 
 abstract class AbstractDiagnosticsTestWithStdLibUsingJavac : AbstractDiagnosticsTestWithStdLib() {
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+
+    override fun shouldSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
+        return isJavacSkipTest(wholeFile, files)
+    }
+
+    override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList<TestFile>) {
         val testDataFileText = testDataFile.readText()
-        if (InTextDirectivesUtils.isDirectiveDefined(testDataFileText, "// JAVAC_SKIP")) {
+
-            println("${testDataFile.name} test is skipped")
-            return
-        }
         val groupedByModule = files.groupBy(TestFile::module)
         val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) }
 
         if (InTextDirectivesUtils.isDirectiveDefined(testDataFileText, "// FULL_JDK")) {
             environment.registerJavac(kotlinFiles = allKtFiles)
-        }
+        } else {
-        else {
             val mockJdk = listOf(File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar"))
             environment.registerJavac(kotlinFiles = allKtFiles, bootClasspath = mockJdk)
         }
 
         environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
-        super.analyzeAndCheck(testDataFile, files)
     }
 }

compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignAnnotationsTest.kt

@@ -17,18 +17,16 @@
 package org.jetbrains.kotlin.checkers.javac
 
 import org.jetbrains.kotlin.checkers.AbstractForeignAnnotationsTest
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import java.io.File
 
 abstract class AbstractJavacForeignAnnotationsTest : AbstractForeignAnnotationsTest() {
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList<TestFile>) {
         val groupedByModule = files.groupBy(TestFile::module)
         val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) }
         environment.registerJavac(kotlinFiles = allKtFiles)
         environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
-
-        super.analyzeAndCheck(testDataFile, files)
     }
-
 }

compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractJavacForeignJava8AnnotationsTest.kt

@@ -17,21 +17,22 @@
 package org.jetbrains.kotlin.checkers.javac
 
 import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsTest
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import java.io.File
 
 abstract class AbstractJavacForeignJava8AnnotationsTest : AbstractForeignJava8AnnotationsTest() {
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun shouldSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
-        if (files.any { file -> InTextDirectivesUtils.isDirectiveDefined(file.expectedText, "// SKIP_JAVAC") }) return
+        return isSkipJavacTest(wholeFile, files)
+    }
 
+    override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList<TestFile>) {
         val groupedByModule = files.groupBy(TestFile::module)
         val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) }
         environment.registerJavac(kotlinFiles = allKtFiles)
         environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
-
-        super.analyzeAndCheck(testDataFile, files)
     }
 
 }

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathTest.kt

@@ -42,9 +42,8 @@ abstract class AbstractForeignAnnotationsNoAnnotationInClasspathTest : AbstractF
         return listOf(compiledJavaPath) + testAnnotations
     }
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun shouldSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
-        if (files.any { file -> InTextDirectivesUtils.isDirectiveDefined(file.expectedText, "// SOURCE_RETENTION_ANNOTATIONS") }) return
+        return files.any { file -> InTextDirectivesUtils.isDirectiveDefined(file.expectedText, "// SOURCE_RETENTION_ANNOTATIONS") }
-        super.analyzeAndCheck(testDataFile, files)
     }
 
     override fun isJavaSourceRootNeeded() = false

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignJava8AnnotationsTest.kt

@@ -28,9 +28,8 @@ abstract class AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest : Abst
     override val annotationsPath: String
         get() = JAVA8_ANNOTATION_SOURCES_PATH
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun shouldSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
-        if (skipForCompiledVersion(files)) return
+        return skipForCompiledVersion(files)
-        super.analyzeAndCheck(testDataFile, files)
     }
 }
 
@@ -39,9 +38,8 @@ abstract class AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClas
     override val annotationsPath: String
         get() = JAVA8_ANNOTATION_SOURCES_PATH
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun shouldSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
-        if (skipForCompiledVersion(files)) return
+        return skipForCompiledVersion(files)
-        super.analyzeAndCheck(testDataFile, files)
     }
 }
 

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt

@@ -52,6 +52,7 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl
+import org.jetbrains.kotlin.test.InTextDirectivesUtils.isDirectiveDefined
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinBaseTest
 import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF
@@ -91,10 +92,17 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         files: List<TestFile>
     ) {
         environment = createEnvironment(wholeFile)
+        //after environment initialization cause of `tearDown` logic, maybe it's obsolete
+        if (shouldSkipTest(wholeFile, files)) {
+            println("${wholeFile.name} test is skipped")
+            return
+        }
         setupEnvironment(environment)
         analyzeAndCheck(wholeFile, files)
     }
 
+    protected open fun shouldSkipTest(wholeFile: File, files: List<TestFile>) : Boolean = false
+
     protected abstract fun analyzeAndCheck(testDataFile: File, files: List<TestFile>)
 
     protected open fun getKtFiles(testFiles: List<TestFile>, includeExtras: Boolean): List<KtFile> {
@@ -477,6 +485,23 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             val textWithoutDiagnostics = KotlinTestUtils.doLoadFile(file).replace(DIAGNOSTIC_IN_TESTDATA_PATTERN, "")
             return StringUtil.convertLineSeparators(textWithoutDiagnostics.trim()).trimTrailingWhitespacesAndAddNewlineAtEOF()
         }
+
+        fun isJavacSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
+            val testDataFileText = wholeFile.readText()
+            if (isDirectiveDefined(testDataFileText, "// JAVAC_SKIP")) {
+                return true
+            }
+            return false
+        }
+
+        //TODO: merge with isJavacSkipTest
+        fun isSkipJavacTest(wholeFile: File, files: List<TestFile>): Boolean {
+            val testDataFileText = wholeFile.readText()
+            if (isDirectiveDefined(testDataFileText, "// SKIP_JAVAC")) {
+                return true
+            }
+            return false
+        }
     }
 
     private fun parseJvmTarget(directiveMap: Map<String, String>) = directiveMap[JVM_TARGET]?.let { JvmTarget.fromString(it) }

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

@@ -97,6 +97,10 @@ public abstract class KotlinMultiFileTestWithJava<M extends KotlinBaseTest.TestM
 
     }
 
+    protected void setupEnvironment(@NotNull KotlinCoreEnvironment environment,@NotNull File testDataFile, @NotNull List<BaseDiagnosticsTest.TestFile> files) {
+        setupEnvironment(environment);
+    }
+
     @NotNull
     protected ConfigurationKind getConfigurationKind() {
         return ConfigurationKind.JDK_ONLY;

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.checkers.javac
 
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils.getHomeDirectory
@@ -24,24 +25,22 @@ import java.io.File
 
 abstract class AbstractDiagnosticsUsingJavacTest : AbstractDiagnosticsTest() {
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun shouldSkipTest(wholeFile: File, files: List<TestFile>): Boolean {
+        return isJavacSkipTest(wholeFile, files)
+    }
+
+    override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList<TestFile>) {
         val testDataFileText = testDataFile.readText()
-        if (InTextDirectivesUtils.isDirectiveDefined(testDataFileText, "// JAVAC_SKIP")) {
-            println("${testDataFile.name} test is skipped")
-            return
-        }
         val groupedByModule = files.groupBy(TestFile::module)
         val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) }
 
         if (InTextDirectivesUtils.isDirectiveDefined(testDataFileText, "// FULL_JDK")) {
             environment.registerJavac(kotlinFiles = allKtFiles)
-        }
+        } else {
-        else {
             val mockJdk = listOf(File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar"))
             environment.registerJavac(kotlinFiles = allKtFiles, bootClasspath = mockJdk)
         }
 
         environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
-        super.analyzeAndCheck(testDataFile, files)
     }
 }

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.checkers.javac
 
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
@@ -25,14 +26,13 @@ abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() {
 
     private var useJavac = true
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList<TestFile>) {
         if (useJavac) {
             val groupedByModule = files.groupBy(TestFile::module)
             val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) }
             environment.registerJavac(kotlinFiles = allKtFiles)
             environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
         }
-        super.analyzeAndCheck(testDataFile, files)
     }
 
     fun doTestWithoutJavacWrapper(path: String) {

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.checkers.javac
 
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import java.io.File
 
@@ -24,14 +25,13 @@ abstract class AbstractJavacFieldResolutionTest : AbstractDiagnosticsTest() {
 
     private var useJavac = true
 
-    override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {
+    override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: MutableList<TestFile>) {
         if (useJavac) {
             val groupedByModule = files.groupBy(TestFile::module)
             val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) }
             environment.registerJavac(kotlinFiles = allKtFiles)
             environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
         }
-        super.analyzeAndCheck(testDataFile, files)
     }
 
     fun doTestWithoutJavacWrapper(path: String) {