From 0899eb99242e526a971cac338230343a8e291de2 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 25 May 2017 16:26:49 +0300 Subject: [PATCH] J2K CompileKotlinAgainstCustomBinariesTest: prettify --- .../CompileKotlinAgainstCustomBinariesTest.kt | 337 ++++++------------ 1 file changed, 115 insertions(+), 222 deletions(-) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt index a15366fd9b4..388bba820c4 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt @@ -16,10 +16,7 @@ package org.jetbrains.kotlin.jvm.compiler -import com.google.common.collect.Iterables -import com.intellij.openapi.util.Ref import com.intellij.openapi.util.io.FileUtil -import com.intellij.util.ArrayUtil import org.jetbrains.kotlin.cli.AbstractCliTest import org.jetbrains.kotlin.cli.WrongBytecodeVersionTest import org.jetbrains.kotlin.cli.common.CLICompiler @@ -41,21 +38,13 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.DescriptorUtils.isObject import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.* -import org.jetbrains.kotlin.test.util.DescriptorValidator import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile import org.jetbrains.kotlin.utils.JsMetadataVersion -import org.jetbrains.kotlin.utils.join -import org.jetbrains.kotlin.utils.rethrow import org.jetbrains.org.objectweb.asm.ClassReader import org.jetbrains.org.objectweb.asm.ClassVisitor import org.jetbrains.org.objectweb.asm.ClassWriter import org.jetbrains.org.objectweb.asm.Opcodes -import org.junit.Assert -import java.io.BufferedOutputStream import java.io.File -import java.io.FileOutputStream -import java.io.IOException -import java.util.* import java.util.jar.JarEntry import java.util.jar.JarFile import java.util.regex.Pattern @@ -67,109 +56,77 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { get() = File(TEST_DATA_PATH, getTestName(true)) private fun getTestDataFileWithExtension(extension: String): File { - return File(testDataDirectory, getTestName(true) + "." + extension) - } - - private fun compileLibrary(sourcePath: String, vararg extraClassPath: File): File { - return compileLibrary(sourcePath, emptyList(), *extraClassPath) - } - - private fun compileLibrary(sourcePath: String, additionalOptions: List, vararg extraClassPath: File): File { - val destination = File(tmpdir, sourcePath + ".jar") - compileLibrary(K2JVMCompiler(), sourcePath, destination, additionalOptions, *extraClassPath) - return destination + return File(testDataDirectory, "${getTestName(true)}.$extension") } private fun compileLibrary( - compiler: CLICompiler<*>, sourcePath: String, destination: File, additionalOptions: List, vararg extraClassPath: File - ) { - val output = compileKotlin(compiler, sourcePath, destination, additionalOptions, *extraClassPath) - Assert.assertEquals(normalizeOutput(Pair("", ExitCode.OK)), normalizeOutput(output)) + sourcePath: String, + compiler: CLICompiler<*> = K2JVMCompiler(), + destination: File = File(tmpdir, "$sourcePath.jar"), + additionalOptions: List = emptyList(), + vararg extraClassPath: File + ): File { + val output = compileKotlin(sourcePath, destination, extraClassPath.toList(), compiler, additionalOptions) + assertEquals(normalizeOutput("" to ExitCode.OK), normalizeOutput(output)) + return destination } private fun normalizeOutput(output: Pair): String { return AbstractCliTest.getNormalizedCompilerOutput(output.first, output.second, testDataDirectory.path) - .replace(FileUtil.toSystemIndependentName(tmpdir.absolutePath), "\$TMP_DIR$") + .replace(FileUtil.toSystemIndependentName(tmpdir.absolutePath), "\$TMP_DIR\$") } - @Throws(Exception::class) private fun doTestWithTxt(vararg extraClassPath: File) { - val packageView = analyzeFileToPackageView(*extraClassPath) - - val comparator = AbstractLoadJavaTest.COMPARATOR_CONFIGURATION - .withValidationStrategy(DescriptorValidator.ValidationVisitor.errorTypesAllowed()) - validateAndCompareDescriptorWithFile(packageView, comparator, getTestDataFileWithExtension("txt")) + validateAndCompareDescriptorWithFile( + analyzeFileToPackageView(*extraClassPath), + AbstractLoadJavaTest.COMPARATOR_CONFIGURATION, + getTestDataFileWithExtension("txt") + ) } - @Throws(IOException::class) private fun analyzeFileToPackageView(vararg extraClassPath: File): PackageViewDescriptor { - val environment = createEnvironment(Arrays.asList(*extraClassPath)) + val environment = createEnvironment(extraClassPath.toList()) - val result = JvmResolveUtil.analyzeAndCheckForErrors( - KotlinTestUtils.loadJetFile(environment.project, getTestDataFileWithExtension("kt")), environment - ) + val ktFile = KotlinTestUtils.loadJetFile(environment.project, getTestDataFileWithExtension("kt")) + val result = JvmResolveUtil.analyzeAndCheckForErrors(ktFile, environment) - val packageView = result.moduleDescriptor.getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME) - assertFalse("Failed to find package: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView.isEmpty()) - return packageView + return result.moduleDescriptor.getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME).also { + assertFalse("Failed to find package: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, it.isEmpty()) + } } private fun createEnvironment(extraClassPath: List): KotlinCoreEnvironment { - val extras = ArrayList() - extras.addAll(extraClassPath) - extras.add(KotlinTestUtils.getAnnotationsJar()) - - val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, *extras.toTypedArray()) + val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, *extraClassPath.toTypedArray()) return KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) } - @Throws(IOException::class) - private fun analyzeAndGetAllDescriptors(vararg extraClassPath: File): Collection { - return DescriptorUtils.getAllDescriptors(analyzeFileToPackageView(*extraClassPath).memberScope) - } + private fun analyzeAndGetAllDescriptors(vararg extraClassPath: File): Collection = + DescriptorUtils.getAllDescriptors(analyzeFileToPackageView(*extraClassPath).memberScope) - @Throws(Exception::class) private fun compileJava(libraryDir: String): File { val allJavaFiles = FileUtil.findFilesByMask(JAVA_FILES, File(testDataDirectory, libraryDir)) val result = File(tmpdir, libraryDir) - assert(result.mkdirs()) { "Could not create directory: " + result } - KotlinTestUtils.compileJavaFiles(allJavaFiles, Arrays.asList("-d", result.path)) + assert(result.mkdirs()) { "Could not create directory: $result" } + KotlinTestUtils.compileJavaFiles(allJavaFiles, listOf("-d", result.path)) return result } private fun compileKotlin( fileName: String, output: File, - vararg classpath: File + classpath: List = emptyList(), + compiler: CLICompiler<*> = K2JVMCompiler(), + additionalOptions: List = emptyList() ): Pair { - return compileKotlin(fileName, output, emptyList(), *classpath) - } - - private fun compileKotlin( - fileName: String, - output: File, - additionalOptions: List, - vararg classpath: File - ): Pair { - return compileKotlin(K2JVMCompiler(), fileName, output, additionalOptions, *classpath) - } - - private fun compileKotlin( - compiler: CLICompiler<*>, - fileName: String, - output: File, - additionalOptions: List, - vararg classpath: File - ): Pair { - val args = ArrayList() + val args = mutableListOf() val sourceFile = File(testDataDirectory, fileName) - assert(sourceFile.exists()) { "Source file does not exist: " + sourceFile.absolutePath } + assert(sourceFile.exists()) { "Source file does not exist: ${sourceFile.absolutePath}" } args.add(sourceFile.path) if (compiler is K2JSCompiler) { if (classpath.isNotEmpty()) { args.add("-libraries") - args.add(join(Arrays.asList(*classpath), File.pathSeparator)) + args.add(classpath.joinToString(File.pathSeparator)) } args.add("-output") args.add(output.path) @@ -178,7 +135,7 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { else if (compiler is K2JVMCompiler) { if (classpath.isNotEmpty()) { args.add("-classpath") - args.add(join(Arrays.asList(*classpath), File.pathSeparator)) + args.add(classpath.joinToString(File.pathSeparator)) } args.add("-d") args.add(output.path) @@ -192,25 +149,22 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { return AbstractCliTest.executeCompilerGrabOutput(compiler, args) } - @Throws(Exception::class) private fun doTestBrokenJavaLibrary(libraryName: String, vararg pathsToDelete: String) { // This function compiles a Java library, then deletes one class file and attempts to compile a Kotlin source against // this broken library. The expected result is an error message from the compiler val library = deletePaths(compileJava(libraryName), *pathsToDelete) - val output = compileKotlin("source.kt", tmpdir, library) + val output = compileKotlin("source.kt", tmpdir, listOf(library)) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) private fun doTestBrokenKotlinLibrary(libraryName: String, vararg pathsToDelete: String) { // Analogous to doTestBrokenJavaLibrary, but with a Kotlin library compiled to a JAR file val library = copyJarFileWithoutEntry(compileLibrary(libraryName), *pathsToDelete) - val output = compileKotlin("source.kt", tmpdir, library) + val output = compileKotlin("source.kt", tmpdir, listOf(library)) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) private fun doTestKotlinLibraryWithWrongMetadataVersion( libraryName: String, additionalTransformation: ((fieldName: String, value: Any?) -> Any?)?, @@ -219,22 +173,19 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { val version = JvmMetadataVersion(42, 0, 0).toArray() val library = transformJar( compileLibrary(libraryName), - { entryName, bytes -> + { _, bytes -> WrongBytecodeVersionTest.transformMetadataInClassFile(bytes) { fieldName, value -> - if (additionalTransformation != null) { - val result = additionalTransformation.invoke(fieldName, value) - if (result != null) return@transformMetadataInClassFile result - } - if (JvmAnnotationNames.METADATA_VERSION_FIELD_NAME == fieldName) version else null + additionalTransformation?.invoke(fieldName, value) ?: + version.takeIf { JvmAnnotationNames.METADATA_VERSION_FIELD_NAME == fieldName } } } ) - val output = compileKotlin("source.kt", tmpdir, Arrays.asList(*additionalOptions), library) + val output = compileKotlin("source.kt", tmpdir, listOf(library), K2JVMCompiler(), additionalOptions.toList()) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } private fun doTestKotlinLibraryWithWrongMetadataVersionJs(libraryName: String, vararg additionalOptions: String) { - compileLibrary(K2JSCompiler(), libraryName, File(tmpdir, "library.js"), emptyList()) + compileLibrary(libraryName, K2JSCompiler(), File(tmpdir, "library.js"), emptyList()) val library = File(tmpdir, "library.meta.js") library.writeText(library.readText(Charsets.UTF_8).replace( @@ -242,13 +193,10 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { "(" + JsMetadataVersion(42, 0, 0).toInteger() + ", " ), Charsets.UTF_8) - val output = compileKotlin( - K2JSCompiler(), "source.kt", File(tmpdir, "usage.js"), Arrays.asList(*additionalOptions), library - ) + val output = compileKotlin("source.kt", File(tmpdir, "usage.js"), listOf(library), K2JSCompiler(), additionalOptions.toList()) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) private fun doTestPreReleaseKotlinLibrary( compiler: CLICompiler<*>, libraryName: String, @@ -261,7 +209,7 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { try { System.setProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY, "true") - compileLibrary(compiler, libraryName, destination, emptyList()) + compileLibrary(libraryName, compiler, destination) } finally { System.clearProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY) @@ -270,7 +218,7 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { val output: Pair try { System.setProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY, "false") - output = compileKotlin(compiler, "source.kt", usageDestination, Arrays.asList(*additionalOptions), result) + output = compileKotlin("source.kt", usageDestination, listOf(result), compiler, additionalOptions.toList()) } finally { System.clearProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY) @@ -281,23 +229,21 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { // ------------------------------------------------------------------------------ - @Throws(Exception::class) fun testRawTypes() { KotlinTestUtils.compileJavaFiles( listOf(File(testDataDirectory.toString() + "/library/test/A.java")), - Arrays.asList("-d", tmpdir.path) + listOf("-d", tmpdir.path) ) - val outputLib = compileKotlin("library/test/lib.kt", tmpdir, tmpdir) + val outputLib = compileKotlin("library/test/lib.kt", tmpdir, listOf(tmpdir)) - val outputMain = compileKotlin("main.kt", tmpdir, tmpdir) + val outputMain = compileKotlin("main.kt", tmpdir, listOf(tmpdir)) KotlinTestUtils.assertEqualsToFile( File(testDataDirectory, "output.txt"), normalizeOutput(outputLib) + "\n" + normalizeOutput(outputMain) ) } - @Throws(Exception::class) fun testDuplicateObjectInBinaryAndSources() { val allDescriptors = analyzeAndGetAllDescriptors(compileLibrary("library")) assertEquals(allDescriptors.toString(), 2, allDescriptors.size) @@ -307,109 +253,92 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { } } - @Throws(Exception::class) fun testBrokenJarWithNoClassForObject() { val brokenJar = copyJarFileWithoutEntry(compileLibrary("library"), "test/Lol.class") val allDescriptors = analyzeAndGetAllDescriptors(brokenJar) assertEmpty("No descriptors should be found: " + allDescriptors, allDescriptors) } - @Throws(Exception::class) fun testSameLibraryTwiceInClasspath() { doTestWithTxt(compileLibrary("library-1"), compileLibrary("library-2")) } - @Throws(Exception::class) fun testMissingEnumReferencedInAnnotationArgument() { doTestWithTxt(copyJarFileWithoutEntry(compileLibrary("library"), "test/E.class")) } - @Throws(Exception::class) fun testNoWarningsOnJavaKotlinInheritance() { // This test checks that there are no PARAMETER_NAME_CHANGED_ON_OVERRIDE or DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES // warnings when subclassing in Kotlin from Java binaries (in case when no parameter names are available for Java classes) KotlinTestUtils.compileJavaFiles( listOf(getTestDataFileWithExtension("java")), - Arrays.asList("-d", tmpdir.path) + listOf("-d", tmpdir.path) ) val environment = createEnvironment(listOf(tmpdir)) - val result = JvmResolveUtil.analyze( - KotlinTestUtils.loadJetFile(environment.project, getTestDataFileWithExtension("kt")), environment - ) + val ktFile = KotlinTestUtils.loadJetFile(environment.project, getTestDataFileWithExtension("kt")) + val result = JvmResolveUtil.analyze(ktFile, environment) result.throwIfError() - val bindingContext = result.bindingContext AnalyzerWithCompilerReport.reportDiagnostics( - bindingContext.diagnostics, + result.bindingContext.diagnostics, PrintingMessageCollector(System.err, MessageRenderer.PLAIN_FULL_PATHS, false) ) - assertEquals("There should be no diagnostics", 0, Iterables.size(bindingContext.diagnostics)) + assertEquals("There should be no diagnostics", 0, result.bindingContext.diagnostics.count()) } - @Throws(Exception::class) fun testIncompleteHierarchyInJava() { doTestBrokenJavaLibrary("library", "test/Super.class") } - @Throws(Exception::class) fun testIncompleteHierarchyInKotlin() { doTestBrokenKotlinLibrary("library", "test/Super.class") } - @Throws(Exception::class) fun testMissingDependencySimple() { doTestBrokenKotlinLibrary("library", "a/A.class") } - @Throws(Exception::class) fun testMissingDependencyDifferentCases() { doTestBrokenKotlinLibrary("library", "a/A.class") } - @Throws(Exception::class) fun testMissingDependencyNestedAnnotation() { doTestBrokenKotlinLibrary("library", "a/A\$Anno.class") } - @Throws(Exception::class) fun testMissingDependencyConflictingLibraries() { val library1 = copyJarFileWithoutEntry(compileLibrary("library1"), "a/A.class", "a/A\$Inner.class", "a/AA.class", "a/AA\$Inner.class") val library2 = copyJarFileWithoutEntry(compileLibrary("library2"), "a/A.class", "a/A\$Inner.class", "a/AA.class", "a/AA\$Inner.class") - val output = compileKotlin("source.kt", tmpdir, library1, library2) + val output = compileKotlin("source.kt", tmpdir, listOf(library1, library2)) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) fun testMissingDependencyJava() { doTestBrokenJavaLibrary("library", "test/Bar.class") } - @Throws(Exception::class) fun testMissingDependencyJavaConflictingLibraries() { val library1 = deletePaths(compileJava("library1"), "test/A.class", "test/A\$Inner.class") val library2 = deletePaths(compileJava("library2"), "test/A.class", "test/A\$Inner.class") - val output = compileKotlin("source.kt", tmpdir, library1, library2) + val output = compileKotlin("source.kt", tmpdir, listOf(library1, library2)) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) fun testMissingDependencyJavaNestedAnnotation() { doTestBrokenJavaLibrary("library", "test/A\$Anno.class") } - @Throws(Exception::class) fun testReleaseCompilerAgainstPreReleaseLibrary() { val destination = File(tmpdir, "library.jar") doTestPreReleaseKotlinLibrary(K2JVMCompiler(), "library", destination, destination, tmpdir) } - @Throws(Exception::class) fun testReleaseCompilerAgainstPreReleaseLibraryJs() { doTestPreReleaseKotlinLibrary( K2JSCompiler(), "library", @@ -418,7 +347,6 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { ) } - @Throws(Exception::class) fun testReleaseCompilerAgainstPreReleaseLibrarySkipVersionCheck() { val destination = File(tmpdir, "library.jar") doTestPreReleaseKotlinLibrary( @@ -428,7 +356,6 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { ) } - @Throws(Exception::class) fun testReleaseCompilerAgainstPreReleaseLibraryJsSkipVersionCheck() { doTestPreReleaseKotlinLibrary( K2JSCompiler(), "library", @@ -438,67 +365,49 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { ) } - @Throws(Exception::class) fun testWrongMetadataVersion() { doTestKotlinLibraryWithWrongMetadataVersion("library", null) } - @Throws(Exception::class) fun testWrongMetadataVersionJs() { doTestKotlinLibraryWithWrongMetadataVersionJs("library") } - @Throws(Exception::class) fun testWrongMetadataVersionBadMetadata() { - doTestKotlinLibraryWithWrongMetadataVersion( - "library", - { name, value -> - if (JvmAnnotationNames.METADATA_DATA_FIELD_NAME == name) { - val strings = value as Array - for (i in strings.indices) { - val bytes = strings[i].toByteArray() - for (j in bytes.indices) bytes[j] = bytes[j] xor 42 - strings[i] = String(bytes) - } - return@doTestKotlinLibraryWithWrongMetadataVersion strings - } - null - } - ) + doTestKotlinLibraryWithWrongMetadataVersion("library", { name, value -> + if (JvmAnnotationNames.METADATA_DATA_FIELD_NAME == name) { + @Suppress("UNCHECKED_CAST") + val strings = value as Array + strings.map { string -> + String(string.toByteArray().map { x -> x xor 42 }.toTypedArray().toByteArray()) + }.toTypedArray() + } + else null + }) } - @Throws(Exception::class) fun testWrongMetadataVersionBadMetadata2() { - doTestKotlinLibraryWithWrongMetadataVersion( - "library", - { name, value -> - if (JvmAnnotationNames.METADATA_STRINGS_FIELD_NAME == name) { - return@doTestKotlinLibraryWithWrongMetadataVersion ArrayUtil.EMPTY_STRING_ARRAY - } - null - } - ) + doTestKotlinLibraryWithWrongMetadataVersion("library", { name, _ -> + if (JvmAnnotationNames.METADATA_STRINGS_FIELD_NAME == name) arrayOf() else null + }) } - @Throws(Exception::class) fun testWrongMetadataVersionSkipVersionCheck() { doTestKotlinLibraryWithWrongMetadataVersion("library", null, "-Xskip-metadata-version-check") } - @Throws(Exception::class) fun testWrongMetadataVersionJsSkipVersionCheck() { doTestKotlinLibraryWithWrongMetadataVersionJs("library", "-Xskip-metadata-version-check") } /*test source mapping generation when source info is absent*/ - @Throws(Exception::class) fun testInlineFunWithoutDebugInfo() { compileKotlin("sourceInline.kt", tmpdir) val inlineFunClass = File(tmpdir.absolutePath, "test/A.class") val cw = ClassWriter(Opcodes.ASM5) ClassReader(inlineFunClass.readBytes()).accept(object : ClassVisitor(Opcodes.ASM5, cw) { - override fun visitSource(source: String, debug: String) { + override fun visitSource(source: String?, debug: String?) { //skip debug info } }, 0) @@ -508,54 +417,53 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { inlineFunClass.writeBytes(cw.toByteArray()) - compileKotlin("source.kt", tmpdir, tmpdir) + compileKotlin("source.kt", tmpdir, listOf(tmpdir)) - val debugInfo = Ref() + var debugInfo: String? = null val resultFile = File(tmpdir.absolutePath, "test/B.class") ClassReader(resultFile.readBytes()).accept(object : ClassVisitor(Opcodes.ASM5) { - override fun visitSource(source: String, debug: String) { - //skip debug info - debugInfo.set(debug) + override fun visitSource(source: String?, debug: String?) { + debugInfo = debug } }, 0) - val expected = "SMAP\n" + - "source.kt\n" + - "Kotlin\n" + - "*S Kotlin\n" + - "*F\n" + - "+ 1 source.kt\n" + - "test/B\n" + - "*L\n" + - "1#1,13:1\n" + - "*E\n" + val expected = """ + SMAP + source.kt + Kotlin + *S Kotlin + *F + + 1 source.kt + test/B + *L + 1#1,13:1 + *E + """.trimIndent() + "\n" if (InlineCodegenUtil.GENERATE_SMAP) { - assertEquals(expected, debugInfo.get()) + assertEquals(expected, debugInfo) } else { - assertEquals(null, debugInfo.get()) + assertEquals(null, debugInfo) } } - @Throws(Exception::class) fun testReplaceAnnotationClassWithInterface() { val library1 = compileLibrary("library-1") - val usage = compileLibrary("usage", library1) + val usage = compileLibrary("usage", extraClassPath = *arrayOf(library1)) val library2 = compileLibrary("library-2") doTestWithTxt(usage, library2) } - @Throws(Exception::class) fun testProhibitNestedClassesByDollarName() { val library = compileLibrary("library") KotlinTestUtils.compileJavaFiles( listOf(File(testDataDirectory.toString() + "/library/test/JavaOuter.java")), - Arrays.asList("-d", tmpdir.path) + listOf("-d", tmpdir.path) ) - val outputMain = compileKotlin("main.kt", tmpdir, tmpdir, library) + val outputMain = compileKotlin("main.kt", tmpdir, listOf(tmpdir, library)) KotlinTestUtils.assertEqualsToFile( File(testDataDirectory, "output.txt"), normalizeOutput(outputMain) @@ -565,25 +473,22 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { fun testTypeAliasesAreInvisibleInCompatibilityMode() { compileKotlin("typeAliases.kt", tmpdir) - val outputMain = compileKotlin("main.kt", tmpdir, Arrays.asList("-language-version", "1.0"), tmpdir) + val outputMain = compileKotlin("main.kt", tmpdir, listOf(tmpdir), K2JVMCompiler(), listOf("-language-version", "1.0")) KotlinTestUtils.assertEqualsToFile( File(testDataDirectory, "output.txt"), normalizeOutput(outputMain) ) } - @Throws(Exception::class) fun testInnerClassPackageConflict() { compileJava("library") - FileUtil.copy(File(testDataDirectory, "library/test/Foo/x.txt"), - File(tmpdir, "library/test/Foo/x.txt")) + File(testDataDirectory, "library/test/Foo/x.txt").copyTo(File(tmpdir, "library/test/Foo/x.txt")) MockLibraryUtil.createJarFile(tmpdir, File(tmpdir, "library"), null, "library", false) val jarPath = File(tmpdir, "library.jar") - val output = compileKotlin("source.kt", tmpdir, jarPath) + val output = compileKotlin("source.kt", tmpdir, listOf(jarPath)) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) fun testInnerClassPackageConflict2() { val library1 = compileJava("library1") val library2 = compileJava("library2") @@ -600,15 +505,14 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { true } - val output = compileKotlin("source.kt", tmpdir, library1) + val output = compileKotlin("source.kt", tmpdir, listOf(library1)) KotlinTestUtils.assertEqualsToFile(File(testDataDirectory, "output.txt"), normalizeOutput(output)) } - @Throws(Exception::class) fun testWrongInlineTarget() { - val library = compileLibrary("library", Arrays.asList("-jvm-target", "1.8")) + val library = compileLibrary("library", additionalOptions = listOf("-jvm-target", "1.8")) - val outputMain = compileKotlin("source.kt", tmpdir, library) + val outputMain = compileKotlin("source.kt", tmpdir, listOf(library)) KotlinTestUtils.assertEqualsToFile( File(testDataDirectory, "output.txt"), normalizeOutput(outputMain) @@ -619,51 +523,40 @@ class CompileKotlinAgainstCustomBinariesTest : TestCaseWithTmpdir() { private val TEST_DATA_PATH = "compiler/testData/compileKotlinAgainstCustomBinaries/" private val JAVA_FILES = Pattern.compile(".*\\.java$") - private fun copyJarFileWithoutEntry(jarPath: File, vararg entriesToDelete: String): File { - return transformJar(jarPath, { s, bytes -> bytes }, *entriesToDelete) - } + private fun copyJarFileWithoutEntry(jarPath: File, vararg entriesToDelete: String): File = + transformJar(jarPath, { _, bytes -> bytes }, entriesToDelete.toSet()) private fun transformJar( jarPath: File, - transformEntry: Function2, - vararg entriesToDelete: String + transformEntry: (String, ByteArray) -> ByteArray, + entriesToDelete: Set = emptySet() ): File { - try { - val outputFile = File(jarPath.parentFile, FileUtil.getNameWithoutExtension(jarPath) + "-after.jar") - val toDelete = setOf(*entriesToDelete) + val outputFile = File(jarPath.parentFile, "${jarPath.nameWithoutExtension}-after.jar") - JarFile(jarPath).use { jar -> - ZipOutputStream(BufferedOutputStream(FileOutputStream(outputFile))).use { output -> - val enumeration = jar.entries() - while (enumeration.hasMoreElements()) { - val jarEntry = enumeration.nextElement() - val name = jarEntry.name - if (toDelete.contains(name)) { - continue - } - val bytes = FileUtil.loadBytes(jar.getInputStream(jarEntry)) - val newBytes = if (name.endsWith(".class")) transformEntry.invoke(name, bytes) else bytes - val newEntry = JarEntry(name) - newEntry.size = newBytes.size.toLong() - output.putNextEntry(newEntry) - output.write(newBytes) - output.closeEntry() - } + JarFile(jarPath).use { jar -> + ZipOutputStream(outputFile.outputStream().buffered()).use { output -> + for (jarEntry in jar.entries()) { + val name = jarEntry.name + if (name in entriesToDelete) continue + + val bytes = jar.getInputStream(jarEntry).readBytes() + val newBytes = if (name.endsWith(".class")) transformEntry(name, bytes) else bytes + val newEntry = JarEntry(name) + newEntry.size = newBytes.size.toLong() + output.putNextEntry(newEntry) + output.write(newBytes) + output.closeEntry() } } - - return outputFile - } - catch (e: IOException) { - throw rethrow(e) } + return outputFile } private fun deletePaths(library: File, vararg pathsToDelete: String): File { for (pathToDelete in pathsToDelete) { val fileToDelete = File(library, pathToDelete) - assert(fileToDelete.delete()) { "Can't delete " + fileToDelete } + assert(fileToDelete.delete()) { "Can't delete $fileToDelete" } } return library }