azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Test] Extract MockLibraryUtil to :compiler:tests-compiler-utils

Browse Source 
Also provide MockLibraryUtilExt with bridges to MockLibraryUtil
  with JUnit4Assertions
This commit is contained in:
Dmitriy Novozhilov
2020-12-22 13:56:06 +03:00
committed by TeamCityServer
parent eadec08937
commit cb7b1652e7
26 changed files with 271 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt
+1 -1
View File
@@ -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())
compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt
-31
View File
@@ -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 }) {
compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/KtAssert.kt
+45
View File
@@ -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 <T> assertEquals(message: String, expected: T, actual: T) {
if (expected != actual) {
fail(message)
}
}
}
compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt
+1 -1
View File
@@ -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
compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt
+3 -3
View File
@@ -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<File>): List<File> =
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<File> = listOf(
MockLibraryUtil.compileJavaFilesLibraryToJar(annotationsPath, "foreign-annotations"),
MockLibraryUtilExt.compileJavaFilesLibraryToJar(annotationsPath, "foreign-annotations"),
ForTestCompileRuntime.jvmAnnotationsForTests()
)
compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt
+5 -3
View File
@@ -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
)
compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
+2 -2
View File
@@ -115,7 +115,7 @@ public class LoadDescriptorUtil {
List<File> 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());
compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java
+4 -58
View File
@@ -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<File> files, List<String> options, @Nullable File javaErrorFile) throws IOException {
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<>();
try (StandardJavaFileManager fileManager =
javaCompiler.getStandardFileManager(diagnosticCollector, Locale.ENGLISH, Charset.forName("utf-8"))) {
Iterable<? extends JavaFileObject> 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<File> files, @NotNull List<String> options) {
return compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home());
return JvmCompilationUtils.compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home());
}
public static boolean compileJavaFilesExternally(@NotNull Collection<File> files, @NotNull List<String> options, @NotNull File jdkHome) {
List<String> 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<JavaFileObject> diagnosticCollector, boolean humanReadable) {
StringBuilder builder = new StringBuilder();
for (javax.tools.Diagnostic<? extends JavaFileObject> 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) {
compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtilExt.kt
+72
View File
@@ -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<String> = emptyList(),
extraClasspath: List<String> = 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<String> = emptyList(),
extraClasspath: List<String> = 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<String> = emptyList(),
extraClasspath: List<String> = emptyList(),
useJava9: Boolean = false
): File {
return MockLibraryUtil.compileLibraryToJar(
sourcesPath,
contentDir,
jarName,
addSources,
allowKotlinSources,
extraOptions,
extraClasspath,
useJava9,
JUnit4Assertions
)
}
}
compiler/tests-compiler-utils/build.gradle.kts
+1
View File
@@ -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()) {
compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/JvmCompilationUtils.kt
+81
View File
@@ -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<File>, options: List<String?>?, javaErrorFile: File? = null, assertions: Assertions): Boolean {
val javaCompiler = ToolProvider.getSystemJavaCompiler()
val diagnosticCollector = DiagnosticCollector<JavaFileObject>()
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<File>, options: List<String?>): Boolean {
return compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home())
}
fun compileJavaFilesExternally(files: Collection<File>, options: List<String?>, jdkHome: File): Boolean {
val command: MutableList<String?> = 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<JavaFileObject>, 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()
}
compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt → compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt
+21 -31
View File
@@ -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<ClassLoader>(null)
@JvmStatic
@JvmOverloads
fun compileJvmLibraryToJar(
sourcesPath: String,
jarName: String,
@@ -50,38 +36,40 @@ object MockLibraryUtil {
allowKotlinSources: Boolean = true,
extraOptions: List<String> = emptyList(),
extraClasspath: List<String> = 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<String> = emptyList(),
extraClasspath: List<String> = emptyList()
extraClasspath: List<String> = 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<String> = emptyList(),
extraClasspath: List<String> = 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<String> = 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<String>::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
compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt
+2 -5
View File
@@ -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")
}
compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt
+2 -5
View File
@@ -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"
)
idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/SdkAndMockLibraryProjectDescriptor.java
+2 -1
View File
@@ -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 =
idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinBinariesCheckerTest.kt
+2 -2
View File
@@ -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
idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt
+2 -2
View File
@@ -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)
)
idea/tests/org/jetbrains/kotlin/idea/caches/resolve/HighlightingWithDependentLibrariesTest.kt
+3 -3
View File
@@ -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"))
idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt
+2 -2
View File
@@ -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
idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleHighlightingTest.kt
+4 -7
View File
@@ -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")
)
idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt
+3 -3
View File
@@ -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))
idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt
+2 -1
View File
@@ -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")
idea/tests/org/jetbrains/kotlin/idea/highlighter/Jsr305HighlightingTest.kt
+3 -3
View File
@@ -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)
)
idea/tests/org/jetbrains/kotlin/idea/navigation/GotoWithMultipleLibrariesTest.kt
+2 -2
View File
@@ -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
jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt
+3 -3
View File
@@ -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)
jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201
+3 -3
View File
@@ -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)