[TEST] Introduce test-infrastructure-utils module and extract common test utilities here

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.android.tests
 
-import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.io.FileUtil
@@ -23,6 +22,7 @@ import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.*
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.File
 import java.io.FileWriter
@@ -303,7 +303,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                         if (kind.withReflection) JVM8REFLECT else JVM8
                     } else if (kind.withReflection) REFLECT else COMMON
                     val filesHolder = holders.getOrPut(key) {
-                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
+                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind,
+                                                                               KtTestUtil.getAnnotationsJar()
+                        ).apply {
                             println("Creating new configuration by $key")
                             KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
@@ -341,7 +343,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         @Throws(IOException::class)
         internal fun writeAndroidSkdToLocalProperties(pathManager: PathManager) {
-            val sdkRoot = KotlinTestUtils.getAndroidSdkSystemIndependentPath()
+            val sdkRoot = KtTestUtil.getAndroidSdkSystemIndependentPath()
             println("Writing android sdk to local.properties: $sdkRoot")
             val file = File(pathManager.tmpFolder + "/local.properties")
             FileWriter(file).use { fw -> fw.write("sdk.dir=$sdkRoot") }

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/PathManager.java

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android.tests;
 
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.File;
 
@@ -69,7 +69,7 @@ public class PathManager {
     }
 
     public String getAndroidSdkRoot() {
-        return KotlinTestUtils.getAndroidSdkSystemIndependentPath();
+        return KtTestUtil.getAndroidSdkSystemIndependentPath();
     }
 
     public String getAndroidModuleRoot() {

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.daemon
 
 import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -30,13 +30,16 @@ import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.PrintStream
 import java.net.URLClassLoader
 import java.nio.file.Path
-import kotlin.io.path.*
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.createTempFile
+import kotlin.io.path.deleteIfExists
 
 @OptIn(ExperimentalPathApi::class)
 class CompilerApiTest : KotlinIntegrationTestBase() {
@@ -83,8 +86,8 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
         return code to outputs
     }
 
-    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
-    private fun getSimpleScriptBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/simpleScript"
+    private fun getSimpleScriptBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/simpleScript"
 
     private fun run(baseDir: String, logName: String, vararg args: String): Int = runJava(baseDir, logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.daemon.client.*
 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.KotlinPaths
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -95,8 +95,8 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             assertEquals("build results differ", AbstractCliTest.removePerfOutput(res1.out), AbstractCliTest.removePerfOutput(res2.out))
     }
 
-    private fun getTestBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
+    private fun getTestBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
-    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
 
     private fun run(logName: String, vararg args: String): Int = runJava(getTestBaseDir(), logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.daemon.experimental.integration
 import com.intellij.openapi.application.ApplicationManager
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.test.IgnoreAll
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import org.junit.runner.RunWith
 import java.io.File
@@ -31,7 +32,8 @@ import java.net.URLClassLoader
 import java.nio.file.Path
 import java.util.logging.LogManager
 import java.util.logging.Logger
-import kotlin.io.path.*
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.createTempFile
 
 private val logFiles = arrayListOf<String>()
 
@@ -150,8 +152,8 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
         code to outputs
     }
 
-    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
-    private fun getSimpleScriptBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/simpleScript"
+    private fun getSimpleScriptBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/simpleScript"
 
     private fun run(baseDir: String, logName: String, vararg args: String): Int = runJava(baseDir, logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.daemon.common.experimental.findCallbackServerSocket
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.progress.experimental.CompilationCanceledStatus
 import org.jetbrains.kotlin.test.IgnoreAll
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.KotlinPaths
 import org.junit.runner.RunWith
 import java.io.ByteArrayOutputStream
@@ -157,8 +157,8 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
         }
     }
 
-    private fun getTestBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
+    private fun getTestBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
-    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
 
     private fun run(logName: String, vararg args: String): Int = runJava(getTestBaseDir(), logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.daemon.experimental.CompileServiceServerSideImpl
 import org.jetbrains.kotlin.daemon.loggerCompatiblePath
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.test.IgnoreAll
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.runner.RunWith
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -36,7 +36,9 @@ import java.util.*
 import java.util.logging.LogManager
 import java.util.logging.Logger
 import kotlin.concurrent.schedule
-import kotlin.io.path.*
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.createTempFile
+import kotlin.io.path.deleteIfExists
 
 @OptIn(ExperimentalPathApi::class)
 @RunWith(IgnoreAll::class)
@@ -364,7 +366,7 @@ class ConnectionsTest : KotlinIntegrationTestBase() {
                                 CompileService.NO_SESSION,
                                 arrayOf(
                                     "-include-runtime",
-                                    File(KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp", "hello.kt").absolutePath,
+                                    File(KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp", "hello.kt").absolutePath,
                                     "-d",
                                     jar
                                 ),

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -31,9 +31,9 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType
 import org.jetbrains.kotlin.test.*
-import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar
 import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar
 import java.io.File
 import java.io.IOException
 import kotlin.reflect.jvm.javaField

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtParsingTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import kotlin.reflect.full.memberProperties
 import kotlin.reflect.jvm.isAccessible
@@ -45,7 +46,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
     "kt",
     KotlinParserDefinition()
 ) {
-    override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory()
+    override fun getTestDataPath() = KtTestUtil.getHomeDirectory()
 
     private fun createFile(filePath: String, fileType: IElementType): PsiFile {
         val psiFactory = KtPsiFactory(myProject)

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJvmCompilerRunnerTest.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.incremental.utils.TestCompilationResult
 import org.jetbrains.kotlin.incremental.utils.TestICReporter
 import org.jetbrains.kotlin.incremental.utils.TestMessageCollector
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.ByteArrayOutputStream
 import java.io.File
 import javax.tools.ToolProvider
@@ -79,6 +79,6 @@ abstract class AbstractIncrementalJvmCompilerRunnerTest : AbstractIncrementalCom
     private val compileClasspath =
         listOf(
             kotlinStdlibJvm,
-            KotlinTestUtils.getAnnotationsJar()
+            KtTestUtil.getAnnotationsJar()
         ).joinToString(File.pathSeparator) { it.canonicalPath }
 }

compiler/test-infrastructure-utils/build.gradle.kts

@@ -0,0 +1,27 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    testImplementation(project(":compiler:fir:entrypoint"))
+    testImplementation(project(":compiler:cli"))
+    testImplementation(intellijCoreDep()) { includeJars("intellij-core") }
+
+    testCompileOnly(project(":kotlin-reflect-api"))
+    testRuntimeOnly(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":core:descriptors.runtime"))
+
+    testImplementation(intellijDep()) {
+        // This dependency is needed only for FileComparisonFailure
+        includeJars("idea_rt", rootProject = rootProject)
+        isTransitive = false
+    }
+}
+
+sourceSets {
+    "main" { none() }
+    "test" { projectDefault() }
+}
+
+testsJar()

compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt

@@ -9,7 +9,6 @@ import com.intellij.util.containers.Stack
 import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil
 import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo
 import java.io.File
-import java.lang.StringBuilder
 
 object CodeMetaInfoRenderer {
     fun renderTagsToText(

compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java

@@ -0,0 +1,196 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.test.util;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtilRt;
+import com.intellij.openapi.vfs.CharsetToolkit;
+import com.intellij.psi.PsiFileFactory;
+import com.intellij.psi.impl.PsiFileFactoryImpl;
+import com.intellij.testFramework.LightVirtualFile;
+import com.intellij.util.PathUtil;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.idea.KotlinLanguage;
+import org.jetbrains.kotlin.psi.KtFile;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class KtTestUtil {
+    private static String homeDir = computeHomeDirectory();
+
+    @NotNull
+    public static File tmpDirForTest(@NotNull String testClassName, @NotNull String testName) throws IOException {
+        return normalizeFile(FileUtil.createTempDirectory(testClassName, testName, false));
+    }
+
+    @NotNull
+    public static File tmpDir(String name) throws IOException {
+        return normalizeFile(FileUtil.createTempDirectory(name, "", false));
+    }
+
+    @NotNull
+    public static File tmpDirForReusableFolder(String name) throws IOException {
+        return normalizeFile(FileUtil.createTempDirectory(new File(System.getProperty("java.io.tmpdir")), name, "", true));
+    }
+
+    private static File normalizeFile(File file) throws IOException {
+        // Get canonical file to be sure that it's the same as inside the compiler,
+        // for example, on Windows, if a canonical path contains any space from FileUtil.createTempDirectory we will get
+        // a File with short names (8.3) in its path and it will break some normalization passes in tests.
+        return file.getCanonicalFile();
+    }
+
+    @NotNull
+    public static KtFile createFile(@NotNull @NonNls String name, @NotNull String text, @NotNull Project project) {
+        String shortName = name.substring(name.lastIndexOf('/') + 1);
+        shortName = shortName.substring(shortName.lastIndexOf('\\') + 1);
+        LightVirtualFile virtualFile = new LightVirtualFile(shortName, KotlinLanguage.INSTANCE, StringUtilRt.convertLineSeparators(text));
+
+        virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
+        PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project);
+        //noinspection ConstantConditions
+        return (KtFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false);
+    }
+
+    public static String doLoadFile(String myFullDataPath, String name) throws IOException {
+        String fullName = myFullDataPath + File.separatorChar + name;
+        return doLoadFile(new File(fullName));
+    }
+
+    public static String doLoadFile(@NotNull File file) throws IOException {
+        try {
+            return FileUtil.loadFile(file, CharsetToolkit.UTF8, true);
+        }
+        catch (FileNotFoundException fileNotFoundException) {
+            /*
+             * Unfortunately, the FileNotFoundException will only show the relative path in it's exception message.
+             * This clarifies the exception by showing the full path.
+             */
+            String messageWithFullPath = file.getAbsolutePath() + " (No such file or directory)";
+            throw new IOException(
+                    "Ensure you have your 'Working Directory' configured correctly as the root " +
+                    "Kotlin project directory in your test configuration\n\t" +
+                    messageWithFullPath,
+                    fileNotFoundException);
+        }
+    }
+
+    public static String getFilePath(File file) {
+        return FileUtil.toSystemIndependentName(file.getPath());
+    }
+
+    @NotNull
+    public static File getJdk9Home() {
+        String jdk9 = System.getenv("JDK_9");
+        if (jdk9 == null) {
+            jdk9 = System.getenv("JDK_19");
+            if (jdk9 == null) {
+                throw new AssertionError("Environment variable JDK_9 is not set!");
+            }
+        }
+        return new File(jdk9);
+    }
+
+    @Nullable
+    public static File getJdk11Home() {
+        String jdk11 = System.getenv("JDK_11");
+        if (jdk11 == null) {
+            return null;
+        }
+        return new File(jdk11);
+    }
+
+    @NotNull
+    public static File getJdk15Home() {
+        String jdk15 = System.getenv("JDK_15");
+
+        if (jdk15 == null) {
+            jdk15 = System.getenv("JDK_15_0");
+        }
+
+        if (jdk15 == null) {
+            throw new AssertionError("Environment variable JDK_15 is not set!");
+        }
+        return new File(jdk15);
+    }
+
+    @NotNull
+    public static String getTestDataPathBase() {
+        return getHomeDirectory() + "/compiler/testData";
+    }
+
+    @NotNull
+    public static String getHomeDirectory() {
+        return homeDir;
+    }
+
+    @NotNull
+    private static String computeHomeDirectory() {
+        String userDir = System.getProperty("user.dir");
+        File dir = new File(userDir == null ? "." : userDir);
+        return FileUtil.toCanonicalPath(dir.getAbsolutePath());
+    }
+
+    public static File findMockJdkRtJar() {
+        return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar");
+    }
+
+    // Differs from common mock JDK only by one additional 'nonExistingMethod' in Collection and constructor from Double in Throwable
+    // It's needed to test the way we load additional built-ins members that neither in black nor white lists
+    public static File findMockJdkRtModified() {
+        return new File(getHomeDirectory(), "compiler/testData/mockJDKModified/rt.jar");
+    }
+
+    public static File findAndroidApiJar() {
+        String androidJarProp = System.getProperty("android.jar");
+        File androidJarFile = androidJarProp == null ? null : new File(androidJarProp);
+        if (androidJarFile == null || !androidJarFile.isFile()) {
+            throw new RuntimeException(
+                    "Unable to get a valid path from 'android.jar' property (" +
+                    androidJarProp +
+                    "), please point it to the 'android.jar' file location");
+        }
+        return androidJarFile;
+    }
+
+    @NotNull
+    public static File findAndroidSdk() {
+        String androidSdkProp = System.getProperty("android.sdk");
+        File androidSdkDir = androidSdkProp == null ? null : new File(androidSdkProp);
+        if (androidSdkDir == null || !androidSdkDir.isDirectory()) {
+            throw new RuntimeException(
+                    "Unable to get a valid path from 'android.sdk' property (" +
+                    androidSdkProp +
+                    "), please point it to the android SDK location");
+        }
+        return androidSdkDir;
+    }
+
+    public static String getAndroidSdkSystemIndependentPath() {
+        return PathUtil.toSystemIndependentName(findAndroidSdk().getAbsolutePath());
+    }
+
+    public static File getAnnotationsJar() {
+        return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/annotations.jar");
+    }
+
+    public static void mkdirs(@NotNull File file) {
+        if (file.isDirectory()) {
+            return;
+        }
+        if (!file.mkdirs()) {
+            if (file.exists()) {
+                throw new IllegalStateException("Failed to create " + file + ": file exists and not a directory");
+            }
+            throw new IllegalStateException("Failed to create " + file);
+        }
+    }
+}

compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt

@@ -13,8 +13,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment.Companion.cre
 import org.jetbrains.kotlin.codegen.AbstractBlackBoxCodegenTest
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.nio.file.Paths
 import java.util.*
@@ -30,7 +30,7 @@ abstract class AbstractCompileKotlinAgainstKlibTest : AbstractBlackBoxCodegenTes
         klibName = Paths.get(outputDir.toString(), wholeFile.name.toString().removeSuffix(".kt")).toString()
 
         val classpath: MutableList<File> = ArrayList()
-        classpath.add(KotlinTestUtils.getAnnotationsJar())
+        classpath.add(KtTestUtil.getAnnotationsJar())
         val configuration = createConfiguration(
             configurationKind, getTestJdkKind(files), backend, classpath, listOf(outputDir), files
         )

compiler/tests-common/build.gradle.kts

@@ -48,6 +48,7 @@ dependencies {
     testCompile(project(":kotlin-test:kotlin-test-jvm"))
     testCompile(projectTests(":compiler:tests-common-jvm6"))
     testCompile(project(":kotlin-scripting-compiler-impl"))
+    testCompile(projectTests(":compiler:test-infrastructure-utils"))
     testCompile(commonDep("junit:junit"))
     testCompile(androidDxJar()) { isTransitive = false }
     testCompile(commonDep("com.android.tools:r8"))

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

@@ -20,7 +20,7 @@ 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
+import org.jetbrains.kotlin.test.util.KtTestUtil.getHomeDirectory
 import java.io.File
 
 abstract class AbstractDiagnosticsTestWithStdLibUsingJavac : AbstractDiagnosticsTestWithStdLib() {

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

@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.checkers
 
 import org.jetbrains.kotlin.codegen.CodegenTestUtil
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractForeignAnnotationsNoAnnotationInClasspathTest : AbstractForeignAnnotationsTest() {
     // This should be executed after setUp runs, since setUp changes the root folder
     // for temporary files.
     private val compiledJavaPath by lazy {
-        KotlinTestUtils.tmpDir("java-compiled-files")
+        KtTestUtil.tmpDir("java-compiled-files")
     }
 
     override fun getExtraClasspath(): List<File> {

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

@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl
 import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.InTextDirectivesUtils.isDirectiveDefined
 import org.jetbrains.kotlin.test.KotlinBaseTest
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.junit.Assert
 import java.io.File
@@ -118,12 +118,24 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
 
         if (includeExtras) {
             if (declareFlexibleType) {
-                ktFiles.add(KotlinTestUtils.createFile("EXPLICIT_FLEXIBLE_TYPES.kt", EXPLICIT_FLEXIBLE_TYPES_DECLARATIONS, project))
+                ktFiles.add(
+                    KtTestUtil.createFile(
+                        "EXPLICIT_FLEXIBLE_TYPES.kt",
+                        EXPLICIT_FLEXIBLE_TYPES_DECLARATIONS,
+                        project
+                    )
+                )
             }
             if (declareCheckType) {
                 val checkTypeDeclarations = File("$HELPERS_PATH/types/checkType.kt").readText()
 
-                ktFiles.add(KotlinTestUtils.createFile("CHECK_TYPE.kt", checkTypeDeclarations, project))
+                ktFiles.add(
+                    KtTestUtil.createFile(
+                        "CHECK_TYPE.kt",
+                        checkTypeDeclarations,
+                        project
+                    )
+                )
             }
         }
 

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

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.tests.di.createContainerForTests
 import java.io.File
 import kotlin.test.assertEquals
@@ -106,14 +107,14 @@ class CheckerTestUtilTest : KotlinTestWithEnvironment() {
         DiagnosticData(7, 6, "TOO_MANY_ARGUMENTS", 164, 166)
     )
 
-    private fun getTestDataPath() = KotlinTestUtils.getTestDataPathBase() + "/diagnostics/checkerTestUtil"
+    private fun getTestDataPath() = KtTestUtil.getTestDataPathBase() + "/diagnostics/checkerTestUtil"
 
     override fun createEnvironment() = createEnvironmentWithMockJdk(ConfigurationKind.ALL)
 
     private fun doTest(test: Test) = test.test(
         TestCheckerUtil.createCheckAndReturnPsiFile(
             "test.kt",
-            KotlinTestUtils.doLoadFile(getTestDataPath(), "test.kt"),
+            KtTestUtil.doLoadFile(getTestDataPath(), "test.kt"),
             project
         ),
         environment

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

@@ -13,8 +13,12 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.script.loadScriptingPlugin
-import org.jetbrains.kotlin.test.*
+import org.jetbrains.kotlin.test.Directives
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.test.KotlinBaseTest
+import org.jetbrains.kotlin.test.TestFiles
 import org.jetbrains.kotlin.test.TestFiles.TestFileFactory
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.*
 
@@ -27,9 +31,9 @@ abstract class KotlinMultiFileTestWithJava<M : KotlinBaseTest.TestModule, F : Ko
     public override fun setUp() {
         super.setUp()
         // TODO: do not create temporary directory for tests without Java sources
-        javaFilesDir = KotlinTestUtils.tmpDir("java-files")
+        javaFilesDir = KtTestUtil.tmpDir("java-files")
         if (isKotlinSourceRootNeeded()) {
-            kotlinSourceRoot = KotlinTestUtils.tmpDir("kotlin-src")
+            kotlinSourceRoot = KtTestUtil.tmpDir("kotlin-src")
         }
     }
 
@@ -79,7 +83,7 @@ abstract class KotlinMultiFileTestWithJava<M : KotlinBaseTest.TestModule, F : Ko
 
     private fun getClasspath(file: File): List<File> {
         val result: MutableList<File> = ArrayList()
-        result.add(KotlinTestUtils.getAnnotationsJar())
+        result.add(KtTestUtil.getAnnotationsJar())
         result.addAll(getExtraClasspath())
         val fileText = file.readText(Charsets.UTF_8)
         if (InTextDirectivesUtils.isDirectiveDefined(fileText, "ANDROID_ANNOTATIONS")) {
@@ -104,7 +108,7 @@ abstract class KotlinMultiFileTestWithJava<M : KotlinBaseTest.TestModule, F : Ko
     @Throws(Exception::class)
     public override fun doTest(filePath: String) {
         val file = createTestFileFromPath(filePath)
-        val expectedText = KotlinTestUtils.doLoadFile(file)
+        val expectedText = KtTestUtil.doLoadFile(file)
         //TODO: move to proper tests
         if (InTextDirectivesUtils.isDirectiveDefined(expectedText, "// SKIP_JAVAC")) return
         super.doTest(file.path)
@@ -144,7 +148,7 @@ abstract class KotlinMultiFileTestWithJava<M : KotlinBaseTest.TestModule, F : Ko
 
             private fun writeSourceFile(fileName: String, content: String, targetDir: File) {
                 val tmpFile = File(targetDir, fileName)
-                KotlinTestUtils.mkdirs(tmpFile.parentFile)
+                KtTestUtil.mkdirs(tmpFile.parentFile)
                 tmpFile.writeText(content, Charsets.UTF_8)
             }
         })

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

@@ -25,13 +25,13 @@ import com.intellij.testFramework.LightVirtualFile;
 import junit.framework.TestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.KtFile;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 
 public class TestCheckerUtil {
     @NotNull
     public static KtFile createCheckAndReturnPsiFile(@NotNull String fileName, @NotNull String text, @NotNull Project project) {
-        KtFile myFile = KotlinTestUtils.createFile(fileName, text, project);
+        KtFile myFile = KtTestUtil.createFile(fileName, text, project);
         ensureParsed(myFile);
         TestCase.assertEquals("light virtual file text mismatch", text, ((LightVirtualFile) myFile.getVirtualFile()).getContent().toString());
         TestCase.assertEquals("virtual file text mismatch", text, LoadTextUtil.loadText(myFile.getVirtualFile()));

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

@@ -20,7 +20,7 @@ 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
+import org.jetbrains.kotlin.test.util.KtTestUtil.getHomeDirectory
 import java.io.File
 
 abstract class AbstractDiagnosticsUsingJavacTest : AbstractDiagnosticsTest() {

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

@@ -19,7 +19,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 org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() {
@@ -52,7 +52,8 @@ abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() {
             return super.createTestFiles(file, expectedText, modules)
         }
 
-        return super.createTestFiles(specialFile, KotlinTestUtils.doLoadFile(specialFile), modules)
+        return super.createTestFiles(specialFile,
+                                     KtTestUtil.doLoadFile(specialFile), modules)
     }
 }
 

compiler/tests-common/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.test.CompilerTestUtil;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.kotlin.utils.JsMetadataVersion;
 import org.jetbrains.kotlin.utils.PathUtil;
@@ -263,7 +264,7 @@ public abstract class AbstractCliTest extends TestCaseWithTmpdir {
                         new File(AbstractForeignAnnotationsTestKt.getFOREIGN_ANNOTATIONS_SOURCES_PATH()).getPath()
                 ).replace(
                         "$JDK_15$",
-                        KotlinTestUtils.getJdk15Home().getPath()
+                        KtTestUtil.getJdk15Home().getPath()
                 );
     }
 

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinJdk15Test.kt

@@ -6,13 +6,13 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 
 abstract class AbstractCompileKotlinAgainstKotlinJdk15Test : AbstractCompileKotlinAgainstKotlinTest() {
     override fun invokeBox(className: String) {
         runJvmInstance(
-            KotlinTestUtils.getJdk15Home(),
+            KtTestUtil.getJdk15Home(),
             additionalArgs = listOf("--enable-preview"),
             classPath = listOfNotNull(
                 aDir, bDir, ForTestCompileRuntime.runtimeJarForTests(),

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TargetBackend;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 
 import java.io.File;
@@ -44,8 +45,8 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest
         tmpdir = KotlinTestUtils.tmpDirForTest(this);
         aDir = new File(tmpdir, "a");
         bDir = new File(tmpdir, "b");
-        KotlinTestUtils.mkdirs(aDir);
+        KtTestUtil.mkdirs(aDir);
-        KotlinTestUtils.mkdirs(bDir);
+        KtTestUtil.mkdirs(bDir);
     }
 
     @Override
@@ -115,7 +116,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest
         Disposable compileDisposable = createDisposable("compileA");
         CompilerConfiguration configuration = createConfiguration(
                 ConfigurationKind.ALL, getTestJdkKind(files), getBackendA(),
-                Collections.singletonList(KotlinTestUtils.getAnnotationsJar()),
+                Collections.singletonList(KtTestUtil.getAnnotationsJar()),
                 Collections.emptyList(), Collections.singletonList(testFile)
         );
 
@@ -138,7 +139,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest
         String commonHeader = StringsKt.substringBefore(files.get(0).content, "FILE:", "");
         CompilerConfiguration configuration = createConfiguration(
                 ConfigurationKind.ALL, getTestJdkKind(files), getBackendB(),
-                Arrays.asList(KotlinTestUtils.getAnnotationsJar(), aDir),
+                Arrays.asList(KtTestUtil.getAnnotationsJar(), aDir),
                 Collections.emptyList(), Arrays.asList(testFile, new TestFile("header", commonHeader))
         );
 
@@ -167,7 +168,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest
     ) {
 
         List<KtFile> ktFiles =
-                files.stream().map(file -> KotlinTestUtils.createFile(file.name, file.content, environment.getProject()))
+                files.stream().map(file -> KtTestUtil.createFile(file.name, file.content, environment.getProject()))
                         .collect(Collectors.toList());
 
         ModuleVisibilityManager.SERVICE.getInstance(environment.getProject()).addModule(

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCustomJDKBlackBoxCodegenTest.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.concurrent.TimeUnit
 
@@ -18,7 +19,7 @@ abstract class AbstractCustomJDKBlackBoxCodegenTest : AbstractBlackBoxCodegenTes
     override fun doTest(filePath: String) {
         val file = File(filePath)
         val expectedText =
-            KotlinTestUtils.doLoadFile(file) +
+            KtTestUtil.doLoadFile(file) +
                     "\n" +
                     """
                         fun main() {

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractGenerateNotNullAssertionsTest.java

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.org.objectweb.asm.ClassReader;
 import org.jetbrains.org.objectweb.asm.ClassVisitor;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
@@ -49,7 +50,7 @@ abstract public class AbstractGenerateNotNullAssertionsTest extends CodegenTestC
     }
 
     private void loadSource(@NotNull String fileName) {
-        loadFileByFullPath(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + fileName);
+        loadFileByFullPath(KtTestUtil.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + fileName);
     }
 
     protected void doTestNoAssertionsForKotlinFromBinary(String binaryDependencyFilename, String testFilename) {

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk15BlackBoxCodegenTest.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractJdk15BlackBoxCodegenTest : AbstractCustomJDKBlackBoxCodegenTest() {
     override fun getTestJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_15
-    override fun getJdkHome(): File = KotlinTestUtils.getJdk15Home()
+    override fun getJdkHome(): File = KtTestUtil.getJdk15Home()
     override fun getPrefix(): String = "java15/box"
 
     override fun getAdditionalJvmArgs(): List<String> = listOf("--enable-preview")

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk9BlackBoxCodegenTest.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractJdk9BlackBoxCodegenTest : AbstractCustomJDKBlackBoxCodegenTest() {
     override fun getTestJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_9
-    override fun getJdkHome(): File = KotlinTestUtils.getJdk9Home()
+    override fun getJdkHome(): File = KtTestUtil.getJdk9Home()
     override fun getPrefix(): String = "java9/box"
 }

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PartialAnalysisHandlerExtension
-import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar
+import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 import java.io.File
 

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java

@@ -24,6 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.test.*;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.File;
 import java.util.Collections;
@@ -51,13 +52,13 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte
                 getTestRootDisposable(),
                 KotlinTestUtils.newConfiguration(
                         ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK,
-                        CollectionsKt.plus(classPath, KotlinTestUtils.getAnnotationsJar()), Collections.emptyList()
+                        CollectionsKt.plus(classPath, KtTestUtil.getAnnotationsJar()), Collections.emptyList()
                 ),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         loadFiles(ArrayUtil.toStringArray(sourceFiles));
 
-        List<OccurrenceInfo> expected = readExpectedOccurrences(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + sourceFiles.get(0));
+        List<OccurrenceInfo> expected = readExpectedOccurrences(KtTestUtil.getTestDataPathBase() + "/codegen/" + sourceFiles.get(0));
         String actual = generateToText();
         Companion.checkGeneratedTextAgainstExpectedOccurrences(actual, expected, TargetBackend.ANY, true);
     }

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider;
 import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationWrapper;
 import org.jetbrains.kotlin.test.*;
 import org.jetbrains.kotlin.test.clientserver.TestProxy;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.org.objectweb.asm.ClassReader;
 import org.jetbrains.org.objectweb.asm.tree.ClassNode;
@@ -63,8 +64,8 @@ import java.util.stream.Collectors;
 import static org.jetbrains.kotlin.cli.common.output.OutputUtilsKt.writeAllTo;
 import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*;
 import static org.jetbrains.kotlin.codegen.TestUtilsKt.extractUrls;
-import static org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar;
 import static org.jetbrains.kotlin.test.clientserver.TestProcessServerKt.*;
+import static org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar;
 
 public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.TestFile> {
     private static final String DEFAULT_TEST_FILE_NAME = "a_test";
@@ -134,7 +135,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
 
     @NotNull
     protected String loadFile(@NotNull @TestDataFile String name) {
-        return loadFileByFullPath(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + name);
+        return loadFileByFullPath(KtTestUtil.getTestDataPathBase() + "/codegen/" + name);
     }
 
     @NotNull
@@ -172,7 +173,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
             if (file.name.endsWith(".kt") || file.name.endsWith(".kts")) {
                 // `rangesToDiagnosticNames` parameter is not-null only for diagnostic tests, it's using for lazy diagnostics
                 String content = CheckerTestUtil.INSTANCE.parseDiagnosedRanges(file.content, new ArrayList<>(0), null);
-                ktFiles.add(KotlinTestUtils.createFile(file.name, content, project));
+                ktFiles.add(KtTestUtil.createFile(file.name, content, project));
             }
         }
 
@@ -608,7 +609,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
     protected void doTest(@NotNull String filePath) throws Exception {
         File file = new File(filePath);
 
-        String expectedText = KotlinTestUtils.doLoadFile(file);
+        String expectedText = KtTestUtil.doLoadFile(file);
         List<TestFile> testFiles = createTestFilesFromFile(file, expectedText);
 
         doMultiFileTest(file, testFiles);
@@ -659,7 +660,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
     @NotNull
     private static File createTempDirectory(String prefix) {
         try {
-            return KotlinTestUtils.tmpDir(prefix);
+            return KtTestUtil.tmpDir(prefix);
         } catch (IOException e) {
             throw ExceptionUtilsKt.rethrow(e);
         }
@@ -674,7 +675,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
 
         for (TestFile testFile : javaFiles) {
             File file = new File(dir, testFile.name);
-            KotlinTestUtils.mkdirs(file.getParentFile());
+            KtTestUtil.mkdirs(file.getParentFile());
             FilesKt.writeText(file, testFile.content, Charsets.UTF_8);
         }
 

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestFiles.java

@@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -81,15 +81,15 @@ public class CodegenTestFiles {
     }
 
     public static CodegenTestFiles create(Project project, String[] names) {
-        return create(project, names, KotlinTestUtils.getTestDataPathBase());
+        return create(project, names, KtTestUtil.getTestDataPathBase());
     }
 
     public static CodegenTestFiles create(Project project, String[] names, String testDataPath) {
         List<KtFile> files = new ArrayList<>(names.length);
         for (String name : names) {
             try {
-                String content = KotlinTestUtils.doLoadFile(testDataPath + "/codegen/", name);
+                String content = KtTestUtil.doLoadFile(testDataPath + "/codegen/", name);
-                KtFile file = KotlinTestUtils.createFile(name, content, project);
+                KtFile file = KtTestUtil.createFile(name, content, project);
                 files.add(file);
             }
             catch (IOException e) {
@@ -103,7 +103,7 @@ public class CodegenTestFiles {
     public static CodegenTestFiles create(@NotNull String fileName, @NotNull String contentWithDiagnosticMarkup, @NotNull Project project) {
         // `rangesToDiagnosticNames` parameter is not-null only for diagnostic tests, it's using for lazy diagnostics
         String content = CheckerTestUtil.INSTANCE.parseDiagnosedRanges(contentWithDiagnosticMarkup, new ArrayList<>(), null);
-        KtFile file = KotlinTestUtils.createFile(fileName, content, project);
+        KtFile file = KtTestUtil.createFile(fileName, content, project);
         List<PsiErrorElement> ranges = AnalyzingUtils.getSyntaxErrorRanges(file);
         assert ranges.isEmpty() : "Syntax errors found in " + file + ": " + ranges;
 

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java

@@ -25,6 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.kotlin.utils.StringsKt;
 
@@ -85,7 +86,7 @@ public class CodegenTestUtil {
             @NotNull List<String> additionalOptions
     ) {
         try {
-            File directory = KotlinTestUtils.tmpDir("java-classes");
+            File directory = KtTestUtil.tmpDir("java-classes");
             compileJava(fileNames, additionalClasspath, additionalOptions, directory);
             return directory;
         }
@@ -118,7 +119,7 @@ public class CodegenTestUtil {
         List<String> classpath = new ArrayList<>();
         classpath.add(ForTestCompileRuntime.runtimeJarForTests().getPath());
         classpath.add(ForTestCompileRuntime.reflectJarForTests().getPath());
-        classpath.add(KotlinTestUtils.getAnnotationsJar().getPath());
+        classpath.add(KtTestUtil.getAnnotationsJar().getPath());
         classpath.addAll(additionalClasspath);
 
         List<String> options = new ArrayList<>(Arrays.asList(

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/debugInformation/AbstractDebugTest.kt

@@ -25,10 +25,10 @@ import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.clientserver.TestProcessServer
 import org.jetbrains.kotlin.test.clientserver.TestProxy
 import org.jetbrains.kotlin.test.clientserver.getGeneratedClass
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.After
 import org.junit.Before
 import java.io.File
-import java.lang.IllegalStateException
 import java.net.URLClassLoader
 import kotlin.properties.Delegates
 
@@ -158,7 +158,7 @@ abstract class AbstractDebugTest : CodegenTestCase() {
             GenerationUtils.compileFiles(myFiles.psiFiles, myEnvironment, classBuilderFactory)
         classFileFactory = generationState.factory
 
-        val tempDirForTest = KotlinTestUtils.tmpDir("debuggerTest")
+        val tempDirForTest = KtTestUtil.tmpDir("debuggerTest")
         val classesDir = File(tempDirForTest, "classes")
         try {
             classFileFactory.writeAllTo(classesDir)

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticsWithLightTreeTest.kt

@@ -12,14 +12,14 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirLightDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import kotlin.math.abs
 
 abstract class AbstractFirDiagnosticsWithLightTreeTest : AbstractFirDiagnosticsTest() {
     override fun doTest(filePath: String) {
         val file = createTestFileFromPath(filePath)
-        val expectedText = KotlinTestUtils.doLoadFile(file)
+        val expectedText = KtTestUtil.doLoadFile(file)
         if (InTextDirectivesUtils.isDirectiveDefined(expectedText, "// IGNORE_LIGHT_TREE")) return
 
         super.doTest(filePath)

compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirTestUtils.kt

@@ -10,7 +10,7 @@ import junit.framework.TestCase
 import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.Companion.DIAGNOSTIC_IN_TESTDATA_PATTERN
 import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.Companion.SPEC_LINKED_TESTDATA_PATTERN
 import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.Companion.SPEC_NOT_LINED_TESTDATA_PATTERN
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF
 import java.io.File
 
@@ -53,7 +53,7 @@ fun compareAndMergeFirFileAndOldFrontendFile(
 }
 
 private fun loadTestData(file: File, vararg patternsToBeRemoved: Regex): String {
-    var text = KotlinTestUtils.doLoadFile(file)
+    var text = KtTestUtil.doLoadFile(file)
     patternsToBeRemoved.forEach { text = text.replace(it, "") }
     return StringUtil.convertLineSeparators(text.trim()).trimTrailingWhitespacesAndAddNewlineAtEOF()
 }

compiler/tests-common/tests/org/jetbrains/kotlin/integration/KotlinIntegrationTestBase.java

@@ -22,7 +22,6 @@ import com.intellij.execution.process.OSProcessHandler;
 import com.intellij.execution.process.ProcessAdapter;
 import com.intellij.execution.process.ProcessEvent;
 import com.intellij.execution.process.ProcessOutputTypes;
-import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.io.FileUtil;
@@ -35,6 +34,7 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
 import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.KotlinPaths;
 import org.jetbrains.kotlin.utils.PathUtil;
 
@@ -88,7 +88,7 @@ public abstract class KotlinIntegrationTestBase extends TestCaseWithTmpdir {
         content = normalizePath(content, testDataDir, "[TestData]");
         content = normalizePath(content, tmpdir, "[Temp]");
         content = normalizePath(content, getCompilerLib(), "[CompilerLib]");
-        content = normalizePath(content, new File(KotlinTestUtils.getHomeDirectory()), "[KotlinProjectHome]");
+        content = normalizePath(content, new File(KtTestUtil.getHomeDirectory()), "[KotlinProjectHome]");
         content = content.replaceAll(Pattern.quote(KotlinCompilerVersion.VERSION), "[KotlinVersion]");
         content = content.replaceAll("\\(JRE .+\\)", "(JRE [JREVersion])");
         content = StringUtil.convertLineSeparators(content);

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt

@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar
+import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar
 import java.io.File
 import java.util.*
 

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

@@ -27,21 +27,24 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.renderer.*
+import org.jetbrains.kotlin.renderer.AnnotationArgumentsRenderingPolicy
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
+import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations
+import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile
 import org.junit.Assert
-
 import java.io.File
 import java.io.IOException
 import java.lang.annotation.Retention
 
-import org.jetbrains.kotlin.test.KotlinTestUtils.*
-import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile
-
 abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
 
     @Throws(IOException::class)
@@ -80,7 +83,8 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
 
         if (!compiledSuccessfully) return
 
-        val configuration = newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, getAnnotationsJar(), out)
+        val configuration = newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
+                                             KtTestUtil.getAnnotationsJar(), out)
         configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true)
         val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
         setupLanguageVersionSettingsForCompilerTests(ktFile.readText(), environment)

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

@@ -33,9 +33,11 @@ import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
-import org.jetbrains.kotlin.test.KotlinTestUtils.*
+import org.jetbrains.kotlin.test.KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations
+import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile
 import org.junit.Assert
 import java.io.File
@@ -67,13 +69,14 @@ abstract class AbstractCompileKotlinAgainstJavaTest : TestCaseWithTmpdir() {
 
         val environment = KotlinCoreEnvironment.createForTests(
             testRootDisposable,
-            newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, getAnnotationsJar(), out),
+            newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK,
+                             KtTestUtil.getAnnotationsJar(), out),
             EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
 
         environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
         environment.configuration.put(JVMConfigurationKeys.OUTPUT_DIRECTORY, out)
-        environment.registerJavac(emptyList(), bootClasspath = listOf(findMockJdkRtJar()))
+        environment.registerJavac(emptyList(), bootClasspath = listOf(KtTestUtil.findMockJdkRtJar()))
 
         val analysisResult = JvmResolveUtil.analyze(environment)
         val packageView = analysisResult.moduleDescriptor.getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME)
@@ -95,13 +98,17 @@ abstract class AbstractCompileKotlinAgainstJavaTest : TestCaseWithTmpdir() {
         environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
         environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true)
         val ktFiles = kotlinFiles.map { kotlinFile: File ->
-            createFile(kotlinFile.name, FileUtil.loadFile(kotlinFile, true), environment.project)
+            KtTestUtil.createFile(
+                kotlinFile.name,
+                FileUtil.loadFile(kotlinFile, true),
+                environment.project
+            )
         }
         environment.registerJavac(
             javaFiles = javaFiles,
             kotlinFiles = ktFiles,
             arguments = if (aptMode) arrayOf() else arrayOf("-proc:none"),
-            bootClasspath = listOf(findMockJdkRtJar())
+            bootClasspath = listOf(KtTestUtil.findMockJdkRtJar())
         )
         ModuleVisibilityManager.SERVICE.getInstance(environment.project).addModule(
             ModuleBuilder("module for test", tmpdir.absolutePath, "test")

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

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.jvm.compiler
 
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractLoadJava15Test : AbstractLoadJavaTest() {
     override fun getJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_15
-    override fun getJdkHomeForJavac(): File = KotlinTestUtils.getJdk15Home()
+    override fun getJdkHomeForJavac(): File = KtTestUtil.getJdk15Home()
     override fun getAdditionalJavacArgs(): List<String> = ADDITIONAL_JAVAC_ARGS_FOR_15
 }
 

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

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.jvm.compiler
 
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractLoadJava15WithPsiClassReadingTest : AbstractLoadJavaWithPsiClassReadingTest() {
     override fun getJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_15
-    override fun getJdkHomeForJavac(): File = KotlinTestUtils.getJdk15Home()
+    override fun getJdkHomeForJavac(): File = KtTestUtil.getJdk15Home()
     override fun getAdditionalJavacArgs(): List<String> = ADDITIONAL_JAVAC_ARGS_FOR_15
 }

compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.kotlin.test.*;
 import org.jetbrains.kotlin.test.util.DescriptorValidator;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.junit.Assert;
 
 import java.io.File;
@@ -39,7 +40,8 @@ import java.util.*;
 import java.util.regex.Pattern;
 
 import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.*;
-import static org.jetbrains.kotlin.test.KotlinTestUtils.*;
+import static org.jetbrains.kotlin.test.KotlinTestUtils.compileKotlinWithJava;
+import static org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration;
 import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed;
 import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden;
 import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.*;
@@ -89,7 +91,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
     @NotNull
     private List<File> getClasspath(File... files) {
         List<File> classpath = new ArrayList<>(getExtraClasspath());
-        classpath.add(getAnnotationsJar());
+        classpath.add(KtTestUtil.getAnnotationsJar());
         classpath.addAll(Arrays.asList(files));
         return classpath;
     }
@@ -240,7 +242,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         );
         registerJavacIfNeeded(environment);
         configureEnvironment(environment);
-        KtFile ktFile = KotlinTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject());
+        KtFile ktFile = KtTestUtil.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject());
 
         ModuleDescriptor module = GenerationUtils.compileFiles(Collections.singletonList(ktFile), environment).getModule();
         PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);

compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java

@@ -47,6 +47,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 
 import java.io.File;
@@ -111,7 +112,7 @@ public class LoadDescriptorUtil {
     ) {
         List<File> javaBinaryRoots = new ArrayList<>();
         // TODO: use the same additional binary roots as those were used for compilation
-        javaBinaryRoots.add(KotlinTestUtils.getAnnotationsJar());
+        javaBinaryRoots.add(KtTestUtil.getAnnotationsJar());
         javaBinaryRoots.add(ForTestCompileRuntime.jvmAnnotationsForTests());
         javaBinaryRoots.addAll(additionalClasspath);
 
@@ -156,7 +157,7 @@ public class LoadDescriptorUtil {
         List<File> classpath = new ArrayList<>();
 
         classpath.add(ForTestCompileRuntime.runtimeJarForTests());
-        classpath.add(KotlinTestUtils.getAnnotationsJar());
+        classpath.add(KtTestUtil.getAnnotationsJar());
 
         for (File test : javaFiles) {
             String content = FilesKt.readText(test, Charsets.UTF_8);
@@ -189,7 +190,7 @@ public class LoadDescriptorUtil {
     private static List<KtFile> createKtFiles(@NotNull List<File> kotlinFiles, @NotNull KotlinCoreEnvironment environment) {
         return CollectionsKt.map(kotlinFiles, kotlinFile -> {
             try {
-                return KotlinTestUtils.createFile(kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject());
+                return KtTestUtil.createFile(kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject());
             }
             catch (IOException e) {
                 throw ExceptionUtilsKt.rethrow(e);

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.*;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.File;
 import java.util.List;
@@ -43,7 +44,7 @@ public abstract class ExtensibleResolveTestCase extends KotlinTestWithEnvironmen
 
     protected void doTest(@NonNls String filePath) throws Exception {
         File file = new File(filePath);
-        String text = KotlinTestUtils.doLoadFile(file);
+        String text = KtTestUtil.doLoadFile(file);
         List<KtFile> files = TestFiles.createTestFiles("file.kt", text, new TestFiles.TestFileFactoryNoModules<KtFile>() {
             @NotNull
             @Override

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java

@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.PackageDescriptorUtilKt;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.File;
 import java.io.IOException;
@@ -340,7 +341,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends KotlinTest
 
     @NotNull
     protected KtFile getFile(@NotNull String content) {
-        KtFile ktFile = KotlinTestUtils.createFile("dummy.kt", content, getProject());
+        KtFile ktFile = KtTestUtil.createFile("dummy.kt", content, getProject());
         analysisResult = KotlinTestUtils.analyzeFile(ktFile, getEnvironment());
 
         return ktFile;
@@ -361,7 +362,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends KotlinTest
 
     protected static String getContent(@NotNull String annotationText) throws IOException {
         File file = new File(PATH);
-        return KotlinTestUtils.doLoadFile(file).replaceAll("ANNOTATION", annotationText);
+        return KtTestUtil.doLoadFile(file).replaceAll("ANNOTATION", annotationText);
     }
 
     public static String renderAnnotations(Annotations annotations) {

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt

@@ -43,13 +43,14 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.Receiver
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 abstract class AbstractResolvedCallsTest : KotlinTestWithEnvironment() {
     override fun createEnvironment(): KotlinCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.ALL)
 
     fun doTest(filePath: String) {
-        val originalText = KotlinTestUtils.doLoadFile(File(filePath))!!
+        val originalText = KtTestUtil.doLoadFile(File(filePath))!!
         val (text, carets) = extractCarets(originalText)
 
         setupLanguageVersionSettingsForCompilerTests(originalText, environment)

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.tests.di.createContainerForTests
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.KotlinType
@@ -61,12 +62,16 @@ abstract class AbstractConstraintSystemTest : KotlinTestWithEnvironment() {
     }
 
     private val testDataPath: String
-        get() = KotlinTestUtils.getTestDataPathBase() + "/constraintSystem/"
+        get() = KtTestUtil.getTestDataPathBase() + "/constraintSystem/"
 
     private fun analyzeDeclarations(): ConstraintSystemTestData {
         val fileName = "declarations.kt"
 
-        val psiFile = KotlinTestUtils.createFile(fileName, KotlinTestUtils.doLoadFile(testDataPath, fileName), project)
+        val psiFile = KtTestUtil.createFile(
+            fileName,
+            KtTestUtil.doLoadFile(testDataPath, fileName),
+            project
+        )
         val bindingContext = JvmResolveUtil.analyzeAndCheckForErrors(psiFile, environment).bindingContext
         return ConstraintSystemTestData(bindingContext, project, typeResolver)
     }

compiler/tests-common/tests/org/jetbrains/kotlin/test/CompilerTestUtil.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.test
 import org.jetbrains.kotlin.cli.common.CLITool
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.PrintStream
@@ -53,7 +54,7 @@ object CompilerTestUtil {
             extraOptions: List<String> = emptyList(),
             extraClasspath: List<File> = emptyList()
     ): File {
-        val destination = File(KotlinTestUtils.tmpDir("testLibrary"), "$libraryName.jar")
+        val destination = File(KtTestUtil.tmpDir("testLibrary"), "$libraryName.jar")
         val args = mutableListOf<String>().apply {
             add(src.path)
             add("-d")

compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.config.JvmTarget.Companion.fromString
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.lang.reflect.Field
 import java.util.*
@@ -32,7 +33,7 @@ abstract class KotlinBaseTest<F : KotlinBaseTest.TestFile> : KtUsefulTestCase()
     @Throws(java.lang.Exception::class)
     protected open fun doTest(filePath: String) {
         val file = File(filePath)
-        val expectedText = KotlinTestUtils.doLoadFile(file)
+        val expectedText = KtTestUtil.doLoadFile(file)
         doMultiFileTest(file, createTestFilesFromFile(file, expectedText))
     }
 

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

@@ -12,19 +12,13 @@ import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.ShutDownTracker;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.util.text.StringUtilRt;
 import com.intellij.openapi.vfs.CharsetToolkit;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFileFactory;
-import com.intellij.psi.impl.PsiFileFactoryImpl;
 import com.intellij.rt.execution.junit.FileComparisonFailure;
-import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.testFramework.TestDataFile;
-import com.intellij.util.PathUtil;
 import com.intellij.util.containers.ContainerUtil;
 import junit.framework.TestCase;
 import kotlin.Unit;
@@ -32,7 +26,6 @@ import kotlin.collections.CollectionsKt;
 import kotlin.collections.SetsKt;
 import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
-import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
@@ -43,8 +36,8 @@ import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.config.ContentRootsKt;
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot;
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation;
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -52,7 +45,6 @@ import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.config.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
@@ -61,12 +53,12 @@ import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.test.util.JetTestUtilsKt;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.junit.Assert;
 
 import javax.tools.*;
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.lang.annotation.Annotation;
@@ -96,8 +88,6 @@ public class KotlinTestUtils {
     private static final boolean AUTOMATICALLY_UNMUTE_PASSED_TESTS = false;
     private static final boolean AUTOMATICALLY_MUTE_FAILED_TESTS = false;
 
-    private static final List<File> filesToDelete = new ArrayList<>();
-
     private static final Pattern DIRECTIVE_PATTERN = Pattern.compile("^//\\s*[!]?([A-Z_]+)(:[ \\t]*(.*))?$", Pattern.MULTILINE);
 
     private KotlinTestUtils() {
@@ -125,7 +115,7 @@ public class KotlinTestUtils {
             @NotNull TestJdkKind jdkKind
     ) {
         return KotlinCoreEnvironment.createForTests(
-                disposable, newConfiguration(configurationKind, jdkKind, getAnnotationsJar()), EnvironmentConfigFiles.JVM_CONFIG_FILES
+                disposable, newConfiguration(configurationKind, jdkKind, KtTestUtil.getAnnotationsJar()), EnvironmentConfigFiles.JVM_CONFIG_FILES
         );
     }
 
@@ -134,156 +124,9 @@ public class KotlinTestUtils {
         return createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(disposable, ConfigurationKind.ALL, TestJdkKind.FULL_JDK);
     }
 
-    @NotNull
-    public static String getTestDataPathBase() {
-        return getHomeDirectory() + "/compiler/testData";
-    }
-
-    private static String homeDir = computeHomeDirectory();
-
-    @NotNull
-    public static String getHomeDirectory() {
-        return homeDir;
-    }
-
-    @NotNull
-    private static String computeHomeDirectory() {
-        String userDir = System.getProperty("user.dir");
-        File dir = new File(userDir == null ? "." : userDir);
-        return FileUtil.toCanonicalPath(dir.getAbsolutePath());
-    }
-
-    public static File findMockJdkRtJar() {
-        return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar");
-    }
-
-    // Differs from common mock JDK only by one additional 'nonExistingMethod' in Collection and constructor from Double in Throwable
-    // It's needed to test the way we load additional built-ins members that neither in black nor white lists
-    public static File findMockJdkRtModified() {
-        return new File(getHomeDirectory(), "compiler/testData/mockJDKModified/rt.jar");
-    }
-
-    public static File findAndroidApiJar() {
-        String androidJarProp = System.getProperty("android.jar");
-        File androidJarFile = androidJarProp == null ? null : new File(androidJarProp);
-        if (androidJarFile == null || !androidJarFile.isFile()) {
-            throw new RuntimeException(
-                    "Unable to get a valid path from 'android.jar' property (" +
-                    androidJarProp +
-                    "), please point it to the 'android.jar' file location");
-        }
-        return androidJarFile;
-    }
-
-    @NotNull
-    public static File findAndroidSdk() {
-        String androidSdkProp = System.getProperty("android.sdk");
-        File androidSdkDir = androidSdkProp == null ? null : new File(androidSdkProp);
-        if (androidSdkDir == null || !androidSdkDir.isDirectory()) {
-            throw new RuntimeException(
-                    "Unable to get a valid path from 'android.sdk' property (" +
-                    androidSdkProp +
-                    "), please point it to the android SDK location");
-        }
-        return androidSdkDir;
-    }
-
-    public static String getAndroidSdkSystemIndependentPath() {
-        return PathUtil.toSystemIndependentName(findAndroidSdk().getAbsolutePath());
-    }
-
-    public static File getAnnotationsJar() {
-        return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/annotations.jar");
-    }
-
-    public static void mkdirs(@NotNull File file) {
-        if (file.isDirectory()) {
-            return;
-        }
-        if (!file.mkdirs()) {
-            if (file.exists()) {
-                throw new IllegalStateException("Failed to create " + file + ": file exists and not a directory");
-            }
-            throw new IllegalStateException("Failed to create " + file);
-        }
-    }
-
-    @NotNull
-    public static File tmpDirForTest(@NotNull String testClassName, @NotNull String testName) throws IOException {
-        return normalizeFile(FileUtil.createTempDirectory(testClassName, testName, false));
-    }
-
     @NotNull
     public static File tmpDirForTest(TestCase test) throws IOException {
-        return tmpDirForTest(test.getClass().getSimpleName(), test.getName());
+        return KtTestUtil.tmpDirForTest(test.getClass().getSimpleName(), test.getName());
-    }
-
-    @NotNull
-    public static File tmpDir(String name) throws IOException {
-        return normalizeFile(FileUtil.createTempDirectory(name, "", false));
-    }
-
-    @NotNull
-    public static File tmpDirForReusableFolder(String name) throws IOException {
-        return normalizeFile(FileUtil.createTempDirectory(new File(System.getProperty("java.io.tmpdir")), name, "", true));
-    }
-
-    private static File normalizeFile(File file) throws IOException {
-        // Get canonical file to be sure that it's the same as inside the compiler,
-        // for example, on Windows, if a canonical path contains any space from FileUtil.createTempDirectory we will get
-        // a File with short names (8.3) in its path and it will break some normalization passes in tests.
-        return file.getCanonicalFile();
-    }
-
-    private static void deleteOnShutdown(File file) {
-        if (filesToDelete.isEmpty()) {
-            ShutDownTracker.getInstance().registerShutdownTask(() -> {
-                for (File victim : filesToDelete) {
-                    FileUtil.delete(victim);
-                }
-            });
-        }
-
-        filesToDelete.add(file);
-    }
-
-    @NotNull
-    public static KtFile createFile(@NotNull @NonNls String name, @NotNull String text, @NotNull Project project) {
-        String shortName = name.substring(name.lastIndexOf('/') + 1);
-        shortName = shortName.substring(shortName.lastIndexOf('\\') + 1);
-        LightVirtualFile virtualFile = new LightVirtualFile(shortName, KotlinLanguage.INSTANCE, StringUtilRt.convertLineSeparators(text));
-
-        virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
-        PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project);
-        //noinspection ConstantConditions
-        return (KtFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false);
-    }
-
-    public static String doLoadFile(String myFullDataPath, String name) throws IOException {
-        String fullName = myFullDataPath + File.separatorChar + name;
-        return doLoadFile(new File(fullName));
-    }
-
-    public static String doLoadFile(@NotNull File file) throws IOException {
-        try {
-            return FileUtil.loadFile(file, CharsetToolkit.UTF8, true);
-        }
-        catch (FileNotFoundException fileNotFoundException) {
-            /*
-             * Unfortunately, the FileNotFoundException will only show the relative path in it's exception message.
-             * This clarifies the exception by showing the full path.
-             */
-            String messageWithFullPath = file.getAbsolutePath() + " (No such file or directory)";
-            throw new IOException(
-                    "Ensure you have your 'Working Directory' configured correctly as the root " +
-                    "Kotlin project directory in your test configuration\n\t" +
-                    messageWithFullPath,
-                    fileNotFoundException);
-        }
-    }
-
-    public static String getFilePath(File file) {
-        return FileUtil.toSystemIndependentName(file.getPath());
     }
 
     @NotNull
@@ -346,15 +189,15 @@ public class KotlinTestUtils {
         CompilerConfiguration configuration = newConfiguration();
         JvmContentRootsKt.addJavaSourceRoots(configuration, javaSource);
         if (jdkKind == TestJdkKind.MOCK_JDK) {
-            JvmContentRootsKt.addJvmClasspathRoot(configuration, findMockJdkRtJar());
+            JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.findMockJdkRtJar());
             configuration.put(JVMConfigurationKeys.NO_JDK, true);
         }
         else if (jdkKind == TestJdkKind.MODIFIED_MOCK_JDK) {
-            JvmContentRootsKt.addJvmClasspathRoot(configuration, findMockJdkRtModified());
+            JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.findMockJdkRtModified());
             configuration.put(JVMConfigurationKeys.NO_JDK, true);
         }
         else if (jdkKind == TestJdkKind.ANDROID_API) {
-            JvmContentRootsKt.addJvmClasspathRoot(configuration, findAndroidApiJar());
+            JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.findAndroidApiJar());
             configuration.put(JVMConfigurationKeys.NO_JDK, true);
         }
         else if (jdkKind == TestJdkKind.FULL_JDK_6) {
@@ -363,10 +206,10 @@ public class KotlinTestUtils {
             configuration.put(JVMConfigurationKeys.JDK_HOME, new File(jdk6));
         }
         else if (jdkKind == TestJdkKind.FULL_JDK_9) {
-            configuration.put(JVMConfigurationKeys.JDK_HOME, getJdk9Home());
+            configuration.put(JVMConfigurationKeys.JDK_HOME, KtTestUtil.getJdk9Home());
         }
         else if (jdkKind == TestJdkKind.FULL_JDK_15) {
-            configuration.put(JVMConfigurationKeys.JDK_HOME, getJdk15Home());
+            configuration.put(JVMConfigurationKeys.JDK_HOME, KtTestUtil.getJdk15Home());
         }
         else if (SystemInfo.IS_AT_LEAST_JAVA9) {
             configuration.put(JVMConfigurationKeys.JDK_HOME, new File(System.getProperty("java.home")));
@@ -390,41 +233,6 @@ public class KotlinTestUtils {
         return configuration;
     }
 
-    @NotNull
-    public static File getJdk9Home() {
-        String jdk9 = System.getenv("JDK_9");
-        if (jdk9 == null) {
-            jdk9 = System.getenv("JDK_19");
-            if (jdk9 == null) {
-                throw new AssertionError("Environment variable JDK_9 is not set!");
-            }
-        }
-        return new File(jdk9);
-    }
-
-    @Nullable
-    public static File getJdk11Home() {
-        String jdk11 = System.getenv("JDK_11");
-        if (jdk11 == null) {
-            return null;
-        }
-        return new File(jdk11);
-    }
-
-    @NotNull
-    public static File getJdk15Home() {
-        String jdk15 = System.getenv("JDK_15");
-
-        if (jdk15 == null) {
-            jdk15 = System.getenv("JDK_15_0");
-        }
-
-        if (jdk15 == null) {
-            throw new AssertionError("Environment variable JDK_15 is not set!");
-        }
-        return new File(jdk15);
-    }
-
     public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
         List<KotlinSourceRoot> roots = ContentRootsKt.getKotlinSourceRoots(environment.getConfiguration());
         if (roots.isEmpty()) return;
@@ -685,7 +493,7 @@ public class KotlinTestUtils {
     }
 
     public static boolean compileJavaFilesExternallyWithJava9(@NotNull Collection<File> files, @NotNull List<String> options) {
-        return compileJavaFilesExternally(files, options, getJdk9Home());
+        return compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home());
     }
 
     public static boolean compileJavaFilesExternally(@NotNull Collection<File> files, @NotNull List<String> options, @NotNull File jdkHome) {
@@ -825,7 +633,7 @@ public class KotlinTestUtils {
             }
             catch (Throwable e) {
                 if (!isIgnored && AUTOMATICALLY_MUTE_FAILED_TESTS) {
-                    String text = doLoadFile(testDataFile);
+                    String text = KtTestUtil.doLoadFile(testDataFile);
                     String directive = ignoreDirective + targetBackend.name() + "\n";
 
                     String newText;
@@ -864,7 +672,7 @@ public class KotlinTestUtils {
 
             if (isIgnored) {
                 if (AUTOMATICALLY_UNMUTE_PASSED_TESTS) {
-                    String text = doLoadFile(testDataFile);
+                    String text = KtTestUtil.doLoadFile(testDataFile);
                     String directive = ignoreDirective + targetBackend.name();
                     String newText = Pattern.compile("^" + directive + "\n", Pattern.MULTILINE).matcher(text).replaceAll("");
                     if (!newText.equals(text)) {
@@ -1069,7 +877,7 @@ public class KotlinTestUtils {
     private static void assertTestClassPresentByMetadata(@NotNull Class<?> outerClass, @NotNull File testDataDir) {
         for (Class<?> nestedClass : outerClass.getDeclaredClasses()) {
             TestMetadata testMetadata = nestedClass.getAnnotation(TestMetadata.class);
-            if (testMetadata != null && testMetadata.value().equals(getFilePath(testDataDir))) {
+            if (testMetadata != null && testMetadata.value().equals(KtTestUtil.getFilePath(testDataDir))) {
                 return;
             }
         }

compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.preloading.ClassPreloadingUtils
 import org.jetbrains.kotlin.preloading.Preloader
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.PathUtil
 import org.junit.Assert
 import org.junit.Assert.assertEquals
@@ -52,7 +53,7 @@ object MockLibraryUtil {
             useJava9: Boolean = false
     ): File {
         return compileLibraryToJar(
-            sourcesPath, KotlinTestUtils.tmpDirForReusableFolder("testLibrary-" + jarName), jarName, addSources, allowKotlinSources, extraOptions, extraClasspath
+            sourcesPath, KtTestUtil.tmpDirForReusableFolder("testLibrary-" + jarName), jarName, addSources, allowKotlinSources, extraOptions, extraClasspath
             , useJava9)}
 
     @JvmStatic
@@ -96,7 +97,7 @@ object MockLibraryUtil {
         if (javaFiles.isNotEmpty()) {
             val classpath = mutableListOf<String>()
             classpath += ForTestCompileRuntime.runtimeJarForTests().path
-            classpath += KotlinTestUtils.getAnnotationsJar().path
+            classpath += KtTestUtil.getAnnotationsJar().path
             classpath += extraClasspath
 
             // Probably no kotlin files were present, so dir might not have been created after kotlin compiler
@@ -127,7 +128,7 @@ object MockLibraryUtil {
 
     @JvmStatic
     fun compileJsLibraryToJar(sourcesPath: String, jarName: String, addSources: Boolean, extraOptions: List<String> = emptyList()): File {
-        val contentDir = KotlinTestUtils.tmpDirForReusableFolder("testLibrary-" + jarName)
+        val contentDir = KtTestUtil.tmpDirForReusableFolder("testLibrary-" + jarName)
 
         val outDir = File(contentDir, "out")
         val outputFile = File(outDir, jarName + ".js")

compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/AbstractDiagnosticsTestSpec.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.spec.utils.parsers.CommonParser
 import org.jetbrains.kotlin.spec.utils.validators.DiagnosticTestTypeValidator
 import org.jetbrains.kotlin.spec.utils.validators.SpecTestValidationException
 import org.jetbrains.kotlin.test.ConfigurationKind
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.File
 import java.util.regex.Matcher
@@ -41,7 +41,7 @@ abstract class AbstractDiagnosticsTestSpec : org.jetbrains.kotlin.checkers.Abstr
                 val helperContent = FileUtil.loadFile(File("$HELPERS_PATH/$filename"), true)
 
 
-                KotlinTestUtils.createFile(filename, helperContent, project)
+                KtTestUtil.createFile(filename, helperContent, project)
             }
         }
     }

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClass;
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.File;
 import java.util.Collections;
@@ -40,7 +41,7 @@ public class LightClassAnnotationsTest extends KotlinAsJavaTestBase {
 
     @Override
     protected void extraConfiguration(@NotNull CompilerConfiguration configuration) {
-        JvmContentRootsKt.addJvmClasspathRoot(configuration, KotlinTestUtils.getAnnotationsJar());
+        JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.getAnnotationsJar());
     }
 
     public void testExtraAnnotations() throws Exception {

compiler/tests/org/jetbrains/kotlin/cli/LauncherScriptTest.kt

@@ -20,9 +20,10 @@ import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.addToStdlib.cast
-import java.io.*
+import java.io.File
 import java.util.concurrent.TimeUnit
 
 class LauncherScriptTest : TestCaseWithTmpdir() {
@@ -75,7 +76,7 @@ class LauncherScriptTest : TestCaseWithTmpdir() {
         else args.cast()
 
     private val testDataDirectory: String
-        get() = KotlinTestUtils.getTestDataPathBase() + "/launcher"
+        get() = KtTestUtil.getTestDataPathBase() + "/launcher"
 
     fun testKotlincSimple() {
         runProcess(

compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
 
@@ -31,11 +32,11 @@ class WrongBytecodeVersionTest : KtUsefulTestCase() {
     private val incompatibleVersion = JvmBytecodeBinaryVersion(42, 0, 0).toArray()
 
     private fun doTest(relativeDirectory: String, version: IntArray = incompatibleVersion) {
-        val directory = KotlinTestUtils.getTestDataPathBase() + relativeDirectory
+        val directory = KtTestUtil.getTestDataPathBase() + relativeDirectory
         val librarySource = File(directory, "A.kt")
         val usageSource = File(directory, "B.kt")
 
-        val tmpdir = KotlinTestUtils.tmpDir(this::class.java.simpleName)
+        val tmpdir = KtTestUtil.tmpDir(this::class.java.simpleName)
 
         val environment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(testRootDisposable)
         LoadDescriptorUtil.compileKotlinToDirAndGetModule(listOf(librarySource), tmpdir, environment)

compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() {
@@ -182,7 +183,7 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() {
     }
 
     override fun createEnvironment(): KotlinCoreEnvironment {
-        javaFilesDir = KotlinTestUtils.tmpDir("java-file-manager-test")
+        javaFilesDir = KtTestUtil.tmpDir("java-file-manager-test")
 
         val configuration = KotlinTestUtils.newConfiguration(
                 ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), listOf(javaFilesDir)

compiler/tests/org/jetbrains/kotlin/codegen/JvmModuleProtoBufTest.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
 import org.jetbrains.kotlin.test.CompilerTestUtil
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 class JvmModuleProtoBufTest : KtUsefulTestCase() {
@@ -35,8 +36,8 @@ class JvmModuleProtoBufTest : KtUsefulTestCase() {
         loadWith: LanguageVersion = LanguageVersion.LATEST_STABLE,
         extraOptions: List<String> = emptyList()
     ) {
-        val directory = KotlinTestUtils.getTestDataPathBase() + relativeDirectory
+        val directory = KtTestUtil.getTestDataPathBase() + relativeDirectory
-        val tmpdir = KotlinTestUtils.tmpDir(this::class.simpleName)
+        val tmpdir = KtTestUtil.tmpDir(this::class.simpleName)
 
         val moduleName = "main"
         CompilerTestUtil.executeCompilerAssertSuccessful(

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.test.ConfigurationKind;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.StringsKt;
 import org.jetbrains.org.objectweb.asm.ClassReader;
 import org.jetbrains.org.objectweb.asm.ClassVisitor;
@@ -156,7 +156,7 @@ public class OuterClassGenTest extends CodegenTestCase {
 
     private void doTest(@NotNull String classFqName, @NotNull String javaClassName, @NotNull String testDataFile) {
         File javaOut = CodegenTestUtil.compileJava(
-                Collections.singletonList(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + testDataFile + ".java"),
+                Collections.singletonList(KtTestUtil.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + testDataFile + ".java"),
                 Collections.emptyList(),
                 Collections.emptyList()
         );

compiler/tests/org/jetbrains/kotlin/codegen/ScriptGenTest.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.scripting.resolve.KotlinScriptDefinitionFromAnnotate
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.org.objectweb.asm.Opcodes
 import java.io.File
 import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
@@ -132,7 +133,7 @@ class ScriptGenTest : CodegenTestCase() {
             add(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS, NO_PARAM_SCRIPT_DEFINITION)
             put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)
 
-            addKotlinSourceRoots(sourcePaths.map { "${KotlinTestUtils.getTestDataPathBase()}/codegen/$it" })
+            addKotlinSourceRoots(sourcePaths.map { "${KtTestUtil.getTestDataPathBase()}/codegen/$it" })
             addJvmClasspathRoots(additionalDependencies)
         }
         loadScriptingPlugin(configuration)

compiler/tests/org/jetbrains/kotlin/integration/CompilerFileLimitTest.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.integration
 
 import com.intellij.openapi.util.io.FileUtil
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.File
 
@@ -112,5 +112,5 @@ class CompilerFileLimitTest : CompilerSmokeTestBase() {
 
     }
 
-    private fun tempDir(markerName: String) = KotlinTestUtils.tmpDir("${CompilerFileLimitTest::class.simpleName}$markerName")
+    private fun tempDir(markerName: String) = KtTestUtil.tmpDir("${CompilerFileLimitTest::class.simpleName}$markerName")
 }

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.integration;
 
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.jetbrains.kotlin.utils.StringsKt;
 
 import java.io.File;
@@ -30,7 +30,7 @@ import java.util.Collections;
 public abstract class CompilerSmokeTestBase extends KotlinIntegrationTestBase {
     @NotNull
     protected String getTestDataDir() {
-        return KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true);
+        return KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true);
     }
 
     protected int run(String logName, String... args) throws Exception {

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

@@ -21,7 +21,7 @@ import junit.framework.TestCase;
 import org.jetbrains.kotlin.cli.common.ExitCode;
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.junit.Assert;
 
 import java.io.File;
@@ -39,7 +39,7 @@ public class CompileEnvironmentTest extends TestCase {
             File stdlib = ForTestCompileRuntime.runtimeJarForTests();
             ExitCode exitCode = new K2JVMCompiler().exec(
                     System.out,
-                    KotlinTestUtils.getTestDataPathBase() + "/compiler/smoke/Smoke.kt",
+                    KtTestUtil.getTestDataPathBase() + "/compiler/smoke/Smoke.kt",
                     "-d", out.getAbsolutePath(),
                     "-no-stdlib",
                     "-classpath", stdlib.getAbsolutePath()

compiler/tests/org/jetbrains/kotlin/jvm/compiler/Java9ModulesIntegrationTest.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.AbstractCliTest
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.concurrent.TimeUnit
 import java.util.jar.Manifest
@@ -27,7 +28,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() {
         val paths = (modulePath + ForTestCompileRuntime.runtimeJarForTests()).joinToString(separator = File.pathSeparator) { it.path }
 
         val kotlinOptions = mutableListOf(
-            "-jdk-home", KotlinTestUtils.getJdk9Home().path,
+            "-jdk-home", KtTestUtil.getJdk9Home().path,
             "-jvm-target", "1.8",
             "-Xmodule-path=$paths"
         )
@@ -63,7 +64,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() {
 
     private fun runModule(className: String, modulePath: List<File>): ModuleRunResult {
         val command = listOf(
-            File(KotlinTestUtils.getJdk9Home(), "bin/java").path,
+            File(KtTestUtil.getJdk9Home(), "bin/java").path,
             "-p", (modulePath + ForTestCompileRuntime.runtimeJarForTests()).joinToString(File.pathSeparator, transform = File::getPath),
             "-m", className
         )
@@ -170,7 +171,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() {
 
         val kotlinOptions = mutableListOf(
             "$testDataDirectory/someOtherDirectoryWithTheActualModuleInfo/module-info.java",
-            "-jdk-home", KotlinTestUtils.getJdk9Home().path,
+            "-jdk-home", KtTestUtil.getJdk9Home().path,
             "-Xmodule-path=${a.path}"
         )
         compileLibrary(
@@ -192,7 +193,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() {
 
         // Use the name other from 'library' to prevent it from being loaded as an automatic module if module-info.class is not found
         val libraryJar = createMultiReleaseJar(
-            KotlinTestUtils.getJdk9Home(), File(tmpdir, "multi-release-library.jar"), libraryOut, libraryOut9
+            KtTestUtil.getJdk9Home(), File(tmpdir, "multi-release-library.jar"), libraryOut, libraryOut9
         )
 
         module("main", listOf(libraryJar))

compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import java.io.File
 
@@ -41,7 +42,7 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() {
 
     private fun doTest(useJavac: Boolean, configurator: (CompilerConfiguration) -> Unit) {
         val configuration = KotlinTestUtils.newConfiguration(
-                ConfigurationKind.ALL, TestJdkKind.FULL_JDK, KotlinTestUtils.getAnnotationsJar()
+            ConfigurationKind.ALL, TestJdkKind.FULL_JDK, KtTestUtil.getAnnotationsJar()
         ).apply {
             if (useJavac) {
                 put(JVMConfigurationKeys.USE_JAVAC, true)

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.types.FlexibleType
 import org.jetbrains.kotlin.types.TypeConstructorSubstitution
 import org.jetbrains.kotlin.types.lowerIfFlexible
@@ -75,8 +76,8 @@ class MemoryOptimizationsTest : KtUsefulTestCase() {
                         )
         val moduleDescriptor =
                 JvmResolveUtil.analyze(
-                        KotlinTestUtils.createFile("main.kt", text, environment.project),
+                    KtTestUtil.createFile("main.kt", text, environment.project),
-                        environment
+                    environment
                 ).moduleDescriptor
 
         val aClass =

compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import java.io.File
 
@@ -88,8 +89,8 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
         val configuration = KotlinTestUtils.newConfiguration(
                 ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
                 listOf(
-                        KotlinTestUtils.getAnnotationsJar(),
+                    KtTestUtil.getAnnotationsJar(),
-                        MockLibraryUtil.compileJavaFilesLibraryToJar(
+                    MockLibraryUtil.compileJavaFilesLibraryToJar(
                                 FOREIGN_ANNOTATIONS_SOURCES_PATH,
                                 "foreign-annotations"
                         )

compiler/tests/org/jetbrains/kotlin/multiplatform/AbstractMultiPlatformIntegrationTest.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF
 import java.io.File
 import java.nio.file.Files
@@ -40,7 +41,7 @@ abstract class AbstractMultiPlatformIntegrationTest : KtUsefulTestCase() {
         val common2Src = File(root, "common2.kt").takeIf(File::exists)
         val jvm2Src = File(root, "jvm2.kt").takeIf(File::exists)
 
-        val tmpdir = KotlinTestUtils.tmpDir(getTestName(true))
+        val tmpdir = KtTestUtil.tmpDir(getTestName(true))
 
         val optionalStdlibCommon =
             if (InTextDirectivesUtils.isDirectiveDefined(commonSrc.readText(), "WITH_RUNTIME"))

compiler/tests/org/jetbrains/kotlin/parsing/AbstractParsingTest.java

@@ -31,8 +31,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.TestsCompilerError;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.testFramework.KtParsingTestCase;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
@@ -42,7 +42,7 @@ public abstract class AbstractParsingTest extends KtParsingTestCase {
 
     @Override
     protected String getTestDataPath() {
-        return KotlinTestUtils.getHomeDirectory();
+        return KtTestUtil.getHomeDirectory();
     }
 
     public AbstractParsingTest() {

compiler/tests/org/jetbrains/kotlin/psi/KtPsiUtilTest.java

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.psi.psiUtil.KtPsiUtilKt;
 import org.jetbrains.kotlin.resolve.ImportPath;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 import org.junit.Assert;
 
 import java.io.File;
@@ -40,8 +41,8 @@ public class KtPsiUtilTest extends KotlinTestWithEnvironment {
     @NotNull
     private KtFile loadPsiFile(@NotNull String name) {
         try {
-            String text = KotlinTestUtils.doLoadFile(KotlinTestUtils.getTestDataPathBase(), name);
+            String text = KtTestUtil.doLoadFile(KtTestUtil.getTestDataPathBase(), name);
-            return KotlinTestUtils.createFile(name + ".kt", text, getProject());
+            return KtTestUtil.createFile(name + ".kt", text, getProject());
         }
         catch (IOException e) {
             throw new RuntimeException(e);
@@ -84,7 +85,7 @@ public class KtPsiUtilTest extends KotlinTestWithEnvironment {
     }
 
     public void testIsLocalClass() throws IOException {
-        String text = FileUtil.loadFile(new File(KotlinTestUtils.getTestDataPathBase() + "/psiUtil/isLocalClass.kt"), true);
+        String text = FileUtil.loadFile(new File(KtTestUtil.getTestDataPathBase() + "/psiUtil/isLocalClass.kt"), true);
         KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(text);
 
         @SuppressWarnings("unchecked")

compiler/tests/org/jetbrains/kotlin/reflection/ReflectionIntegrationTest.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.test.CompilerTestUtil
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.concurrent.TimeUnit
 
@@ -20,7 +21,7 @@ class ReflectionIntegrationTest : KtUsefulTestCase() {
     fun testClassLoaderForBuiltIns() {
         val tmpdir = KotlinTestUtils.tmpDirForTest(this)
 
-        val root = KotlinTestUtils.getTestDataPathBase() + "/reflection/classLoaderForBuiltIns"
+        val root = KtTestUtil.getTestDataPathBase() + "/reflection/classLoaderForBuiltIns"
         KotlinTestUtils.compileJavaFiles(
             listOf(File("$root/Main.java")),
             listOf("-d", tmpdir.absolutePath)

compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.types.TypeProjection
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.TypeSubstitutor
@@ -38,7 +39,7 @@ import java.util.*
 
 class CapturedTypeApproximationTest : KotlinTestWithEnvironment() {
     private val testDataPath: String
-        get() = KotlinTestUtils.getTestDataPathBase() + "/capturedTypeApproximation/"
+        get() = KtTestUtil.getTestDataPathBase() + "/capturedTypeApproximation/"
 
     override fun createEnvironment(): KotlinCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY)
 
@@ -46,7 +47,8 @@ class CapturedTypeApproximationTest : KotlinTestWithEnvironment() {
         assert(substitutions.size in 1..2) { "Captured type approximation test requires substitutions for (T) or (T, R)" }
         val oneTypeVariable = substitutions.size == 1
 
-        val declarationsText = KotlinTestUtils.doLoadFile(File(testDataPath + "/declarations.kt"))
+        val declarationsText =
+            KtTestUtil.doLoadFile(File(testDataPath + "/declarations.kt"))
 
         fun analyzeTestFile(testType: String) = run {
             val test = declarationsText.replace("#TestType#", testType)

compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.serialization.AbstractVersionRequirementTest
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 class JsVersionRequirementTest : AbstractVersionRequirementTest() {
@@ -37,7 +38,13 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() {
         analysisFlags: Map<AnalysisFlag<*>, Any?>
     ) {
         val environment = createEnvironment(languageVersion)
-        val ktFiles = files.map { file -> KotlinTestUtils.createFile(file.name, file.readText(), environment.project) }
+        val ktFiles = files.map { file ->
+            KtTestUtil.createFile(
+                file.name,
+                file.readText(),
+                environment.project
+            )
+        }
         val trace = BindingTraceContext()
         val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(
             ktFiles, trace, createModule(environment), environment.configuration

compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java

@@ -43,7 +43,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
         File ktFile = new File("compiler/testData/recursiveProcessor/declarations.kt");
         File txtFile = new File("compiler/testData/recursiveProcessor/declarations.txt");
         String text = FileUtil.loadFile(ktFile, true);
-        KtFile jetFile = KotlinTestUtils.createFile("declarations.kt", text, getEnvironment().getProject());
+        KtFile jetFile = KtTestUtil.createFile("declarations.kt", text, getEnvironment().getProject());
         AnalysisResult result = KotlinTestUtils.analyzeFile(jetFile, getEnvironment());
         PackageViewDescriptor testPackage = result.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test")));
 

core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl
 import org.jetbrains.kotlin.test.*
 import org.jetbrains.kotlin.test.TestFiles.TestFileFactoryNoModules
 import org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator
 import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.Configuration
 import org.jetbrains.kotlin.utils.Printer
@@ -133,7 +134,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() {
                 for (root in environment.configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS)) {
                     LOG.info("root: $root")
                 }
-                val ktFile = KotlinTestUtils.createFile(file.path, text, environment.project)
+                val ktFile = KtTestUtil.createFile(file.path, text, environment.project)
                 GenerationUtils.compileFileTo(ktFile, environment, tmpdir)
             }
         }

generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.generators.impl
 
 import com.intellij.openapi.util.text.StringUtil
-import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.generators.MethodGenerator
+import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.generators.model.SimpleTestClassModel
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
@@ -36,7 +36,7 @@ object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator<
             val assertTestsPresentStr = if (classModel.targetBackend === TargetBackend.ANY) {
                 String.format(
                     "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);",
-                    KotlinTestUtils.getFilePath(classModel.rootFile),
+                    KtTestUtil.getFilePath(classModel.rootFile),
                     StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()),
                     excludedArgument,
                     classModel.recursive,
@@ -45,7 +45,7 @@ object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator<
             } else {
                 String.format(
                     "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);",
-                    KotlinTestUtils.getFilePath(classModel.rootFile),
+                    KtTestUtil.getFilePath(classModel.rootFile),
                     StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()),
                     excludedArgument, TargetBackend::class.java.simpleName, classModel.targetBackend.toString(), classModel.recursive, exclude
                 )

generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.generators.impl
 
-import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.generators.MethodGenerator
+import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.generators.model.RunTestMethodModel
 import org.jetbrains.kotlin.generators.model.SimpleTestMethodModel
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.Printer
 
 object SimpleTestMethodGenerator : MethodGenerator<SimpleTestMethodModel>() {
@@ -22,7 +22,7 @@ object SimpleTestMethodGenerator : MethodGenerator<SimpleTestMethodModel>() {
 
     override fun generateBody(method: SimpleTestMethodModel, p: Printer) {
         with(method) {
-            val filePath = KotlinTestUtils.getFilePath(file) + if (file.isDirectory) "/" else ""
+            val filePath = KtTestUtil.getFilePath(file) + if (file.isDirectory) "/" else ""
             p.println(RunTestMethodModel.METHOD_NAME, "(\"", filePath, "\");")
         }
     }

generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.generators.impl
 
 import com.intellij.openapi.util.text.StringUtil
-import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.generators.MethodGenerator
+import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.generators.model.SingleClassTestModel
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.Printer
 
 object SingleClassTestModelAllFilesPresentedMethodGenerator : MethodGenerator<SingleClassTestModel.TestAllFilesPresentMethodModel>() {
@@ -37,13 +37,13 @@ object SingleClassTestModelAllFilesPresentedMethodGenerator : MethodGenerator<Si
                 assertTestsPresentStr = if (targetBackend !== TargetBackend.ANY) {
                     String.format(
                         "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s);",
-                        KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()),
+                        KtTestUtil.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()),
                         excludedArgument, TargetBackend::class.java.simpleName, targetBackend.toString()
                     )
                 } else {
                     String.format(
                         "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s);",
-                        KotlinTestUtils.getFilePath(rootFile),
+                        KtTestUtil.getFilePath(rootFile),
                         StringUtil.escapeStringCharacters(filenamePattern.pattern()),
                         excludedArgument
                     )

generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt

@@ -8,6 +8,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.fileNameToJavaIdentifier
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.*
 import java.util.regex.Pattern
@@ -120,7 +121,7 @@ class SimpleTestClassModel(
         }
 
     override val dataString: String
-        get() = KotlinTestUtils.getFilePath(rootFile)
+        get() = KtTestUtil.getFilePath(rootFile)
 
     override val dataPathRoot: String
         get() = "\$PROJECT_ROOT"

generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestMethodModel.kt

@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.generators.model
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.escapeForJavaIdentifier
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.regex.Pattern
 
@@ -28,7 +28,7 @@ open class SimpleTestMethodModel(
     override val dataString: String
         get() {
             val path = FileUtil.getRelativePath(rootDir, file)!!
-            return KotlinTestUtils.getFilePath(File(path))
+            return KtTestUtil.getFilePath(File(path))
         }
 
     override fun shouldBeGenerated(): Boolean {

generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt

@@ -5,8 +5,8 @@
 package org.jetbrains.kotlin.generators.model
 
 import com.intellij.openapi.util.io.FileUtil
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.util.*
 import java.util.regex.Pattern
@@ -54,7 +54,7 @@ class SingleClassTestModel(
     // There's always one test for checking if all tests are present
     override val isEmpty: Boolean
         get() = methods.size <= 1
-    override val dataString: String = KotlinTestUtils.getFilePath(rootFile)
+    override val dataString: String = KtTestUtil.getFilePath(rootFile)
     override val dataPathRoot: String = "\$PROJECT_ROOT"
 
     object AllFilesPresentedMethodKind : MethodModel.Kind()

generators/tests/org/jetbrains/kotlin/generators/protobuf/ProtoBufCompareConsistencyTest.kt

@@ -19,11 +19,12 @@ package org.jetbrains.kotlin.generators.protobuf
 import com.intellij.openapi.util.io.FileUtil
 import junit.framework.TestCase
 import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 
 class ProtoBufCompareConsistencyTest : TestCase() {
     fun testAlreadyGenerated() {
-        val testDir = KotlinTestUtils.tmpDir("testDirectory")
+        val testDir = KtTestUtil.tmpDir("testDirectory")
         val newFile = File(testDir, "ProtoCompareGenerated.kt")
         GenerateProtoBufCompare.generate(newFile)
 

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompletionTestUtil.kt

@@ -9,12 +9,12 @@ import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.codeInsight.lookup.LookupElement
 import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 
 val RELATIVE_COMPLETION_TEST_DATA_BASE_PATH = "idea/idea-completion/testData"
 
-val COMPLETION_TEST_DATA_BASE_PATH = KotlinTestUtils.getHomeDirectory() + "/" + RELATIVE_COMPLETION_TEST_DATA_BASE_PATH
+val COMPLETION_TEST_DATA_BASE_PATH = KtTestUtil.getHomeDirectory() + "/" + RELATIVE_COMPLETION_TEST_DATA_BASE_PATH
 
 fun testCompletion(
     fileText: String,

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

@@ -11,20 +11,21 @@ import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 @WithMutedInDatabaseRunTest
 abstract public class KotlinCompletionTestCase extends CompletionTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory());
+        VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory());
         CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = new String[]{"excludedPackage", "somePackage.ExcludedClass"};
     }
 
     @Override
     protected void tearDown() throws Exception {
         CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = ArrayUtil.EMPTY_STRING_ARRAY;
-        VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory());
+        VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory());
         super.tearDown();
     }
 

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinCompletionTestCase.java.203

@@ -11,15 +11,15 @@ import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.ThrowableRunnable;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 @WithMutedInDatabaseRunTest
 abstract public class KotlinCompletionTestCase extends CompletionTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        VfsRootAccess.allowRootAccess(getTestRootDisposable(), KotlinTestUtils.getHomeDirectory());
+        VfsRootAccess.allowRootAccess(getTestRootDisposable(), KtTestUtil.getHomeDirectory());
         CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = new String[]{"excludedPackage", "somePackage.ExcludedClass"};
     }
 

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirMultiModuleLazyResolveTest.kt

@@ -17,12 +17,13 @@ import org.jetbrains.kotlin.idea.stubs.AbstractMultiModuleTest
 import org.jetbrains.kotlin.idea.util.sourceRoots
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import java.nio.file.Paths
 
 abstract class AbstractFirMultiModuleLazyResolveTest : AbstractMultiModuleTest() {
     override fun getTestDataPath(): String =
-        "${KotlinTestUtils.getHomeDirectory()}/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/multiModuleLazyResolve/"
+        "${KtTestUtil.getHomeDirectory()}/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/multiModuleLazyResolve/"
 
     fun doTest(path: String) {
         val testStructure = MultiModuleTestProjectStructure.fromTestProjectStructure(TestProjectStructureReader.read(Paths.get(path)))

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/AbstractSessionsInvalidationTest.kt

@@ -20,13 +20,14 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.incModificationTracker
 import org.jetbrains.kotlin.idea.jsonUtils.getString
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiModuleTest
 import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.nio.file.Files
 import java.nio.file.Paths
 import kotlin.io.path.writeText
 
 abstract class AbstractSessionsInvalidationTest : AbstractMultiModuleTest() {
     override fun getTestDataPath(): String =
-        "${KotlinTestUtils.getHomeDirectory()}/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/sessionInvalidation/"
+        "${KtTestUtil.getHomeDirectory()}/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/sessionInvalidation/"
 
     protected fun doTest(path: String) {
         val testStructure = TestProjectStructureReader.readToTestStructure(

idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import java.io.File
 import kotlin.reflect.KProperty1
 import kotlin.reflect.full.memberProperties
@@ -32,7 +33,7 @@ import kotlin.reflect.jvm.javaGetter
 
 
 abstract class AbstractResolveCallTest : @Suppress("DEPRECATION") LightCodeInsightTestCase() {
-    override fun getTestDataPath(): String = KotlinTestUtils.getHomeDirectory() + "/"
+    override fun getTestDataPath(): String = KtTestUtil.getHomeDirectory() + "/"
 
     protected fun doTest(path: String) {
         addExternalTestFiles(path)