Add simple configuration cache integration tests

Author: ALikhachev

integration/src/main/kotlin/kotlinx/benchmark/integration/GradleTestVersion.kt

@@ -0,0 +1,5 @@
+package kotlinx.benchmark.integration
+
+enum class GradleTestVersion(val versionString: String) {
+    v8_0("8.0.2"),
+}

integration/src/main/kotlin/kotlinx/benchmark/integration/Runner.kt

@@ -5,7 +5,8 @@ import java.io.*
 
 class Runner(
     private val projectDir: File,
-    private val print: Boolean
+    private val print: Boolean,
+    private val gradleVersion: GradleTestVersion? = null,
 ) {
 
     private fun gradle(vararg tasks: String): GradleRunner =
@@ -15,6 +16,9 @@ class Runner(
             .run {
                 if (print) forwardStdOutput(System.out.bufferedWriter()) else this
             }
+            .run {
+                if (gradleVersion != null) withGradleVersion(gradleVersion.versionString) else this
+            }
 
     fun run(vararg tasks: String, fn: BuildResult.() -> Unit = {}) {
         val gradle = gradle(*tasks)

integration/src/test/kotlin/kotlinx/benchmark/integration/ConfigurationCacheTest.kt

@@ -0,0 +1,72 @@
+package kotlinx.benchmark.integration
+
+import org.gradle.testkit.runner.BuildResult
+import kotlin.test.*
+
+class ConfigurationCacheTest : GradleTest() {
+    private fun runConfigurationCacheTest(projectName: String, invokedTasks: List<String>, executedTasks: List<String>) {
+        val project = project(projectName, gradleVersion = GradleTestVersion.v8_0) {
+            // this test doesn't pass for K/N on Gradle 8.1 yet: https://youtrack.jetbrains.com/issue/KT-58063
+            configuration("main") {
+                warmups = 1
+                iterations = 1
+                iterationTime = 100
+                iterationTimeUnit = "ms"
+            }
+        }
+
+        project.run(*invokedTasks.toTypedArray(), "--configuration-cache") {
+            assertTasksExecuted(invokedTasks + executedTasks)
+            assertConfigurationCacheStored()
+        }
+        project.run("clean", "--configuration-cache") {
+            assertConfigurationCacheStored()
+        }
+        project.run(*invokedTasks.toTypedArray(), "--configuration-cache") {
+            assertTasksExecuted(invokedTasks + executedTasks)
+            assertConfigurationCacheReused()
+        }
+        project.run(*invokedTasks.toTypedArray(), "--configuration-cache") {
+            assertTasksUpToDate(executedTasks)
+            assertConfigurationCacheReused()
+        }
+    }
+
+    @Test
+    fun testConfigurationCacheNative() = runConfigurationCacheTest(
+        "kotlin-multiplatform",
+        listOf(":nativeBenchmark"),
+        listOf(":compileKotlinNative", ":nativeBenchmarkGenerate", ":compileNativeBenchmarkKotlinNative", ":linkNativeBenchmarkReleaseExecutableNative")
+    )
+
+    @Test
+    @Ignore("https://youtrack.jetbrains.com/issue/KT-58250")
+    fun testConfigurationCacheJs() = runConfigurationCacheTest(
+        "kotlin-multiplatform",
+        listOf(":jsIrBenchmark"),
+        listOf(":compileKotlinJsIr", ":jsIrBenchmarkGenerate", ":compileJsIrBenchmarkProductionExecutableKotlinJsIr")
+    )
+
+    @Test
+    fun testConfigurationCacheJvm() = runConfigurationCacheTest(
+        "kotlin-multiplatform",
+        listOf(":jvmBenchmark"),
+        listOf(":compileKotlinJvm", ":jvmBenchmarkGenerate", ":jvmBenchmarkCompile")
+    )
+
+    @Test
+    @Ignore("https://youtrack.jetbrains.com/issue/KT-58256")
+    fun testConfigurationCacheWasm() = runConfigurationCacheTest(
+        "kotlin-multiplatform",
+        listOf(":wasmBenchmark"),
+        listOf(":compileKotlinWasm", ":wasmBenchmarkGenerate", ":compileWasmBenchmarkProductionExecutableKotlinWasm")
+    )
+}
+
+private fun BuildResult.assertConfigurationCacheStored() {
+    assertOutputContains("Configuration cache entry stored.")
+}
+
+private fun BuildResult.assertConfigurationCacheReused() {
+    assertOutputContains("Configuration cache entry reused.")
+}

integration/src/test/kotlin/kotlinx/benchmark/integration/GradleTest.kt

@@ -20,6 +20,7 @@ abstract class GradleTest {
     fun project(
         name: String,
         print: Boolean = false,
+        gradleVersion: GradleTestVersion? = null,
         build: ProjectBuilder.() -> Unit = {}
     ): Runner {
         val builder = ProjectBuilder().apply(build)
@@ -30,7 +31,7 @@ abstract class GradleTest {
         if (!kotlinDevUrl.isNullOrBlank()) {
             file("gradle.properties").appendText("\nkotlin_repo_url=$kotlinDevUrl")
         }
-        return Runner(rootProjectDir, print)
+        return Runner(rootProjectDir, print, gradleVersion)
     }
 }
 

integration/src/test/kotlin/kotlinx/benchmark/integration/testDsl.kt

@@ -0,0 +1,48 @@
+package kotlinx.benchmark.integration
+
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.TaskOutcome
+
+internal fun BuildResult.printBuildOutput() {
+    println(
+        """
+        |Failed assertion build output:
+        |#######################
+        |$output
+        |#######################
+        |
+        """.trimMargin()
+    )
+}
+
+internal fun BuildResult.assertTasksExecuted(vararg tasks: String) {
+    tasks.forEach { task ->
+        assert(task(task)?.outcome == TaskOutcome.SUCCESS) {
+            printBuildOutput()
+            "Task $task didn't have 'SUCCESS' state: ${task(task)?.outcome}"
+        }
+    }
+}
+
+internal fun BuildResult.assertTasksExecuted(tasks: Collection<String>) = assertTasksExecuted(*tasks.toTypedArray())
+
+fun BuildResult.assertTasksUpToDate(vararg tasks: String) {
+    tasks.forEach { task ->
+        assert(task(task)?.outcome == TaskOutcome.UP_TO_DATE) {
+            printBuildOutput()
+            "Task $task didn't have 'UP-TO-DATE' state: ${task(task)?.outcome}"
+        }
+    }
+}
+
+internal fun BuildResult.assertOutputContains(
+    expectedSubString: String,
+    message: String = "Build output does not contain \"$expectedSubString\""
+) {
+    assert(output.contains(expectedSubString)) {
+        printBuildOutput()
+        message
+    }
+}
+
+internal fun BuildResult.assertTasksUpToDate(tasks: Collection<String>) = assertTasksUpToDate(*tasks.toTypedArray())