Drop TestCaseWithTempDir usage from scripting compiler plugin tests

fighting with flaky tests

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCompilerPluginTest.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.scripting.compiler.plugin
 
+import com.intellij.openapi.Disposable
 import junit.framework.TestCase
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.ExitCode
@@ -29,7 +30,6 @@ import org.jetbrains.kotlin.scripting.definitions.discoverScriptTemplatesInClass
 import org.jetbrains.kotlin.scripting.definitions.loadScriptTemplatesFromClasspath
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
-import org.jetbrains.kotlin.test.TestCaseWithTmpdir
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.utils.KotlinPaths
 import org.jetbrains.kotlin.utils.PathUtil
@@ -37,7 +37,7 @@ import org.junit.Assert
 import java.io.File
 import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
 
-class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
+class ScriptingCompilerPluginTest : TestCase() {
 
     companion object {
         const val TEST_DATA_DIR = "plugins/scripting/scripting-compiler/testData"
@@ -54,7 +54,11 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
     val scriptingClasspath = listOf("kotlin-scripting-common.jar").map { File(kotlinPaths.libPath, it) }
 
     private fun createEnvironment(
-        sources: List<String>, destDir: File, messageCollector: MessageCollector, confBody: CompilerConfiguration.() -> Unit
+        sources: List<String>,
+        destDir: File,
+        messageCollector: MessageCollector,
+        disposable: Disposable,
+        confBody: CompilerConfiguration.() -> Unit
     ): KotlinCoreEnvironment {
         val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.NO_KOTLIN_REFLECT, TestJdkKind.FULL_JDK).apply {
             put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
@@ -64,7 +68,7 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
         }
         configuration.add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, ScriptingCompilerConfigurationComponentRegistrar())
 
-        return KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+        return KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 
     fun testScriptResolverEnvironmentArgsParsing() {
@@ -90,6 +94,8 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
 
     fun testLazyScriptDefinitionDiscovery() {
 
+        withTempDir { tmpdir ->
+            withDisposable { disposable ->
                 // Three tests in one function: the direct loading, the discovery code separately, and as a part of regular compilation
                 // tests are combined to avoid multiple compilation of script definition modules
 
@@ -103,7 +109,7 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
                 val messageCollector = TestMessageCollector()
 
                 val definitionsCompileResult = KotlinToJVMBytecodeCompiler.compileBunchOfSources(
-            createEnvironment(defClasses.map { File(defsSrc, "$it.kt").canonicalPath }, defsOut, messageCollector) {
+                    createEnvironment(defClasses.map { File(defsSrc, "$it.kt").canonicalPath }, defsOut, messageCollector, disposable) {
                         addJvmClasspathRoots(runtimeClasspath)
                         addJvmClasspathRoots(scriptingClasspath)
                     }
@@ -117,7 +123,11 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
 
                 loadScriptTemplatesFromClasspath(
                     listOf("TestScriptWithReceivers", "TestScriptWithSimpleEnvVars"),
-            listOf(defsOut), emptyList(), this::class.java.classLoader, defaultJvmScriptingHostConfiguration, messageCollector.reporter
+                    listOf(defsOut),
+                    emptyList(),
+                    this::class.java.classLoader,
+                    defaultJvmScriptingHostConfiguration,
+                    messageCollector.reporter
                 ).toList()
 
                 for (def in defClasses) {
@@ -163,9 +173,9 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
 
                 messageCollector.clear()
 
-        val scriptFiles = scriptsSrc.listFiles { file: File -> file.extension == "kts" }.map { it.canonicalPath}
+                val scriptFiles = scriptsSrc.listFiles { file: File -> file.extension == "kts" }.map { it.canonicalPath }
 
-        val scriptsCompileEnv = createEnvironment(scriptFiles, scriptsOut, messageCollector) {
+                val scriptsCompileEnv = createEnvironment(scriptFiles, scriptsOut, messageCollector, disposable) {
                     addJvmClasspathRoots(runtimeClasspath)
                     addJvmClasspathRoots(scriptingClasspath)
                     addJvmClasspathRoot(defsOut)
@@ -183,9 +193,13 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
 
                 Assert.assertEquals(ExitCode.OK, exitCode)
             }
+        }
+    }
 
     fun testLazyScriptDefinitionOtherAnnotation() {
 
+        withTempDir { tmpdir ->
+            withDisposable { disposable ->
                 val defsOut = File(tmpdir, "testLazyScriptDefinition/out/otherAnn")
                 val defsSrc = File(TEST_DATA_DIR, "lazyDefinitions/definitions")
                 val defClasses = listOf("TestScriptWithOtherAnnotation")
@@ -193,7 +207,7 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
                 val messageCollector = TestMessageCollector()
 
                 val definitionsCompileResult = KotlinToJVMBytecodeCompiler.compileBunchOfSources(
-            createEnvironment(defClasses.map { File(defsSrc, "$it.kt").canonicalPath }, defsOut, messageCollector) {
+                    createEnvironment(defClasses.map { File(defsSrc, "$it.kt").canonicalPath }, defsOut, messageCollector, disposable) {
                         addJvmClasspathRoots(runtimeClasspath)
                         addJvmClasspathRoots(scriptingClasspath)
                     }
@@ -224,6 +238,8 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
                     "Unexpected messages from discovery sequence:\n$messageCollector"
                 }
             }
+        }
+    }
 }
 
 

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/plugin/testUtil.kt

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.scripting.compiler.plugin
 
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.util.Disposer
 import junit.framework.Assert
 import org.jetbrains.kotlin.cli.common.CLITool
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -12,6 +14,7 @@ import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.InputStream
 import java.io.PrintStream
+import java.nio.file.Files
 import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
 
@@ -151,3 +154,22 @@ internal fun <T> captureOutErrRet(body: () -> T): Triple<String, String, T> {
     return Triple(outStream.toString().trim(), errStream.toString().trim(), ret)
 }
 
+internal fun <R> withTempDir(keyName: String = "tmp", body: (File) -> R) {
+    val tempDir = Files.createTempDirectory(keyName).toFile()
+    try {
+        body(tempDir)
+    } finally {
+        tempDir.deleteRecursively()
+    }
+}
+
+internal fun <R> withDisposable(body: (Disposable) -> R) {
+    val disposable = Disposer.newDisposable()
+    try {
+        body(disposable)
+    } finally {
+        Disposer.dispose(disposable)
+    }
+}
+
+