Convert IncrementalJavaChangeIT test to new tests dsl

^KT-45745 In Progress

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

@@ -5,69 +5,28 @@
 
 package org.jetbrains.kotlin.gradle
 
-import org.jetbrains.kotlin.gradle.util.getFileByName
+import org.gradle.api.logging.LogLevel
-import org.jetbrains.kotlin.gradle.util.getFilesByNames
+import org.gradle.testkit.runner.BuildResult
-import org.jetbrains.kotlin.gradle.util.modify
+import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.testbase.*
+import java.nio.file.Path
+import kotlin.io.path.relativeTo
 
-abstract class IncrementalCompilationBaseIT : BaseGradleIT() {
+abstract class IncrementalCompilationBaseIT : KGPBaseTest() {
 
-    protected abstract fun defaultProject(): Project
+    protected abstract val defaultProjectName: String
 
-    override fun defaultBuildOptions() = super.defaultBuildOptions().copy(incremental = true)
+    fun defaultProject(
+        gradleVersion: GradleVersion,
+        test: TestProject.() -> Unit = {}
+    ): TestProject = project(
+        defaultProjectName,
+        gradleVersion,
+        test = test
+    )
 
-    protected fun doTest(
+    override val defaultBuildOptions = super.defaultBuildOptions.copy(
-        fileToModify: String,
+        incremental = true,
-        modifyFileContents: (originalContents: String) -> String,
+        logLevel = LogLevel.DEBUG
-        expectedCompiledFileNames: Collection<String>,
+    )
-    ) {
-        doTest(
-            modifyProject = { projectDir.getFileByName(fileToModify).modify(modifyFileContents) },
-            expectedCompiledFileNames = expectedCompiledFileNames
-        )
-    }
-
-    protected fun doTest(
-        fileToModify: String,
-        modifyFileContents: (originalContents: String) -> String,
-        assertResults: CompiledProject.() -> Unit,
-    ) {
-        doTest(
-            modifyProject = { projectDir.getFileByName(fileToModify).modify(modifyFileContents) },
-            assertResults = { assertResults() }
-        )
-    }
-
-    protected fun doTest(
-        project: Project = defaultProject(),
-        task: String = "build",
-        options: BuildOptions = defaultBuildOptions(),
-        modifyProject: Project.() -> Unit,
-        expectedCompiledFileNames: Collection<String>,
-    ) {
-        doTest(
-            project, task, options, modifyProject,
-            assertResults = {
-                assertCompiledKotlinFiles(project.projectDir.getFilesByNames(*expectedCompiledFileNames.toTypedArray()))
-            }
-        )
-    }
-
-    protected fun doTest(
-        project: Project = defaultProject(),
-        task: String = "build",
-        options: BuildOptions = defaultBuildOptions(),
-        modifyProject: Project.() -> Unit,
-        assertResults: CompiledProject.() -> Unit
-    ) {
-        project.build(task, options = options) {
-            assertSuccessful()
-        }
-
-        modifyProject(project)
-
-        project.build(task, options = options) {
-            assertSuccessful()
-            assertResults()
-        }
-    }
 }

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

@@ -5,129 +5,250 @@
 
 package org.jetbrains.kotlin.gradle
 
-import org.jetbrains.kotlin.gradle.util.getFilesByNames
+import org.gradle.util.GradleVersion
-import org.junit.Test
+import org.jetbrains.kotlin.gradle.testbase.*
-import java.io.File
+import org.junit.jupiter.api.DisplayName
+import java.nio.file.Path
 
+@DisplayName("Default incremental compilation with default precise java tracking")
 open class IncrementalJavaChangeDefaultIT : IncrementalCompilationJavaChangesBase(usePreciseJavaTracking = null) {
-    @Test
+
-    override fun testAbiChangeInLib_changeMethodSignature_tracked() {
+    @DisplayName("Lib: tracked method signature ABI change")
-        doTest(
+    @GradleTest
-            trackedJavaClassInLib, changeMethodSignature,
+    override fun testAbiChangeInLib_changeMethodSignature_tracked(gradleVersion: GradleVersion) {
-            expectedCompiledFileNames = listOf("TrackedJavaClassChild.kt", "useTrackedJavaClass.kt") // In app
+        defaultProject(gradleVersion) {
-        )
+            build("assemble")
+
+            trackedJavaClassInLib.modify(changeMethodSignature)
+
+            build("assemble") {
+                val expectedSources = sourceFilesRelativeToProject(
+                    listOf("foo/TrackedJavaClassChild.kt", "foo/useTrackedJavaClass.kt"),
+                    subProjectName = "app"
+                )
+                assertCompiledKotlinSources(expectedSources, output)
+            }
+        }
     }
 
-    @Test
+    @DisplayName("Lib: tracked method body non-ABI change")
-    override fun testNonAbiChangeInLib_changeMethodBody_tracked() {
+    @GradleTest
-        doTest(
+    override fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion) {
-            trackedJavaClassInLib, changeMethodBody,
+        defaultProject(gradleVersion) {
-            expectedCompiledFileNames = emptyList()
+            build("assemble")
-        )
+
+            trackedJavaClassInLib.modify(changeMethodBody)
+
+            build("assemble") {
+                assertCompiledKotlinSources(emptyList(), output)
+            }
+        }
     }
 }
 
+@DisplayName("Incremental compilation via classpath snapshots with default precise java tracking")
 class IncrementalJavaChangeClasspathSnapshotIT : IncrementalJavaChangeDefaultIT() {
 
-    override fun defaultBuildOptions() = super.defaultBuildOptions().copy(useClasspathSnapshot = true)
+    override val defaultBuildOptions = super.defaultBuildOptions.copy(useGradleClasspathSnapshot = true)
 
-    @Test
+    @DisplayName("Lib: tracked method signature ABI change")
-    override fun testAbiChangeInLib_changeMethodSignature() {
+    @GradleTest
-        doTest(
+    override fun testAbiChangeInLib_changeMethodSignature(gradleVersion: GradleVersion) {
-            javaClassInLib, changeMethodSignature,
+        defaultProject(gradleVersion) {
-            assertResults = {
+            build("assemble")
+
+            javaClassInLib.modify(changeMethodSignature)
+
+            build("assemble") {
                 // Fewer Kotlin files are recompiled
-                assertCompiledKotlinFiles(
+                val expectedSources = sourceFilesRelativeToProject(
-                    File(project.projectDir, "app").getFilesByNames("JavaClassChild.kt", "useJavaClass.kt")
+                    listOf("foo/JavaClassChild.kt", "foo/useJavaClass.kt"),
+                    subProjectName = "app"
                 )
+                assertCompiledKotlinSources(expectedSources, output)
             }
-        )
+        }
     }
 
-    @Test
+    @DisplayName("Lib: method body non-ABI change")
-    override fun testNonAbiChangeInLib_changeMethodBody() {
+    @GradleTest
-        doTest(
+    override fun testNonAbiChangeInLib_changeMethodBody(gradleVersion: GradleVersion) {
-            javaClassInLib, changeMethodBody,
+        defaultProject(gradleVersion) {
-            assertResults = {
+            build("assemble")
+
+            javaClassInLib.modify(changeMethodBody)
+
+            build("assemble") {
                 assertTasksExecuted(":lib:compileKotlin")
                 assertTasksUpToDate(":app:compileKotlin") // App compilation has 'compile avoidance'
-                assertCompiledKotlinFiles(emptyList())
+                assertCompiledKotlinSources(emptyList(), output)
             }
-        )
+        }
     }
 }
 
-class IncrementalJavaChangePreciseIT : IncrementalCompilationJavaChangesBase(usePreciseJavaTracking = true) {
+@DisplayName("Default incremental compilation with enabled precise java tracking")
-    @Test
+class IncrementalJavaChangePreciseIT : IncrementalCompilationJavaChangesBase(
-    override fun testAbiChangeInLib_changeMethodSignature_tracked() {
+    usePreciseJavaTracking = true
-        doTest(
+) {
-            trackedJavaClassInLib,
+    @DisplayName("Lib: tracked method signature ABI change")
-            changeMethodSignature,
+    @GradleTest
-            expectedCompiledFileNames = listOf("TrackedJavaClassChild.kt", "useTrackedJavaClass.kt") // In app
+    override fun testAbiChangeInLib_changeMethodSignature_tracked(gradleVersion: GradleVersion) {
-        )
+        defaultProject(gradleVersion) {
+            build("assemble")
+
+            trackedJavaClassInLib.modify(changeMethodSignature)
+
+            build("assemble") {
+                val expectedSources = sourceFilesRelativeToProject(
+                    listOf("foo/TrackedJavaClassChild.kt", "foo/useTrackedJavaClass.kt"),
+                    subProjectName = "app"
+                )
+                assertCompiledKotlinSources(expectedSources, output)
+            }
+        }
     }
 
-    @Test
+    @DisplayName("Lib: tracked method body non-ABI change")
-    override fun testNonAbiChangeInLib_changeMethodBody_tracked() {
+    @GradleTest
-        doTest(trackedJavaClassInLib, changeMethodBody, expectedCompiledFileNames = emptyList())
+    override fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion) {
+        defaultProject(gradleVersion) {
+            build("assemble")
+
+            trackedJavaClassInLib.modify(changeMethodBody)
+
+            build("assemble") {
+                assertCompiledKotlinSources(emptyList(), output)
+            }
+        }
     }
 }
 
-open class IncrementalJavaChangeDisablePreciseIT : IncrementalCompilationJavaChangesBase(usePreciseJavaTracking = false) {
+@DisplayName("Default incremental compilation with disabled precise java tracking")
-    @Test
+open class IncrementalJavaChangeDisablePreciseIT : IncrementalCompilationJavaChangesBase(
-    override fun testAbiChangeInLib_changeMethodSignature_tracked() {
+    usePreciseJavaTracking = false
-        doTest(
+) {
-            trackedJavaClassInLib, changeMethodSignature,
+    @DisplayName("Lib: tracked method signature ABI change")
-            expectedCompiledFileNames = listOf(
+    @GradleTest
-                "TrackedJavaClassChild.kt", "useTrackedJavaClass.kt", "useTrackedJavaClassFooMethodUsage.kt", // In app
+    override fun testAbiChangeInLib_changeMethodSignature_tracked(gradleVersion: GradleVersion) {
-                "useTrackedJavaClassSameModule.kt" // In lib
+        defaultProject(gradleVersion) {
-            )
+            build("assemble")
-        )
+
+            trackedJavaClassInLib.modify(changeMethodSignature)
+
+            build("assemble") {
+                val expectedSources = sourceFilesRelativeToProject(
+                    listOf(
+                        "foo/TrackedJavaClassChild.kt",
+                        "foo/useTrackedJavaClass.kt",
+                        "foo/useTrackedJavaClassFooMethodUsage.kt"
+                    ),
+                    subProjectName = "app"
+                ) + sourceFilesRelativeToProject(
+                    listOf("bar/useTrackedJavaClassSameModule.kt"),
+                    subProjectName = "lib"
+                )
+                assertCompiledKotlinSources(expectedSources, output)
+            }
+        }
     }
 
-    @Test
+    @DisplayName("Lib: tracked method body non-ABI change")
-    override fun testNonAbiChangeInLib_changeMethodBody_tracked() {
+    @GradleTest
-        doTest(
+    override fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion) {
-            trackedJavaClassInLib, changeMethodBody,
+        defaultProject(gradleVersion) {
-            expectedCompiledFileNames = listOf(
+            build("assemble")
-                "TrackedJavaClassChild.kt", "useTrackedJavaClass.kt", "useTrackedJavaClassFooMethodUsage.kt", // In app
+
-                "useTrackedJavaClassSameModule.kt" // In lib
+            trackedJavaClassInLib.modify(changeMethodBody)
-            )
+
-        )
+            build("assemble") {
+                val expectedSources = sourceFilesRelativeToProject(
+                    listOf(
+                        "foo/TrackedJavaClassChild.kt",
+                        "foo/useTrackedJavaClass.kt",
+                        "foo/useTrackedJavaClassFooMethodUsage.kt"
+                    ),
+                    subProjectName = "app"
+                ) + sourceFilesRelativeToProject(
+                    listOf("bar/useTrackedJavaClassSameModule.kt"),
+                    subProjectName = "lib"
+                )
+                assertCompiledKotlinSources(expectedSources, output)
+            }
+        }
     }
 }
 
+@DisplayName("Default incremental compilation with disabled precise java tracking and enabled FIR")
 class IncrementalFirJavaChangeDisablePreciseIT : IncrementalJavaChangeDisablePreciseIT() {
-    override fun defaultBuildOptions(): BuildOptions {
+    override val defaultBuildOptions = super.defaultBuildOptions.copy(useFir = true)
-        return super.defaultBuildOptions().copy(useFir = true)
-    }
 }
 
-abstract class IncrementalCompilationJavaChangesBase(val usePreciseJavaTracking: Boolean?) : IncrementalCompilationBaseIT() {
+@JvmGradlePluginTests
-    override fun defaultProject() = Project("incrementalMultiproject")
+abstract class IncrementalCompilationJavaChangesBase(
-    override fun defaultBuildOptions() = super.defaultBuildOptions().copy(usePreciseJavaTracking = usePreciseJavaTracking)
+    val usePreciseJavaTracking: Boolean?
+) : IncrementalCompilationBaseIT() {
+    override val defaultProjectName: String
+        get() = "incrementalMultiproject"
 
-    protected val javaClassInLib = "JavaClass.java"
+    override val defaultBuildOptions = super.defaultBuildOptions.copy(usePreciseJavaTracking = usePreciseJavaTracking)
-    protected val trackedJavaClassInLib = "TrackedJavaClass.java"
+
+    protected val TestProject.javaClassInLib: Path get() = subProject("lib").javaSourcesDir().resolve("bar/JavaClass.java")
+    protected val TestProject.trackedJavaClassInLib: Path get() = subProject("lib").javaSourcesDir().resolve("bar/TrackedJavaClass.java")
     protected val changeMethodSignature: (String) -> String = { it.replace("String getString", "Object getString") }
     protected val changeMethodBody: (String) -> String = { it.replace("Hello, World!", "Hello, World!!!!") }
 
-    @Test
+    @DisplayName("Lib: method signature ABI change")
-    open fun testAbiChangeInLib_changeMethodSignature() {
+    @GradleTest
-        doTest(
+    open fun testAbiChangeInLib_changeMethodSignature(gradleVersion: GradleVersion) {
-            javaClassInLib, changeMethodSignature,
+        defaultProject(gradleVersion) {
-            expectedCompiledFileNames = listOf("JavaClassChild.kt", "useJavaClass.kt", "useJavaClassFooMethodUsage.kt") // In app
+            build("assemble")
-        )
+
+            javaClassInLib.modify(changeMethodSignature)
+
+            build("assemble") {
+                val expectedToCompileSources = sourceFilesRelativeToProject(
+                    listOf(
+                        "foo/JavaClassChild.kt",
+                        "foo/useJavaClass.kt",
+                        "foo/useJavaClassFooMethodUsage.kt"
+                    ),
+                    subProjectName = "app"
+                )
+                assertCompiledKotlinSources(
+                    expectedToCompileSources,
+                    output
+                )
+            }
+        }
     }
 
-    @Test
+    @DisplayName("Lib: method body non-ABI change")
-    open fun testNonAbiChangeInLib_changeMethodBody() {
+    @GradleTest
-        doTest(
+    open fun testNonAbiChangeInLib_changeMethodBody(gradleVersion: GradleVersion) {
-            javaClassInLib, changeMethodBody,
+        defaultProject(gradleVersion) {
-            expectedCompiledFileNames = listOf("JavaClassChild.kt", "useJavaClass.kt", "useJavaClassFooMethodUsage.kt") // In app
+            build("assemble")
-        )
+
+            javaClassInLib.modify(changeMethodBody)
+
+            build("assemble") {
+                val expectedToCompileSources = sourceFilesRelativeToProject(
+                    listOf(
+                        "foo/JavaClassChild.kt",
+                        "foo/useJavaClass.kt",
+                        "foo/useJavaClassFooMethodUsage.kt"
+                    ),
+                    subProjectName = "app"
+                )
+
+                assertCompiledKotlinSources(
+                    expectedToCompileSources,
+                    output
+                )
+            }
+        }
     }
 
-    abstract fun testAbiChangeInLib_changeMethodSignature_tracked()
+    abstract fun testAbiChangeInLib_changeMethodSignature_tracked(gradleVersion: GradleVersion)
-    abstract fun testNonAbiChangeInLib_changeMethodBody_tracked()
+    abstract fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion)
 }