From 76fc4328d1810783738bdc649ecedd83b4a13689 Mon Sep 17 00:00:00 2001 From: Yahor Berdnikau Date: Thu, 10 Mar 2022 20:41:28 +0100 Subject: [PATCH] Migrate KotlinGradlePluginIT to new test dsl Moved some tests to another test suites ^KT-45745 In Progress --- .../jetbrains/kotlin/gradle/BaseGradleIT.kt | 19 - .../jetbrains/kotlin/gradle/BuildReportsIT.kt | 112 + .../kotlin/gradle/ConfigurationAvoidanceIT.kt | 110 +- .../kotlin/gradle/DifferentClassloadersIT.kt | 98 + .../kotlin/gradle/IncrementalJavaChangeIT.kt | 50 + .../kotlin/gradle/KotlinGradlePluginIT.kt | 1807 ++++++----------- .../kotlin/gradle/MultiplatformGradleIT.kt | 28 + .../jetbrains/kotlin/gradle/PublishingIT.kt | 85 + .../jetbrains/kotlin/gradle/ScriptingIT.kt | 12 + .../kotlin/gradle/UnnamedTaskInputsIT.kt | 92 + .../Project Path With Spaces/build.gradle | 13 +- .../testProject/classpathTest/build.gradle | 26 - .../src/main/kotlin/helloWorld.kt | 18 - .../classpathTest/src/test/kotlin/tests.kt | 11 - .../convertBetweenJavaAndKotlin/build.gradle | 18 +- .../gradle.properties | 1 - .../differentClassloaders/build.gradle | 2 +- .../testProject/internalTest/build.gradle | 13 +- .../javaLibraryProject/app/build.gradle | 7 +- .../javaLibraryProject/build.gradle | 10 - .../javaLibraryProject/libA/build.gradle | 6 +- .../javaLibraryProject/libB/build.gradle | 6 +- .../javaPackagePrefix/build.gradle | 18 +- .../build.gradle.kts | 2 +- .../kotlin2JsNoOutputFileProject/build.gradle | 12 +- .../app/src/main/kotlin/classes.kt | 5 + .../app/src/main/kotlin/main.kt | 5 + .../kotlinJavaProject/build.gradle | 14 +- .../build.gradle.kts | 2 +- .../buildSrc/build.gradle.kts | 5 +- .../buildSrc/settings.gradle.kts | 2 + .../testProject/kt-29971/build.gradle | 10 - .../testProject/kt-29971/jvm-app/build.gradle | 4 - .../testProject/kt-29971/mpp-lib/build.gradle | 2 +- .../moveClassToOtherModule/app/build.gradle | 5 +- .../app/src/main/java/foo/A.kt.delete | 0 .../moveClassToOtherModule/build.gradle | 10 +- .../moveClassToOtherModule/lib/build.gradle | 6 +- .../subproject/build.gradle | 5 +- .../multiprojectWithDependency/build.gradle | 4 + .../projA/build.gradle | 6 +- .../projB/build.gradle | 5 +- .../settings.gradle | 13 - .../new-model-in-old-plugin/build.gradle.kts | 2 +- .../testProject/typeAlias/build.gradle | 16 +- .../testProject/typeAlias/gradle.properties | 1 - 46 files changed, 1250 insertions(+), 1448 deletions(-) create mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildReportsIT.kt create mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/DifferentClassloadersIT.kt create mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/UnnamedTaskInputsIT.kt delete mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/build.gradle delete mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/main/kotlin/helloWorld.kt delete mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/test/kotlin/tests.kt delete mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/gradle.properties delete mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/src/main/java/foo/A.kt.delete delete mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/gradle.properties diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt index 8d62eae175e..2b4ee65e308 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt @@ -371,25 +371,6 @@ abstract class BaseGradleIT { fun relativize(vararg files: File): List = files.map { it.relativeTo(projectDir).path } - - fun performModifications() { - for (file in projectDir.walk()) { - if (!file.isFile) continue - - val fileWithoutExt = File(file.parentFile, file.nameWithoutExtension) - - when (file.extension) { - "new" -> { - file.copyTo(fileWithoutExt, overwrite = true) - file.delete() - } - "delete" -> { - fileWithoutExt.delete() - file.delete() - } - } - } - } } class CompiledProject(val project: Project, val output: String, val resultCode: Int) diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildReportsIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildReportsIT.kt new file mode 100644 index 00000000000..cd89d0965ae --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildReportsIT.kt @@ -0,0 +1,112 @@ +/* + * Copyright 2010-2022 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.gradle + +import org.gradle.util.GradleVersion +import org.jetbrains.kotlin.gradle.internal.build.metrics.GradleBuildMetricsData +import org.jetbrains.kotlin.gradle.report.BuildReportType +import org.jetbrains.kotlin.gradle.testbase.* +import org.junit.jupiter.api.DisplayName +import java.io.ObjectInputStream +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +@DisplayName("Build reports") +@JvmGradlePluginTests +class BuildReportsIT : KGPBaseTest() { + override val defaultBuildOptions: BuildOptions + get() = super.defaultBuildOptions.copy( + buildReport = listOf(BuildReportType.FILE) + ) + + @DisplayName("Build report is created") + @GradleTest + fun testBuildReportSmokeTest(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + build("assemble") { + assertOutputContains("Kotlin build report is written to") + } + + build("clean", "assemble") { + assertOutputContains("Kotlin build report is written to") + } + } + } + + @DisplayName("Build report output property accepts only certain values") + @GradleTest + fun testBuildReportOutputProperty(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + buildAndFail("assemble", "-Pkotlin.build.report.output=file,invalid") { + assertOutputContains("Unknown output type:") + } + } + } + + @DisplayName("Build metrics produces valid report") + @GradleTest + fun testBuildMetricsSmokeTest(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + build("assemble") { + assertOutputContains("Kotlin build report is written to") + } + val reportFolder = projectPath.resolve("build/reports/kotlin-build").toFile() + val reports = reportFolder.listFiles() + assertNotNull(reports) + assertEquals(1, reports.size) + val report = reports[0].readText() + + //Should contains build metrics for all compile kotlin tasks + assertTrue { report.contains("Time metrics:") } + assertTrue { report.contains("Run compilation:") } + assertTrue { report.contains("Incremental compilation in daemon:") } + assertTrue { report.contains("Build performance metrics:") } + assertTrue { report.contains("Total size of the cache directory:") } + assertTrue { report.contains("Total compiler iteration:") } + assertTrue { report.contains("ABI snapshot size:") } + //for non-incremental builds + assertTrue { report.contains("Build attributes:") } + assertTrue { report.contains("REBUILD_REASON:") } + } + } + + @DisplayName("Compiler build metrics report is produced") + @GradleTest + fun testCompilerBuildMetricsSmokeTest(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + build("assemble") { + assertOutputContains("Kotlin build report is written to") + } + val reportFolder = projectPath.resolve("build/reports/kotlin-build").toFile() + val reports = reportFolder.listFiles() + assertNotNull(reports) + assertEquals(1, reports.size) + val report = reports[0].readText() + assertTrue { report.contains("Compiler code analysis:") } + assertTrue { report.contains("Compiler code generation:") } + assertTrue { report.contains("Compiler initialization time:") } + } + } + + @DisplayName("") + @GradleTest + fun testSingleBuildMetricsFileSmoke(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + val metricsFile = projectPath.resolve("metrics.bin").toFile() + build( + "compileKotlin", + "-Pkotlin.internal.single.build.metrics.file=${metricsFile.absolutePath}" + ) + + assertTrue { metricsFile.exists() } + // test whether we can deserialize data from the file + ObjectInputStream(metricsFile.inputStream().buffered()).use { input -> + input.readObject() as GradleBuildMetricsData + } + } + } +} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationAvoidanceIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationAvoidanceIT.kt index e0766c1df5e..0c578e497e7 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationAvoidanceIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationAvoidanceIT.kt @@ -8,34 +8,24 @@ package org.jetbrains.kotlin.gradle import org.gradle.util.GradleVersion import org.jetbrains.kotlin.gradle.testbase.* import org.junit.jupiter.api.DisplayName +import kotlin.io.path.appendText @DisplayName("Tasks configuration avoidance") -@SimpleGradlePluginTests class ConfigurationAvoidanceIT : KGPBaseTest() { - @DisplayName("Unrelated tasks are not configured") + @JvmGradlePluginTests + @DisplayName("JVM unrelated tasks are not configured") @GradleTest fun testUnrelatedTaskNotConfigured(gradleVersion: GradleVersion) { project("simpleProject", gradleVersion) { - - val expensivelyConfiguredTaskName = "expensivelyConfiguredTask" - - @Suppress("GroovyAssignabilityCheck") - buildGradle.append( - //language=Groovy - """ - - tasks.register("$expensivelyConfiguredTaskName") { - throw new GradleException("Should not configure expensive task!") - } - """.trimIndent() - ) + createTaskWithExpensiveConfiguration() build("compileKotlin") } } - @DisplayName("Android tasks are not configured") + @JvmGradlePluginTests // TODO: move it into Android tests tag + @DisplayName("Android unrelated tasks are not configured") @GradleTestVersions(minVersion = TestVersions.Gradle.G_6_7) @GradleTest fun testAndroidUnrelatedTaskNotConfigured(gradleVersion: GradleVersion) { @@ -86,4 +76,92 @@ class ConfigurationAvoidanceIT : KGPBaseTest() { ) } } + + @JsGradlePluginTests + @DisplayName("JS unrelated tasks are not configured") + @GradleTest + fun jsNoTasksConfigured(gradleVersion: GradleVersion) { + project("kotlin2JsNoOutputFileProject", gradleVersion) { + createTaskWithExpensiveConfiguration() + + build("help") + } + } + + @MppGradlePluginTests + @DisplayName("MPP unrelated tasks are not configured") + @GradleTest + fun mppNoTasksConfigured(gradleVersion: GradleVersion) { + project("new-mpp-lib-and-app/sample-app", gradleVersion) { + createTaskWithExpensiveConfiguration() + + build("help") + } + } + + private fun TestProject.createTaskWithExpensiveConfiguration( + expensivelyConfiguredTaskName: String = "expensivelyConfiguredTask" + ): String { + @Suppress("GroovyAssignabilityCheck") + buildGradle.append( + //language=Groovy + """ + + tasks.register("$expensivelyConfiguredTaskName") { + throw new GradleException("Should not configure expensive task!") + } + """.trimIndent() + ) + + return expensivelyConfiguredTaskName + } + + @JvmGradlePluginTests + @DisplayName("JVM early configuration resolution") + @GradleTest + fun testEarlyConfigurationsResolutionKotlin(gradleVersion: GradleVersion) { + testEarlyConfigurationsResolution("kotlinProject", gradleVersion, kts = false) + } + + @JsGradlePluginTests + @DisplayName("JS early configuration resolution") + @GradleTest + fun testEarlyConfigurationsResolutionKotlinJs(gradleVersion: GradleVersion) { + testEarlyConfigurationsResolution("kotlin-js-browser-project", gradleVersion, kts = true) + } + + private fun testEarlyConfigurationsResolution( + projectName: String, + gradleVersion: GradleVersion, + kts: Boolean + ) = project(projectName, gradleVersion) { + (if (kts) buildGradleKts else buildGradle).appendText( + //language=Gradle + """${'\n'} + // KT-45834 start + ${if (kts) "var" else "def"} ready = false + gradle.taskGraph.whenReady { + println("Task Graph Ready") + ready = true + } + + allprojects { + configurations.forEach { configuration -> + configuration.incoming.beforeResolve { + println("Resolving ${'$'}configuration") + if (!ready) { + throw ${if (kts) "" else "new"} GradleException("${'$'}configuration is being resolved at configuration time") + } + } + } + } + // KT-45834 end + """.trimIndent() + ) + + build( + "assemble", + "-m" + ) + } } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/DifferentClassloadersIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/DifferentClassloadersIT.kt new file mode 100644 index 00000000000..c668e1c35a3 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/DifferentClassloadersIT.kt @@ -0,0 +1,98 @@ +/* + * Copyright 2010-2022 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.gradle + +import org.gradle.util.GradleVersion +import org.jetbrains.kotlin.gradle.plugin.MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING +import org.jetbrains.kotlin.gradle.plugin.MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING +import org.jetbrains.kotlin.gradle.testbase.* +import org.jetbrains.kotlin.gradle.util.checkedReplace +import org.junit.jupiter.api.DisplayName +import kotlin.io.path.appendText +import kotlin.test.assertEquals + +@DisplayName("Different Gradle classloaders warning") +@MppGradlePluginTests +class DifferentClassloadersIT : KGPBaseTest() { + + @DisplayName("Different classloaders message is not displayed") + @GradleTest + fun testDifferentClassloadersNotDisplayed(gradleVersion: GradleVersion) { + project("differentClassloaders", gradleVersion) { + build("publish", "-PmppProjectDependency=true") { + assertOutputDoesNotContain(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) + assertOutputDoesNotContain(MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING) + } + } + } + + @DisplayName("Different classloader message is displayed on different plugin versions") + @GradleTest + fun testDetectingDifferentClassLoaders(gradleVersion: GradleVersion) { + project("differentClassloaders", gradleVersion) { + setupDifferentClassloadersProject() + + buildAndFail("publish", "-PmppProjectDependency=true") { + assertOutputContains(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) + } + } + } + + @DisplayName("KT-50598: Different classloaders message is only displayed on the first build") + @GradleTest + fun differentClassloadersOnlyFirstBuild(gradleVersion: GradleVersion) { + project("differentClassloaders", gradleVersion) { + setupDifferentClassloadersProject() + + build("-PmppProjectDependency=true") { + assertOutputContains(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) + + val specificProjectsReported = Regex("$MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING((?:'.*'(?:, )?)+)") + .find(output)!!.groupValues[1].split(", ").map { it.removeSurrounding("'") }.toSet() + + assertEquals(setOf(":mpp-lib", ":jvm-app", ":js-app"), specificProjectsReported) + } + + // Test the flag that turns off the warnings + build("-PmppProjectDependency=true", "-Pkotlin.pluginLoadedInMultipleProjects.ignore=true") { + assertOutputDoesNotContain(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) + assertOutputDoesNotContain(MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING) + } + } + } + + private fun TestProject.setupDifferentClassloadersProject() { + // Specify the plugin versions in the subprojects with different plugin sets – + // this will make Gradle use separate class loaders + buildGradle.modify { + it.checkedReplace("id \"org.jetbrains.kotlin.multiplatform\"", "//") + } + subProject("mpp-lib").buildGradle.modify { + it.checkedReplace( + "id \"org.jetbrains.kotlin.multiplatform\"", + "id \"org.jetbrains.kotlin.multiplatform\" version \"${TestVersions.Kotlin.CURRENT}\"" + ) + } + subProject("jvm-app").buildGradle.modify { + it.checkedReplace( + "id \"org.jetbrains.kotlin.jvm\"", + "id \"org.jetbrains.kotlin.jvm\" version \"${TestVersions.Kotlin.CURRENT}\"" + ) + } + subProject("js-app").buildGradle.modify { + it.checkedReplace( + "id \"kotlin2js\"", + "id \"kotlin2js\" version \"${TestVersions.Kotlin.CURRENT}\"" + ) + } + + // Also include another project via a composite build: + includeOtherProjectAsIncludedBuild("allopenPluginsDsl", "pluginsDsl") + buildGradle.appendText( + "\ntasks.create(\"publish\").dependsOn(gradle.includedBuild(\"allopenPluginsDsl\").task(\":assemble\"))" + ) + } +} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt index da41e33d0b6..482114746c6 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt @@ -9,6 +9,11 @@ import org.gradle.util.GradleVersion import org.jetbrains.kotlin.gradle.testbase.* import org.junit.jupiter.api.DisplayName import java.nio.file.Path +import kotlin.io.path.createDirectories +import kotlin.io.path.deleteExisting +import kotlin.io.path.relativeTo +import kotlin.io.path.writeText +import kotlin.test.assertTrue @DisplayName("Default incremental compilation with default precise java tracking") open class IncrementalJavaChangeDefaultIT : IncrementalCompilationJavaChangesBase(usePreciseJavaTracking = null) { @@ -44,6 +49,51 @@ open class IncrementalJavaChangeDefaultIT : IncrementalCompilationJavaChangesBas } } } + + @DisplayName("KT-38692: should clean all outputs after removing all Kotlin sources") + @GradleTest + fun testIncrementalWhenNoKotlinSources(gradleVersion: GradleVersion) { + project("kotlinProject", gradleVersion) { + build(":compileKotlin") { + assertTasksExecuted(":compileKotlin") + } + + // Remove all Kotlin sources and force non-incremental run + projectPath.allKotlinFiles.forEach { it.deleteExisting() } + javaSourcesDir().resolve("Sample.java").also { + it.parent.createDirectories() + it.writeText("public class Sample {}") + } + build("compileKotlin", "--rerun-tasks") { + assertTasksExecuted(":compileKotlin") + val compiledKotlinClasses = kotlinClassesDir().allFilesWithExtension("class").toList() + + assertTrue(compiledKotlinClasses.isEmpty()) + } + } + } + + @DisplayName("Type alias change is incremental") + @GradleTest + fun testTypeAliasIncremental(gradleVersion: GradleVersion) { + project("typeAlias", gradleVersion) { + build("build") + + val curryKt = kotlinSourcesDir().resolve("Curry.kt") + val useCurryKt = kotlinSourcesDir().resolve("UseCurry.kt") + + curryKt.modify { + it.replace("class Curry", "internal class Curry") + } + + build("build") { + assertCompiledKotlinSources( + listOf(curryKt, useCurryKt).map { it.relativeTo(projectPath) }, + output + ) + } + } + } } @DisplayName("Incremental compilation via classpath snapshots with default precise java tracking") diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt index 101cb79b84b..c68d1246dc4 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt @@ -19,626 +19,382 @@ package org.jetbrains.kotlin.gradle import org.gradle.api.logging.LogLevel import org.gradle.api.logging.configuration.WarningMode import org.gradle.util.GradleVersion -import org.jetbrains.kotlin.gradle.internal.build.metrics.GradleBuildMetricsData -import org.jetbrains.kotlin.gradle.plugin.MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING -import org.jetbrains.kotlin.gradle.plugin.MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING -import org.jetbrains.kotlin.gradle.report.BuildReportType -import org.jetbrains.kotlin.gradle.scripting.internal.ScriptingGradleSubplugin import org.jetbrains.kotlin.gradle.tasks.USING_JVM_INCREMENTAL_COMPILATION_MESSAGE -import org.jetbrains.kotlin.gradle.testbase.TestVersions -import org.jetbrains.kotlin.gradle.util.* -import org.jetbrains.kotlin.test.util.KtTestUtil -import org.junit.Test -import java.io.File -import java.io.ObjectInputStream -import java.nio.file.FileSystemException -import java.nio.file.Files -import java.util.* +import org.jetbrains.kotlin.gradle.testbase.* +import org.jetbrains.kotlin.gradle.util.checkBytecodeContains +import org.jetbrains.kotlin.gradle.util.checkedReplace +import org.jetbrains.kotlin.gradle.util.testResolveAllConfigurations +import org.junit.jupiter.api.Disabled +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.condition.DisabledOnOs +import org.junit.jupiter.api.condition.OS +import org.junit.jupiter.api.io.TempDir +import java.nio.file.Path import java.util.zip.ZipFile +import kotlin.io.path.* import kotlin.test.* -class KotlinGradleIT : BaseGradleIT() { +@DisplayName("Basic Kotlin/JVM plugin tests") +@JvmGradlePluginTests +class KotlinGradleIT : KGPBaseTest() { - private fun defaultOptionsWithReports() = defaultBuildOptions().copy(withReports = listOf(BuildReportType.FILE)) - - @Test - fun testCrossCompile() { - val project = Project("kotlinJavaProject") - - project.build("compileDeployKotlin", "build") { - assertSuccessful() - assertReportExists() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin", ":compileDeployKotlin") - } - - project.build("compileDeployKotlin", "build") { - assertSuccessful() - assertTasksUpToDate( - ":compileKotlin", - ":compileTestKotlin", - ":compileDeployKotlin", - ":compileJava" - ) - } - } - - @Test - fun testRunningInDifferentDir() { - val wd0 = workingDir - val wd1 = File(wd0, "subdir").apply { mkdirs() } - workingDir = wd1 - val project1 = Project("kotlinJavaProject") - - project1.build("assemble") { - assertSuccessful() - } - - val wd2 = createTempDir("testRunningInDifferentDir") - wd1.copyRecursively(wd2) - wd1.deleteRecursively() - if (wd1.exists()) { - val files = buildString { - wd1.walk().forEach { appendLine(" " + it.relativeTo(wd1).path) } + @DisplayName("Kotlin/Java cross compilation") + @GradleTest + fun testCrossCompile(gradleVersion: GradleVersion) { + project("kotlinJavaProject", gradleVersion) { + build("compileDeployKotlin", "build") { + assertTasksExecuted( + ":compileKotlin", + ":compileTestKotlin", + ":compileDeployKotlin" + ) } - error("Some files in $wd1 were not removed:\n$files") - } - wd0.setWritable(false) - workingDir = wd2 - project1.build("test") { - assertSuccessful() - } - } - - @Test - fun testKotlinOnlyCompile() { - val project = Project("kotlinProject") - - project.build("build") { - assertSuccessful() - assertFileExists(kotlinClassesDir() + "META-INF/kotlinProject.kotlin_module") - assertReportExists() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin") - assertNotContains("Forcing System.gc") - } - - project.build("build") { - assertSuccessful() - assertTasksUpToDate(":compileKotlin", ":compileTestKotlin") - } - } - - @Test - fun testKotlinCompileInFolderWithSpaces() { - val project = Project(projectName = "Project Path With Spaces") - - project.build("build") { - assertSuccessful() - assertReportExists() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin") - assertNotContains("Forcing System.gc") - } - } - - @Test - fun testLogLevelForceGC() { - val debugProject = Project("simpleProject", minLogLevel = LogLevel.LIFECYCLE) - debugProject.build("build", "-Dkotlin.gradle.test.report.memory.usage=true") { - assertContains("Forcing System.gc()") - } - - val infoProject = Project("simpleProject", minLogLevel = LogLevel.QUIET) - infoProject.build("clean", "build", "-Dkotlin.gradle.test.report.memory.usage=true") { - assertNotContains("Forcing System.gc()") - } - } - - @Test - fun testKotlinClasspath() { - Project("classpathTest").build("build") { - assertSuccessful() - assertReportExists() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin") - } - } - - @Test - fun testMultiprojectPluginClasspath() { - Project("multiprojectClassPathTest").build("build") { - assertSuccessful() - assertReportExists("subproject") - assertTasksExecuted(":subproject:compileKotlin", ":subproject:compileTestKotlin") - checkKotlinGradleBuildServices() - } - } - - @Test - fun testIncremental() { - val project = Project("kotlinProject") - val options = defaultBuildOptions().copy(incremental = true) - - project.build("build", options = options) { - assertSuccessful() - assertNoWarnings() - } - - val greeterKt = project.projectDir.getFileByName("Greeter.kt") - greeterKt.modify { - it.replace("greeting: String", "greeting: CharSequence") - } - - project.build("build", options = options) { - assertSuccessful() - assertNoWarnings() - val affectedSources = project.projectDir.getFilesByNames( - "Greeter.kt", "KotlinGreetingJoiner.kt", - "TestGreeter.kt", "TestKotlinGreetingJoiner.kt" - ) - assertCompiledKotlinSources(project.relativize(affectedSources)) - } - } - - @Test - fun testIncrementalFir() { - val project = Project("kotlinProject") - val options = defaultBuildOptions().copy(incremental = true, useFir = true) - - project.build("build", options = options) { - assertSuccessful() - assertNoWarnings { removeFirWarning(it) } - } - - val greeterKt = project.projectDir.getFileByName("Greeter.kt") - greeterKt.modify { - it.replace("greeting: String", "greeting: CharSequence") - } - - project.build("build", options = options) { - assertSuccessful() - assertNoWarnings { removeFirWarning(it) } - val affectedSources = project.projectDir.getFilesByNames( - "Greeter.kt", "KotlinGreetingJoiner.kt", - "TestGreeter.kt", "TestKotlinGreetingJoiner.kt" - ) - assertCompiledKotlinSources(project.relativize(affectedSources)) - } - } - - private fun removeFirWarning(output: String): String { - return output.replace( - """ - |w: ATTENTION! - | This build uses in-dev FIR: - | -Xuse-fir - """.trimMargin().replace("\n", SYSTEM_LINE_SEPARATOR), "" - ) - } - - @Test - fun testManyClassesIC() { - val project = Project("manyClasses") - val options = defaultBuildOptions().copy(incremental = true) - - project.setupWorkingDir() - val classesKt = project.projectFile("classes.kt") - classesKt.writeText((0..1024).joinToString("\n") { "class Class$it { fun f() = $it }" }) - - project.build("build", options = options) { - assertSuccessful() - assertNoWarnings() - } - - val dummyKt = project.projectFile("dummy.kt") - dummyKt.modify { "$it " } - project.build("build", options = options) { - assertSuccessful() - assertCompiledKotlinSources(project.relativize(dummyKt)) - } - } - - @Test - fun testSimpleMultiprojectIncremental() { - val incremental = defaultBuildOptions().copy(incremental = true) - - Project("multiprojectWithDependency").build("assemble", options = incremental) { - assertSuccessful() - assertReportExists("projA") - assertReportExists("projB") - assertTasksExecuted(":projA:compileKotlin", ":projB:compileKotlin") - } - Project("multiprojectWithDependency").apply { - val oldSrc = File(this.projectDir, "projA/src/main/kotlin/a.kt") - val newSrc = File(this.projectDir, "projA/src/main/kotlin/a.kt.new") - assertTrue { oldSrc.exists() } - assertTrue { newSrc.exists() } - newSrc.copyTo(oldSrc, overwrite = true) - }.build("assemble", options = incremental) { - assertSuccessful() - assertReportExists("projA") - assertReportExists("projB") - assertTasksExecuted(":projA:compileKotlin", ":projB:compileKotlin") - } - } - - @Test - fun testIncrementalPropertyFromLocalPropertiesFile() { - val project = Project("kotlinProject") - project.setupWorkingDir() - - val localPropertyFile = File(project.projectDir, "local.properties") - localPropertyFile.writeText("kotlin.incremental=true") - - project.build("build") { - assertContains(USING_JVM_INCREMENTAL_COMPILATION_MESSAGE) - } - } - - @Test - fun testIncrementalCompilationLogLevel() { - val infoProject = Project("kotlinProject", minLogLevel = LogLevel.INFO) - infoProject.build("build") { - assertContains(USING_JVM_INCREMENTAL_COMPILATION_MESSAGE) - } - - val lifecycleProject = Project("kotlinProject", minLogLevel = LogLevel.LIFECYCLE) - lifecycleProject.build("build") { - assertNotContains(USING_JVM_INCREMENTAL_COMPILATION_MESSAGE) - } - } - - @Test - fun testConvertJavaToKotlin() { - val project = Project("convertBetweenJavaAndKotlin") - project.setupWorkingDir() - - val barKt = project.projectDir.getFileByName("Bar.kt") - val barKtContent = barKt.readText() - barKt.delete() - - project.build("build") { - assertSuccessful() - } - - val barClass = project.projectDir.getFileByName("Bar.class") - val barClassTimestamp = barClass.lastModified() - - val barJava = project.projectDir.getFileByName("Bar.java") - barJava.delete() - barKt.writeText(barKtContent) - - project.build("build") { - assertSuccessful() - assertNotContains(":compileKotlin UP-TO-DATE", ":compileJava UP-TO-DATE") - assertNotEquals(barClassTimestamp, barClass.lastModified(), "Bar.class timestamp hasn't been updated") - } - } - - @Test - fun testMoveClassToOtherModule() { - val project = Project("moveClassToOtherModule") - - project.build("build") { - assertSuccessful() - assertContains("Connected to daemon") - } - - project.performModifications() - project.build("build") { - assertSuccessful() - assertContains("Connected to daemon") - } - } - - @Test - fun testTypeAliasIncremental() { - val project = Project("typeAlias") - val options = defaultBuildOptions().copy(incremental = true) - - project.build("build", options = options) { - assertSuccessful() - } - - val curryKt = project.projectDir.getFileByName("Curry.kt") - val useCurryKt = project.projectDir.getFileByName("UseCurry.kt") - - curryKt.modify { - it.replace("class Curry", "internal class Curry") - } - - project.build("build", options = options) { - assertSuccessful() - assertCompiledKotlinSources(project.relativize(curryKt, useCurryKt)) - } - } - - @Test - fun testKotlinBuiltins() { - val project = Project("kotlinBuiltins") - - project.build("build") { - assertSuccessful() - } - } - - @Test - fun testFreeCompilerArgs() { - val project = Project("kotlinProject") - project.setupWorkingDir() - - val customModuleName = "custom_module_name" - - File(project.projectDir, "build.gradle").modify { - it + """ - compileKotlin { - kotlinOptions.freeCompilerArgs = [ "-module-name", "$customModuleName" ] - }""" - } - - project.build("build") { - assertSuccessful() - assertFileExists(kotlinClassesDir() + "META-INF/$customModuleName.kotlin_module") - } - } - - @Test - fun testDowngradePluginVersion() { - val project = Project("kotlinProject") - val options = defaultBuildOptions().copy(incremental = true, withDaemon = false) - - project.build("assemble", options = options) { - assertSuccessful() - } - - project.build("clean", "assemble", options = options.copy(kotlinVersion = TestVersions.Kotlin.STABLE_RELEASE)) { - assertSuccessful() - } - } - - @Test - fun testOmittedStdlibVersion() { - val project = Project("kotlinProject") - project.setupWorkingDir() - File(project.projectDir, "build.gradle").modify { - """ - $it - - plugins.apply('maven-publish') - - group = "com.example" - version = "1.0" - - publishing { - publications { - myLibrary(MavenPublication) { - from components.kotlin - } - } - repositories { - maven { - url = "${'$'}buildDir/repo" - } - } + build("compileDeployKotlin", "build") { + assertTasksUpToDate( + ":compileKotlin", + ":compileTestKotlin", + ":compileDeployKotlin", + ":compileJava" + ) } - """.trimIndent() - } - - project.build( - "build", - "publishAllPublicationsToMavenRepository", - options = defaultBuildOptions().copy(warningMode = WarningMode.Summary) - ) { - assertSuccessful() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin") - val pomLines = File(project.projectDir, "build/publications/myLibrary/pom-default.xml").readLines() - val stdlibVersionLineNumber = pomLines.indexOfFirst { "kotlin-stdlib-jdk8" in it } + 1 - val versionLine = pomLines[stdlibVersionLineNumber] - assertTrue { "${defaultBuildOptions().kotlinVersion}" in versionLine } } } - @Test - fun testCleanAfterIncrementalBuild() { - val project = Project("kotlinProject") - val options = defaultBuildOptions().copy(incremental = true) + @DisplayName("Kotlin only project compilation") + @GradleTest + fun testKotlinOnlyCompile(gradleVersion: GradleVersion) { + project("kotlinProject", gradleVersion) { + build("build") { + assertFileExists(kotlinClassesDir().resolve("META-INF/kotlinProject.kotlin_module")) + assertTasksExecuted(":compileKotlin", ":compileTestKotlin") + assertOutputDoesNotContain("Forcing System.gc") + } - project.build("build", "clean", options = options) { - assertSuccessful() + build("build") { + assertTasksUpToDate( + ":compileKotlin", + ":compileTestKotlin" + ) + } } } - @Test - fun testIncrementalTestCompile() { - val project = Project("kotlinProject") - val options = defaultBuildOptions().copy(incremental = true) - - project.build("build", options = options) { - assertSuccessful() - } - - val joinerKt = project.projectDir.getFileByName("KotlinGreetingJoiner.kt") - joinerKt.modify { - it.replace("class KotlinGreetingJoiner", "internal class KotlinGreetingJoiner") - } - - project.build("build", options = options) { - assertSuccessful() - val testJoinerKt = project.projectDir.getFileByName("TestKotlinGreetingJoiner.kt") - assertCompiledKotlinSources(project.relativize(joinerKt, testJoinerKt)) + @DisplayName("Project path contains spaces") + @GradleTest + fun testKotlinCompileInFolderWithSpaces(gradleVersion: GradleVersion) { + project(projectName = "Project Path With Spaces", gradleVersion) { + build("build") { + assertTasksExecuted(":compileKotlin", ":compileTestKotlin") + assertOutputDoesNotContain("Forcing System.gc") + } } } - @Test - fun testIncrementalFirTestCompile() { - val project = Project("kotlinProject") - val options = defaultBuildOptions().copy(incremental = true, useFir = true) - - project.build("build", options = options) { - assertSuccessful() - } - - val joinerKt = project.projectDir.getFileByName("KotlinGreetingJoiner.kt") - joinerKt.modify { - it.replace("class KotlinGreetingJoiner", "internal class KotlinGreetingJoiner") - } - - project.build("build", options = options) { - assertSuccessful() - val testJoinerKt = project.projectDir.getFileByName("TestKotlinGreetingJoiner.kt") - assertCompiledKotlinSources(project.relativize(joinerKt, testJoinerKt)) + @DisplayName("Logs contain memory usage entries on LIFECYCLE log level") + @GradleTest + fun testLogLevelForceGC(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + build( + "assemble", + "-Dkotlin.gradle.test.report.memory.usage=true", + buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.LIFECYCLE) + ) { + assertOutputContains("Forcing System.gc()") + } + build( + "clean", + "assemble", + "-Dkotlin.gradle.test.report.memory.usage=true", + buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.QUIET) + ) { + assertOutputDoesNotContain("Forcing System.gc()") + } } } - @Test - fun testLanguageVersionApiVersionExplicit() { - val project = Project("kotlinProject") - project.setupWorkingDir() + @DisplayName("Plugin is avialble when applied via buildscript classpath") + @GradleTest + fun testMultiprojectPluginClasspath(gradleVersion: GradleVersion) { + project("multiprojectClassPathTest", gradleVersion) { + build("build") { + assertTasksExecuted( + ":subproject:compileKotlin", + ":subproject:compileTestKotlin" + ) + } + } + } - val buildGradle = File(project.projectDir, "build.gradle") - val buildGradleContentCopy = buildGradle.readText() + @DisplayName("Incremental logs are available on INFO log level") + @GradleTest + fun testIncrementalCompilationLogLevel(gradleVersion: GradleVersion) { + project("kotlinProject", gradleVersion) { + build( + "assemble", + buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.INFO) + ) { + assertOutputContains(USING_JVM_INCREMENTAL_COMPILATION_MESSAGE) + } - fun updateBuildGradle(langVersion: String, apiVersion: String) { - buildGradle.writeText( + build( + "assemble", + buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.LIFECYCLE) + ) { + assertOutputDoesNotContain(USING_JVM_INCREMENTAL_COMPILATION_MESSAGE) + } + } + } + + @DisplayName("Conversion between Kotlin and Java") + @GradleTest + fun testConvertJavaToKotlin(gradleVersion: GradleVersion) { + project("convertBetweenJavaAndKotlin", gradleVersion) { + val barKt = javaSourcesDir().resolve("foo/Bar.kt") + val barKtContent = barKt.readText() + barKt.deleteIfExists() + + build("build") + + val barClass = kotlinClassesDir().resolve("foo/Bar.class").toFile() + val barClassTimestamp = barClass.lastModified() + + val barJava = javaSourcesDir().resolve("foo/Bar.java") + barJava.deleteIfExists() + barKt.writeText(barKtContent) + + build("build") { + assertTasksExecuted(":compileKotlin", ":compileJava") + assertNotEquals( + barClassTimestamp, + barClass.lastModified(), + "Bar.class timestamp hasn't been updated" + ) + } + } + } + + @DisplayName("Moving class to another Gradle subproject") + @GradleTest + fun testMoveClassToOtherModule(gradleVersion: GradleVersion) { + project("moveClassToOtherModule", gradleVersion) { + build("assemble") + + with(subProject("lib").javaSourcesDir()) { + resolve("bar/A.kt.new").moveTo(resolve("bar/A.kt")) + } + with(subProject("app").javaSourcesDir()) { + resolve("foo/A.kt").deleteIfExists() + resolve("foo/useA.kt.new") + .moveTo(resolve("foo/useA.kt"), overwrite = true) + } + + build("assemble") + } + } + + @DisplayName("Adding free compiler arguments") + @GradleTest + fun testFreeCompilerArgs(gradleVersion: GradleVersion) { + project("kotlinProject", gradleVersion) { + val customModuleName = "custom_module_name" + + buildGradle.appendText( + //language=Groovy """ - $buildGradleContentCopy - + compileKotlin { - kotlinOptions { - languageVersion = '$langVersion' - apiVersion = '$apiVersion' - } + kotlinOptions.freeCompilerArgs = [ "-module-name", "$customModuleName" ] } - """.trimIndent() + """.trimIndent() ) - } - assert(buildGradleContentCopy.indexOf("languageVersion") < 0) { "build.gradle should not contain 'languageVersion'" } - assert(buildGradleContentCopy.indexOf("apiVersion") < 0) { "build.gradle should not contain 'apiVersion'" } - - // check the arguments are not passed by default (they are inferred by the compiler) - project.build("clean", "compileKotlin") { - assertSuccessful() - assertNotContains("-language-version") - assertNotContains("-api-version") - assertNoWarnings() - } - - // check the arguments are always passed if specified explicitly - updateBuildGradle("1.4", "1.4") - project.build("clean", "compileKotlin") { - assertSuccessful() - assertContains("-language-version 1.4") - assertContains("-api-version 1.4") - } - - updateBuildGradle("1.5", "1.5") - project.build("clean", "compileKotlin") { - assertSuccessful() - assertContains("-language-version 1.5") - assertContains("-api-version 1.5") + build("build") { + assertFileExists(kotlinClassesDir().resolve("META-INF/$customModuleName.kotlin_module")) + } } } - @Test - fun testSeparateOutputGradle40() { - val project = Project("kotlinJavaProject") - project.build("compileDeployKotlin", "assemble") { - assertSuccessful() - - // Check that the Kotlin classes are placed under directories following the guideline: - assertFileExists(kotlinClassesDir() + "demo/KotlinGreetingJoiner.class") - assertFileExists(kotlinClassesDir(sourceSet = "deploy") + "demo/ExampleSource.class") - - // Check that the resulting JAR contains the Kotlin classes, without duplicates: - val jar = ZipFile(fileInWorkingDir("build/libs/${project.projectName}.jar")) - assertEquals(1, jar.entries().asSequence().count { it.name == "demo/KotlinGreetingJoiner.class" }) - - // Check that the Java output is intact: - assertFileExists("build/classes/java/main/demo/Greeter.class") - } - } - - @Test - fun testArchiveBaseNameForModuleName() { - val project = Project("simpleProject") - project.setupWorkingDir() - - val archivesBaseName = "myArchivesBaseName" - - val buildGradle = File(project.projectDir, "build.gradle") - buildGradle.appendText("\narchivesBaseName = '$archivesBaseName'") - - // Add top-level members to force generation of the *.kotlin_module files for the two source sets - val mainHelloWorldKt = File(project.projectDir, "src/main/kotlin/helloWorld.kt") - mainHelloWorldKt.appendText("\nfun topLevelFun() = 1") - val deployKotlinSrcKt = File(project.projectDir, "src/deploy/kotlin/kotlinSrc.kt") - deployKotlinSrcKt.appendText("\nfun topLevelFun() = 1") - - project.build("build", "deployClasses") { - assertSuccessful() - // Main source set should have a *.kotlin_module file without '_main' - assertFileExists(kotlinClassesDir() + "META-INF/$archivesBaseName.kotlin_module") - assertFileExists(kotlinClassesDir(sourceSet = "deploy") + "META-INF/${archivesBaseName}_deploy.kotlin_module") - } - } - - @Test - fun testJavaPackagePrefix() { - val project = Project("javaPackagePrefix") - project.build("build") { - assertSuccessful() - - // Check that the Java source in a non-full-depth package structure was located correctly: - checkBytecodeContains( - File(project.projectDir, kotlinClassesDir() + "my/pack/name/app/MyApp.class"), - "my/pack/name/util/JUtil.util" + @DisplayName("Downgrading Kotlin plugin version") + @GradleTest + fun testDowngradePluginVersion(gradleVersion: GradleVersion) { + project( + "kotlinProject", + gradleVersion, + buildOptions = defaultBuildOptions.copy(incremental = true) + ) { + build("assemble") + build( + "clean", + "assemble", + buildOptions = buildOptions.copy( + kotlinVersion = TestVersions.Kotlin.STABLE_RELEASE + ) ) } } - @Test - fun testSrcDirTaskDependency() { - Project("simpleProject").apply { - setupWorkingDir() - File(projectDir, "build.gradle").appendText( - """${'\n'} - task generateSources { + @DisplayName("Passing api/language version") + @GradleTest + fun testLanguageVersionApiVersionExplicit(gradleVersion: GradleVersion) { + project( + "kotlinProject", + gradleVersion, + buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG) + ) { + val buildGradleContentCopy = buildGradle.readText() + + fun updateBuildGradle(langVersion: String, apiVersion: String) { + buildGradle.writeText( + //language=Groovy + """ + $buildGradleContentCopy + + compileKotlin { + kotlinOptions { + languageVersion = '$langVersion' + apiVersion = '$apiVersion' + } + } + """.trimIndent() + ) + } + + assert(buildGradleContentCopy.indexOf("languageVersion") < 0) { "build.gradle should not contain 'languageVersion'" } + assert(buildGradleContentCopy.indexOf("apiVersion") < 0) { "build.gradle should not contain 'apiVersion'" } + + // check the arguments are not passed by default (they are inferred by the compiler) + build("clean", "compileKotlin") { + assertOutputDoesNotContain("-language-version") + assertOutputDoesNotContain("-api-version") + assertNoBuildWarnings() + } + + // check the arguments are always passed if specified explicitly + updateBuildGradle("1.6", "1.6") + build("clean", "compileKotlin") { + assertOutputContains("-language-version 1.6") + assertOutputContains("-api-version 1.6") + } + + updateBuildGradle("1.7", "1.7") + build("clean", "compileKotlin") { + assertOutputContains("-language-version 1.7") + assertOutputContains("-api-version 1.7") + } + } + } + + @DisplayName("Mixed project with additional sourceset produce outputs in correct dirs") + @GradleTest + fun testSeparateOutputGradle40(gradleVersion: GradleVersion) { + project("kotlinJavaProject", gradleVersion) { + build("compileDeployKotlin", "assemble") { + // Check that the Kotlin classes are placed under directories following the guideline: + assertFileExists(kotlinClassesDir().resolve("demo/KotlinGreetingJoiner.class")) + assertFileExists(kotlinClassesDir(sourceSet = "deploy").resolve("demo/ExampleSource.class")) + + // Check that the resulting JAR contains the Kotlin classes, without duplicates: + ZipFile(projectPath.resolve("build/libs/$projectName.jar").toFile()).use { jar -> + assertEquals( + 1, + jar.entries().asSequence().count { it.name == "demo/KotlinGreetingJoiner.class" } + ) + } + + + // Check that the Java output is intact: + assertFileInProjectExists("build/classes/java/main/demo/Greeter.class") + } + } + } + + @DisplayName("archivesBaseName is used for module name") + @GradleTest + fun testArchiveBaseNameForModuleName(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + val archivesBaseName = "myArchivesBaseName" + buildGradle.appendText("\narchivesBaseName = '$archivesBaseName'") + + // Add top-level members to force generation of the *.kotlin_module files for the two source sets + val mainHelloWorldKt = kotlinSourcesDir().resolve("helloWorld.kt") + mainHelloWorldKt.appendText("\nfun topLevelFun() = 1") + val deployKotlinSrcKt = kotlinSourcesDir(sourceSet = "deploy").resolve("kotlinSrc.kt") + deployKotlinSrcKt.appendText("\nfun topLevelFun() = 1") + + build("build", "deployClasses") { + // Main source set should have a *.kotlin_module file without '_main' + assertFileExists(kotlinClassesDir().resolve("META-INF/$archivesBaseName.kotlin_module")) + assertFileExists(kotlinClassesDir(sourceSet = "deploy").resolve("META-INF/${archivesBaseName}_deploy.kotlin_module")) + } + } + } + + @DisplayName("'javaPackagePrefix' change is applied") + @GradleTest + fun testJavaPackagePrefix(gradleVersion: GradleVersion) { + project("javaPackagePrefix", gradleVersion) { + build("build") { + // Check that the Java source in a non-full-depth package structure was located correctly: + checkBytecodeContains( + kotlinClassesDir().resolve("my/pack/name/app/MyApp.class").toFile(), + "my/pack/name/util/JUtil.util" + ) + } + } + } + + @DisplayName("Should add generated sources from task dependency") + @Disabled("Not working as expected") + @GradleTest + fun testSrcDirTaskDependency(gradleVersion: GradleVersion) { + project( + "simpleProject", + gradleVersion + ) { + buildGradle.appendText( + """ + + def generateTask = tasks.register('generateSources') { outputs.dir('generated') doLast { def file = new File('generated/test/TestClass.java') file.parentFile.mkdirs() file.text = ""${'"'} package test; - + public class TestClass { } ""${'"'} } } - sourceSets.main.java.srcDir(tasks.generateSources) + sourceSets.main.java.srcDir(generateTask) """.trimIndent() ) - File(projectDir, "src/main/kotlin/helloWorld.kt").appendText( - """${'\n'} + kotlinSourcesDir().resolve("helloWorld.kt").appendText( + """ + fun usageOfGeneratedSource() = test.TestClass() """.trimIndent() ) - build("build") { - assertSuccessful() - } + build("build") } } - @Test - fun testSourceJar() { - Project("simpleProject").apply { - setupWorkingDir() + @DisplayName("Sources jar include Kotlin files") + @GradleTest + fun testSourceJar(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { val additionalSrcDir = "src/additional/kotlin/" - File(projectDir, additionalSrcDir).mkdirs() - File(projectDir, "$additionalSrcDir/additionalSource.kt").writeText("fun hello() = 123") + with(projectPath.resolve(additionalSrcDir)) { + createDirectories() + resolve("additionalSource.kt").writeText("fun hello() = 123") + } - File(projectDir, "build.gradle").appendText( - """${'\n'} + buildGradle.appendText( + """ + task sourcesJar(type: Jar) { from sourceSets.main.allSource classifier 'source' @@ -650,702 +406,361 @@ class KotlinGradleIT : BaseGradleIT() { ) build("sourcesJar") { - assertSuccessful() - val sourcesJar = ZipFile(File(projectDir, "build/libs/simpleProject-source.jar")) - assertNotNull(sourcesJar.getEntry("additionalSource.kt")) - } - } - } - - @Test - fun testNoUnnamedInputsOutputs() { - - val projects = listOf( - Project("simpleProject"), - Project("kotlin2JsProject"), - Project("multiplatformProject"), - Project("simple", directoryPrefix = "kapt2") - ) - - projects.forEach { - it.apply { - // Enable caching to make sure Gradle reports the task inputs/outputs during key construction: - val options = defaultBuildOptions().copy(withBuildCache = true) - build("assemble", options = options) { - // Check that all inputs/outputs added at runtime have proper names - // (the unnamed ones are listed as $1, $2 etc.): - assertNotContains("Appending inputPropertyHash for '\\$\\d+'".toRegex()) - assertNotContains("Appending outputPropertyName to build cache key: \\$\\d+".toRegex()) + ZipFile(projectPath.resolve("build/libs/simpleProject-source.jar").toFile()).use { + assertNotNull(it.getEntry("additionalSource.kt")) } } } } - @Test - fun testModuleNameFiltering() = with(Project("typeAlias")) { // Use a Project with a top-level typealias - setupWorkingDir() + @DisplayName("Handling special characters in Kotlin module name") + @GradleTest + fun testModuleNameFiltering(gradleVersion: GradleVersion) { + project("typeAlias", gradleVersion) { // Use a Project with a top-level typealias + buildGradle.appendText( + """ + + archivesBaseName = 'a/really\\tricky\n\rmodule\tname' + """.trimIndent() + ) - gradleBuildScript().appendText("\n" + """archivesBaseName = 'a/really\\tricky\n\rmodule\tname'""") - build("classes") { - assertSuccessful() - - val metaInfDir = File(projectDir, kotlinClassesDir() + "META-INF") - assertNotNull(metaInfDir.listFiles().singleOrNull { it.name.endsWith(".kotlin_module") }) - } - } - - @Test - fun testJavaIcCompatibility() { - val project = Project("kotlinJavaProject") - project.setupWorkingDir() - - val buildScript = File(project.projectDir, "build.gradle") - - buildScript.modify { "$it\n" + "compileJava.options.incremental = true" } - project.build("build") { - assertSuccessful() - } - - // Then modify a Java source and check that compileJava is incremental: - File(project.projectDir, "src/main/java/demo/HelloWorld.java").modify { "$it\n" + "class NewClass { }" } - project.build("build") { - assertSuccessful() - assertContains("Incremental compilation") - assertNotContains("not incremental") - } - - // Then modify a Kotlin source and check that Gradle sees that Java is not up-to-date: - File(project.projectDir, "src/main/kotlin/helloWorld.kt").modify { - it.trim('\r', '\n').trimEnd('}') + "\nval z: Int = 0 }" - } - project.build("build") { - assertSuccessful() - assertTasksExecuted(":compileKotlin", ":compileJava") - assertNotContains("not incremental") - assertNotContains("None of the classes needs to be compiled!") - } - } - - @Test - fun testApplyPluginFromBuildSrc() { - val project = Project("kotlinProjectWithBuildSrc") - project.setupWorkingDir() - File(project.projectDir, "buildSrc/build.gradle").modify { it.replace("\$kotlin_version", KOTLIN_VERSION) } - project.build("build") { - assertSuccessful() - } - } - - @Test - fun testKotlinPluginDependenciesInBuildSrc() { - val project = transformProjectWithPluginsDsl("kotlinPluginDepsInBuildSrc") - project.setupWorkingDir() - project.build("build") { - assertSuccessful() - assertContains("Hi from BuildSrc") - } - - } - - @Test - fun testInternalTest() = with( - Project("internalTest") - ) { - build("build") { - assertSuccessful() - assertReportExists() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin") - } - - // Check KT-35341: use symlinked build dir - val buildDir = projectDir.resolve("build") - buildDir.deleteRecursively() - val externalBuildDir = Files.createTempDirectory(workingDir.toPath(), "externalBuild") - try { - Files.createSymbolicLink(buildDir.toPath(), externalBuildDir) - } catch (_: FileSystemException) { - //Windows requires SeSymbolicLink privilege and we can't grant it - null - } ?: return@with - - build("build") { - assertSuccessful() - assertReportExists() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin") - } - } - - @Test - fun testJavaLibraryCompatibility() { - val project = Project("javaLibraryProject") - - val compileKotlinTasks = listOf(":libA:compileKotlin", ":libB:compileKotlin", ":app:compileKotlin") - project.build("build") { - assertSuccessful() - assertNotContains("Could not register Kotlin output") - assertTasksExecuted(compileKotlinTasks) - } - - // Modify a library source and its usage and re-build the project: - for (path in listOf("libA/src/main/kotlin/HelloA.kt", "libB/src/main/kotlin/HelloB.kt", "app/src/main/kotlin/App.kt")) { - File(project.projectDir, path).modify { original -> - original.replace("helloA", "helloA1") - .replace("helloB", "helloB1") - .apply { assert(!equals(original)) } + build("classes") { + val metaInfDir = kotlinClassesDir().resolve("META-INF").toFile() + assertNotNull( + metaInfDir.listFiles()?.singleOrNull { + it.name.endsWith(".kotlin_module") + } + ) } } + } - project.build("build") { - assertSuccessful() - assertNotContains("Could not register Kotlin output") - assertTasksExecuted(compileKotlinTasks) + @DisplayName("Plugin from buildSrc dependencies is available") + @GradleTest + fun testApplyPluginFromBuildSrc(gradleVersion: GradleVersion) { + project("kotlinProjectWithBuildSrc", gradleVersion) { + settingsGradle.writeText( + //language=Groovy + """ + pluginManagement { + repositories { + mavenLocal() + gradlePluginPortal() + } + + plugins { + id "org.jetbrains.kotlin.test.fixes.android" version "${'$'}test_fixes_version" + } + } + """.trimIndent() + ) + build("build") } } - @Test - fun testKotlinSourceInJavaSourceSet() = with(Project("multiplatformProject")) { - setupWorkingDir() + @DisplayName("KGP dependencies in buildSrc module") + @GradleTest + fun testKotlinPluginDependenciesInBuildSrc(gradleVersion: GradleVersion) { + project("kotlinPluginDepsInBuildSrc", gradleVersion) { + build("build") { + assertOutputContains("Hi from BuildSrc") + } + } + } - val srcDirPrefix = "srcDir: " + @DisplayName("Test sources should be able to access internal methods or properties") + @GradleTest + fun testInternalTest(gradleVersion: GradleVersion) { + project("internalTest", gradleVersion) { + build("build") { + assertTasksExecuted(":compileKotlin", ":compileTestKotlin") + } + } + } - gradleBuildScript().appendText( - "\n" + """ - subprojects { project -> - project.afterEvaluate { - project.sourceSets.each { sourceSet -> - sourceSet.allJava.srcDirs.each { srcDir -> - println "$srcDirPrefix" + srcDir.canonicalPath + @DisplayName("KT-35341: symlinked build dir") + @DisabledOnOs(OS.WINDOWS, disabledReason = "Windows requires SeSymbolicLink privilege and we can't grant it") + @GradleTest + fun symlinkedBuildDir( + gradleVersion: GradleVersion, + @TempDir tempDir: Path + ) { + project("internalTest", gradleVersion) { + val externalBuildDir = tempDir.resolve("externalBuild") + externalBuildDir.createSymbolicLinkPointingTo(projectPath.resolve("build")) + + build("build") { + assertTasksExecuted(":compileKotlin", ":compileTestKotlin") + } + } + } + + @DisplayName("'java-library' plugin compatibility") + @GradleTest + fun testJavaLibraryCompatibility(gradleVersion: GradleVersion) { + project("javaLibraryProject", gradleVersion) { + val compileKotlinTasks = arrayOf(":libA:compileKotlin", ":libB:compileKotlin", ":app:compileKotlin") + build("build") { + assertTasksExecuted(*compileKotlinTasks) + assertOutputDoesNotContain("Could not register Kotlin output") + } + + // Modify a library source and its usage and re-build the project: + listOf( + subProject("libA").kotlinSourcesDir().resolve("HelloA.kt"), + subProject("libB").kotlinSourcesDir().resolve("HelloB.kt"), + subProject("app").kotlinSourcesDir().resolve("App.kt") + ).forEach { sourceFile -> + sourceFile.modify { + it.replace("helloA", "helloA1") + .replace("helloB", "helloB1") + } + } + + build("build") { + assertOutputDoesNotContain("Could not register Kotlin output") + assertTasksExecuted(*compileKotlinTasks) + } + } + } + + @DisplayName("Kotlin source directories are available in Java source directories") + @GradleTest + fun testKotlinSourceInJavaSourceSet(gradleVersion: GradleVersion) { + project("multiplatformProject", gradleVersion) { + val srcDirPrefix = "srcDir: " + + buildGradle.appendText( + """ + + subprojects { project -> + project.afterEvaluate { + project.sourceSets.each { sourceSet -> + sourceSet.allJava.srcDirs.each { srcDir -> + println "$srcDirPrefix" + srcDir.canonicalPath + } } } } - } - """.trimIndent() - ) - val srcDirRegex = "$srcDirPrefix(.*)".toRegex() - - build("help") { - assertSuccessful() - val reportedSrcDirs = srcDirRegex.findAll(output).map { it.groupValues[1] }.toSet() - - val expectedKotlinDirs = listOf("lib", "libJvm", "libJs").flatMap { module -> - listOf("main", "test").map { sourceSet -> - projectDir.resolve("$module/src/$sourceSet/kotlin").absolutePath - } - } - - expectedKotlinDirs.forEach { assertTrue(it in reportedSrcDirs, "$it should be included into the Java source sets") } - } - } - - @Test - fun testDefaultKotlinVersionIsNotAffectedByTransitiveDependencies() = - with(Project("simpleProject")) { - setupWorkingDir() - // Add a dependency with an explicit lower Kotlin version that has a kotlin-stdlib transitive dependency: - gradleBuildScript().appendText("\ndependencies { implementation 'org.jetbrains.kotlin:kotlin-reflect:1.2.71' }") - testResolveAllConfigurations { - assertSuccessful() - assertContains(">> :compileClasspath --> kotlin-reflect-1.2.71.jar") - // Check that the default newer Kotlin version still wins for 'kotlin-stdlib': - assertContains(">> :compileClasspath --> kotlin-stdlib-${defaultBuildOptions().kotlinVersion}.jar") - } - } - - @Test - fun testKotlinJvmProjectPublishesKotlinApiDependenciesAsCompile() = - with(Project("simpleProject")) { - setupWorkingDir() - gradleBuildScript().appendText( - "\n" + """ - dependencies { - api 'org.jetbrains.kotlin:kotlin-reflect' - } - apply plugin: 'maven-publish' - group "com.example" - version "1.0" - publishing { - repositories { maven { url file("${'$'}buildDir/repo").toURI() } } - publications { maven(MavenPublication) { from components.java } } - } """.trimIndent() ) - build("publish") { - assertSuccessful() - val pomText = projectDir.resolve("build/repo/com/example/simpleProject/1.0/simpleProject-1.0.pom").readText() - .replace("\\s+|\\n".toRegex(), "") - assertTrue { - pomText.contains( - "org.jetbrains.kotlin" + - "kotlin-reflect" + - "${defaultBuildOptions().kotlinVersion}" + - "compile" - ) - } - } - } + val srcDirRegex = "$srcDirPrefix(.*)".toRegex() - @Test - fun testNoTaskConfigurationForcing() { - val projects = listOf( - Project("simpleProject"), - Project("kotlin2JsNoOutputFileProject"), - Project("sample-app", GradleVersionRequired.FOR_MPP_SUPPORT, "new-mpp-lib-and-app") - ) + build("help") { + val reportedSrcDirs = srcDirRegex.findAll(output).map { it.groupValues[1] }.toSet() - projects.forEach { - it.apply { - setupWorkingDir() - - val taskConfigureFlag = "Configured the task!" - - gradleBuildScript().appendText("\n" + """ - tasks.register("myTask") { println '$taskConfigureFlag' } - """.trimIndent()) - - build("help") { - assertSuccessful() - assertNotContains(taskConfigureFlag) - } - } - } - } - - @Test - fun testBuildReportSmokeTest() = with(Project("simpleProject"), ) { - build("assemble", options = defaultOptionsWithReports()) { - assertSuccessful() - assertContains("Kotlin build report is written to") - } - - build("clean", "assemble", options = defaultOptionsWithReports()) { - assertSuccessful() - assertContains("Kotlin build report is written to") - } - } - - @Test - fun testBuildReportOutputProperty() = with(Project("simpleProject"), ) { - build("assemble", "-Pkotlin.build.report.output=file,invalid") { - assertFailed() - assertContains("Unknown output type:") - } - - } - - @Test - fun testBuildMetricsSmokeTest() = with(Project("simpleProject")) { - build("assemble", options = defaultOptionsWithReports()) { - assertSuccessful() - assertContains("Kotlin build report is written to") - } - val reportFolder = projectDir.resolve("build/reports/kotlin-build") - val reports = reportFolder.listFiles() - assertNotNull(reports) - assertEquals(1, reports.size) - val report = reports[0].readText() - - //Should contains build metrics for all compile kotlin tasks - assertTrue { report.contains("Time metrics:") } - assertTrue { report.contains("Run compilation:") } - assertTrue { report.contains("Incremental compilation in daemon:") } - assertTrue { report.contains("Build performance metrics:") } - assertTrue { report.contains("Total size of the cache directory:") } - assertTrue { report.contains("Total compiler iteration:") } - assertTrue { report.contains("ABI snapshot size:") } - //for non-incremental builds - assertTrue { report.contains("Build attributes:") } - assertTrue { report.contains("REBUILD_REASON:") } - } - - @Test - fun testCompilerBuildMetricsSmokeTest() = with(Project("simpleProject")) { - build("assemble", options = defaultOptionsWithReports()) { - assertSuccessful() - assertContains("Kotlin build report is written to") - } - val reportFolder = projectDir.resolve("build/reports/kotlin-build") - val reports = reportFolder.listFiles() - assertNotNull(reports) - assertEquals(1, reports.size) - val report = reports[0].readText() - assertTrue { report.contains("Compiler code analysis:") } - assertTrue { report.contains("Compiler code generation:") } - assertTrue { report.contains("Compiler initialization time:") } - } - - @Test - fun testSingleBuildMetricsFileSmoke() { - with(Project("simpleProject")) { - val metricsFile = projectDir.resolve("metrics.bin") - assertFalse { metricsFile.exists() } - build("compileKotlin", "-Pkotlin.internal.single.build.metrics.file=${metricsFile.absolutePath}") { - assertSuccessful() - } - assertTrue { metricsFile.exists() } - // test whether we can deserialize data from the file - ObjectInputStream(metricsFile.inputStream().buffered()).use { input -> - input.readObject() as GradleBuildMetricsData - } - } - } - - @Test - fun testKt29971() = with(Project("kt-29971", GradleVersionRequired.FOR_MPP_SUPPORT)) { - build("jvm-app:build") { - assertSuccessful() - assertTasksExecuted(":jvm-app:compileKotlin") - } - } - - @Test - fun testDetectingDifferentClassLoaders() = with(Project("differentClassloaders", GradleVersionRequired.FOR_MPP_SUPPORT)) { - setupWorkingDir() - - val originalRootBuildScript = gradleBuildScript().readText() - gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl) - - build("publish", "-PmppProjectDependency=true") { - assertSuccessful() - assertNotContains(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) - assertNotContains(MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING) - } - - // Specify the plugin versions in the subprojects with different plugin sets – this will make Gradle use separate class loaders - gradleBuildScript().modify { - originalRootBuildScript.checkedReplace("id \"org.jetbrains.kotlin.multiplatform\"", "//") - } - gradleBuildScript("mpp-lib").modify { - it.checkedReplace( - "id \"org.jetbrains.kotlin.multiplatform\"", - "id \"org.jetbrains.kotlin.multiplatform\" version \"\"" - ).let(::transformBuildScriptWithPluginsDsl) - } - gradleBuildScript("jvm-app").modify { - it.checkedReplace( - "id \"org.jetbrains.kotlin.jvm\"", - "id \"org.jetbrains.kotlin.jvm\" version \"\"" - ).let(::transformBuildScriptWithPluginsDsl) - } - gradleBuildScript("js-app").modify { - it.checkedReplace( - "id \"kotlin2js\"", - "id \"kotlin2js\" version \"\"" - ).let(::transformBuildScriptWithPluginsDsl) - } - - // Also include another project via a composite build: - transformProjectWithPluginsDsl("allopenPluginsDsl", directoryPrefix = "pluginsDsl").let { other -> - val result = other.projectName - other.setupWorkingDir() - other.projectDir.copyRecursively(projectDir.resolve(result)) - gradleSettingsScript().appendText("\nincludeBuild(\"${result}\")") - gradleBuildScript().appendText( - "\ntasks.create(\"publish\").dependsOn(gradle.includedBuild(\"${result}\").task(\":assemble\"))" - ) - result - } - - build("publish", "-PmppProjectDependency=true") { - assertFailed() - assertContains(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) - } - - //https://youtrack.jetbrains.com/issue/KT-50598 - val withoutDaemon= defaultBuildOptions().copy(withDaemon = false) - - build("-PmppProjectDependency=true", options = withoutDaemon) { - assertSuccessful() - assertContains(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) - - val specificProjectsReported = Regex("$MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING((?:'.*'(?:, )?)+)") - .find(output)!!.groupValues[1].split(", ").map { it.removeSurrounding("'") }.toSet() - - assertEquals(setOf(":mpp-lib", ":jvm-app", ":js-app"), specificProjectsReported) - } - - // Test the flag that turns off the warnings - build("-PmppProjectDependency=true", "-Pkotlin.pluginLoadedInMultipleProjects.ignore=true", options = withoutDaemon) { - assertSuccessful() - assertNotContains(MULTIPLE_KOTLIN_PLUGINS_LOADED_WARNING) - assertNotContains(MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJECTS_WARNING) - } - } - - @Test - fun testNewModelInOldJvmPlugin() = with(Project("new-model-in-old-plugin")) { - setupWorkingDir() - gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl) - - build("publish", "check", "runBenchmark", options = defaultBuildOptions().copy(warningMode = WarningMode.Summary)) { - assertSuccessful() - assertTasksExecuted(":compileKotlin", ":compileTestKotlin", ":compileBenchmarkKotlin", ":test", ":runBenchmark") - - // Find the benchmark output: - assertContains("f ran at the speed of light") - - val moduleDir = "build/repo/com/example/new-model/1.0/" - - val publishedJar = fileInWorkingDir(moduleDir + "new-model-1.0.jar") - ZipFile(publishedJar).use { zip -> - val entries = zip.entries().asSequence().map { it.name } - assertTrue { "com/example/A.class" in entries } - } - - val publishedPom = fileInWorkingDir(moduleDir + "new-model-1.0.pom") - val kotlinVersion = defaultBuildOptions().kotlinVersion - val pomText = publishedPom.readText().replace(Regex("\\s+"), "") - assertTrue { "kotlin-gradle-plugin-api$kotlinVersioncompile" in pomText } - assertTrue { "kotlin-stdlib-jdk8$kotlinVersionruntime" in pomText } - - assertFileExists(moduleDir + "new-model-1.0-sources.jar") - } - } - - @Test - fun testUserDefinedAttributesInSinglePlatformProject() = - with(Project("multiprojectWithDependency")) { - setupWorkingDir() - gradleBuildScript("projA").appendText( - "\n" + """ - def targetAttribute = Attribute.of("com.example.target", String) - def compilationAttribute = Attribute.of("com.example.compilation", String) - kotlin.target.attributes.attribute(targetAttribute, "foo") - kotlin.target.compilations["main"].attributes.attribute(compilationAttribute, "foo") - """.trimIndent() - ) - gradleBuildScript("projB").appendText( - "\n" + """ - def targetAttribute = Attribute.of("com.example.target", String) - def compilationAttribute = Attribute.of("com.example.compilation", String) - kotlin.target.attributes.attribute(targetAttribute, "foo") - kotlin.target.compilations["main"].attributes.attribute(compilationAttribute, "foo") - """.trimIndent() - ) - build(":projB:compileKotlin") { - assertSuccessful() - } - - val projectGradleVersion = GradleVersion.version(chooseWrapperVersionOrFinishTest()) - // Break dependency resolution by providing incompatible custom attributes in the target: - gradleBuildScript("projB").appendText("\nkotlin.target.attributes.attribute(targetAttribute, \"bar\")") - build(":projB:compileKotlin") { - assertFailed() - when { - projectGradleVersion < GradleVersion.version("6.4") -> { - assertContains("Required com.example.target 'bar'") + val expectedKotlinDirs = listOf("lib", "libJvm", "libJs").flatMap { module -> + listOf("main", "test").map { sourceSet -> + projectPath.resolve("$module/src/$sourceSet/kotlin").toFile().absolutePath } - projectGradleVersion < GradleVersion.version("6.8.4") -> { - assertContains( + } + + expectedKotlinDirs.forEach { assertTrue(it in reportedSrcDirs, "$it should be included into the Java source sets") } + } + } + } + + @DisplayName("Default Kotlin version is not affected by transitive dependencies") + @GradleTest + fun testDefaultKotlinVersionIsNotAffectedByTransitiveDependencies(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + // Add a dependency with an explicit lower Kotlin version that has a kotlin-stdlib transitive dependency: + buildGradle.appendText("\ndependencies { implementation 'org.jetbrains.kotlin:kotlin-reflect:1.5.32' }") + testResolveAllConfigurations { unresolvedConfigurations, buildResult -> + assertTrue("Unresolved configurations: $unresolvedConfigurations") { unresolvedConfigurations.isEmpty() } + buildResult.assertOutputContains(">> :compileClasspath --> kotlin-reflect-1.5.32.jar") + // Check that the default newer Kotlin version still wins for 'kotlin-stdlib': + buildResult.assertOutputContains( + ">> :compileClasspath --> kotlin-stdlib-${buildOptions.kotlinVersion}.jar" + ) + } + } + } + + @DisplayName("KT-29971: concurrent modification exception on task execution") + @GradleTest + fun concurrentModificationException(gradleVersion: GradleVersion) { + project("kt-29971", gradleVersion) { + build("jvm-app:build") { + assertTasksExecuted(":jvm-app:compileKotlin") + } + } + } + + @DisplayName("New extensions models are working as expected") + @GradleTest + fun testNewModelInOldJvmPlugin(gradleVersion: GradleVersion) { + project( + "new-model-in-old-plugin", + gradleVersion + ) { + build( + "publish", + "check", + "runBenchmark" + ) { + assertTasksExecuted( + ":compileKotlin", + ":compileTestKotlin", + ":compileBenchmarkKotlin", + ":test", + ":runBenchmark" + ) + + // Find the benchmark output: + assertOutputContains("f ran at the speed of light") + + val moduleDir = projectPath.resolve("build/repo/com/example/new-model/1.0/") + + val publishedJar = moduleDir.resolve("new-model-1.0.jar") + ZipFile(publishedJar.toFile()).use { zip -> + val entries = zip.entries().asSequence().map { it.name } + assertTrue { "com/example/A.class" in entries } + } + + val publishedPom = moduleDir.resolve("new-model-1.0.pom") + val kotlinVersion = buildOptions.kotlinVersion + val pomText = publishedPom.readText().replace(Regex("\\s+"), "") + assertTrue { "kotlin-gradle-plugin-api$kotlinVersioncompile" in pomText } + assertTrue { "kotlin-stdlib-jdk8$kotlinVersionruntime" in pomText } + + assertFileExists(moduleDir.resolve("new-model-1.0-sources.jar")) + } + } + } + + @DisplayName("User-defined attributes") + @GradleTest + fun testUserDefinedAttributesInSinglePlatformProject(gradleVersion: GradleVersion) { + project("multiprojectWithDependency", gradleVersion) { + subProject("projA").buildGradle.appendText( + """ + + def targetAttribute = Attribute.of("com.example.target", String) + def compilationAttribute = Attribute.of("com.example.compilation", String) + kotlin.target.attributes.attribute(targetAttribute, "foo") + kotlin.target.compilations["main"].attributes.attribute(compilationAttribute, "foo") + """.trimIndent() + ) + subProject("projB").buildGradle.appendText( + """ + + def targetAttribute = Attribute.of("com.example.target", String) + def compilationAttribute = Attribute.of("com.example.compilation", String) + kotlin.target.attributes.attribute(targetAttribute, "foo") + kotlin.target.compilations["main"].attributes.attribute(compilationAttribute, "foo") + """.trimIndent() + ) + + build(":projB:compileKotlin") + + // Break dependency resolution by providing incompatible custom attributes in the target: + subProject("projB").buildGradle.appendText("\nkotlin.target.attributes.attribute(targetAttribute, \"bar\")") + buildAndFail(":projB:compileKotlin") { + when { + gradleVersion < GradleVersion.version("6.8.4") -> { + assertOutputContains( "No matching variant of project :projA was found. The consumer was configured to find an API of a library " + - "compatible with Java 8, preferably in the form of class files, " + - "and its dependencies declared externally, " + - "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + - "attribute 'com.example.compilation' with value 'foo', " + - "attribute 'com.example.target' with value 'bar' but:" + "compatible with Java 8, preferably in the form of class files, " + + "and its dependencies declared externally, " + + "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + + "attribute 'com.example.compilation' with value 'foo', " + + "attribute 'com.example.target' with value 'bar' but:" ) } else -> { - assertContains( + assertOutputContains( "No matching variant of project :projA was found. The consumer was configured to find an API of a library " + - "compatible with Java 8, preferably in the form of class files, " + - "preferably optimized for standard JVMs, and its dependencies declared externally, " + - "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + - "attribute 'com.example.compilation' with value 'foo', " + - "attribute 'com.example.target' with value 'bar' but:" + "compatible with Java 8, preferably in the form of class files, " + + "preferably optimized for standard JVMs, and its dependencies declared externally, " + + "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + + "attribute 'com.example.compilation' with value 'foo', " + + "attribute 'com.example.target' with value 'bar' but:" ) } } } // And using the compilation attributes (fix the target attributes first): - gradleBuildScript("projB").appendText( - "\n" + """ + subProject("projB").buildGradle.appendText( + """ + kotlin.target.attributes.attribute(targetAttribute, "foo") kotlin.target.compilations["main"].attributes.attribute(compilationAttribute, "bar") """.trimIndent() ) - build(":projB:compileKotlin") { - assertFailed() + buildAndFail(":projB:compileKotlin") { when { - projectGradleVersion < GradleVersion.version("6.4") -> { - assertContains("Required com.example.compilation 'bar'") - } - projectGradleVersion < GradleVersion.version("6.8.4") -> { - assertContains( + gradleVersion < GradleVersion.version("6.8.4") -> { + assertOutputContains( "No matching variant of project :projA was found. The consumer was configured to find an API of a library " + - "compatible with Java 8, preferably in the form of class files, and its dependencies declared externally, " + - "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + - "attribute 'com.example.compilation' with value 'bar', " + - "attribute 'com.example.target' with value 'foo' but:" + "compatible with Java 8, preferably in the form of class files, and its dependencies declared externally, " + + "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + + "attribute 'com.example.compilation' with value 'bar', " + + "attribute 'com.example.target' with value 'foo' but:" ) } else -> { - assertContains( + assertOutputContains( "No matching variant of project :projA was found. The consumer was configured to find an API of a library " + - "compatible with Java 8, preferably in the form of class files, preferably optimized for standard JVMs, " + - "and its dependencies declared externally, " + - "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + - "attribute 'com.example.compilation' with value 'bar', " + - "attribute 'com.example.target' with value 'foo' but:" + "compatible with Java 8, preferably in the form of class files, preferably optimized for standard JVMs, " + + "and its dependencies declared externally, " + + "as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm', " + + "attribute 'com.example.compilation' with value 'bar', " + + "attribute 'com.example.target' with value 'foo' but:" ) } } } } + } - @Test - fun testLoadCompilerEmbeddableAfterOtherKotlinArtifacts() = with(Project("simpleProjectClasspath")) { - setupWorkingDir() - val buildscriptClasspathPrefix = "buildscript-classpath = " - gradleBuildScript() - .appendText( + @DisplayName("Load compiler-embeddable after other plugin artifacts") + @GradleTest + fun testLoadCompilerEmbeddableAfterOtherKotlinArtifacts(gradleVersion: GradleVersion) { + project("simpleProjectClasspath", gradleVersion) { + val buildscriptClasspathPrefix = "buildscript-classpath = " + buildGradle.appendText( """ - + println "$buildscriptClasspathPrefix" + Arrays.toString(buildscript.classLoader.getURLs()) """.trimIndent() ) - // get the classpath, then reorder it so that kotlin-compiler-embeddable is loaded after all other JARs - lateinit var classpath: List + // get the classpath, then reorder it so that kotlin-compiler-embeddable is loaded after all other JARs + lateinit var classpath: List - build { - val classpathLine = output.lines().single { buildscriptClasspathPrefix in it } - classpath = classpathLine.substringAfter(buildscriptClasspathPrefix).removeSurrounding("[", "]").split(", ") - } - - gradleBuildScript().modify { - val reorderedClasspath = run { - val (kotlinCompilerEmbeddable, others) = classpath.partition { "kotlin-compiler-embeddable" in it } - others + kotlinCompilerEmbeddable + build("help") { + val classpathLine = output.lines().single { buildscriptClasspathPrefix in it } + classpath = classpathLine + .substringAfter(buildscriptClasspathPrefix) + .removeSurrounding("[", "]") + .split(", ") } - val newClasspathString = "classpath files(\n" + reorderedClasspath.joinToString(",\n") { "'$it'" } + "\n)" - it.checkedReplace("classpath \"org.jetbrains.kotlin:kotlin-gradle-plugin:${'$'}kotlin_version\"", newClasspathString) - } - build("compileKotlin") { - assertSuccessful() - } - } + buildGradle.modify { + val reorderedClasspath = run { + val (kotlinCompilerEmbeddable, others) = classpath.partition { "kotlin-compiler-embeddable" in it } + others + kotlinCompilerEmbeddable + } + val newClasspathString = "classpath files(\n" + reorderedClasspath.joinToString(",\n") { "'$it'" } + "\n)" + it.checkedReplace("classpath \"org.jetbrains.kotlin:kotlin-gradle-plugin:${'$'}kotlin_version\"", newClasspathString) + } - @Test - fun testNoScriptingWarning() = with(Project("simpleProject")) { - // KT-31124 - build { - assertNotContains(ScriptingGradleSubplugin.MISCONFIGURATION_MESSAGE_SUFFIX) - } - } - - @Test - fun testKtKt35942InternalsFromMainInTestViaTransitiveDeps() = with(Project("kt-35942-jvm", GradleVersionRequired.FOR_MPP_SUPPORT)) { - build(":lib1:compileTestKotlin") { - assertSuccessful() - assertTasksExecuted(":lib1:compileKotlin", ":lib2:jar") - } - } - - @Test - fun testKtKt35942InternalsFromMainInTestViaTransitiveDepsAndroid() = with( - Project( - projectName = "kt-35942-android" - ) - ) { - build( - ":lib1:compileDebugUnitTestKotlin", - options = defaultBuildOptions().copy( - androidGradlePluginVersion = AGPVersion.v4_2_0, - androidHome = KtTestUtil.findAndroidSdk().also { acceptAndroidSdkLicenses(it) }, - ), - ) { - assertSuccessful() - assertTasksExecuted(":lib1:compileDebugKotlin") - } - } - - /** Regression test for KT-38692. */ - @Test - fun testIncrementalWhenNoKotlinSources() = with( - Project("kotlinProject") - ) { - setupWorkingDir() - assertTrue(this.allKotlinFiles.toList().isNotEmpty()) - build(":compileKotlin") { - assertSuccessful() - assertTasksExecuted(":compileKotlin") - } - - // Remove all Kotlin sources and force non-incremental run - allKotlinFiles.forEach { assertTrue(it.delete()) } - projectDir.resolve("src/main/java/Sample.java").also { - it.parentFile.mkdirs() - it.writeText("public class Sample {}") - } - build("compileKotlin", "--rerun-tasks") { - assertSuccessful() - assertTasksExecuted(":compileKotlin") - val compiledKotlinClasses = fileInWorkingDir(classesDir()).allFilesWithExtension("class").toList() - - assertTrue(compiledKotlinClasses.isEmpty()) + build("compileKotlin") } } /** Regression test for KT-45787. **/ - @Test - fun testPluginDoesNotUseDeprecatedConfigurationsForAssociatedDependencies() { - with( - Project( - projectName = "associatedDependencies", - minLogLevel = LogLevel.INFO - ) + @DisplayName("KT-45787: no Gradle deprecation on adding associated dependencies") + @GradleTest + fun testNoDeprecationOnAssociatedDep(gradleVersion: GradleVersion) { + project( + "associatedDependencies", + gradleVersion, + buildOptions = defaultBuildOptions.copy(warningMode = WarningMode.Fail) ) { - setupWorkingDir() - - build( - "tasks", - options = defaultBuildOptions().copy(warningMode = WarningMode.Fail) - ) { - assertSuccessful() - } - } - } - - @Test - fun testEarlyConfigurationsResolutionKotlin() = testEarlyConfigurationsResolution("kotlinProject", kts = false) - - @Test - fun testEarlyConfigurationsResolutionKotlinJs() = testEarlyConfigurationsResolution("kotlin-js-browser-project", kts = true) - - private fun testEarlyConfigurationsResolution(projectName: String, kts: Boolean) = with(Project(projectName = projectName)) { - setupWorkingDir() - gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl) - //language=Gradle - gradleBuildScript().appendText( - """${'\n'} - // KT-45834 start - ${if (kts) "var" else "def"} ready = false - gradle.taskGraph.whenReady { - println("Task Graph Ready") - ready = true - } - - allprojects { - configurations.forEach { configuration -> - configuration.incoming.beforeResolve { - println("Resolving ${'$'}configuration") - if (!ready) { - throw ${if (kts) "" else "new"} GradleException("${'$'}configuration is being resolved at configuration time") - } - } - } - } - // KT-45834 end - """.trimIndent() - ) - - build( - "assemble", - options = defaultBuildOptions().copy(dryRun = true) - ) { - assertSuccessful() + build("tasks") } } } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/MultiplatformGradleIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/MultiplatformGradleIT.kt index 810e2c51579..9305c75bcaa 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/MultiplatformGradleIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/MultiplatformGradleIT.kt @@ -23,8 +23,10 @@ import org.jetbrains.kotlin.gradle.internals.KOTLIN_12X_MPP_DEPRECATION_WARNING import org.jetbrains.kotlin.gradle.plugin.EXPECTED_BY_CONFIG_NAME import org.jetbrains.kotlin.gradle.plugin.IMPLEMENT_CONFIG_NAME import org.jetbrains.kotlin.gradle.plugin.IMPLEMENT_DEPRECATION_WARNING +import org.jetbrains.kotlin.gradle.util.AGPVersion import org.jetbrains.kotlin.gradle.util.getFileByName import org.jetbrains.kotlin.gradle.util.modify +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import java.io.File import kotlin.test.assertTrue @@ -347,4 +349,30 @@ class MultiplatformGradleIT : BaseGradleIT() { assertNotContains("no duplicate handling strategy has been set") } } + + @Test + fun testKtKt35942InternalsFromMainInTestViaTransitiveDeps() = with(Project("kt-35942-jvm", GradleVersionRequired.FOR_MPP_SUPPORT)) { + build(":lib1:compileTestKotlin") { + assertSuccessful() + assertTasksExecuted(":lib1:compileKotlin", ":lib2:jar") + } + } + + @Test + fun testKtKt35942InternalsFromMainInTestViaTransitiveDepsAndroid() = with( + Project( + projectName = "kt-35942-android" + ) + ) { + build( + ":lib1:compileDebugUnitTestKotlin", + options = defaultBuildOptions().copy( + androidGradlePluginVersion = AGPVersion.v4_2_0, + androidHome = KtTestUtil.findAndroidSdk().also { acceptAndroidSdkLicenses(it) }, + ), + ) { + assertSuccessful() + assertTasksExecuted(":lib1:compileDebugKotlin") + } + } } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/PublishingIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/PublishingIT.kt index ecab110e6ad..ea7f3ea3b7a 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/PublishingIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/PublishingIT.kt @@ -8,6 +8,10 @@ package org.jetbrains.kotlin.gradle import org.gradle.util.GradleVersion import org.jetbrains.kotlin.gradle.testbase.* import org.junit.jupiter.api.DisplayName +import kotlin.io.path.appendText +import kotlin.io.path.readLines +import kotlin.io.path.readText +import kotlin.test.assertTrue @DisplayName("Artifacts publication") @JvmGradlePluginTests @@ -22,4 +26,85 @@ class PublishingIT : KGPBaseTest() { build("publishToMavenLocal") } } + + @DisplayName("Publishes Kotlin api dependencies as compile") + @GradleTest + fun testKotlinJvmProjectPublishesKotlinApiDependenciesAsCompile(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + buildGradle.appendText( + //language=Groovy + """ + + dependencies { + api 'org.jetbrains.kotlin:kotlin-reflect' + } + + plugins.apply('maven-publish') + + group "com.example" + version "1.0" + publishing { + repositories { maven { url file("${'$'}buildDir/repo").toURI() } } + publications { maven(MavenPublication) { from components.java } } + } + """.trimIndent() + ) + + build("publish") { + val pomText = projectPath + .resolve("build/repo/com/example/simpleProject/1.0/simpleProject-1.0.pom") + .readText() + .replace("\\s+|\\n".toRegex(), "") + assertTrue { + pomText.contains( + "org.jetbrains.kotlin" + + "kotlin-reflect" + + "${buildOptions.kotlinVersion}" + + "compile" + ) + } + } + } + } + + @DisplayName("Publishing includes stdlib version") + @GradleTest + fun testOmittedStdlibVersion(gradleVersion: GradleVersion) { + project("kotlinProject", gradleVersion) { + buildGradle.appendText( + //language=Groovy + """ + + plugins.apply('maven-publish') + + group = "com.example" + version = "1.0" + + publishing { + publications { + myLibrary(MavenPublication) { + from components.kotlin + } + } + repositories { + maven { + url = "${'$'}buildDir/repo" + } + } + } + """.trimIndent() + ) + + build( + "build", + "publishAllPublicationsToMavenRepository", + ) { + assertTasksExecuted(":compileKotlin", ":compileTestKotlin") + val pomLines = projectPath.resolve("build/publications/myLibrary/pom-default.xml").readLines() + val stdlibVersionLineNumber = pomLines.indexOfFirst { "kotlin-stdlib-jdk8" in it } + 1 + val versionLine = pomLines[stdlibVersionLineNumber] + assertTrue { "${buildOptions.kotlinVersion}" in versionLine } + } + } + } } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ScriptingIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ScriptingIT.kt index 4681581cf36..4c6dd21c4f5 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ScriptingIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ScriptingIT.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.gradle import org.gradle.api.logging.LogLevel import org.gradle.util.GradleVersion +import org.jetbrains.kotlin.gradle.scripting.internal.ScriptingGradleSubplugin import org.jetbrains.kotlin.gradle.testbase.* import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.condition.DisabledOnOs @@ -97,4 +98,15 @@ class ScriptingIT : KGPBaseTest() { } } } + + @DisplayName("KT-31124: No scripting warning") + @GradleTest + fun testNoScriptingWarning(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + build("help") { + assertOutputDoesNotContain(ScriptingGradleSubplugin.MISCONFIGURATION_MESSAGE_SUFFIX) + } + } + } + } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/UnnamedTaskInputsIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/UnnamedTaskInputsIT.kt new file mode 100644 index 00000000000..40dec4a00c2 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/UnnamedTaskInputsIT.kt @@ -0,0 +1,92 @@ +/* + * Copyright 2010-2022 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.gradle + +import org.gradle.testkit.runner.BuildResult +import org.gradle.util.GradleVersion +import org.jetbrains.kotlin.gradle.testbase.* +import org.junit.jupiter.api.DisplayName + +@DisplayName("Tasks don't have unnamed inputs and outputs") +class UnnamedTaskInputsIT : KGPBaseTest() { + + override val defaultBuildOptions: BuildOptions + get() = super.defaultBuildOptions.copy(buildCacheEnabled = true) + + private val localBuildCacheDir get() = workingDir.resolve("custom-jdk-build-cache-2") + + @JvmGradlePluginTests + @DisplayName("JVM") + @GradleTest + fun inputsJvm(gradleVersion: GradleVersion) { + project("simpleProject", gradleVersion) { + enableLocalBuildCache(localBuildCacheDir) + + build("assemble") { + assertNoUnnamedInputsOutputs() + } + } + } + + @JsGradlePluginTests + @DisplayName("JS - kotlin2js plugin") + @GradleTest + fun inputsKotlin2Js(gradleVersion: GradleVersion) { + project("kotlin2JsProject", gradleVersion) { + enableLocalBuildCache(localBuildCacheDir) + + build("assemble") { + assertNoUnnamedInputsOutputs() + } + } + } + + @JsGradlePluginTests + @DisplayName("JS") + @GradleTest + fun inputsJs(gradleVersion: GradleVersion) { + project("kotlin-js-nodejs-project", gradleVersion) { + enableLocalBuildCache(localBuildCacheDir) + + build("assemble") { + assertNoUnnamedInputsOutputs() + } + } + } + + @MppGradlePluginTests + @DisplayName("MPP") + @GradleTest + fun inputsMpp(gradleVersion: GradleVersion) { + project("multiplatformProject", gradleVersion) { + enableLocalBuildCache(localBuildCacheDir) + + build("assemble") { + assertNoUnnamedInputsOutputs() + } + } + } + + @OtherGradlePluginTests + @DisplayName("Kapt") + @GradleTest + fun inputsKapt(gradleVersion: GradleVersion) { + project("kapt2/simple", gradleVersion) { + enableLocalBuildCache(localBuildCacheDir) + + build("assemble") { + assertNoUnnamedInputsOutputs() + } + } + } + + private fun BuildResult.assertNoUnnamedInputsOutputs() { + // Check that all inputs/outputs added at runtime have proper names + // (the unnamed ones are listed as $1, $2 etc.): + assertOutputDoesNotContain("Appending inputPropertyHash for '\\$\\d+'".toRegex()) + assertOutputDoesNotContain("Appending outputPropertyName to build cache key: \\$\\d+".toRegex()) + } +} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/Project Path With Spaces/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/Project Path With Spaces/build.gradle index 7d140d98fe3..96f923ba4c2 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/Project Path With Spaces/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/Project Path With Spaces/build.gradle @@ -1,15 +1,7 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "org.jetbrains.kotlin.jvm" } -apply plugin: "kotlin" - repositories { mavenLocal() mavenCentral() @@ -18,7 +10,6 @@ repositories { dependencies { implementation 'com.google.guava:guava:12.0' testImplementation 'org.testng:testng:6.8' - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" } test { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/build.gradle deleted file mode 100644 index d2f1da10d9e..00000000000 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/build.gradle +++ /dev/null @@ -1,26 +0,0 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } -} - -apply plugin: "kotlin" - -repositories { - mavenLocal() - mavenCentral() -} - -dependencies { - implementation 'com.google.guava:guava:12.0' - testImplementation 'org.testng:testng:6.8' - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" -} - -test { - useTestNG() -} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/main/kotlin/helloWorld.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/main/kotlin/helloWorld.kt deleted file mode 100644 index f1e2b0d1f91..00000000000 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/main/kotlin/helloWorld.kt +++ /dev/null @@ -1,18 +0,0 @@ -package demo - -import sun.nio.cs.ext.Big5 -import sun.net.spi.nameservice.dns.DNSNameService -import javax.crypto.Cipher -import com.sun.crypto.provider.SunJCE -import sun.nio.ByteBuffered - -fun box(): String { - val a = Big5() // charsets.jar - val c = DNSNameService() // dnsns.ajr - val e : Cipher? = null // jce.jar - val f : SunJCE? = null // sunjce_provider.jar - val j : ByteBuffered? = null // rt.jar - return "OK" -} - - diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/test/kotlin/tests.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/test/kotlin/tests.kt deleted file mode 100644 index 6e9eb5e69b8..00000000000 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/classpathTest/src/test/kotlin/tests.kt +++ /dev/null @@ -1,11 +0,0 @@ -package demo - -import org.testng.Assert.* -import org.testng.annotations.Test as test - -class TestSource() { - @test fun f() { - assertEquals(box(), "OK") - } -} - diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/build.gradle index 16abee31975..3afe5fec0df 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/build.gradle @@ -1,25 +1,13 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "java" + id "org.jetbrains.kotlin.jvm" } -apply plugin: "java" -apply plugin: "kotlin" - repositories { mavenLocal() mavenCentral() } -dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" -} - compileJava { options.incremental = true } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/gradle.properties b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/gradle.properties deleted file mode 100644 index 93ce6a94e63..00000000000 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/convertBetweenJavaAndKotlin/gradle.properties +++ /dev/null @@ -1 +0,0 @@ -org.gradle.jvmargs=-Xmx1024m -XX:MaxPermSize=512m \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/differentClassloaders/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/differentClassloaders/build.gradle index d2b1003ab16..2619257cc7d 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/differentClassloaders/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/differentClassloaders/build.gradle @@ -1,5 +1,5 @@ plugins { - id "org.jetbrains.kotlin.multiplatform" version "" apply false + id "org.jetbrains.kotlin.multiplatform" apply false } allprojects { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/internalTest/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/internalTest/build.gradle index add556d4541..9969484b68e 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/internalTest/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/internalTest/build.gradle @@ -1,15 +1,7 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "org.jetbrains.kotlin.jvm" } -apply plugin: "kotlin" - repositories { mavenLocal() @@ -18,7 +10,6 @@ repositories { dependencies { testImplementation 'org.testng:testng:6.8' - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" } test { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/app/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/app/build.gradle index 4751de79db8..9ffdfba9453 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/app/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/app/build.gradle @@ -1,7 +1,8 @@ -apply plugin: 'java' -apply plugin: 'kotlin' +plugins { + id "java" + id "org.jetbrains.kotlin.jvm" +} dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" implementation project(':libB') } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/build.gradle index f37b00da1c9..56aea34f419 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/build.gradle @@ -1,13 +1,3 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } -} - subprojects { repositories { mavenLocal() diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libA/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libA/build.gradle index 0f32c18d089..173061e7b4e 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libA/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libA/build.gradle @@ -1,5 +1,7 @@ -apply plugin: 'java-library' -apply plugin: 'kotlin' +plugins { + id "java-library" + id "org.jetbrains.kotlin.jvm" +} dependencies { api "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libB/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libB/build.gradle index 6068d8085c8..a82bd723e7c 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libB/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaLibraryProject/libB/build.gradle @@ -1,5 +1,7 @@ -apply plugin: 'java-library' -apply plugin: 'kotlin' +plugins { + id "java-library" + id "org.jetbrains.kotlin.jvm" +} dependencies { api "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaPackagePrefix/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaPackagePrefix/build.gradle index 44aa27fa00b..3e57257502e 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaPackagePrefix/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/javaPackagePrefix/build.gradle @@ -1,23 +1,11 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "java" + id "org.jetbrains.kotlin.jvm" } -apply plugin: 'java' -apply plugin: 'kotlin' - repositories { mavenLocal() mavenCentral() } -dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" -} - compileKotlin.javaPackagePrefix = "my.pack.name" \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin-js-browser-project/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin-js-browser-project/build.gradle.kts index 83a117202ec..877c415742c 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin-js-browser-project/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin-js-browser-project/build.gradle.kts @@ -1,5 +1,5 @@ plugins { - kotlin("js").version("").apply(false) + kotlin("js").apply(false) } group = "com.example" diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin2JsNoOutputFileProject/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin2JsNoOutputFileProject/build.gradle index 60ce4bbed01..8e0de6e44ee 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin2JsNoOutputFileProject/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlin2JsNoOutputFileProject/build.gradle @@ -1,15 +1,7 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "kotlin2js" } -apply plugin: "kotlin2js" - repositories { mavenLocal() mavenCentral() diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/classes.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/classes.kt index 78a93a022b6..58b55a82788 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/classes.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/classes.kt @@ -1,3 +1,8 @@ +/* + * Copyright 2010-2022 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 foo class A diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/main.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/main.kt index 2984dc942e6..65f6766d04d 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/main.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinBuiltins/app/src/main/kotlin/main.kt @@ -1,3 +1,8 @@ +/* + * Copyright 2010-2022 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 foo fun main() { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinJavaProject/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinJavaProject/build.gradle index 8b674103187..cdc6babe2d5 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinJavaProject/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinJavaProject/build.gradle @@ -1,16 +1,8 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id 'java' + id 'org.jetbrains.kotlin.jvm' } -apply plugin: "kotlin" -apply plugin: "java" - sourceSets { deploy } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/build.gradle.kts index 4c9f3bc74ab..e1664b4ebfc 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/build.gradle.kts @@ -1,7 +1,7 @@ import foo.bar.configureFromBuildSrc plugins { - kotlin("jvm") version "" + kotlin("jvm") } kotlin { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/build.gradle.kts index b98834a7730..cf99370df67 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/build.gradle.kts @@ -1,5 +1,5 @@ plugins { - kotlin("jvm") version "" + kotlin("jvm") } repositories { @@ -7,8 +7,9 @@ repositories { mavenLocal() } +val kotlin_version: String by extra allprojects { dependencies { - implementation("org.jetbrains.kotlin:kotlin-gradle-plugin-api:") + implementation("org.jetbrains.kotlin:kotlin-gradle-plugin-api:$kotlin_version") } } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/settings.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/settings.gradle.kts index 0415904e20c..2bd5bf8e2c7 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/settings.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kotlinPluginDepsInBuildSrc/buildSrc/settings.gradle.kts @@ -5,7 +5,9 @@ pluginManagement { } val test_fixes_version: String by settings + val kotlin_version: String by settings plugins { id("org.jetbrains.kotlin.test.fixes.android") version test_fixes_version + id("org.jetbrains.kotlin.jvm") version kotlin_version } } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/build.gradle index 9940f2d973d..106ff4160cf 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/build.gradle @@ -1,13 +1,3 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } -} - allprojects { repositories { mavenLocal() diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/jvm-app/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/jvm-app/build.gradle index e4ce4dc88de..59118915544 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/jvm-app/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/jvm-app/build.gradle @@ -4,7 +4,3 @@ plugins { group = "com.example.jvm" version = "1.0" - -dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" -} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/mpp-lib/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/mpp-lib/build.gradle index 10db9ae526c..b5b3c4bf85f 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/mpp-lib/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kt-29971/mpp-lib/build.gradle @@ -20,5 +20,5 @@ kotlin { } // While this plugin seems not to do anything in this setup, IT IS needed to reproduce KT-29971 -apply plugin: "application" +plugins.apply("application") mainClassName = "foo" \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/build.gradle index db36830d9d1..e9e2f2c15ed 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/build.gradle @@ -1,6 +1,7 @@ -apply plugin: 'kotlin' +plugins { + id "org.jetbrains.kotlin.jvm" +} dependencies { implementation project(':lib') - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/src/main/java/foo/A.kt.delete b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/app/src/main/java/foo/A.kt.delete deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/build.gradle index f37b00da1c9..db9e7e35d46 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/build.gradle @@ -1,11 +1,5 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "org.jetbrains.kotlin.jvm" apply false } subprojects { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/lib/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/lib/build.gradle index 83e41992508..546933fb729 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/lib/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/moveClassToOtherModule/lib/build.gradle @@ -1,5 +1,3 @@ -apply plugin: 'kotlin' - -dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" +plugins { + id "org.jetbrains.kotlin.jvm" } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectClassPathTest/subproject/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectClassPathTest/subproject/build.gradle index 7004b107968..4fbec931ab6 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectClassPathTest/subproject/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectClassPathTest/subproject/build.gradle @@ -1,9 +1,10 @@ -apply plugin: "kotlin" +plugins { + id "org.jetbrains.kotlin.jvm" +} dependencies { implementation 'com.google.guava:guava:12.0' testImplementation 'org.testng:testng:6.8' - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" } test { diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/build.gradle index 506324b4f50..3cf0e0f6204 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/build.gradle @@ -8,6 +8,10 @@ buildscript { } } +plugins { + id "org.jetbrains.kotlin.jvm" apply false +} + allprojects { repositories { mavenLocal() diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projA/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projA/build.gradle index ae9666ab55c..546933fb729 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projA/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projA/build.gradle @@ -1,5 +1,3 @@ -apply plugin: "kotlin" - -dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" +plugins { + id "org.jetbrains.kotlin.jvm" } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projB/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projB/build.gradle index 058dff93b37..1097f34aa5a 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projB/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/projB/build.gradle @@ -1,6 +1,7 @@ -apply plugin: "kotlin" +plugins { + id "org.jetbrains.kotlin.jvm" +} dependencies { implementation project(':projA') - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/settings.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/settings.gradle index f689a98b67c..e0685135bd5 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/settings.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/multiprojectWithDependency/settings.gradle @@ -1,14 +1 @@ -pluginManagement { - repositories { - mavenLocal() - mavenCentral() - google() - gradlePluginPortal() - } - - plugins { - id "org.jetbrains.kotlin.test.fixes.android" version "$test_fixes_version" - } -} - include 'projA', 'projB' diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/new-model-in-old-plugin/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/new-model-in-old-plugin/build.gradle.kts index 33889a39d28..061f1adfdbb 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/new-model-in-old-plugin/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/new-model-in-old-plugin/build.gradle.kts @@ -1,5 +1,5 @@ plugins { - kotlin("jvm").version("") + kotlin("jvm") `maven-publish` } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/build.gradle index e25c321b2ee..d7bad4b04e3 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/build.gradle @@ -1,20 +1,8 @@ -buildscript { - repositories { - mavenLocal() - mavenCentral() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +plugins { + id "org.jetbrains.kotlin.jvm" } -apply plugin: "kotlin" - repositories { mavenLocal() mavenCentral() } - -dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" -} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/gradle.properties b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/gradle.properties deleted file mode 100644 index 93ce6a94e63..00000000000 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/typeAlias/gradle.properties +++ /dev/null @@ -1 +0,0 @@ -org.gradle.jvmargs=-Xmx1024m -XX:MaxPermSize=512m \ No newline at end of file