From 8af923c5ff418501bb7998169ce34834a75c315b Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 16 Jun 2017 15:48:25 +0300 Subject: [PATCH] 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 --- ...AbstractTopLevelMembersInvocationTest.java | 7 ++- .../jetbrains/kotlin/test/MockLibraryUtil.kt | 61 ++++++------------- .../AbstractForeignAnnotationsTest.kt | 8 +-- .../CompileKotlinAgainstCustomBinariesTest.kt | 2 +- .../JdkAndMockLibraryProjectDescriptor.java | 16 +++-- ...actJavaAgainstKotlinBinariesCheckerTest.kt | 7 +-- .../resolve/AbstractIdeLightClassTest.kt | 2 +- .../HighlightingWithDependentLibrariesTest.kt | 25 ++++---- .../idea/debugger/KotlinDebuggerTestCase.java | 3 +- .../NavigationWithMultipleLibrariesTest.kt | 4 +- .../stubBuilder/AbstractClsStubBuilderTest.kt | 2 +- .../AbstractKotlinExceptionFilterTest.kt | 4 +- .../GotoWithMultipleLibrariesTest.kt | 4 +- .../script/AbstractScriptConfigurationTest.kt | 15 ++--- .../kotlin/psi/KotlinLibInjectionTest.kt | 3 +- .../kotlin/jps/build/KotlinJpsBuildTest.kt | 4 +- 16 files changed, 72 insertions(+), 95 deletions(-) diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java index cee30507bbf..c9fa018bb83 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java +++ b/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 classPath = library.exists() ? - Collections.singletonList(MockLibraryUtil.compileLibraryToJar(library.getPath(), LIBRARY, false, false)) : - Collections.emptyList(); + List classPath = + library.exists() + ? Collections.singletonList(MockLibraryUtil.compileJvmLibraryToJar(library.getPath(), LIBRARY)) + : Collections.emptyList(); assert !sourceFiles.isEmpty() : getTestName(true) + " should contain at least one .kt file"; Collections.sort(sourceFiles); diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.kt b/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.kt index e720ba299f0..78522bf267f 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.kt @@ -40,51 +40,35 @@ object MockLibraryUtil { private var compilerClassLoader = SoftReference(null) @JvmStatic - fun compileLibraryToJar( + @JvmOverloads + fun compileJvmLibraryToJar( sourcesPath: String, jarName: String, - addSources: Boolean, - isJsLibrary: Boolean, - allowKotlinPackage: Boolean, - 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 + addSources: Boolean = false, + extraOptions: List = emptyList(), + extraClasspath: List = emptyList() ): File { return compileLibraryToJar( - sourcesPath, KotlinTestUtils.tmpDir("testLibrary-" + jarName), jarName, addSources, allowKotlinPackage, - *extraClasspath + sourcesPath, KotlinTestUtils.tmpDir("testLibrary-" + jarName), jarName, addSources, extraOptions, extraClasspath ) } @JvmStatic + @JvmOverloads fun compileLibraryToJar( sourcesPath: String, contentDir: File, jarName: String, - addSources: Boolean, - allowKotlinPackage: Boolean, - vararg extraClasspath: String + addSources: Boolean = false, + extraOptions: List = emptyList(), + extraClasspath: List = 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) { - compileKotlin(sourcesPath, outDir, false, *extraClasspath) - } - + @JvmOverloads fun compileKotlin( sourcesPath: String, outDir: File, - allowKotlinPackage: Boolean, + extraOptions: List = emptyList(), vararg extraClasspath: String ) { val classpath = mutableListOf() @@ -174,10 +156,7 @@ object MockLibraryUtil { sourcesPath, "-d", outDir.absolutePath, "-classpath", classpath.joinToString(File.pathSeparator) - ) - if (allowKotlinPackage) { - args += "-Xallow-kotlin-package" - } + ) + extraOptions runJvmCompiler(args) } diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt index ebfc2919f69..a19336eeed1 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt +++ b/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 { - return listOf(MockLibraryUtil.compileLibraryToJar( - annotationsPath, - "foreign-annotations", /* addSources = */false, /* allowKotlinPackage = */ false - )) - } + override fun getExtraClasspath(): List = + listOf(MockLibraryUtil.compileJvmLibraryToJar(annotationsPath, "foreign-annotations")) open protected val annotationsPath: String get() = "compiler/testData/foreignAnnotations/annotations" diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt index 042057d804f..a3579148808 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt +++ b/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"))) } diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/JdkAndMockLibraryProjectDescriptor.java b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/JdkAndMockLibraryProjectDescriptor.java index 77283f0b58f..227b79ea4ed 100644 --- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/JdkAndMockLibraryProjectDescriptor.java +++ b/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 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 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 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(); diff --git a/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt b/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt index b606e2587c7..095c32d3c84 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt +++ b/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.compileLibraryToJar( + val libraryJar = MockLibraryUtil.compileJvmLibraryToJar( 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")) } -} \ No newline at end of file +} 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 3b1966ec7f1..78c35de3af2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt +++ b/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) } 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 eb0e4580b7d..f8318bf1c2a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt +++ b/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 compiledJar2 = MockLibraryUtil.compileLibraryToJar("$TEST_DATA_PATH/lib2", "lib2", false, false, compiledJar1.canonicalPath) + val compiledJar1 = + 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")) diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java index 363c43090e3..8210096a23e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java +++ b/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_SOURCES.getPath(), jarDir, "debuggerCustomLibrary", false, false); + CUSTOM_LIBRARY_JAR = MockLibraryUtil.compileLibraryToJar(CUSTOM_LIBRARY_SOURCES.getPath(), jarDir, "debuggerCustomLibrary"); String sourcesDir = modulePath + File.separator + "src"; 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 97ee78e81ee..a3632d5eefa 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt +++ b/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)) diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt index daf051febf5..a8bbd5bdfeb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt +++ b/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)) } diff --git a/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt b/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt index 0f952a7c122..b764a534033 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt +++ b/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()) diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt index 129fff1c056..a8ffe8bc3b1 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt +++ b/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)!! -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt index e776b5a0dfe..5cc3fb254ab 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt +++ b/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): 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( - srcDir.path, outDir, - *classpath.toTypedArray() - ) + MockLibraryUtil.compileKotlin(srcDir.path, outDir, extraClasspath = *classpath) } 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) -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/psi/KotlinLibInjectionTest.kt b/idea/tests/org/jetbrains/kotlin/psi/KotlinLibInjectionTest.kt index 3fd4b5adefa..d361e7172b2 100644 --- a/idea/tests/org/jetbrains/kotlin/psi/KotlinLibInjectionTest.kt +++ b/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")) } } - 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 928c61d8924..2706d875e56 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 @@ -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)