[mpp] Migrate AGP Compatbility checks to the new infra

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.kt

@@ -7,7 +7,10 @@ package org.jetbrains.kotlin.gradle.plugin
 
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
-import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_ANDROID_GRADLE_PLUGIN_COMPATIBILITY_NO_WARN
+import org.jetbrains.kotlin.gradle.plugin.diagnostics.KotlinToolingDiagnostics.FailedToGetAgpVersionWarning
+import org.jetbrains.kotlin.gradle.plugin.diagnostics.KotlinToolingDiagnostics.IncompatibleAgpVersionTooHighWarning
+import org.jetbrains.kotlin.gradle.plugin.diagnostics.KotlinToolingDiagnostics.IncompatibleAgpVersionTooLowWarning
+import org.jetbrains.kotlin.gradle.plugin.diagnostics.kotlinToolingDiagnosticsCollector
 import org.jetbrains.kotlin.gradle.utils.androidPluginIds
 import org.jetbrains.kotlin.gradle.utils.findAppliedAndroidPluginIdOrNull
 import org.jetbrains.kotlin.gradle.utils.getOrPutRootProjectProperty
@@ -21,11 +24,6 @@ internal object KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck {
         maxSupportedVersion = AndroidGradlePluginVersionRange.Version(8, 0)
     )
 
-    /**
-     * Used to store previously emitted messages in the build
-     */
-    private const val PROPERTY_KEY_EMITTED_MESSAGES = "KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.emittedMessages"
-
     /**
      * Used to store project paths that executed this health check
      */
@@ -70,31 +68,19 @@ internal object KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck {
     }
 
     fun Project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheckWhenAndroidIsApplied(
-        warningLogger: (warningMessage: String) -> Unit = project.logger::warn,
         androidGradlePluginVersionProvider: AndroidGradlePluginVersionProvider = AndroidGradlePluginVersionProvider.Default
     ) {
-        val emittedMessages = project.getOrPutRootProjectProperty(PROPERTY_KEY_EMITTED_MESSAGES) { mutableSetOf<String>() }
-
-        val deduplicateWarningMessageLogger = { message: String ->
-            if (emittedMessages.add(message)) {
-                warningLogger(message)
-            }
-        }
-
         val executed = AtomicBoolean(false)
         androidPluginIds.forEach { id ->
             plugins.withId(id) {
                 if (!executed.getAndSet(true)) {
-                    runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
+                    runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(androidGradlePluginVersionProvider)
-                        deduplicateWarningMessageLogger, androidGradlePluginVersionProvider
-                    )
                 }
             }
         }
     }
 
     fun Project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
-        warningLogger: (warningMessage: String) -> Unit = project.logger::warn,
         androidGradlePluginVersionProvider: AndroidGradlePluginVersionProvider = AndroidGradlePluginVersionProvider.Default,
         compatibleAndroidGradlePluginVersionRange: AndroidGradlePluginVersionRange =
             KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.compatibleAndroidGradlePluginVersionRange
@@ -105,46 +91,38 @@ internal object KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck {
         /* Return when no android plugin is applied */
         findAppliedAndroidPluginIdOrNull() ?: return@check
 
+        val collector = project.kotlinToolingDiagnosticsCollector
         val androidGradlePluginVersion = androidGradlePluginVersionProvider.getAndroidGradlePluginVersion()
-            ?: return warningLogger(Messages.failedGettingAndroidGradlePluginVersion())
+        if (androidGradlePluginVersion == null) {
+            collector.reportOncePerGradleBuild(project, FailedToGetAgpVersionWarning())
+            return@check
+        }
+
+        val minSupportedRendered = compatibleAndroidGradlePluginVersionRange.minSupportedVersion.major.toString() +
+                "." + compatibleAndroidGradlePluginVersionRange.minSupportedVersion.minor
+        val maxTestedRendered = compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.major.toString() +
+                "." + compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.minor
 
         if (compatibleAndroidGradlePluginVersionRange.isTooLow(androidGradlePluginVersion)) {
-            warningLogger(Messages.androidGradlePluginVersionTooLow(androidGradlePluginVersion.toString()))
+            collector.reportOncePerGradleBuild(
+                project,
+                IncompatibleAgpVersionTooLowWarning(
+                    androidGradlePluginVersion.toString(),
+                    minSupportedRendered,
+                    maxTestedRendered
+                )
+            )
         }
 
         if (compatibleAndroidGradlePluginVersionRange.isTooHigh(androidGradlePluginVersion)) {
-            warningLogger(Messages.androidGradlePluginVersionTooHigh(androidGradlePluginVersion.toString()))
+            collector.reportOncePerGradleBuild(
-        }
+                project,
-    }
+                IncompatibleAgpVersionTooHighWarning(
-
+                    androidGradlePluginVersion.toString(),
-    object Messages {
+                    minSupportedRendered,
-
+                    maxTestedRendered
-        fun failedGettingAndroidGradlePluginVersion() =
+                )
-            "w: Failed to get AndroidGradlePluginVersion"
-
-        fun androidGradlePluginVersionTooLow(androidGradlePluginVersionString: String) = createCompatibilityWarningMessage(
-            "The applied Android Gradle Plugin version ($androidGradlePluginVersionString) is lower than the minimum supported"
-        )
-
-        fun androidGradlePluginVersionTooHigh(androidGradlePluginVersionString: String) = createCompatibilityWarningMessage(
-            "The applied Android Gradle Plugin version ($androidGradlePluginVersionString) " +
-                    "is higher than the maximum known to the Kotlin Gradle Plugin. " +
-                    "Tooling stability in such configuration isn't tested, please report encountered issues to https://kotl.in/issue"
-        )
-
-        private fun createCompatibilityWarningMessage(warning: String) = buildString {
-            appendLine("w: Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue: $warning")
-            appendLine(
-                "Minimum supported Android Gradle Plugin version: " +
-                        "${compatibleAndroidGradlePluginVersionRange.minSupportedVersion.major}." +
-                        "${compatibleAndroidGradlePluginVersionRange.minSupportedVersion.minor}"
             )
-            appendLine(
-                "Maximum tested Android Gradle Plugin version: " +
-                        "${compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.major}." +
-                        "${compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.minor}"
-            )
-            appendLine("To suppress this message add '$KOTLIN_MPP_ANDROID_GRADLE_PLUGIN_COMPATIBILITY_NO_WARN=true' to your gradle.properties")
         }
     }
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/diagnostics/KotlinToolingDiagnostics.kt

@@ -127,4 +127,38 @@ object KotlinToolingDiagnostics {
             """.trimIndent()
         )
     }
+
+    object IncompatibleAgpVersionTooHighWarning : ToolingDiagnosticFactory(WARNING) {
+        operator fun invoke(androidGradlePluginVersionString: String, minSupported: String, maxTested: String) = build(
+            """
+                Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue:
+                The applied Android Gradle Plugin version ($androidGradlePluginVersionString) is higher 
+                than the maximum known to the Kotlin Gradle Plugin.
+                Tooling stability in such configuration isn't tested, please report encountered issues to https://kotl.in/issue"
+                
+                Minimum supported Android Gradle Plugin version: $minSupported
+                Maximum tested Android Gradle Plugin version: $maxTested
+                
+                To suppress this message add '${PropertiesProvider.PropertyNames.KOTLIN_MPP_ANDROID_GRADLE_PLUGIN_COMPATIBILITY_NO_WARN}=true' to your gradle.properties
+            """.trimIndent()
+        )
+    }
+
+    object IncompatibleAgpVersionTooLowWarning : ToolingDiagnosticFactory(WARNING) {
+        operator fun invoke(androidGradlePluginVersionString: String, minSupported: String, maxTested: String) = build(
+            """
+                Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue:
+                The applied Android Gradle Plugin version ($androidGradlePluginVersionString) is lower than the minimum supported
+                
+                Minimum supported Android Gradle Plugin version: $minSupported
+                Maximum tested Android Gradle Plugin version: $maxTested
+                
+                To suppress this message add '${PropertiesProvider.PropertyNames.KOTLIN_MPP_ANDROID_GRADLE_PLUGIN_COMPATIBILITY_NO_WARN}=true' to your gradle.properties
+            """.trimIndent()
+        )
+    }
+
+    object FailedToGetAgpVersionWarning : ToolingDiagnosticFactory(WARNING) {
+        operator fun invoke() = build("Failed to get AndroidGradlePluginVersion")
+    }
 }

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest.kt

@@ -8,16 +8,17 @@
 package org.jetbrains.kotlin.gradle.unitTests
 
 import com.android.build.gradle.LibraryPlugin
+import org.gradle.api.Project
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.kotlin.gradle.plugin.AndroidGradlePluginVersion
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.AndroidGradlePluginVersionProvider
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.AndroidGradlePluginVersionRange
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.Messages
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.PROPERTY_KEY_EXECUTED_PROJECT_PATHS
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.compatibleAndroidGradlePluginVersionRange
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheck.runMultiplatformAndroidGradlePluginCompatibilityHealthCheckWhenAndroidIsApplied
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
+import org.jetbrains.kotlin.gradle.plugin.diagnostics.kotlinToolingDiagnosticsCollector
 import org.jetbrains.kotlin.gradle.util.*
 import org.jetbrains.kotlin.gradle.utils.getOrPutRootProjectProperty
 import org.junit.Test
@@ -30,18 +31,12 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
 
     val project by lazy {
         buildProjectWithMPP {
+            setMultiplatformAndroidSourceSetLayoutVersion(2) // To not provoke warnings
             plugins.apply(LibraryPlugin::class.java)
             kotlin { androidTarget() }
         }
     }
 
-    private val testLogger = object : (String) -> Unit {
-        val messages = mutableListOf<String>()
-        override fun invoke(message: String) {
-            messages.add(message)
-        }
-    }
-
     internal class FixedAndroidGradlePluginVersionProvider(private val version: String?) : AndroidGradlePluginVersionProvider {
         override fun getAndroidGradlePluginVersion(): AndroidGradlePluginVersion? {
             if (version == null) return null
@@ -49,82 +44,75 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
         }
     }
 
+    // Hardcode it so that testdata doesn't change when the version range is bumped
+    private val AGP_COMPATIBILITY_RANGE_FOR_TESTS = AndroidGradlePluginVersionRange(
+        minSupportedVersion = AndroidGradlePluginVersionRange.Version(4, 2),
+        maxSupportedVersion = AndroidGradlePluginVersionRange.Version(8, 0)
+    )
+
+    private fun runAgpCompatiblityCheck(agpVersion: AndroidGradlePluginVersion) {
+        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
+            FixedAndroidGradlePluginVersionProvider(agpVersion.toString()),
+            AGP_COMPATIBILITY_RANGE_FOR_TESTS
+        )
+    }
+
     @Test
     fun `test - version too low - major`() {
         val androidGradlePluginVersion = AndroidGradlePluginVersion(
-            major = compatibleAndroidGradlePluginVersionRange.minSupportedVersion.major - 1,
+            major = AGP_COMPATIBILITY_RANGE_FOR_TESTS.minSupportedVersion.major - 1,
-            minor = compatibleAndroidGradlePluginVersionRange.minSupportedVersion.minor
+            minor = AGP_COMPATIBILITY_RANGE_FOR_TESTS.minSupportedVersion.minor
         )
 
-        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
+        runAgpCompatiblityCheck(androidGradlePluginVersion)
-            testLogger, FixedAndroidGradlePluginVersionProvider(androidGradlePluginVersion.toString())
-        )
 
-        assertEquals(Messages.androidGradlePluginVersionTooLow(androidGradlePluginVersion.toString()), assertSingleWarningMessage())
+        project.checkDiagnostics("agpCompatibility/versionTooLowMajor")
     }
 
     @Test
     fun `test - version too low - minor`() {
-        val androidGradlePluginVersion = AndroidGradlePluginVersion(1, 1)
+        val androidGradlePluginVersion = AndroidGradlePluginVersion(
-
+            major = AGP_COMPATIBILITY_RANGE_FOR_TESTS.minSupportedVersion.major,
-        val compatibleAndroidGradlePluginVersionRange = AndroidGradlePluginVersionRange(
+            minor = AGP_COMPATIBILITY_RANGE_FOR_TESTS.minSupportedVersion.minor - 1
-            minSupportedVersionMajor = 1, minSupportedVersionMinor = 2,
-            maxSupportedVersionMajor = 2
         )
 
-        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
+        runAgpCompatiblityCheck(androidGradlePluginVersion)
-            testLogger, FixedAndroidGradlePluginVersionProvider(androidGradlePluginVersion.toString()),
-            compatibleAndroidGradlePluginVersionRange = compatibleAndroidGradlePluginVersionRange
-        )
 
-        assertEquals(Messages.androidGradlePluginVersionTooLow(androidGradlePluginVersion.toString()), assertSingleWarningMessage())
+        project.checkDiagnostics("agpCompatibility/versionTooLowMinor")
     }
 
     @Test
     fun `test - version too high - major`() {
         val androidGradlePluginVersion = AndroidGradlePluginVersion(
-            major = compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.major + 1,
+            major = AGP_COMPATIBILITY_RANGE_FOR_TESTS.maxSupportedVersion.major + 1,
-            minor = compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.minor
+            minor = AGP_COMPATIBILITY_RANGE_FOR_TESTS.maxSupportedVersion.minor
         )
 
-        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
+        runAgpCompatiblityCheck(androidGradlePluginVersion)
-            testLogger, FixedAndroidGradlePluginVersionProvider(androidGradlePluginVersion.toString())
-        )
 
-        assertEquals(
+        project.checkDiagnostics("agpCompatibility/versionTooHighMajor")
-            Messages.androidGradlePluginVersionTooHigh(androidGradlePluginVersion.toString()), assertSingleWarningMessage()
-        )
     }
 
     @Test
     fun `test - version too high - minor`() {
-        val androidGradlePluginVersion = AndroidGradlePluginVersion(2, 1)
+        val androidGradlePluginVersion = AndroidGradlePluginVersion(
-
+            major = AGP_COMPATIBILITY_RANGE_FOR_TESTS.maxSupportedVersion.major,
-        val compatibleAndroidGradlePluginVersionRange = AndroidGradlePluginVersionRange(
+            minor = AGP_COMPATIBILITY_RANGE_FOR_TESTS.maxSupportedVersion.minor + 1
-            minSupportedVersion = AndroidGradlePluginVersionRange.Version(1, 0),
-            maxSupportedVersion = AndroidGradlePluginVersionRange.Version(2, 0)
         )
 
-        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
+        runAgpCompatiblityCheck(androidGradlePluginVersion)
-            testLogger, FixedAndroidGradlePluginVersionProvider(androidGradlePluginVersion.toString()),
-            compatibleAndroidGradlePluginVersionRange = compatibleAndroidGradlePluginVersionRange
-        )
 
-        assertEquals(
+        project.checkDiagnostics("agpCompatibility/versionTooHighMinor")
-            Messages.androidGradlePluginVersionTooHigh(androidGradlePluginVersion.toString()), assertSingleWarningMessage()
-        )
     }
 
 
     @Test
     fun `test - missing Android Gradle Plugin version string`() {
         project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
-            testLogger, FixedAndroidGradlePluginVersionProvider(null)
+            FixedAndroidGradlePluginVersionProvider(null)
         )
 
-        assertEquals(
+        project.checkDiagnostics("agpCompatibility/missingAgpVersion")
-            Messages.failedGettingAndroidGradlePluginVersion(), assertSingleWarningMessage()
-        )
     }
 
     @Test
@@ -132,35 +120,34 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
         project.propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_ANDROID_GRADLE_PLUGIN_COMPATIBILITY_NO_WARN, "true")
 
         /* Test with missing AGP version */
-        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(testLogger, FixedAndroidGradlePluginVersionProvider(null))
+        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(FixedAndroidGradlePluginVersionProvider(null))
-        assertNoWarningMessage()
+        project.assertNoDiagnostics()
 
         /* Test with too low AGP version */
         project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
-            testLogger, FixedAndroidGradlePluginVersionProvider("${compatibleAndroidGradlePluginVersionRange.minSupportedVersion}")
+            FixedAndroidGradlePluginVersionProvider("${AGP_COMPATIBILITY_RANGE_FOR_TESTS.minSupportedVersion}")
         )
-        assertNoWarningMessage()
+        project.assertNoDiagnostics()
 
         /* Test with too high AGP version */
         project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
-            testLogger,
+            FixedAndroidGradlePluginVersionProvider("${AGP_COMPATIBILITY_RANGE_FOR_TESTS.maxSupportedVersion.major + 1}.0")
-            FixedAndroidGradlePluginVersionProvider("${compatibleAndroidGradlePluginVersionRange.maxSupportedVersion.major + 1}.0")
         )
-        assertNoWarningMessage()
+        project.assertNoDiagnostics()
 
         /* Re-enable the check and test with missing AGP version */
         project.propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_ANDROID_GRADLE_PLUGIN_COMPATIBILITY_NO_WARN, "false")
-        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(testLogger, FixedAndroidGradlePluginVersionProvider(null))
+        project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(FixedAndroidGradlePluginVersionProvider(null))
-        assertEquals(Messages.failedGettingAndroidGradlePluginVersion(), assertSingleWarningMessage())
+        project.checkDiagnostics("agpCompatibility/noWarnProperty")
     }
 
     @Test
     fun `test - compatible versions`() {
         fun assertNoWarnings(androidGradlePluginVersion: String) {
             project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheck(
-                testLogger, FixedAndroidGradlePluginVersionProvider(androidGradlePluginVersion)
+                FixedAndroidGradlePluginVersionProvider(androidGradlePluginVersion)
             )
-            assertNoWarningMessage()
+            project.assertNoWarningMessage()
         }
 
         val minSupportedVersion = compatibleAndroidGradlePluginVersionRange.minSupportedVersion.run {
@@ -199,15 +186,15 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
         project.gradle.registerConfigurationTimePropertiesAccessorForTests()
 
         project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheckWhenAndroidIsApplied(
-            testLogger, FixedAndroidGradlePluginVersionProvider(null)
+            FixedAndroidGradlePluginVersionProvider(null)
         )
 
         /* Not yet, executed, because Android is not applied yet */
-        assertNoWarningMessage()
+        project.assertNoWarningMessage()
 
         addBuildEventsListenerRegistryMock(project)
         project.plugins.apply(LibraryPlugin::class.java)
-        assertEquals(Messages.failedGettingAndroidGradlePluginVersion(), assertSingleWarningMessage())
+        project.checkDiagnostics("agpCompatibility/androidIsAppliedAfterCheckerCall")
     }
 
     @Test
@@ -218,10 +205,10 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
         project.plugins.apply(LibraryPlugin::class.java)
 
         project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheckWhenAndroidIsApplied(
-            testLogger, FixedAndroidGradlePluginVersionProvider(null)
+            FixedAndroidGradlePluginVersionProvider(null)
         )
 
-        assertEquals(Messages.failedGettingAndroidGradlePluginVersion(), assertSingleWarningMessage())
+        project.checkDiagnostics("agpCompatibility/androidIsAppliedBeforeCheckerCall")
     }
 
     @Test
@@ -233,11 +220,11 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
 
         repeat(10) {
             project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheckWhenAndroidIsApplied(
-                testLogger, FixedAndroidGradlePluginVersionProvider(null)
+                FixedAndroidGradlePluginVersionProvider(null)
             )
         }
 
-        assertEquals(Messages.failedGettingAndroidGradlePluginVersion(), assertSingleWarningMessage())
+        project.checkDiagnostics("agpCompatibility/checkerCalledMultipleTimes")
     }
 
     @Test
@@ -328,14 +315,10 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
         }
     }
 
-    private fun assertSingleWarningMessage(): String {
+    private fun Project.assertNoWarningMessage() {
-        if (testLogger.messages.size != 1) fail("Expected exactly one warning message logged. Found: ${testLogger.messages}")
+        val diagnostics = kotlinToolingDiagnosticsCollector.getAllDiagnostics()
-        return testLogger.messages.single()
+        if (diagnostics.isNotEmpty()) {
-    }
+            fail("Expected no warning messages to be emitted. Found: $diagnostics")
-
-    private fun assertNoWarningMessage() {
-        if (testLogger.messages.isNotEmpty()) {
-            fail("Expected no warning messages to be emitted. Found: ${testLogger.messages}")
         }
     }
 }

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/androidIsAppliedAfterCheckerCall.txt

@@ -0,0 +1 @@
+[FailedToGetAgpVersionWarning | WARNING] Failed to get AndroidGradlePluginVersion

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/androidIsAppliedBeforeCheckerCall.txt

@@ -0,0 +1 @@
+[FailedToGetAgpVersionWarning | WARNING] Failed to get AndroidGradlePluginVersion

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/checkerCalledMultipleTimes.txt

@@ -0,0 +1 @@
+[FailedToGetAgpVersionWarning | WARNING] Failed to get AndroidGradlePluginVersion

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/missingAgpVersion.txt

@@ -0,0 +1 @@
+[FailedToGetAgpVersionWarning | WARNING] Failed to get AndroidGradlePluginVersion

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/noWarnProperty.txt

@@ -0,0 +1 @@
+[FailedToGetAgpVersionWarning | WARNING] Failed to get AndroidGradlePluginVersion

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/versionTooHighMajor.txt

@@ -0,0 +1,9 @@
+[IncompatibleAgpVersionTooHighWarning | WARNING] Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue:
+The applied Android Gradle Plugin version (9.0.0) is higher
+than the maximum known to the Kotlin Gradle Plugin.
+Tooling stability in such configuration isn't tested, please report encountered issues to https://kotl.in/issue"
+
+Minimum supported Android Gradle Plugin version: 4.2
+Maximum tested Android Gradle Plugin version: 8.0
+
+To suppress this message add 'kotlin.mpp.androidGradlePluginCompatibility.nowarn=true' to your gradle.properties

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/versionTooHighMinor.txt

@@ -0,0 +1,9 @@
+[IncompatibleAgpVersionTooHighWarning | WARNING] Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue:
+The applied Android Gradle Plugin version (8.1.0) is higher
+than the maximum known to the Kotlin Gradle Plugin.
+Tooling stability in such configuration isn't tested, please report encountered issues to https://kotl.in/issue"
+
+Minimum supported Android Gradle Plugin version: 4.2
+Maximum tested Android Gradle Plugin version: 8.0
+
+To suppress this message add 'kotlin.mpp.androidGradlePluginCompatibility.nowarn=true' to your gradle.properties

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/versionTooLowMajor.txt

@@ -0,0 +1,7 @@
+[IncompatibleAgpVersionTooLowWarning | WARNING] Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue:
+The applied Android Gradle Plugin version (3.2.0) is lower than the minimum supported
+
+Minimum supported Android Gradle Plugin version: 4.2
+Maximum tested Android Gradle Plugin version: 8.0
+
+To suppress this message add 'kotlin.mpp.androidGradlePluginCompatibility.nowarn=true' to your gradle.properties

libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/expectedDiagnostics/agpCompatibility/versionTooLowMinor.txt

@@ -0,0 +1,7 @@
+[IncompatibleAgpVersionTooLowWarning | WARNING] Kotlin Multiplatform <-> Android Gradle Plugin compatibility issue:
+The applied Android Gradle Plugin version (4.1.0) is lower than the minimum supported
+
+Minimum supported Android Gradle Plugin version: 4.2
+Maximum tested Android Gradle Plugin version: 8.0
+
+To suppress this message add 'kotlin.mpp.androidGradlePluginCompatibility.nowarn=true' to your gradle.properties