Setup running tests against different Gradle versions.

^KT-45744 In Progress

libraries/tools/kotlin-gradle-plugin-integration-tests/build.gradle.kts

@@ -41,7 +41,7 @@ dependencies {
     testImplementation(gradleApi())
     testImplementation(gradleTestKit())
     testImplementation("com.google.code.gson:gson:${rootProject.extra["versions.jar.gson"]}")
-    testApiJUnit5(vintageEngine = true)
+    testApiJUnit5(vintageEngine = true, jupiterParams = true)
 
     testRuntimeOnly(projectRuntimeJar(":kotlin-android-extensions"))
     testRuntimeOnly(project(":compiler:tests-mutes"))
@@ -181,6 +181,7 @@ tasks.withType<Test> {
     useAndroidSdk()
 
     maxHeapSize = "512m"
+    maxParallelForks = (Runtime.getRuntime().availableProcessors() / 4).coerceAtLeast(1)
     useJUnitPlatform()
 
     testLogging {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/java/org/jetbrains/kotlin/gradle/testbase/GradleTest.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2021 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.testbase;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+// Has to be java annotation
+// Workaround for https://youtrack.jetbrains.com/issue/IDEA-265284
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@KGPBaseTest.GradleTestVersions
+@ParameterizedTest(name = "{0}: {displayName}")
+@ArgumentsSource(KGPBaseTest.GradleArgumentsProvider.class)
+public @interface GradleTest {
+}

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/KGPBaseTest.kt

@@ -7,9 +7,21 @@ package org.jetbrains.kotlin.gradle.testbase
 
 import org.gradle.api.logging.LogLevel
 import org.gradle.api.logging.configuration.WarningMode
+import org.gradle.internal.impldep.org.junit.platform.commons.support.AnnotationSupport.findAnnotation
+import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.gradle.KOTLIN_VERSION
+import org.jetbrains.kotlin.gradle.utils.minSupportedGradleVersion
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.api.io.TempDir
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.provider.ArgumentsSource
 import java.nio.file.Path
+import java.util.stream.Stream
+import kotlin.streams.asStream
 
 /**
  * Base class for all Kotlin Gradle plugin integration tests.
@@ -48,4 +60,37 @@ abstract class KGPBaseTest {
             return arguments.toList()
         }
     }
+
+    class GradleArgumentsProvider : ArgumentsProvider {
+        override fun provideArguments(
+            context: ExtensionContext
+        ): Stream<out Arguments> {
+            val versionsAnnotation = findAnnotation(context.testMethod, GradleTestVersions::class.java).orElseThrow {
+                IllegalStateException("Define allowed Gradle versions via '@GradleTestVersions'.")
+            }
+
+            val minGradleVersion = GradleVersion.version(versionsAnnotation.minVersion)
+            val maxGradleVersion = GradleVersion.version(versionsAnnotation.maxVersion)
+            val additionalGradleVersions = versionsAnnotation
+                .additionalVersions
+                .map(GradleVersion::version)
+            additionalGradleVersions.forEach {
+                assert(it in minGradleVersion..maxGradleVersion) {
+                    "Additional Gradle version ${it.version} should be between ${minGradleVersion.version} and ${maxGradleVersion.version}"
+                }
+            }
+
+            return sequenceOf(minGradleVersion, *additionalGradleVersions.toTypedArray(), maxGradleVersion)
+                .map { Arguments.of(it) }
+                .asStream()
+        }
+    }
+
+    @Target(AnnotationTarget.FUNCTION, AnnotationTarget.ANNOTATION_CLASS)
+    @Retention(AnnotationRetention.RUNTIME)
+    annotation class GradleTestVersions(
+        val minVersion: String = minSupportedGradleVersion,
+        val maxVersion: String = "7.0-milestone-3",
+        val additionalVersions: Array<String> = []
+    )
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testDsl.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.gradle.testbase
 
 import org.gradle.testkit.runner.BuildResult
 import org.gradle.testkit.runner.GradleRunner
+import org.gradle.util.GradleVersion
 import kotlin.test.assertTrue
 import java.nio.file.*
 import java.nio.file.Files.copy
@@ -22,22 +23,29 @@ import java.nio.file.attribute.BasicFileAttributes
  */
 fun KGPBaseTest.project(
     projectName: String,
+    gradleVersion: GradleVersion,
     buildOptions: KGPBaseTest.BuildOptions = defaultBuildOptions,
     test: TestProject.() -> Unit
 ): TestProject {
-    val projectPath = setupProjectFromTestResources(projectName, KGPBaseTest.workingDir)
+    val projectPath = setupProjectFromTestResources(
+        projectName,
+        gradleVersion,
+        KGPBaseTest.workingDir
+    )
     projectPath.addDefaultBuildFiles()
 
     val gradleRunner = GradleRunner
         .create()
         .withProjectDir(projectPath.toFile())
-        .withTestKitDir(KGPBaseTest.workingDir.testKitDir.toFile())
+        .withTestKitDir(Paths.get(".").testKitDir.toAbsolutePath().toFile())
+        .withGradleVersion(gradleVersion.version)
 
     val testProject = TestProject(
         gradleRunner,
         projectName,
         buildOptions,
-        projectPath
+        projectPath,
+        gradleVersion
     )
     testProject.test()
     return testProject
@@ -75,7 +83,8 @@ class TestProject(
     val gradleRunner: GradleRunner,
     val projectName: String,
     val buildOptions: KGPBaseTest.BuildOptions,
-    val projectPath: Path
+    val projectPath: Path,
+    val gradleVersion: GradleVersion
 )
 
 private fun TestProject.commonBuildSetup(
@@ -85,15 +94,17 @@ private fun TestProject.commonBuildSetup(
     val allBuildArguments = buildOptionsArguments + buildArguments + "--full-stacktrace"
 
     println("<=== Test build: ${this.projectName} ===>")
+    println("<=== Using Gradle version: ${gradleVersion.version} ===>")
     println("<=== Run arguments: ${allBuildArguments.joinToString()} ===>")
 
     return allBuildArguments
 }
 
-private val Path.testKitDir get() = resolve("testKitDir")
+private val Path.testKitDir get() = resolve(".testKitDir")
 
 private fun setupProjectFromTestResources(
     projectName: String,
+    gradleVersion: GradleVersion,
     tempDir: Path
 ): Path {
     val testProjectPath = Paths.get("src", "test", "resources", "testProject", projectName)
@@ -102,6 +113,7 @@ private fun setupProjectFromTestResources(
 
     return tempDir
         .resolve(projectName)
+        .resolve(gradleVersion.version)
         .also {
             testProjectPath.copyRecursively(it)
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/utils/compatibiltiy.kt

@@ -34,7 +34,7 @@ import org.gradle.util.GradleVersion
 import java.io.File
 import java.io.Serializable
 
-const val minSupportedGradleVersion = "6.1"
+const val minSupportedGradleVersion = "6.1.1"
 
 internal val Task.inputsCompatible: TaskInputs get() = inputs