Migrate KaptIncrementalWithAggregatingApt tests to new test DSL

^KT-45745 In Progress

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

@@ -73,8 +73,10 @@ open class IncrementalCompilationJvmMultiProjectIT : BaseIncrementalCompilationM
         val libBuildGradle = File(lib, "build.gradle")
         libBuildGradle.modify {
             """
-            apply plugin: 'groovy'
+            plugins {
-            apply plugin: 'kotlin'
+                id 'groovy'
+                id 'org.jetbrains.kotlin.jvm'
+            }
 
             dependencies {
                 implementation "org.jetbrains.kotlin:kotlin-stdlib:${"$"}kotlin_version"

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

@@ -5,29 +5,27 @@
 
 package org.jetbrains.kotlin.gradle
 
-import org.jetbrains.kotlin.gradle.incapt.*
+import org.gradle.api.JavaVersion
-import org.jetbrains.kotlin.gradle.util.modify
+import org.gradle.util.GradleVersion
-import org.junit.Assert.assertEquals
+import org.jetbrains.kotlin.gradle.incapt.IncrementalAggregatingProcessor
-import org.junit.Assert.assertTrue
+import org.jetbrains.kotlin.gradle.incapt.IncrementalBinaryIsolatingProcessor
-import org.junit.Assume
+import org.jetbrains.kotlin.gradle.incapt.IncrementalIsolatingProcessor
-import org.junit.Test
+import org.jetbrains.kotlin.gradle.incapt.IncrementalProcessor
+import org.jetbrains.kotlin.gradle.testbase.*
+import org.junit.jupiter.api.DisplayName
 import java.io.File
-import kotlin.test.assertFalse
+import kotlin.io.path.createDirectories
+import kotlin.io.path.readLines
+import kotlin.io.path.writeText
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
+@DisplayName("Kapt incremental tests with aggregating apt")
 class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
 
-    override fun getProject() =
+    override val defaultBuildOptions = super.defaultBuildOptions.copy(
-        Project(
-            "kaptIncrementalCompilationProject",
-            GradleVersionRequired.None
-        ).apply {
-            setupIncrementalAptProject("AGGREGATING")
-        }
-
-    override fun defaultBuildOptions(): BuildOptions =
-        super.defaultBuildOptions().copy(
         incremental = true,
-            kaptOptions = KaptOptions(
+        kaptOptions = super.defaultBuildOptions.kaptOptions!!.copy(
             verbose = true,
             useWorkers = true,
             incrementalKapt = true,
@@ -35,101 +33,109 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
         )
     )
 
-    private fun jdk9Options(javaHome: File): BuildOptions {
+    override fun KGPBaseTest.kaptProject(
-        Assume.assumeTrue("JDK 9 isn't available", javaHome.isDirectory)
+        gradleVersion: GradleVersion,
-        return defaultBuildOptions().copy(javaHome = javaHome)
+        buildOptions: BuildOptions,
+        buildJdk: File?,
+        test: TestProject.() -> Unit
+    ): TestProject =
+        project(
+            PROJECT_NAME,
+            gradleVersion,
+            buildOptions,
+            buildJdk = buildJdk
+        ) {
+            setupIncrementalAptProject("AGGREGATING")
+            test(this)
         }
 
-    @Test
+    @DisplayName("On incremental changes")
-    fun testIncrementalChanges() {
+    @GradleTest
-        val project = getProject()
+    fun testIncrementalChanges(gradleVersion: GradleVersion) {
+        kaptProject(gradleVersion) {
+            build("clean", "assemble")
 
-        project.build("clean", "build") {
+            javaSourcesDir()
-            assertSuccessful()
+                .resolve("bar/useB.kt")
-        }
+                .modify { current -> "$current\nfun otherFunction() {}" }
-
-        project.projectFile("useB.kt").modify { current -> "$current\nfun otherFunction() {}" }
-        project.build("build") {
-            assertSuccessful()
 
+            build("assemble") {
                 assertEquals(
-                setOf(
+                    listOf(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/UseBKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/UseBKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/B.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/B.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/UtilKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/baz/UtilKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/foo/A.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/foo/A.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-                ), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
             }
 
-        project.projectFile("JavaClass.java").modify { current ->
+            javaSourcesDir().resolve("foo/JavaClass.java").modify { current ->
                 val lastBrace = current.lastIndexOf("}")
                 current.substring(0, lastBrace) + "private void anotherFun() {}\n }"
             }
-        project.build("build") {
+            build("assemble") {
-            assertSuccessful()
                 assertEquals(
                     setOf(
-                    project.projectFile("JavaClass.java").canonicalPath,
+                        "src/main/java/foo/JavaClass.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/UseBKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/UseBKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/B.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/B.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/UtilKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/baz/UtilKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/foo/A.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/foo/A.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-                ),
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
                     getProcessedSources(output)
                 )
             }
         }
-
-    @Test
-    fun testIncrementalChangesWithJdk9() {
-        val javaHome = File(System.getProperty("jdk9Home")!!)
-        val options = jdk9Options(javaHome)
-        val project = getProject()
-
-        project.build("clean", "build", options = options) {
-            assertSuccessful()
     }
 
-        project.projectFile("useB.kt").modify { current -> "$current\nfun otherFunction() {}" }
+    @DisplayName("Incremental changes in JDK9+")
-        project.build("build", options = options) {
+    @JdkVersions(versions = [JavaVersion.VERSION_1_9])
-            assertSuccessful()
+    @GradleWithJdkTest
+    fun testIncrementalChangesWithJdk9(gradleVersion: GradleVersion, jdk: JdkVersions.ProvidedJdk) {
+        kaptProject(gradleVersion, buildJdk = jdk.location) {
+            build("clean", "assemble")
 
+            javaSourcesDir().resolve("bar/useB.kt").modify { current -> "$current\nfun otherFunction() {}" }
+            build("assemble") {
                 assertEquals(
                     setOf(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/UseBKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/UseBKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/B.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/B.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/UtilKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/baz/UtilKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/foo/A.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/foo/A.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-                ), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
             }
         }
+    }
 
-    @Test
+    @DisplayName("Changes in classpath triggers incremental compilation")
-    fun testClasspathChanges() {
+    @GradleTest
-        val project = Project(
+    fun testClasspathChanges(gradleVersion: GradleVersion) {
-            "incrementalMultiproject",
+        project("incrementalMultiproject", gradleVersion) {
-            GradleVersionRequired.None
-        ).apply {
-            setupWorkingDir()
             val processorPath = generateProcessor("AGGREGATING" to IncrementalProcessor::class.java)
 
-            projectDir.resolve("app/build.gradle").appendText(
+            subProject("app").buildGradle.modify {
+                it
+                    .replace("// kapt-plugin marker", "id 'org.jetbrains.kotlin.kapt'")
+                    .plus(
                         """
                         
-                    apply plugin: "kotlin-kapt"
                         dependencies {
                             implementation "org.jetbrains.kotlin:kotlin-stdlib:${'$'}kotlin_version"
                             kapt files("${processorPath.invariantSeparatorsPath}")
                         }
                         """.trimIndent()
                     )
+            }
 
-            projectDir.resolve("lib/build.gradle").appendText(
+            subProject("lib").buildGradle.append(
                 """
 
                 dependencies {
@@ -137,127 +143,123 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
                 }
                 """.trimIndent()
             )
-        }
 
-        project.build("clean", ":app:build") {
+            build("clean", ":app:assemble")
-            assertSuccessful()
-        }
 
-        project.projectFile("A.kt").modify { current ->
+            val aKtSourceFile = subProject("lib").kotlinSourcesDir().resolve("bar/A.kt")
+            aKtSourceFile.modify { current ->
                 val lastBrace = current.lastIndexOf("}")
                 current.substring(0, lastBrace) + "fun anotherFun() {}\n }"
             }
-        project.build("build") {
-            assertSuccessful()
 
+            build("assemble") {
                 assertEquals(
-                setOf(
+                    listOf(
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/AA.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/AA.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/AAA.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/AAA.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/BB.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/BB.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseAKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseAKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseBKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseBKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseAAKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseAAKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseBBKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseBBKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+                        "app/$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
-                ), getProcessedSources(output)
+                    getProcessedSources(output)
                 )
             }
 
-        project.projectFile("A.kt").modify { current ->
+            aKtSourceFile.modify { current ->
                 val lastBrace = current.lastIndexOf("}")
                 current.substring(0, lastBrace) + "private fun privateFunction() {}\n }"
             }
-        project.build("build") {
+            build("assemble") {
-            assertSuccessful()
+                assertOutputContains("Skipping annotation processing as all sources are up-to-date.")
-            assertTrue(output.contains("Skipping annotation processing as all sources are up-to-date."))
+            }
         }
     }
 
-    @Test
+    @DisplayName("Should clean previously generated files on incompatible classpath changes")
-    fun testIncompatibleClasspathChanges() {
+    @GradleTest
-        val project = getProject()
+    fun testIncompatibleClasspathChanges(gradleVersion: GradleVersion) {
-        project.projectFile("useB.kt").modify { current ->
+        kaptProject(gradleVersion) {
+            val useBSourceFile = javaSourcesDir().resolve("bar/useB.kt")
+            useBSourceFile.modify { current ->
                 current + """
 
                 @example.ExampleAnnotation
                 fun addedFunctionB() = ""
                 """.trimIndent()
             }
-        project.build("clean", "build") {
-            assertSuccessful()
-        }
 
-        project.projectFile("useB.kt").modify { current ->
+            build("clean", "assemble")
+
+            useBSourceFile.modify { current ->
                 current.replace("fun addedFunctionB", "fun renamedFunctionB")
             }
-        project.gradleBuildScript().appendText("""
+
+            buildGradle.append(
+                """
 
                 dependencies {
                     implementation 'com.google.guava:guava:12.0'
                 }
-        """.trimIndent())
+                """.trimIndent()
-        project.build("build") {
+            )
-            assertSuccessful()
+            build("assemble") {
+                // Generated file should be deleted for renamed function when classpath changes
+                assertFileInProjectNotExists("build/generated/source/kapt/main/bar/AddedFunctionBGenerated.java")
+            }
+        }
+    }
 
-            assertFalse(
+    @DisplayName("Incremental aggregating changes")
-                fileInWorkingDir("build/generated/source/kapt/main/bar/AddedFunctionBGenerated.java").exists(),
+    @JdkVersions(versions = [JavaVersion.VERSION_1_8, JavaVersion.VERSION_1_9])
-                "Generated file should be deleted for renamed function when classpath changes."
+    @GradleWithJdkTest
+    fun testIncrementalAggregatingChanges(gradleVersion: GradleVersion, jdk: JdkVersions.ProvidedJdk) {
+        doIncrementalAggregatingChanges(gradleVersion, jdk)
+    }
+
+    @DisplayName("Incremental binary aggregating changes")
+    @JdkVersions(versions = [JavaVersion.VERSION_1_8, JavaVersion.VERSION_1_9])
+    @GradleWithJdkTest
+    fun testIncrementalBinaryAggregatingChanges(gradleVersion: GradleVersion, jdk: JdkVersions.ProvidedJdk) {
+        doIncrementalAggregatingChanges(
+            gradleVersion,
+            jdk,
+            true
         )
     }
-    }
 
-    @Test
+    private fun TestProject.checkAggregatingResource(check: (List<String>) -> Unit) {
-    fun testIncrementalAggregatingChanges() {
-        doIncrementalAggregatingChanges()
-    }
-
-    @Test
-    fun testIncrementalAggregatingChangesWithJdk9() {
-        val javaHome = File(System.getProperty("jdk9Home")!!)
-        doIncrementalAggregatingChanges(buildOptions = jdk9Options(javaHome))
-    }
-
-    @Test
-    fun testIncrementalBinaryAggregatingChanges() {
-        doIncrementalAggregatingChanges(true)
-    }
-
-    @Test
-    fun testIncrementalBinaryAggregatingChangesWithJdk9() {
-        val javaHome = File(System.getProperty("jdk9Home")!!)
-        val options = jdk9Options(javaHome)
-        doIncrementalAggregatingChanges(true, options)
-    }
-
-    private fun CompiledProject.checkAggregatingResource(check: (List<String>) -> Unit) {
         val aggregatingResource = "build/tmp/kapt3/classes/main/generated.txt"
-        assertFileExists(aggregatingResource)
+        assertFileInProjectExists(aggregatingResource)
-        val lines = fileInWorkingDir(aggregatingResource).readLines()
+        val lines = projectPath.resolve(aggregatingResource).readLines()
         check(lines)
     }
 
-    fun doIncrementalAggregatingChanges(isBinary: Boolean = false, buildOptions: BuildOptions = defaultBuildOptions()) {
+    private fun doIncrementalAggregatingChanges(
-        val project = Project(
+        gradleVersion: GradleVersion,
+        jdk: JdkVersions.ProvidedJdk,
+        isBinary: Boolean = false,
+    ) {
+        project(
             "kaptIncrementalAggregatingProcessorProject",
-            GradleVersionRequired.None
+            gradleVersion,
-        ).apply {
+            buildJdk = jdk.location
+        ) {
             setupIncrementalAptProject(
                 "ISOLATING" to if (isBinary) IncrementalBinaryIsolatingProcessor::class.java else IncrementalIsolatingProcessor::class.java,
                 "AGGREGATING" to IncrementalAggregatingProcessor::class.java
             )
-        }
-
-        project.build("clean", "build", options = buildOptions) {
-            assertSuccessful()
 
+            build("clean", "assemble") {
                 assertEquals(
-                setOf(
+                    listOf(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/WithAnnotation.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/WithAnnotation.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/noAnnotations.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/noAnnotations.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-                ), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
 
                 checkAggregatingResource { lines ->
@@ -267,17 +269,17 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
             }
 
             //change file without annotations
-        project.projectFile("noAnnotations.kt").modify { current -> "$current\nfun otherFunction() {}" }
+            val noAnnotationsSourceFile = javaSourcesDir().resolve("bar/noAnnotations.kt")
-
+            noAnnotationsSourceFile.modify { current -> "$current\nfun otherFunction() {}" }
-        project.build("build", options = buildOptions) {
-            assertSuccessful()
 
+            build("assemble") {
                 assertEquals(
-                setOf(
+                    listOfNotNull(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/NoAnnotationsKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/NoAnnotationsKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
 
                 checkAggregatingResource { lines ->
@@ -287,25 +289,26 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
             }
 
             //add new file with annotations
-        val newFile = File(project.projectDir, "src/main/java/baz/BazClass.kt")
+            val newBazClass = javaSourcesDir().resolve("baz/BazClass.kt").also {
-        newFile.parentFile.mkdirs()
+                it.parent.createDirectories()
-        newFile.createNewFile()
+            }
-        project.projectFile("BazClass.kt").modify {
+            newBazClass.writeText(
                 """
                 package baz
 
                 @example.ExampleAnnotation
                 class BazClass() {}
                 """.trimIndent()
-        }
+            )
-        project.build("build", options = buildOptions) {
+
-            assertSuccessful()
+            build("assemble") {
                 assertEquals(
-                setOf(
+                    listOfNotNull(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/BazClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/baz/BazClass.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
 
                 checkAggregatingResource { lines ->
@@ -316,7 +319,7 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
             }
 
             //move annotation to nested class
-        project.projectFile("BazClass.kt").modify {
+            newBazClass.modify {
                 """
                 package baz
 
@@ -326,14 +329,15 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
                 }
                 """.trimIndent()
             }
-        project.build("build", options = buildOptions) {
+
-            assertSuccessful()
+            build("assemble") {
                 assertEquals(
-                setOf(
+                    listOfNotNull(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/BazClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/baz/BazClass.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
 
                 checkAggregatingResource { lines ->
@@ -344,18 +348,17 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
             }
 
             //change file without annotations to check that nested class is aggregated
-        project.projectFile("noAnnotations.kt").modify { current -> "$current\nfun otherFunction2() {}" }
+            noAnnotationsSourceFile.modify { current -> "$current\nfun otherFunction2() {}" }
-
-        project.build("build", options = buildOptions) {
-            assertSuccessful()
 
+            build("assemble") {
                 assertEquals(
-                setOf(
+                    listOfNotNull(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/NoAnnotationsKt.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/NoAnnotationsKt.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
-                    fileInWorkingDir("build/generated/source/kapt/main/BazClass/BazNestedGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "build/generated/source/kapt/main/BazClass/BazNestedGenerated.java".takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
 
                 checkAggregatingResource { lines ->
@@ -366,16 +369,16 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
             }
 
             // make sure that changing the origin of isolating that produced
-        project.projectFile("withAnnotation.kt").modify { current -> current.substringBeforeLast("}") + "\nfun otherFunction() {} }" }
+            javaSourcesDir().resolve("bar/withAnnotation.kt")
-        project.build("build", options = buildOptions) {
+                .modify { current -> current.substringBeforeLast("}") + "\nfun otherFunction() {} }" }
-            assertSuccessful()
+            build("assemble") {
-
                 assertEquals(
-                setOf(
+                    listOfNotNull(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/WithAnnotation.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/WithAnnotation.java",
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-                    fileInWorkingDir("build/generated/source/kapt/main/BazClass/BazNestedGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "build/generated/source/kapt/main/BazClass/BazNestedGenerated.java".takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
                 )
 
                 checkAggregatingResource { lines ->
@@ -385,5 +388,5 @@ class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
                 }
             }
         }
-
+    }
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/incrementalMultiproject/app/build.gradle

@@ -1,6 +1,8 @@
-apply plugin: 'kotlin'
+plugins {
+    id "org.jetbrains.kotlin.jvm"
+    // kapt-plugin marker
+}
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation project(':lib')
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/incrementalMultiproject/build.gradle

@@ -1,3 +1,4 @@
+// Remove buildscript block once js incremental test will be migrated
 buildscript {
     repositories {
         mavenLocal()

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/incrementalMultiproject/lib/build.gradle

@@ -1,5 +1,3 @@
-apply plugin: 'kotlin'
+plugins {
-
+    id 'org.jetbrains.kotlin.jvm'
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kaptIncrementalAggregatingProcessorProject/build.gradle

@@ -1,16 +1,8 @@
-buildscript {
+plugins {
-    repositories {
+    id 'java'
-        mavenLocal()
+    id 'org.jetbrains.kotlin.jvm'
-        mavenCentral()
+    id 'org.jetbrains.kotlin.kapt'
 }
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: "java"
-apply plugin: "kotlin"
-apply plugin: "kotlin-kapt"
 
 repositories {
     mavenLocal()
@@ -21,7 +13,6 @@ repositories {
 }
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
     kapt "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
     kapt "org.jetbrains.intellij.deps:asm-all:9.0"