Refactor MockLibraryUtil and related tests

- separate compileLibraryToJar into two public functions, for JVM and JS
- allow to pass any extra options instead of just -Xallow-kotlin-package
- add a bunch of default arguments for the most common cases

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

@@ -50,9 +50,10 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte
         }, file -> !LIBRARY.equals(file.getName()));
 
         File library = new File(root, LIBRARY);
-        List<File> classPath = library.exists() ?
+        List<File> classPath =
-                               Collections.singletonList(MockLibraryUtil.compileLibraryToJar(library.getPath(), LIBRARY, false, false)) :
+                library.exists()
-                               Collections.emptyList();
+                ? Collections.singletonList(MockLibraryUtil.compileJvmLibraryToJar(library.getPath(), LIBRARY))
+                : Collections.emptyList();
 
         assert !sourceFiles.isEmpty() : getTestName(true) + " should contain at least one .kt file";
         Collections.sort(sourceFiles);

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

@@ -40,51 +40,35 @@ object MockLibraryUtil {
     private var compilerClassLoader = SoftReference<ClassLoader>(null)
 
     @JvmStatic
-    fun compileLibraryToJar(
+    @JvmOverloads
+    fun compileJvmLibraryToJar(
             sourcesPath: String,
             jarName: String,
-            addSources: Boolean,
+            addSources: Boolean = false,
-            isJsLibrary: Boolean,
+            extraOptions: List<String> = emptyList(),
-            allowKotlinPackage: Boolean,
+            extraClasspath: List<String> = emptyList()
-            vararg extraClasspath: String
-    ): File {
-        if (isJsLibrary) {
-            return compileJsLibraryToJar(sourcesPath, jarName, addSources)
-        }
-        else {
-            return compileLibraryToJar(sourcesPath, jarName, addSources, allowKotlinPackage, *extraClasspath)
-        }
-    }
-
-    @JvmStatic
-    fun compileLibraryToJar(
-            sourcesPath: String,
-            jarName: String,
-            addSources: Boolean,
-            allowKotlinPackage: Boolean,
-            vararg extraClasspath: String
     ): File {
         return compileLibraryToJar(
-                sourcesPath, KotlinTestUtils.tmpDir("testLibrary-" + jarName), jarName, addSources, allowKotlinPackage,
+                sourcesPath, KotlinTestUtils.tmpDir("testLibrary-" + jarName), jarName, addSources, extraOptions, extraClasspath
-                *extraClasspath
         )
     }
 
     @JvmStatic
+    @JvmOverloads
     fun compileLibraryToJar(
             sourcesPath: String,
             contentDir: File,
             jarName: String,
-            addSources: Boolean,
+            addSources: Boolean = false,
-            allowKotlinPackage: Boolean,
+            extraOptions: List<String> = emptyList(),
-            vararg extraClasspath: String
+            extraClasspath: List<String> = emptyList()
     ): File {
         val classesDir = File(contentDir, "classes")
 
         val srcFile = File(sourcesPath)
         val kotlinFiles = FileUtil.findFilesByMask(Pattern.compile(".*\\.kt"), srcFile)
         if (srcFile.isFile || kotlinFiles.isNotEmpty()) {
-            compileKotlin(sourcesPath, classesDir, allowKotlinPackage, *extraClasspath)
+            compileKotlin(sourcesPath, classesDir, extraOptions, *extraClasspath.toTypedArray())
         }
 
         val javaFiles = FileUtil.findFilesByMask(Pattern.compile(".*\\.java"), srcFile)
@@ -110,25 +94,26 @@ object MockLibraryUtil {
             KotlinTestUtils.compileJavaFiles(javaFiles, options)
         }
 
-        return createJarFile(contentDir, classesDir, sourcesPath, jarName, addSources)
+        return createJarFile(contentDir, classesDir, jarName, sourcesPath.takeIf { addSources })
     }
 
-    private fun compileJsLibraryToJar(sourcesPath: String, jarName: String, addSources: Boolean): File {
+    @JvmStatic
+    fun compileJsLibraryToJar(sourcesPath: String, jarName: String, addSources: Boolean): File {
         val contentDir = KotlinTestUtils.tmpDir("testLibrary-" + jarName)
 
         val outDir = File(contentDir, "out")
         val outputFile = File(outDir, jarName + ".js")
         compileKotlin2JS(sourcesPath, outputFile)
 
-        return createJarFile(contentDir, outDir, sourcesPath, jarName, addSources)
+        return createJarFile(contentDir, outDir, jarName, sourcesPath.takeIf { addSources })
     }
 
-    fun createJarFile(contentDir: File, dirToAdd: File, sourcesPath: String, jarName: String, addSources: Boolean): File {
+    fun createJarFile(contentDir: File, dirToAdd: File, jarName: String, sourcesPath: String? = null): File {
         val jarFile = File(contentDir, jarName + ".jar")
 
         ZipOutputStream(FileOutputStream(jarFile)).use { zip ->
             ZipUtil.addDirToZipRecursively(zip, jarFile, dirToAdd, "", null, null)
-            if (addSources) {
+            if (sourcesPath != null) {
                 ZipUtil.addDirToZipRecursively(zip, jarFile, File(sourcesPath), "src", null, null)
             }
         }
@@ -154,14 +139,11 @@ object MockLibraryUtil {
     }
 
     @JvmStatic
-    fun compileKotlin(sourcesPath: String, outDir: File, vararg extraClasspath: String) {
+    @JvmOverloads
-        compileKotlin(sourcesPath, outDir, false, *extraClasspath)
-    }
-
     fun compileKotlin(
             sourcesPath: String,
             outDir: File,
-            allowKotlinPackage: Boolean,
+            extraOptions: List<String> = emptyList(),
             vararg extraClasspath: String
     ) {
         val classpath = mutableListOf<String>()
@@ -174,10 +156,7 @@ object MockLibraryUtil {
                 sourcesPath,
                 "-d", outDir.absolutePath,
                 "-classpath", classpath.joinToString(File.pathSeparator)
-        )
+        ) + extraOptions
-        if (allowKotlinPackage) {
-            args += "-Xallow-kotlin-package"
-        }
 
         runJvmCompiler(args)
     }

compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt

@@ -20,12 +20,8 @@ import org.jetbrains.kotlin.test.MockLibraryUtil
 import java.io.File
 
 abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsWithFullJdkTest() {
-    override fun getExtraClasspath(): List<File> {
+    override fun getExtraClasspath(): List<File> =
-        return listOf(MockLibraryUtil.compileLibraryToJar(
+            listOf(MockLibraryUtil.compileJvmLibraryToJar(annotationsPath, "foreign-annotations"))
-                annotationsPath,
-                "foreign-annotations", /* addSources = */false, /* allowKotlinPackage = */ false
-        ))
-    }
 
     open protected val annotationsPath: String
         get() = "compiler/testData/foreignAnnotations/annotations"

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

@@ -461,7 +461,7 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() {
     fun testInnerClassPackageConflict() {
         val output = compileLibrary("library", destination = File(tmpdir, "library"))
         File(testDataDirectory, "library/test/Foo/x.txt").copyTo(File(output, "test/Foo/x.txt"))
-        MockLibraryUtil.createJarFile(tmpdir, output, null, "library", false)
+        MockLibraryUtil.createJarFile(tmpdir, output, "library")
         compileKotlin("source.kt", tmpdir, listOf(File(tmpdir, "library.jar")))
     }
 

idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/JdkAndMockLibraryProjectDescriptor.java

@@ -22,12 +22,13 @@ import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.OrderRootType;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.util.io.FileUtilRt;
-import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.test.MockLibraryUtil;
 import org.jetbrains.kotlin.utils.PathUtil;
 
 import java.io.File;
+import java.util.Collections;
+import java.util.List;
 
 public class JdkAndMockLibraryProjectDescriptor extends KotlinLightProjectDescriptor {
     public static final String LIBRARY_NAME = "myKotlinLib";
@@ -37,7 +38,7 @@ public class JdkAndMockLibraryProjectDescriptor extends KotlinLightProjectDescri
     private final boolean withRuntime;
     private final boolean isJsLibrary;
     private final boolean allowKotlinPackage;
-    private final String[] classpath;
+    private final List<String> classpath;
 
     public JdkAndMockLibraryProjectDescriptor(String sourcesPath, boolean withSources) {
         this(sourcesPath, withSources, false, false, false);
@@ -45,11 +46,12 @@ public class JdkAndMockLibraryProjectDescriptor extends KotlinLightProjectDescri
 
     public JdkAndMockLibraryProjectDescriptor(
             String sourcesPath, boolean withSources, boolean withRuntime, boolean isJsLibrary, boolean allowKotlinPackage) {
-        this(sourcesPath, withSources, withRuntime, isJsLibrary, allowKotlinPackage, ArrayUtil.EMPTY_STRING_ARRAY);
+        this(sourcesPath, withSources, withRuntime, isJsLibrary, allowKotlinPackage, Collections.emptyList());
     }
 
     public JdkAndMockLibraryProjectDescriptor(
-            String sourcesPath, boolean withSources, boolean withRuntime, boolean isJsLibrary, boolean allowKotlinPackage, String[] classpath) {
+            String sourcesPath, boolean withSources, boolean withRuntime, boolean isJsLibrary, boolean allowKotlinPackage, List<String> classpath
+    ) {
         this.sourcesPath = sourcesPath;
         this.withSources = withSources;
         this.withRuntime = withRuntime;
@@ -60,7 +62,11 @@ public class JdkAndMockLibraryProjectDescriptor extends KotlinLightProjectDescri
 
     @Override
     public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model) {
-        File libraryJar = MockLibraryUtil.compileLibraryToJar(sourcesPath, LIBRARY_NAME, withSources, isJsLibrary, allowKotlinPackage, classpath);
+        List<String> extraOptions = allowKotlinPackage ? Collections.singletonList("-Xallow-kotlin-package") : Collections.emptyList();
+        File libraryJar =
+                isJsLibrary
+                ? MockLibraryUtil.compileJsLibraryToJar(sourcesPath, LIBRARY_NAME, withSources)
+                : MockLibraryUtil.compileJvmLibraryToJar(sourcesPath, LIBRARY_NAME, withSources, extraOptions, classpath);
         String jarUrl = getJarUrl(libraryJar);
 
         Library.ModifiableModel libraryModel = model.getModuleLibraryTable().getModifiableModel().createLibrary(LIBRARY_NAME).getModifiableModel();

idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt

@@ -33,10 +33,9 @@ abstract class AbstractJavaAgainstKotlinBinariesCheckerTest : AbstractJavaAgains
         if (KotlinTestUtils.isAllFilesPresentTest(testName)) {
             return
         }
-        val libraryName = "libFor" + testName
+        val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(
-        val libraryJar = MockLibraryUtil.compileLibraryToJar(
                 PluginTestCaseBase.getTestDataPathBase() + "/kotlinAndJavaChecker/javaAgainstKotlin/" + getTestName(false) + ".kt",
-                libraryName, false, false, false
+                "libFor$testName"
         )
         val jarUrl = "jar://" + FileUtilRt.toSystemIndependentName(libraryJar.absolutePath) + "!/"
         ModuleRootModificationUtil.addModuleLibrary(module, jarUrl)
@@ -52,4 +51,4 @@ abstract class AbstractJavaAgainstKotlinBinariesCheckerTest : AbstractJavaAgains
 
         doTest(true, true, path.replace(".kt", ".java"))
     }
-}
+}

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt

@@ -95,7 +95,7 @@ abstract class AbstractIdeCompiledLightClassTest : KotlinDaemonAnalyzerTestCase(
 
         Assert.assertTrue("File doesn't exist $filePath", File(filePath).exists())
 
-        val libraryJar = MockLibraryUtil.compileLibraryToJar(filePath, libName(), false, false, false)
+        val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(filePath, libName())
         val jarUrl = "jar://" + FileUtilRt.toSystemIndependentName(libraryJar.absolutePath) + "!/"
         ModuleRootModificationUtil.addModuleLibrary(module, jarUrl)
     }

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt

@@ -16,26 +16,27 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.test.MockLibraryUtil
-import com.intellij.openapi.roots.libraries.Library
-import java.io.File
-import com.intellij.openapi.roots.OrderRootType
-import com.intellij.openapi.vfs.VfsUtil
-import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar
-import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.roots.ModifiableRootModel
-import com.intellij.openapi.roots.ContentEntry
+import com.intellij.openapi.roots.OrderRootType
+import com.intellij.openapi.roots.libraries.Library
+import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar
+import com.intellij.openapi.vfs.VfsUtil
+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.MockLibraryUtil
+import java.io.File
 
 class HighlightingWithDependentLibrariesTest : KotlinLightCodeInsightFixtureTestCase() {
     private val TEST_DATA_PATH = PluginTestCaseBase.TEST_DATA_DIR + "/highlightingWithDependentLibraries"
 
     override fun getProjectDescriptor() = object : KotlinLightProjectDescriptor() {
         override fun configureModule(module: Module, model: ModifiableRootModel) {
-            val compiledJar1 = MockLibraryUtil.compileLibraryToJar("$TEST_DATA_PATH/lib1", "lib1", false, false)
+            val compiledJar1 =
-            val compiledJar2 = MockLibraryUtil.compileLibraryToJar("$TEST_DATA_PATH/lib2", "lib2", false, false, compiledJar1.canonicalPath)
+                    MockLibraryUtil.compileJvmLibraryToJar("$TEST_DATA_PATH/lib1", "lib1")
+            val compiledJar2 =
+                    MockLibraryUtil.compileJvmLibraryToJar("$TEST_DATA_PATH/lib2", "lib2", extraClasspath = listOf(compiledJar1.canonicalPath))
 
             model.addLibraryEntry(createLibrary(compiledJar1, "baseLibrary"))
             model.addLibraryEntry(createLibrary(compiledJar2, "dependentLibrary"))

idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java

@@ -237,8 +237,7 @@ public abstract class KotlinDebuggerTestCase extends DescriptorTestCase {
                 throw ExceptionUtilsKt.rethrow(e);
             }
 
-            CUSTOM_LIBRARY_JAR = MockLibraryUtil.compileLibraryToJar(
+            CUSTOM_LIBRARY_JAR = MockLibraryUtil.compileLibraryToJar(CUSTOM_LIBRARY_SOURCES.getPath(), jarDir, "debuggerCustomLibrary");
-                    CUSTOM_LIBRARY_SOURCES.getPath(), jarDir, "debuggerCustomLibrary", false, false);
 
             String sourcesDir = modulePath + File.separator + "src";
 

idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt

@@ -56,7 +56,7 @@ class NavigationWithMultipleCustomLibrariesTest : AbstractNavigationToSourceOrDe
     override fun createProjectLib(libraryName: String, withSources: Boolean): Library {
         val librarySrc = testDataPath + "libSrc"
 
-        val libraryJar = MockLibraryUtil.compileLibraryToJar(librarySrc, libraryName, withSources, false, false)
+        val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(librarySrc, libraryName, addSources = withSources)
         val jarRoot = libraryJar.jarRoot
         return projectLibrary(libraryName, jarRoot, jarRoot.findChild("src").takeIf { withSources })
     }
@@ -120,7 +120,7 @@ class NavigationToSingleJarInMultipleLibrariesTest : AbstractNavigationWithMulti
         val moduleB = module("m2", srcPath)
         val moduleC = module("m3", srcPath)
 
-        val sharedJar = MockLibraryUtil.compileLibraryToJar(testDataPath + "libSrc", "sharedJar", true, false, false)
+        val sharedJar = MockLibraryUtil.compileJvmLibraryToJar(testDataPath + "libSrc", "sharedJar", addSources = true)
         val jarRoot = sharedJar.jarRoot
 
         moduleA.addDependency(projectLibrary("libA", jarRoot))

idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt

@@ -55,7 +55,7 @@ abstract class AbstractClsStubBuilderTest : LightCodeInsightFixtureTestCase() {
 
     private fun getClassFileToDecompile(sourcePath: String): VirtualFile {
         val outDir = KotlinTestUtils.tmpDir("libForStubTest-" + sourcePath)
-        MockLibraryUtil.compileKotlin(sourcePath, outDir, true)
+        MockLibraryUtil.compileKotlin(sourcePath, outDir, extraOptions = listOf("-Xallow-kotlin-package"))
         val root = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(outDir)!!
         return root.findClassFileByName(lastSegment(sourcePath))
     }

idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt

@@ -61,7 +61,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.compileLibraryToJar(MOCK_LIBRARY_SOURCES, "mockLibrary", true, false)
+                MOCK_LIBRARY_JAR = MockLibraryUtil.compileJvmLibraryToJar(MOCK_LIBRARY_SOURCES, "mockLibrary", addSources = true)
             }
 
             val mockLibraryJar = MOCK_LIBRARY_JAR ?: throw AssertionError("Mock library JAR is null")
@@ -77,7 +77,7 @@ abstract class AbstractKotlinExceptionFilterTest : KotlinCodeInsightTestCase() {
                 }
                 moduleModel.commit()
             }
-            MockLibraryUtil.compileKotlin(path, File(outDir.path), mockLibraryPath)
+            MockLibraryUtil.compileKotlin(path, File(outDir.path), extraClasspath = mockLibraryPath)
             classLoader = URLClassLoader(
                     arrayOf(URL(outDir.url + "/"), mockLibraryJar.toURI().toURL()),
                     ForTestCompileRuntime.runtimeJarClassLoader())

idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt

@@ -52,7 +52,7 @@ class GotoWithMultipleLibrariesTest : AbstractMultiModuleTest() {
     fun doTestSameJarSharedByLibrariesWithAndWithoutSourceAttached(withSource: Int, noSource: Int) {
         val srcPath = testDataPath + "src"
 
-        val sharedJar = MockLibraryUtil.compileLibraryToJar(testDataPath + "libSrc", "sharedJar", true, false, false)
+        val sharedJar = MockLibraryUtil.compileJvmLibraryToJar(testDataPath + "libSrc", "sharedJar", addSources = true)
         val jarRoot = sharedJar.jarRoot
 
         var i: Int = 0
@@ -69,4 +69,4 @@ class GotoWithMultipleLibrariesTest : AbstractMultiModuleTest() {
     }
 
     protected fun module(name: String, srcPath: String) = createModuleFromTestData(srcPath, name, StdModuleTypes.JAVA, true)!!
-}
+}

idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt

@@ -72,12 +72,12 @@ abstract class AbstractScriptConfigurationTest : AbstractPsiCheckerTest() {
     protected fun configureScriptEnvironment(path: String) {
         val templateOutDir = compileLibToDir(
                 File("${path}template"),
-                classpath = listOf(PathUtil.getKotlinPathsForDistDirectory().scriptRuntimePath.path)
+                PathUtil.getKotlinPathsForDistDirectory().scriptRuntimePath.path
         )
 
         val libSrcDir = File("${path}lib")
         val libClasses = if (libSrcDir.isDirectory) {
-            compileLibToDir(libSrcDir, classpath = listOf())
+            compileLibToDir(libSrcDir)
         }
         else null
 
@@ -92,22 +92,19 @@ abstract class AbstractScriptConfigurationTest : AbstractPsiCheckerTest() {
         return vFile
     }
 
-    private fun compileLibToDir(srcDir: File, classpath: List<String>): File {
+    private fun compileLibToDir(srcDir: File, vararg classpath: String): File {
         val outDir = KotlinTestUtils.tmpDir("${getTestName(false)}${srcDir.name}Out")
 
         val kotlinSourceFiles = FileUtil.findFilesByMask(Pattern.compile(".+\\.kt$"), srcDir)
         if (kotlinSourceFiles.isNotEmpty()) {
-            MockLibraryUtil.compileKotlin(
+            MockLibraryUtil.compileKotlin(srcDir.path, outDir, extraClasspath = *classpath)
-                    srcDir.path, outDir,
-                    *classpath.toTypedArray()
-            )
         }
 
         val javaSourceFiles = FileUtil.findFilesByMask(Pattern.compile(".+\\.java$"), srcDir)
         if (javaSourceFiles.isNotEmpty()) {
             KotlinTestUtils.compileJavaFiles(
                     javaSourceFiles,
-                    listOf("-cp", StringUtil.join(classpath + outDir, File.pathSeparator), "-d", outDir.path)
+                    listOf("-cp", StringUtil.join(listOf(*classpath, outDir), File.pathSeparator), "-d", outDir.path)
             )
         }
         return outDir
@@ -145,4 +142,4 @@ class TestScriptTemplateProvider(
     override val isValid = true
     override val templateClassNames = listOf("custom.scriptDefinition.Template")
     override val dependenciesClasspath = listOf(compiledTemplateDir.canonicalPath)
-}
+}

idea/tests/org/jetbrains/kotlin/psi/KotlinLibInjectionTest.kt

@@ -57,7 +57,6 @@ class KotlinLibInjectionTest : AbstractInjectionTest() {
     override fun getProjectDescriptor(): LightProjectDescriptor {
         return JdkAndMockLibraryProjectDescriptor(
                 PluginTestCaseBase.getTestDataPathBase() + "/injection/lib/", false, false, false, true,
-                arrayOf(KotlinTestUtils.getHomeDirectory() + "/ideaSDK/lib/annotations.jar"))
+                listOf(KotlinTestUtils.getHomeDirectory() + "/ideaSDK/lib/annotations.jar"))
     }
 }
-

jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt

@@ -655,7 +655,7 @@ class KotlinJpsBuildTest : AbstractKotlinJpsBuildTestCase() {
     fun testCircularDependencyWithReferenceToOldVersionLib() {
         initProject(JVM_MOCK_RUNTIME)
 
-        val libraryJar = MockLibraryUtil.compileLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib", false, false)
+        val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib")
 
         AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module1"), findModule("module2")), false, "module-lib", libraryJar)
 
@@ -666,7 +666,7 @@ class KotlinJpsBuildTest : AbstractKotlinJpsBuildTestCase() {
     fun testDependencyToOldKotlinLib() {
         initProject()
 
-        val libraryJar = MockLibraryUtil.compileLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib", false, false)
+        val libraryJar = MockLibraryUtil.compileJvmLibraryToJar(workDir.absolutePath + File.separator + "oldModuleLib/src", "module-lib")
 
         AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module")), false, "module-lib", libraryJar)