diff --git a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index 5b9505f687d..26f76d172a2 100644 --- a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt @@ -61,7 +61,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { } private fun createJarWithForeignAnnotations(): File = - MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations") + MockLibraryUtilExt.compileJavaFilesLibraryToJar(FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations") private fun createEnvironment(content: String): KotlinCoreEnvironment { val classpath = mutableListOf(getAnnotationsJar(), ForTestCompileRuntime.runtimeJarForTests()) diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt index c503da26b99..28b58934b85 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt @@ -3,40 +3,9 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -@file:JvmName("KtAssert") - package org.jetbrains.kotlin.test import java.io.File -import java.util.* -import kotlin.collections.ArrayList -import kotlin.contracts.ExperimentalContracts -import kotlin.contracts.contract - -/* - * Those functions are needed only in this module because it has no testing framework - * with assertions in it's dependencies - */ - -internal fun fail(message: String) { - throw AssertionError(message) -} - -@OptIn(ExperimentalContracts::class) -internal fun assertNotNull(message: String, value: Any?) { - contract { - returns() implies (value != null) - } - if (value == null) { - fail(message) - } -} - -internal fun assertTrue(message: String, value: Boolean) { - if (!value) { - fail(message) - } -} abstract class Assertions { fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String = { it }) { diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/KtAssert.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/KtAssert.kt new file mode 100644 index 00000000000..d79c90c2144 --- /dev/null +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/KtAssert.kt @@ -0,0 +1,45 @@ +/* + * 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 + +import kotlin.contracts.ExperimentalContracts +import kotlin.contracts.contract + + +/* + * Those functions are needed only in modules which are not depend on any testing framework + */ +object KtAssert { + @JvmStatic + fun fail(message: String) { + throw AssertionError(message) + } + + @JvmStatic + @OptIn(ExperimentalContracts::class) + fun assertNotNull(message: String, value: Any?) { + contract { + returns() implies (value != null) + } + if (value == null) { + fail(message) + } + } + + @JvmStatic + fun assertTrue(message: String, value: Boolean) { + if (!value) { + fail(message) + } + } + + @JvmStatic + fun assertEquals(message: String, expected: T, actual: T) { + if (expected != actual) { + fail(message) + } + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt index 57be257095e..650a476a60a 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.checkers -import org.jetbrains.kotlin.test.MockLibraryUtil.compileJavaFilesLibraryToJar +import org.jetbrains.kotlin.test.MockLibraryUtilExt.compileJavaFilesLibraryToJar import java.io.File import kotlin.io.path.ExperimentalPathApi import kotlin.io.path.createTempDirectory diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt index 40b66d1a4ee..9cdb58b1cfe 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt @@ -19,7 +19,7 @@ package org.jetbrains.kotlin.checkers import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.utils.JavaTypeEnhancementState import org.jetbrains.kotlin.utils.ReportLevel import java.io.File @@ -35,7 +35,7 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { } protected fun compileTestAnnotations(extraClassPath: List): List = - listOf(MockLibraryUtil.compileJavaFilesLibraryToJar( + listOf(MockLibraryUtilExt.compileJavaFilesLibraryToJar( TEST_ANNOTATIONS_SOURCE_PATH, "test-foreign-annotations", extraOptions = listOf("-Xallow-kotlin-package"), @@ -43,7 +43,7 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { )) protected fun createJarWithForeignAnnotations(): List = listOf( - MockLibraryUtil.compileJavaFilesLibraryToJar(annotationsPath, "foreign-annotations"), + MockLibraryUtilExt.compileJavaFilesLibraryToJar(annotationsPath, "foreign-annotations"), ForTestCompileRuntime.jvmAnnotationsForTests() ) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt index f4e9707b930..f702b80bf06 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt @@ -8,11 +8,13 @@ package org.jetbrains.kotlin.checkers import com.intellij.openapi.util.io.FileUtil import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import java.io.File import java.util.* import java.util.regex.Pattern -import kotlin.io.path.* +import kotlin.io.path.ExperimentalPathApi +import kotlin.io.path.createTempFile +import kotlin.io.path.writeText const val JSPECIFY_NULLNESS_MISMATCH_MARK = "jspecify_nullness_mismatch" @@ -27,7 +29,7 @@ abstract class AbstractJspecifyAnnotationsTest : AbstractDiagnosticsTest() { super.doMultiFileTest( wholeFile, files, - MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations"), + MockLibraryUtilExt.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations"), usePsiClassFilesReading = false, excludeNonTypeUseJetbrainsAnnotations = true ) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index f387835d13f..96097e5d21b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java @@ -115,7 +115,7 @@ public class LoadDescriptorUtil { List javaBinaryRoots = new ArrayList<>(); // TODO: use the same additional binary roots as those were used for compilation if (withForeignAnnotations) { - javaBinaryRoots.add(MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")); + javaBinaryRoots.add(MockLibraryUtilExt.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")); } javaBinaryRoots.add(KtTestUtil.getAnnotationsJar()); javaBinaryRoots.add(ForTestCompileRuntime.jvmAnnotationsForTests()); @@ -164,7 +164,7 @@ public class LoadDescriptorUtil { classpath.add(ForTestCompileRuntime.runtimeJarForTests()); if (useJetbrainsAnnotationsWithTypeUse) { - classpath.add(MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")); + classpath.add(MockLibraryUtilExt.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")); } classpath.add(KtTestUtil.getAnnotationsJar()); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java index 8863c64da1b..f4caa9bdf60 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -50,6 +50,7 @@ import org.jetbrains.kotlin.psi.KtFile; 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.JUnit4Assertions; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.util.StringUtilsKt; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; @@ -464,70 +465,15 @@ public class KotlinTestUtils { } private static boolean compileJavaFiles(@NotNull Collection files, List options, @Nullable File javaErrorFile) throws IOException { - JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); - DiagnosticCollector diagnosticCollector = new DiagnosticCollector<>(); - try (StandardJavaFileManager fileManager = - javaCompiler.getStandardFileManager(diagnosticCollector, Locale.ENGLISH, Charset.forName("utf-8"))) { - Iterable javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(files); - - JavaCompiler.CompilationTask task = javaCompiler.getTask( - new StringWriter(), // do not write to System.err - fileManager, - diagnosticCollector, - options, - null, - javaFileObjectsFromFiles); - - Boolean success = task.call(); // do NOT inline this variable, call() should complete before errorsToString() - if (javaErrorFile == null || !javaErrorFile.exists()) { - Assert.assertTrue(errorsToString(diagnosticCollector, true), success); - } - else { - assertEqualsToFile(javaErrorFile, errorsToString(diagnosticCollector, false)); - } - return success; - } + return JvmCompilationUtils.compileJavaFiles(files, options, javaErrorFile, JUnit4Assertions.INSTANCE); } public static boolean compileJavaFilesExternallyWithJava9(@NotNull Collection files, @NotNull List options) { - return compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home()); + return JvmCompilationUtils.compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home()); } public static boolean compileJavaFilesExternally(@NotNull Collection files, @NotNull List options, @NotNull File jdkHome) { - List command = new ArrayList<>(); - command.add(new File(jdkHome, "bin/javac").getPath()); - command.addAll(options); - for (File file : files) { - command.add(file.getPath()); - } - - try { - Process process = new ProcessBuilder().command(command).inheritIO().start(); - process.waitFor(); - return process.exitValue() == 0; - } - catch (Exception e) { - throw ExceptionUtilsKt.rethrow(e); - } - } - - @NotNull - private static String errorsToString(@NotNull DiagnosticCollector diagnosticCollector, boolean humanReadable) { - StringBuilder builder = new StringBuilder(); - for (javax.tools.Diagnostic diagnostic : diagnosticCollector.getDiagnostics()) { - if (diagnostic.getKind() != javax.tools.Diagnostic.Kind.ERROR) continue; - - if (humanReadable) { - builder.append(diagnostic).append("\n"); - } - else { - builder.append(new File(diagnostic.getSource().toUri()).getName()).append(":") - .append(diagnostic.getLineNumber()).append(":") - .append(diagnostic.getColumnNumber()).append(":") - .append(diagnostic.getCode()).append("\n"); - } - } - return builder.toString(); + return JvmCompilationUtils.compileJavaFilesExternally(files, options, jdkHome); } public static String navigationMetadata(@TestDataFile String testFile) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtilExt.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtilExt.kt new file mode 100644 index 00000000000..9c7a18975a7 --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtilExt.kt @@ -0,0 +1,72 @@ +/* + * 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 + +import org.jetbrains.kotlin.test.util.JUnit4Assertions +import java.io.File + +object MockLibraryUtilExt { + @JvmStatic + @JvmOverloads + fun compileJavaFilesLibraryToJar( + sourcesPath: String, + jarName: String, + addSources: Boolean = false, + extraOptions: List = emptyList(), + extraClasspath: List = emptyList(), + ): File { + return MockLibraryUtil.compileJavaFilesLibraryToJar(sourcesPath, jarName, addSources, extraOptions, extraClasspath, JUnit4Assertions) + } + + @JvmStatic + @JvmOverloads + fun compileJvmLibraryToJar( + sourcesPath: String, + jarName: String, + addSources: Boolean = false, + allowKotlinSources: Boolean = true, + extraOptions: List = emptyList(), + extraClasspath: List = emptyList(), + useJava9: Boolean = false, + ): File { + return MockLibraryUtil.compileJvmLibraryToJar( + sourcesPath, + jarName, + addSources, + allowKotlinSources, + extraOptions, + extraClasspath, + useJava9, + JUnit4Assertions + ) + } + + @JvmStatic + @JvmOverloads + fun compileLibraryToJar( + sourcesPath: String, + contentDir: File, + jarName: String, + addSources: Boolean = false, + allowKotlinSources: Boolean = true, + extraOptions: List = emptyList(), + extraClasspath: List = emptyList(), + useJava9: Boolean = false + ): File { + return MockLibraryUtil.compileLibraryToJar( + sourcesPath, + contentDir, + jarName, + addSources, + allowKotlinSources, + extraOptions, + extraClasspath, + useJava9, + JUnit4Assertions + ) + } + +} diff --git a/compiler/tests-compiler-utils/build.gradle.kts b/compiler/tests-compiler-utils/build.gradle.kts index c9752ac4938..f75f87e3487 100644 --- a/compiler/tests-compiler-utils/build.gradle.kts +++ b/compiler/tests-compiler-utils/build.gradle.kts @@ -23,6 +23,7 @@ dependencies { testCompile(project(":compiler:cli-js")) testCompile(project(":compiler:serialization")) testCompile(projectTests(":compiler:test-infrastructure-utils")) + testCompile(project(":kotlin-preloader")) testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") } testCompile(intellijDep()) { diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/JvmCompilationUtils.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/JvmCompilationUtils.kt new file mode 100644 index 00000000000..ec832e7e1e1 --- /dev/null +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/JvmCompilationUtils.kt @@ -0,0 +1,81 @@ +/* + * 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. + */ + +@file:JvmName("JvmCompilationUtils") + +package org.jetbrains.kotlin.test + +import org.jetbrains.kotlin.test.util.KtTestUtil +import org.jetbrains.kotlin.utils.rethrow +import java.io.File +import java.io.IOException +import java.io.StringWriter +import java.nio.charset.Charset +import java.util.* +import javax.tools.Diagnostic +import javax.tools.DiagnosticCollector +import javax.tools.JavaFileObject +import javax.tools.ToolProvider + +@JvmOverloads +@Throws(IOException::class) +fun compileJavaFiles(files: Collection, options: List?, javaErrorFile: File? = null, assertions: Assertions): Boolean { + val javaCompiler = ToolProvider.getSystemJavaCompiler() + val diagnosticCollector = DiagnosticCollector() + javaCompiler.getStandardFileManager(diagnosticCollector, Locale.ENGLISH, Charset.forName("utf-8")).use { fileManager -> + val javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(files) + val task = javaCompiler.getTask( + StringWriter(), // do not write to System.err + fileManager, + diagnosticCollector, + options, + null, + javaFileObjectsFromFiles + ) + val success = task.call() // do NOT inline this variable, call() should complete before errorsToString() + if (javaErrorFile == null || !javaErrorFile.exists()) { + assertions.assertTrue(success) { errorsToString(diagnosticCollector, true) } + } else { + assertions.assertEqualsToFile(javaErrorFile, errorsToString(diagnosticCollector, false)) + } + return success + } +} + +fun compileJavaFilesExternallyWithJava9(files: Collection, options: List): Boolean { + return compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home()) +} + +fun compileJavaFilesExternally(files: Collection, options: List, jdkHome: File): Boolean { + val command: MutableList = ArrayList() + command.add(File(jdkHome, "bin/javac").path) + command.addAll(options) + for (file in files) { + command.add(file.path) + } + return try { + val process = ProcessBuilder().command(command).inheritIO().start() + process.waitFor() + process.exitValue() == 0 + } catch (e: Exception) { + throw rethrow(e) + } +} + +private fun errorsToString(diagnosticCollector: DiagnosticCollector, humanReadable: Boolean): String { + val builder = StringBuilder() + for (diagnostic in diagnosticCollector.diagnostics) { + if (diagnostic.kind != Diagnostic.Kind.ERROR) continue + if (humanReadable) { + builder.append(diagnostic).append("\n") + } else { + builder.append(File(diagnostic.source.toUri()).name).append(":") + .append(diagnostic.lineNumber).append(":") + .append(diagnostic.columnNumber).append(":") + .append(diagnostic.code).append("\n") + } + } + return builder.toString() +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt similarity index 83% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt index e33c830397d..0e7df93f0d0 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * 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 @@ -27,8 +16,6 @@ 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 import java.io.ByteArrayOutputStream import java.io.File import java.io.FileOutputStream @@ -42,7 +29,6 @@ object MockLibraryUtil { private var compilerClassLoader = SoftReference(null) @JvmStatic - @JvmOverloads fun compileJvmLibraryToJar( sourcesPath: String, jarName: String, @@ -50,38 +36,40 @@ object MockLibraryUtil { allowKotlinSources: Boolean = true, extraOptions: List = emptyList(), extraClasspath: List = emptyList(), - useJava9: Boolean = false + useJava9: Boolean = false, + assertions: Assertions ): File { return compileLibraryToJar( sourcesPath, - KtTestUtil.tmpDirForReusableFolder("testLibrary-" + jarName), + KtTestUtil.tmpDirForReusableFolder("testLibrary-$jarName"), jarName, addSources, allowKotlinSources, extraOptions, extraClasspath, - useJava9 + useJava9, + assertions ) } @JvmStatic - @JvmOverloads fun compileJavaFilesLibraryToJar( sourcesPath: String, jarName: String, addSources: Boolean = false, extraOptions: List = emptyList(), - extraClasspath: List = emptyList() + extraClasspath: List = emptyList(), + assertions: Assertions ): File { return compileJvmLibraryToJar( sourcesPath, jarName, addSources, allowKotlinSources = false, - extraClasspath = extraClasspath, extraOptions = extraOptions + extraClasspath = extraClasspath, extraOptions = extraOptions, + assertions = assertions ) } @JvmStatic - @JvmOverloads fun compileLibraryToJar( sourcesPath: String, contentDir: File, @@ -90,14 +78,15 @@ object MockLibraryUtil { allowKotlinSources: Boolean = true, extraOptions: List = emptyList(), extraClasspath: List = emptyList(), - useJava9: Boolean = false + useJava9: Boolean = false, + assertions: Assertions ): File { val classesDir = File(contentDir, "classes") val srcFile = File(sourcesPath) val kotlinFiles = FileUtil.findFilesByMask(Pattern.compile(".*\\.kt"), srcFile) if (srcFile.isFile || kotlinFiles.isNotEmpty()) { - Assert.assertTrue("Only java files are expected", allowKotlinSources) + KtAssert.assertTrue("Only java files are expected", allowKotlinSources) compileKotlin(sourcesPath, classesDir, extraOptions, *extraClasspath.toTypedArray()) } @@ -121,8 +110,8 @@ object MockLibraryUtil { ) val compile = - if (useJava9) KotlinTestUtils::compileJavaFilesExternallyWithJava9 - else KotlinTestUtils::compileJavaFiles + if (useJava9) ::compileJavaFilesExternallyWithJava9 + else { files, opts -> compileJavaFiles(files, opts, assertions = assertions) } val success = compile(javaFiles, options) if (!success) { @@ -135,17 +124,18 @@ object MockLibraryUtil { @JvmStatic fun compileJsLibraryToJar(sourcesPath: String, jarName: String, addSources: Boolean, extraOptions: List = emptyList()): File { - val contentDir = KtTestUtil.tmpDirForReusableFolder("testLibrary-" + jarName) + val contentDir = KtTestUtil.tmpDirForReusableFolder("testLibrary-$jarName") val outDir = File(contentDir, "out") - val outputFile = File(outDir, jarName + ".js") + val outputFile = File(outDir, "$jarName.js") compileKotlin2JS(sourcesPath, outputFile, extraOptions) return createJarFile(contentDir, outDir, jarName, sourcesPath.takeIf { addSources }) } + @JvmStatic fun createJarFile(contentDir: File, dirToAdd: File, jarName: String, sourcesPath: String? = null): File { - val jarFile = File(contentDir, jarName + ".jar") + val jarFile = File(contentDir, "$jarName.jar") ZipOutputStream(FileOutputStream(jarFile)).use { zip -> ZipUtil.addDirToZipRecursively(zip, jarFile, dirToAdd, "", null, null) @@ -171,7 +161,7 @@ object MockLibraryUtil { val compiler = compilerClass.newInstance() val execMethod = compilerClass.getMethod("exec", PrintStream::class.java, Array::class.java) val invocationResult = execMethod.invoke(compiler, PrintStream(outStream), args.toTypedArray()) as Enum<*> - assertEquals(String(outStream.toByteArray()), ExitCode.OK.name, invocationResult.name) + KtAssert.assertEquals(String(outStream.toByteArray()), ExitCode.OK.name, invocationResult.name) } @JvmStatic diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt index ebe3e34f39e..caa6d004817 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageFragment import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil -import org.jetbrains.kotlin.test.ConfigurationKind -import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.test.MockLibraryUtil -import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.* import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.JavaTypeEnhancementState @@ -108,5 +105,5 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() { } private fun prepareJar() = - MockLibraryUtil.compileJavaFilesLibraryToJar(TEST_DATA_PATH, "result.jar") + MockLibraryUtilExt.compileJavaFilesLibraryToJar(TEST_DATA_PATH, "result.jar") } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt index f900b4a1bb3..2e1afc1d3a0 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt @@ -33,10 +33,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.renderer.AnnotationArgumentsRenderingPolicy import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil -import org.jetbrains.kotlin.test.ConfigurationKind -import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.test.MockLibraryUtil -import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.* import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.JavaTypeEnhancementState @@ -90,7 +87,7 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() { ConfigurationKind.ALL, TestJdkKind.FULL_JDK, listOf( KtTestUtil.getAnnotationsJar(), - MockLibraryUtil.compileJavaFilesLibraryToJar( + MockLibraryUtilExt.compileJavaFilesLibraryToJar( FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations" ) diff --git a/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/SdkAndMockLibraryProjectDescriptor.java b/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/SdkAndMockLibraryProjectDescriptor.java index 193d55ca4cc..47d2c8ec487 100644 --- a/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/SdkAndMockLibraryProjectDescriptor.java +++ b/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/SdkAndMockLibraryProjectDescriptor.java @@ -28,6 +28,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.framework.JSLibraryKind; import org.jetbrains.kotlin.idea.framework.KotlinSdkType; import org.jetbrains.kotlin.test.MockLibraryUtil; +import org.jetbrains.kotlin.test.MockLibraryUtilExt; import org.jetbrains.kotlin.utils.PathUtil; import java.io.File; @@ -78,7 +79,7 @@ public class SdkAndMockLibraryProjectDescriptor extends KotlinLightProjectDescri File libraryJar = isJsLibrary ? MockLibraryUtil.compileJsLibraryToJar(sourcesPath, LIBRARY_NAME, withSources, Collections.emptyList()) - : MockLibraryUtil.compileJvmLibraryToJar(sourcesPath, LIBRARY_NAME, withSources, true, extraOptions, classpath); + : MockLibraryUtilExt.compileJvmLibraryToJar(sourcesPath, LIBRARY_NAME, withSources, true, extraOptions, classpath); String jarUrl = getJarUrl(libraryJar); Library.ModifiableModel libraryModel = diff --git a/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt b/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt index 9a685e7413e..af86de54107 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt +++ b/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.idea.test.AstAccessControl import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import java.io.File abstract class AbstractJavaAgainstKotlinBinariesCheckerTest : AbstractJavaAgainstKotlinCheckerTest() { @@ -25,7 +25,7 @@ abstract class AbstractJavaAgainstKotlinBinariesCheckerTest : AbstractJavaAgains val languageLevelOption = InTextDirectivesUtils.findListWithPrefixes(configFileText ?: "", "// KOTLINC_EXTRA_OPTS") - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar( + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar( PluginTestCaseBase.getTestDataPathBase() + "/kotlinAndJavaChecker/javaAgainstKotlin/" + getTestName(false) + ".kt", "libFor$testName", extraOptions = languageLevelOption diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt index 1e5e875117a..c57ff31b513 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt @@ -35,7 +35,7 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.keysToMap import org.jetbrains.plugins.groovy.lang.psi.impl.stringValue @@ -108,7 +108,7 @@ abstract class AbstractIdeCompiledLightClassTest : KotlinDaemonAnalyzerTestCase( Assert.assertNotNull("Test file not found!", testFile) - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar( + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar( testFile!!.canonicalPath, libName(), extraClasspath = listOf(ForTestCompileRuntime.jetbrainsAnnotationsForTests().path) ) diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt index 3bb8f84abcf..17588867c39 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.junit.runner.RunWith import java.io.File @@ -27,9 +27,9 @@ class HighlightingWithDependentLibrariesTest : KotlinLightCodeInsightFixtureTest override fun getProjectDescriptor() = object : KotlinLightProjectDescriptor() { override fun configureModule(module: Module, model: ModifiableRootModel) { val compiledJar1 = - MockLibraryUtil.compileJvmLibraryToJar("$TEST_DATA_PATH/lib1", "lib1") + MockLibraryUtilExt.compileJvmLibraryToJar("$TEST_DATA_PATH/lib1", "lib1") val compiledJar2 = - MockLibraryUtil.compileJvmLibraryToJar("$TEST_DATA_PATH/lib2", "lib2", extraClasspath = listOf(compiledJar1.canonicalPath)) + MockLibraryUtilExt.compileJvmLibraryToJar("$TEST_DATA_PATH/lib2", "lib2", extraClasspath = listOf(compiledJar1.canonicalPath)) model.addLibraryEntry(createLibrary(module.project, compiledJar1, "baseLibrary")) model.addLibraryEntry(createLibrary(module.project, compiledJar2, "dependentLibrary")) diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt index 953e051cded..1bdc1fcf6e6 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve import com.intellij.openapi.module.Module import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.test.TestJdkKind.FULL_JDK_9 import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith @@ -26,7 +26,7 @@ class Java9MultiModuleHighlightingTest : AbstractMultiModuleHighlightingTest() { fun testSimpleLibraryExportsPackage() { // -Xallow-kotlin-package to avoid "require kotlin.stdlib" in module-info.java - val library = MockLibraryUtil.compileJvmLibraryToJar( + val library = MockLibraryUtilExt.compileJvmLibraryToJar( testDataPath + "${getTestName(true)}/library", "library", extraOptions = listOf("-jdk-home", KtTestUtil.getJdk9Home().path, "-Xallow-kotlin-package"), useJava9 = true diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleHighlightingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleHighlightingTest.kt index beddb19f694..bf52b8f41bf 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleHighlightingTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleHighlightingTest.kt @@ -39,11 +39,8 @@ import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.idea.util.projectStructure.sdk import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverCommandLineProcessor.Companion.ANNOTATION_OPTION import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverCommandLineProcessor.Companion.PLUGIN_ID -import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.* import org.jetbrains.kotlin.test.TestJdkKind.FULL_JDK -import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest -import org.jetbrains.kotlin.test.runTest import org.junit.Assert.assertNotEquals import org.junit.runner.RunWith @@ -233,7 +230,7 @@ open class MultiModuleHighlightingTest : AbstractMultiModuleHighlightingTest() { } fun testJvmExperimentalLibrary() { - val lib = MockLibraryUtil.compileJvmLibraryToJar( + val lib = MockLibraryUtilExt.compileJvmLibraryToJar( testDataPath + "${getTestName(true)}/lib", "lib", extraOptions = listOf( "-Xopt-in=kotlin.RequiresOptIn", @@ -265,12 +262,12 @@ open class MultiModuleHighlightingTest : AbstractMultiModuleHighlightingTest() { KotlinCommonCompilerArgumentsHolder.getInstance(project).update { skipMetadataVersionCheck = true } KotlinCompilerSettings.getInstance(project).update { additionalArguments = "-Xskip-metadata-version-check" } - val libOld = MockLibraryUtil.compileJvmLibraryToJar( + val libOld = MockLibraryUtilExt.compileJvmLibraryToJar( testDataPath + "${getTestName(true)}/libOld", "libOld", extraOptions = listOf("-language-version", "1.2", "-api-version", "1.2") ) - val libNew = MockLibraryUtil.compileJvmLibraryToJar( + val libNew = MockLibraryUtilExt.compileJvmLibraryToJar( testDataPath + "${getTestName(true)}/libNew", "libNew", extraOptions = listOf("-language-version", "1.3", "-api-version", "1.3") ) diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt index 73524103790..d458e812349 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.idea.decompiler.navigation.NavigationChecker.Compani import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.idea.util.projectStructure.getModuleDir import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.test.testFramework.runWriteAction import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.jarRoot @@ -48,7 +48,7 @@ class NavigationWithMultipleCustomLibrariesTest : AbstractNavigationToSourceOrDe override fun createProjectLib(libraryName: String, withSources: Boolean): Library { val librarySrc = testDataPath + "libSrc" - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(librarySrc, libraryName, addSources = withSources) + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar(librarySrc, libraryName, addSources = withSources) val jarRoot = libraryJar.jarRoot return projectLibrary(libraryName, jarRoot, jarRoot.findChild("src").takeIf { withSources }) } @@ -113,7 +113,7 @@ class NavigationToSingleJarInMultipleLibrariesTest : AbstractNavigationWithMulti val moduleB = module("m2", srcPath) val moduleC = module("m3", srcPath) - val sharedJar = MockLibraryUtil.compileJvmLibraryToJar(testDataPath + "libSrc", "sharedJar", addSources = true) + val sharedJar = MockLibraryUtilExt.compileJvmLibraryToJar(testDataPath + "libSrc", "sharedJar", addSources = true) val jarRoot = sharedJar.jarRoot moduleA.addDependency(projectLibrary("libA", jarRoot)) diff --git a/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt b/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt index f52d317f899..3dad81ccddb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import java.io.File import java.lang.reflect.InvocationTargetException import java.net.URL @@ -50,7 +51,7 @@ abstract class AbstractKotlinExceptionFilterTest : KotlinCodeInsightTestCase() { val classLoader: URLClassLoader if (InTextDirectivesUtils.getPrefixedBoolean(fileText, "// WITH_MOCK_LIBRARY: ") ?: false) { if (MOCK_LIBRARY_JAR == null) { - MOCK_LIBRARY_JAR = MockLibraryUtil.compileJvmLibraryToJar(MOCK_LIBRARY_SOURCES, "mockLibrary", addSources = true) + MOCK_LIBRARY_JAR = MockLibraryUtilExt.compileJvmLibraryToJar(MOCK_LIBRARY_SOURCES, "mockLibrary", addSources = true) } val mockLibraryJar = MOCK_LIBRARY_JAR ?: throw AssertionError("Mock library JAR is null") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/Jsr305HighlightingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/highlighter/Jsr305HighlightingTest.kt index 1c81b4cd776..5e588c7626b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/Jsr305HighlightingTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/Jsr305HighlightingTest.kt @@ -15,15 +15,15 @@ import org.jetbrains.kotlin.idea.test.KotlinJdkAndLibraryProjectDescriptor import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.utils.ReportLevel import org.junit.runner.RunWith @RunWith(JUnit3WithIdeaConfigurationRunner::class) class Jsr305HighlightingTest : KotlinLightCodeInsightFixtureTestCase() { override fun getProjectDescriptor(): LightProjectDescriptor { - val foreignAnnotationsJar = MockLibraryUtil.compileJvmLibraryToJar("third-party/annotations", "foreign-annotations") - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar( + val foreignAnnotationsJar = MockLibraryUtilExt.compileJvmLibraryToJar("third-party/annotations", "foreign-annotations") + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar( "idea/testData/highlighterJsr305/library", "jsr305-library", extraClasspath = listOf(foreignAnnotationsJar.absolutePath) ) diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt index cd0b6233833..d0655284b23 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.idea.stubs.AbstractMultiModuleTest import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.idea.test.allKotlinFiles import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.jarRoot import org.jetbrains.kotlin.test.util.projectLibrary @@ -45,7 +45,7 @@ class GotoWithMultipleLibrariesTest : AbstractMultiModuleTest() { private fun doTestSameJarSharedByLibrariesWithAndWithoutSourceAttached(withSource: Int, noSource: Int) { val srcPath = testDataPath + "src" - val sharedJar = MockLibraryUtil.compileJvmLibraryToJar(testDataPath + "libSrc", "sharedJar", addSources = true) + val sharedJar = MockLibraryUtilExt.compileJvmLibraryToJar(testDataPath + "libSrc", "sharedJar", addSources = true) val jarRoot = sharedJar.jarRoot var i = 0 diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt index 780a2148ae0..2d432cdf16f 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt @@ -68,7 +68,7 @@ import org.jetbrains.kotlin.jps.targets.KotlinModuleBuildTarget import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.Printer @@ -614,7 +614,7 @@ open class KotlinJpsBuildTest : KotlinJpsBuildTestBase() { fun testCircularDependencyWithReferenceToOldVersionLib() { initProject(JVM_MOCK_RUNTIME) - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module1"), findModule("module2")), false, "module-lib", libraryJar) @@ -625,7 +625,7 @@ open class KotlinJpsBuildTest : KotlinJpsBuildTestBase() { fun testDependencyToOldKotlinLib() { initProject() - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module")), false, "module-lib", libraryJar) diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 index 10af39dca01..605d85bce34 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 @@ -68,7 +68,7 @@ import org.jetbrains.kotlin.jps.targets.KotlinModuleBuildTarget import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.MockLibraryUtilExt import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.Printer @@ -614,7 +614,7 @@ open class KotlinJpsBuildTest : KotlinJpsBuildTestBase() { fun testCircularDependencyWithReferenceToOldVersionLib() { initProject(JVM_MOCK_RUNTIME) - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module1"), findModule("module2")), false, "module-lib", libraryJar) @@ -625,7 +625,7 @@ open class KotlinJpsBuildTest : KotlinJpsBuildTestBase() { fun testDependencyToOldKotlinLib() { initProject() - val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") + val libraryJar = MockLibraryUtilExt.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib") AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module")), false, "module-lib", libraryJar)