Add @GradleAndroidTest annotation

This allows to run parameterized tests against combination of different
Gradle and Android Gradle plugin versions.

By default, test is provided with minimal supported Gradle + AGP version
and maximum supported Gradle + AGP version.

Migrate AGP versions to enum with compatibility fields.

^KT-45747 In Progress

libraries/tools/kotlin-gradle-plugin-integration-tests/Readme.md

@@ -10,6 +10,8 @@ To run all tests for all Gradle plugins use `check` task.
 More fine-grained test tasks exist covering different parts of Gradle plugins:
 - `kgpJvmTests` - runs all tests for Kotlin Gradle Plugin/Jvm platform (parallel execution)
 - `kgpJsTests` - runs all tests for Kotlin Gradle Plugin/Js platform (parallel execution)
+- `kgpAndroidTests` - runs all tests for Kotlin Gradle Plugin/Android platform (parallel execution)
+- `kgpMppTests` - run all tests for Kotlin Gradle Multiplatform plugin (parallel execution)
 - `kgpDaemonTests` - runs all tests for Gradle and Kotlin daemons (sequential execution)
 - `kgpOtherTests` - run all tests for support Gradle plugins, such as kapt, allopen, etc (parallel execution)
 - `kgpAllParallelTests` - run all tests for all platforms except daemons tests (parallel execution)
@@ -103,6 +105,27 @@ fun someTest(
 }
 ```
 
+- Whenever Android Gradle plugin different versions should be checked in the tests - it is possible to use `@GradleAndroidTest` annotation 
+instead of `@GradleTest`. Test will receive additionally to Gradle version AGP version and required JDK version:
+```kotlin
+@AndroidTestVersions(additionalVersions = [TestVersions.AGP.AGP_42])
+@GradleAndroidTest
+fun someTest(
+    gradleVersion: GradleVersion,
+    agpVersion: String,
+    jdkVersion: JdkVersions.ProvidedJdk
+) {
+    project(
+        "simpleAndroid",
+        gradleVersion,
+        buildOptions = defaultBuildOptions.copy(androidVersion = agpVersion),
+        buildJdk = jdkVersion.location
+    ) {
+        build("assembleDebug")
+    }
+}
+```
+
 - If you want to copy current state of the test project and play with it separately - you could use `makeSnapshotTo(destinationPath)` function.
 
 ##### Common test fixes

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

@@ -0,0 +1,25 @@
+/*
+ * 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.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)
+@GradleTestVersions
+@AndroidTestVersions
+@ParameterizedTest(name = "AGP {1} with {0}: {displayName}")
+@ArgumentsSource(GradleAndAgpArgumentsProvider.class)
+public @interface GradleAndroidTest {
+}

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

@@ -121,7 +121,7 @@ class BuildCacheRelocationIT : KGPBaseTest() {
         val (firstProject, secondProject) = prepareTestProjects(
             "AndroidProject",
             gradleVersion,
-            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42.version)
         )
 
         checkBuildCacheRelocation(
@@ -146,7 +146,7 @@ class BuildCacheRelocationIT : KGPBaseTest() {
         val (firstProject, secondProject) = prepareTestProjects(
             "kapt2/android-dagger",
             gradleVersion,
-            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42.version)
         ) {
             it.subProject("app").buildGradle.append("\nkapt.useBuildCache = true")
         }
@@ -171,7 +171,7 @@ class BuildCacheRelocationIT : KGPBaseTest() {
         val (firstProject, secondProject) = prepareTestProjects(
             "kapt2/android-dagger",
             gradleVersion,
-            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42.version)
         ) {
             it.subProject("app").buildGradle.append("\nkapt.useBuildCache = true")
         }
@@ -199,7 +199,7 @@ class BuildCacheRelocationIT : KGPBaseTest() {
         val (firstProject, secondProject) = prepareTestProjects(
             "AndroidExtensionsProject",
             gradleVersion,
-            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42.version)
         ) {
             it.subProject("app").buildGradle.append(
                 """

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

@@ -72,7 +72,7 @@ class ConfigurationAvoidanceIT : KGPBaseTest() {
             build(
                 "help",
                 buildOptions = defaultBuildOptions.copy(
-                    androidVersion = TestVersions.AGP.AGP_42
+                    androidVersion = TestVersions.AGP.AGP_42.version
                 )
             )
         }

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

@@ -15,7 +15,7 @@ import org.junit.jupiter.api.DisplayName
 @JvmGradlePluginTests
 class ConfigurationCacheForAndroidIT : AbstractConfigurationCacheIT() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(
-        androidVersion = AGP_42
+        androidVersion = AGP_42.version
     )
 
     @DisplayName("works in android plus kapt project")

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

@@ -292,7 +292,7 @@ class KaptIncrementalWithIsolatingApt : KaptIncrementalIT() {
         project(
             "kaptIncrementalWithParceler",
             gradleVersion,
-            buildOptions = defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            buildOptions = defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42.version)
         ) {
             build("clean", ":mylibrary:assembleDebug")
 

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

@@ -510,7 +510,7 @@ class KotlinJavaToolchainTest : KGPBaseTest() {
             build(
                 "assembleDebug",
                 buildOptions = defaultBuildOptions.copy(
-                    androidVersion = TestVersions.AGP.AGP_42
+                    androidVersion = TestVersions.AGP.AGP_42.version
                 )
             )
         }

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

@@ -97,28 +97,44 @@ class KotlinSpecificDependenciesIT : KGPBaseTest() {
         }
     }
 
-    @JvmGradlePluginTests
+    @AndroidGradlePluginTests
     @DisplayName("Android: kotlin-stdlib dependency is added by default")
-    @GradleTest
-    fun testStdlibDefaultAndroid(gradleVersion: GradleVersion) {
+    @GradleAndroidTest
+    fun testStdlibDefaultAndroid(
+        gradleVersion: GradleVersion,
+        agpVersion: String,
+        jdkVersion: JdkVersions.ProvidedJdk
+    ) {
         project(
             "AndroidLibraryKotlinProject",
             gradleVersion,
-            buildOptions = defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            buildOptions = defaultBuildOptions.copy(
+                androidVersion = agpVersion,
+                warningMode = if (agpVersion == TestVersions.AGP.AGP_36.version) WarningMode.Summary else defaultBuildOptions.warningMode
+            ),
+            buildJdk = jdkVersion.location
         ) {
             removeDependencies(buildGradle)
             checkTaskCompileClasspath("compileDebugKotlin", listOf("kotlin-stdlib" /*any of them*/))
         }
     }
 
-    @JvmGradlePluginTests
+    @AndroidGradlePluginTests
     @DisplayName("Android: kotlin-stdlib dependency is not added when disabled via properties")
-    @GradleTest
-    fun testStdlibDisabledAndroid(gradleVersion: GradleVersion) {
+    @GradleAndroidTest
+    fun testStdlibDisabledAndroid(
+        gradleVersion: GradleVersion,
+        agpVersion: String,
+        jdkVersion: JdkVersions.ProvidedJdk
+    ) {
         project(
             "AndroidLibraryKotlinProject",
             gradleVersion,
-            buildOptions = defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            buildOptions = defaultBuildOptions.copy(
+                androidVersion = agpVersion,
+                warningMode = if (agpVersion == TestVersions.AGP.AGP_36.version) WarningMode.Summary else defaultBuildOptions.warningMode
+            ),
+            buildJdk = jdkVersion.location
         ) {
             removeDependencies(buildGradle)
             gradleProperties.appendText(
@@ -221,14 +237,22 @@ class KotlinSpecificDependenciesIT : KGPBaseTest() {
         }
     }
 
-    @JvmGradlePluginTests
+    @AndroidGradlePluginTests
     @DisplayName("Android: Kotlin test single dependency in unit tests")
-    @GradleTest
-    fun kotlinTestSingleDependencyAndroidUnitTests(gradleVersion: GradleVersion) {
+    @GradleAndroidTest
+    fun kotlinTestSingleDependencyAndroidUnitTests(
+        gradleVersion: GradleVersion,
+        agpVersion: String,
+        jdkVersion: JdkVersions.ProvidedJdk
+    ) {
         project(
             "AndroidLibraryKotlinProject",
             gradleVersion,
-            buildOptions = defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            buildOptions = defaultBuildOptions.copy(
+                androidVersion = agpVersion,
+                warningMode = if (agpVersion == TestVersions.AGP.AGP_36.version) WarningMode.Summary else defaultBuildOptions.warningMode
+            ),
+            buildJdk = jdkVersion.location
         ) {
             assertKotlinTestDependency(
                 listOf("testImplementation"),
@@ -240,14 +264,22 @@ class KotlinSpecificDependenciesIT : KGPBaseTest() {
         }
     }
 
-    @JvmGradlePluginTests
+    @AndroidGradlePluginTests
     @DisplayName("Android: Kotlin test single dependency in ui tests")
-    @GradleTest
-    fun kotlinTestSingleDependencyAndroidUiTests(gradleVersion: GradleVersion) {
+    @GradleAndroidTest
+    fun kotlinTestSingleDependencyAndroidUiTests(
+        gradleVersion: GradleVersion,
+        agpVersion: String,
+        jdkVersion: JdkVersions.ProvidedJdk
+    ) {
         project(
             "AndroidLibraryKotlinProject",
             gradleVersion,
-            buildOptions = defaultBuildOptions.copy(androidVersion = TestVersions.AGP.AGP_42)
+            buildOptions = defaultBuildOptions.copy(
+                androidVersion = agpVersion,
+                warningMode = if (agpVersion == TestVersions.AGP.AGP_36.version) WarningMode.Summary else defaultBuildOptions.warningMode
+            ),
+            buildJdk = jdkVersion.location
         ) {
             assertKotlinTestDependency(
                 listOf("androidTestImplementation"),

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

@@ -168,7 +168,7 @@ class SubpuginsIT : KGPBaseTest() {
             build(
                 ":app:compileDebugKotlin",
                 buildOptions = defaultBuildOptions.copy(
-                    androidVersion = TestVersions.AGP.AGP_42
+                    androidVersion = TestVersions.AGP.AGP_42.version
                 )
             )
         }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinAndroidExtensionIT.kt

@@ -18,7 +18,7 @@ import kotlin.test.assertTrue
 @OtherGradlePluginTests
 class KotlinAndroidExtensionIT : KGPBaseTest() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(
-        androidVersion = TestVersions.AGP.AGP_34,
+        androidVersion = TestVersions.AGP.AGP_34.version,
         warningMode = WarningMode.Summary
     )
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinProjectIT.kt

@@ -18,7 +18,7 @@ import kotlin.test.assertTrue
 @OtherGradlePluginTests
 class KotlinProjectIT : KGPBaseTest() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(
-        androidVersion = TestVersions.AGP.AGP_34,
+        androidVersion = TestVersions.AGP.AGP_34.version,
     )
 
     @DisplayName("Valid model is available in Kotlin only project")

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

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.gradle.testbase
 
+import org.gradle.api.JavaVersion
+import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.gradle.utils.minSupportedGradleVersion
 
 interface TestVersions {
@@ -29,11 +31,25 @@ interface TestVersions {
             get() = System.getProperty("kotlinVersion") ?: error("Required to specify kotlinVersion system property for tests")
     }
 
-    object AGP {
-        const val AGP_34 = "3.4.3"
-        const val AGP_36 = "3.6.4"
-        const val AGP_41 = "4.1.3"
-        const val AGP_42 = "4.2.2"
-        const val AGP_70 = "7.0.2"
+    enum class AGP(
+        val version: String,
+        val minSupportedGradleVersion: GradleVersion,
+        val maxSupportedGradleVersion: GradleVersion,
+        val requiredJdkVersion: JavaVersion
+    ) {
+        AGP_34("3.4.0", GradleVersion.version(Gradle.MIN_SUPPORTED), GradleVersion.version(Gradle.G_6_9), JavaVersion.VERSION_1_8),
+        AGP_36("3.6.4", GradleVersion.version(Gradle.MIN_SUPPORTED), GradleVersion.version(Gradle.G_6_9), JavaVersion.VERSION_1_8),
+        AGP_40("4.0.2", GradleVersion.version(Gradle.MIN_SUPPORTED), GradleVersion.version(Gradle.G_6_9), JavaVersion.VERSION_1_8),
+        AGP_41("4.1.3", GradleVersion.version(Gradle.MIN_SUPPORTED), GradleVersion.version(Gradle.G_6_9), JavaVersion.VERSION_1_8),
+        AGP_42("4.2.2", GradleVersion.version(Gradle.MIN_SUPPORTED), GradleVersion.version(Gradle.G_6_9), JavaVersion.VERSION_1_8),
+        AGP_70("7.0.4", GradleVersion.version(Gradle.G_7_0), GradleVersion.version(Gradle.G_7_4), JavaVersion.VERSION_11),
+        AGP_71("7.1.3", GradleVersion.version(Gradle.G_7_2), GradleVersion.version(Gradle.G_7_4), JavaVersion.VERSION_11),
+        AGP_72("7.2.1", GradleVersion.version(Gradle.G_7_3), GradleVersion.version(Gradle.G_7_4), JavaVersion.VERSION_11),
+        ;
+
+        companion object {
+            const val MIN_SUPPORTED = "3.6.4" // AGP_36 - KotlinAndroidPlugin.MINIMAL_SUPPORTED_AGP_VERSION
+            const val MAX_SUPPORTED = "7.0.4" // AGP_70 - Update once Gradle MAX_SUPPORTED version will be bumped to 7.2+
+        }
     }
 }

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

@@ -139,3 +139,59 @@ class GradleAndJdkArgumentsProvider : GradleArgumentsProvider() {
         )
     }
 }
+
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class AndroidTestVersions(
+    val minVersion: String = TestVersions.AGP.MIN_SUPPORTED,
+    val maxVersion: String = TestVersions.AGP.MAX_SUPPORTED,
+    val additionalVersions: Array<String> = []
+)
+
+class GradleAndAgpArgumentsProvider : GradleArgumentsProvider() {
+    override fun provideArguments(
+        context: ExtensionContext
+    ): Stream<out Arguments> {
+        val agpVersionsAnnotation = findAnnotation<AndroidTestVersions>(context)
+        val agpVersions = setOf(
+            agpVersionsAnnotation.minVersion,
+            *agpVersionsAnnotation.additionalVersions,
+            agpVersionsAnnotation.maxVersion
+        )
+
+        val gradleVersions = super.provideArguments(context).map { it.get().first() as GradleVersion }.toList()
+
+        return agpVersions
+            .flatMap { version ->
+                val agpVersion = TestVersions.AGP.values().find { it.version == version }
+                    ?: throw IllegalArgumentException("AGP version $version is not defined in TestVersions.AGP!")
+
+                val providedJdk = JdkVersions.ProvidedJdk(
+                    agpVersion.requiredJdkVersion,
+                    File(System.getProperty("jdk${agpVersion.requiredJdkVersion.majorVersion}Home"))
+                )
+
+                gradleVersions
+                    .filter { it in agpVersion.minSupportedGradleVersion..agpVersion.maxSupportedGradleVersion }
+                    .map {
+                        AgpTestArguments(it, agpVersion.version, providedJdk)
+                    }
+                    .also {
+                        require(it.isNotEmpty()) {
+                            "Could not find suitable Gradle version for AGP $agpVersion version!"
+                        }
+                    }
+            }
+            .asSequence()
+            .map {
+                Arguments.of(it.gradleVersion, it.agpVersion, it.jdkVersion)
+            }
+            .asStream()
+    }
+
+    data class AgpTestArguments(
+        val gradleVersion: GradleVersion,
+        val agpVersion: String,
+        val jdkVersion: JdkVersions.ProvidedJdk
+    )
+}