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,385 +5,388 @@
 
 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(
+        incremental = true,
-            "kaptIncrementalCompilationProject",
+        kaptOptions = super.defaultBuildOptions.kaptOptions!!.copy(
-            GradleVersionRequired.None
+            verbose = true,
-        ).apply {
+            useWorkers = true,
-            setupIncrementalAptProject("AGGREGATING")
+            incrementalKapt = true,
-        }
+            includeCompileClasspath = false
-
-    override fun defaultBuildOptions(): BuildOptions =
-        super.defaultBuildOptions().copy(
-            incremental = true,
-            kaptOptions = KaptOptions(
-                verbose = true,
-                useWorkers = true,
-                incrementalKapt = true,
-                includeCompileClasspath = false
-            )
         )
+    )
 
-    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
-    @Test
+    ): TestProject =
-    fun testIncrementalChanges() {
+        project(
-        val project = getProject()
+            PROJECT_NAME,
-
+            gradleVersion,
-        project.build("clean", "build") {
+            buildOptions,
-            assertSuccessful()
+            buildJdk = buildJdk
+        ) {
+            setupIncrementalAptProject("AGGREGATING")
+            test(this)
         }
 
-        project.projectFile("useB.kt").modify { current -> "$current\nfun otherFunction() {}" }
+    @DisplayName("On incremental changes")
-        project.build("build") {
+    @GradleTest
-            assertSuccessful()
+    fun testIncrementalChanges(gradleVersion: GradleVersion) {
+        kaptProject(gradleVersion) {
+            build("clean", "assemble")
 
-            assertEquals(
+            javaSourcesDir()
-                setOf(
+                .resolve("bar/useB.kt")
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/UseBKt.java").canonicalPath,
+                .modify { current -> "$current\nfun otherFunction() {}" }
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/B.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/UtilKt.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/foo/A.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
-                ), getProcessedSources(output)
-            )
-        }
 
-        project.projectFile("JavaClass.java").modify { current ->
+            build("assemble") {
-            val lastBrace = current.lastIndexOf("}")
+                assertEquals(
-            current.substring(0, lastBrace) + "private void anotherFun() {}\n }"
+                    listOf(
-        }
+                        "$KAPT3_STUBS_PATH/bar/UseBKt.java",
-        project.build("build") {
+                        "$KAPT3_STUBS_PATH/bar/B.java",
-            assertSuccessful()
+                        "$KAPT3_STUBS_PATH/baz/UtilKt.java",
-            assertEquals(
+                        "$KAPT3_STUBS_PATH/foo/A.java",
-                setOf(
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-                    project.projectFile("JavaClass.java").canonicalPath,
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/UseBKt.java").canonicalPath,
+                    getProcessedSources(output)
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/B.java").canonicalPath,
+                )
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/UtilKt.java").canonicalPath,
+            }
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/foo/A.java").canonicalPath,
+
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+            javaSourcesDir().resolve("foo/JavaClass.java").modify { current ->
-                ),
+                val lastBrace = current.lastIndexOf("}")
-                getProcessedSources(output)
+                current.substring(0, lastBrace) + "private void anotherFun() {}\n }"
-            )
+            }
+            build("assemble") {
+                assertEquals(
+                    setOf(
+                        "src/main/java/foo/JavaClass.java",
+                        "$KAPT3_STUBS_PATH/bar/UseBKt.java",
+                        "$KAPT3_STUBS_PATH/bar/B.java",
+                        "$KAPT3_STUBS_PATH/baz/UtilKt.java",
+                        "$KAPT3_STUBS_PATH/foo/A.java",
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
+            }
         }
     }
 
-    @Test
+    @DisplayName("Incremental changes in JDK9+")
-    fun testIncrementalChangesWithJdk9() {
+    @JdkVersions(versions = [JavaVersion.VERSION_1_9])
-        val javaHome = File(System.getProperty("jdk9Home")!!)
+    @GradleWithJdkTest
-        val options = jdk9Options(javaHome)
+    fun testIncrementalChangesWithJdk9(gradleVersion: GradleVersion, jdk: JdkVersions.ProvidedJdk) {
-        val project = getProject()
+        kaptProject(gradleVersion, buildJdk = jdk.location) {
+            build("clean", "assemble")
 
-        project.build("clean", "build", options = options) {
+            javaSourcesDir().resolve("bar/useB.kt").modify { current -> "$current\nfun otherFunction() {}" }
-            assertSuccessful()
+            build("assemble") {
-        }
+                assertEquals(
-
+                    setOf(
-        project.projectFile("useB.kt").modify { current -> "$current\nfun otherFunction() {}" }
+                        "$KAPT3_STUBS_PATH/bar/UseBKt.java",
-        project.build("build", options = options) {
+                        "$KAPT3_STUBS_PATH/bar/B.java",
-            assertSuccessful()
+                        "$KAPT3_STUBS_PATH/baz/UtilKt.java",
-
+                        "$KAPT3_STUBS_PATH/foo/A.java",
-            assertEquals(
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
-                setOf(
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/UseBKt.java").canonicalPath,
+                    getProcessedSources(output)
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/B.java").canonicalPath,
+                )
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/UtilKt.java").canonicalPath,
+            }
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/foo/A.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
-                ), 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(
+                        """
+                        
+                        dependencies {
+                            implementation "org.jetbrains.kotlin:kotlin-stdlib:${'$'}kotlin_version"
+                            kapt files("${processorPath.invariantSeparatorsPath}")
+                        }
+                        """.trimIndent()
+                    )
+            }
 
-                    apply plugin: "kotlin-kapt"
+            subProject("lib").buildGradle.append(
-                dependencies {
-                  implementation "org.jetbrains.kotlin:kotlin-stdlib:${'$'}kotlin_version"
-                  kapt files("${processorPath.invariantSeparatorsPath}")
-                }
-            """.trimIndent()
-            )
-
-            projectDir.resolve("lib/build.gradle").appendText(
                 """
 
                 dependencies {
-                  implementation "org.jetbrains.kotlin:kotlin-stdlib:${'$'}kotlin_version"
+                    implementation "org.jetbrains.kotlin:kotlin-stdlib:${'$'}kotlin_version"
                 }
-            """.trimIndent()
+                """.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")
-            val lastBrace = current.lastIndexOf("}")
+            aKtSourceFile.modify { current ->
-            current.substring(0, lastBrace) + "fun anotherFun() {}\n }"
+                val lastBrace = current.lastIndexOf("}")
-        }
+                current.substring(0, lastBrace) + "fun anotherFun() {}\n }"
-        project.build("build") {
+            }
-            assertSuccessful()
 
-            assertEquals(
+            build("assemble") {
-                setOf(
+                assertEquals(
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/AA.java").canonicalPath,
+                    listOf(
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/AAA.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/AA.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/BB.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/AAA.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseAKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/BB.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseBKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseAKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseAAKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseBKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/foo/FooUseBBKt.java").canonicalPath,
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseAAKt.java",
-                    fileInWorkingDir("app/build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
+                        "app/$KAPT3_STUBS_PATH/foo/FooUseBBKt.java",
+                        "app/$KAPT3_STUBS_PATH/error/NonExistentClass.java"
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
+            }
 
-                ), getProcessedSources(output)
+            aKtSourceFile.modify { current ->
-            )
+                val lastBrace = current.lastIndexOf("}")
-        }
+                current.substring(0, lastBrace) + "private fun privateFunction() {}\n }"
-
+            }
-        project.projectFile("A.kt").modify { current ->
+            build("assemble") {
-            val lastBrace = current.lastIndexOf("}")
+                assertOutputContains("Skipping annotation processing as all sources are up-to-date.")
-            current.substring(0, lastBrace) + "private fun privateFunction() {}\n }"
+            }
-        }
-        project.build("build") {
-            assertSuccessful()
-            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) {
-            current + """
+            val useBSourceFile = javaSourcesDir().resolve("bar/useB.kt")
-                
+            useBSourceFile.modify { current ->
+                current + """
+
                 @example.ExampleAnnotation
                 fun addedFunctionB() = ""
-            """.trimIndent()
+                """.trimIndent()
-        }
-        project.build("clean", "build") {
-            assertSuccessful()
-        }
-
-        project.projectFile("useB.kt").modify { current ->
-            current.replace("fun addedFunctionB", "fun renamedFunctionB")
-        }
-        project.gradleBuildScript().appendText("""
-            
-            dependencies {
-                implementation 'com.google.guava:guava:12.0'
             }
-        """.trimIndent())
-        project.build("build") {
-            assertSuccessful()
 
-            assertFalse(
+            build("clean", "assemble")
-                fileInWorkingDir("build/generated/source/kapt/main/bar/AddedFunctionBGenerated.java").exists(),
+
-                "Generated file should be deleted for renamed function when classpath changes."
+            useBSourceFile.modify { current ->
+                current.replace("fun addedFunctionB", "fun renamedFunctionB")
+            }
+
+            buildGradle.append(
+                """
+
+                dependencies {
+                    implementation 'com.google.guava:guava:12.0'
+                }
+                """.trimIndent()
             )
+            build("assemble") {
+                // Generated file should be deleted for renamed function when classpath changes
+                assertFileInProjectNotExists("build/generated/source/kapt/main/bar/AddedFunctionBGenerated.java")
+            }
         }
     }
 
-    @Test
+    @DisplayName("Incremental aggregating changes")
-    fun testIncrementalAggregatingChanges() {
+    @JdkVersions(versions = [JavaVersion.VERSION_1_8, JavaVersion.VERSION_1_9])
-        doIncrementalAggregatingChanges()
+    @GradleWithJdkTest
+    fun testIncrementalAggregatingChanges(gradleVersion: GradleVersion, jdk: JdkVersions.ProvidedJdk) {
+        doIncrementalAggregatingChanges(gradleVersion, jdk)
     }
 
-    @Test
+    @DisplayName("Incremental binary aggregating changes")
-    fun testIncrementalAggregatingChangesWithJdk9() {
+    @JdkVersions(versions = [JavaVersion.VERSION_1_8, JavaVersion.VERSION_1_9])
-        val javaHome = File(System.getProperty("jdk9Home")!!)
+    @GradleWithJdkTest
-        doIncrementalAggregatingChanges(buildOptions = jdk9Options(javaHome))
+    fun testIncrementalBinaryAggregatingChanges(gradleVersion: GradleVersion, jdk: JdkVersions.ProvidedJdk) {
+        doIncrementalAggregatingChanges(
+            gradleVersion,
+            jdk,
+            true
+        )
     }
 
-    @Test
+    private fun TestProject.checkAggregatingResource(check: (List<String>) -> Unit) {
-    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) {
+            build("clean", "assemble") {
-            assertSuccessful()
+                assertEquals(
+                    listOf(
+                        "$KAPT3_STUBS_PATH/bar/WithAnnotation.java",
+                        "$KAPT3_STUBS_PATH/bar/noAnnotations.java",
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java"
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
 
-            assertEquals(
+                checkAggregatingResource { lines ->
-                setOf(
+                    assertEquals(1, lines.size)
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/WithAnnotation.java").canonicalPath,
+                    assertTrue(lines.contains("WithAnnotationGenerated"))
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/noAnnotations.java").canonicalPath,
+                }
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath
-                ), getProcessedSources(output)
-            )
-
-            checkAggregatingResource { lines ->
-                assertEquals(1, lines.size)
-                assertTrue(lines.contains("WithAnnotationGenerated"))
             }
-        }
 
-        //change file without annotations
+            //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) {
+            build("assemble") {
-            assertSuccessful()
+                assertEquals(
+                    listOfNotNull(
+                        "$KAPT3_STUBS_PATH/bar/NoAnnotationsKt.java",
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
 
-            assertEquals(
+                checkAggregatingResource { lines ->
-                setOf(
+                    assertEquals(1, lines.size)
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/NoAnnotationsKt.java").canonicalPath,
+                    assertTrue(lines.contains("WithAnnotationGenerated"))
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                }
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
-            )
-
-            checkAggregatingResource { lines ->
-                assertEquals(1, lines.size)
-                assertTrue(lines.contains("WithAnnotationGenerated"))
             }
-        }
 
-        //add new file with annotations
+            //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()
+                """.trimIndent()
-        }
-        project.build("build", options = buildOptions) {
-            assertSuccessful()
-            assertEquals(
-                setOf(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/BazClass.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
             )
 
-            checkAggregatingResource { lines ->
+            build("assemble") {
-                assertEquals(2, lines.size)
+                assertEquals(
-                assertTrue(lines.contains("WithAnnotationGenerated"))
+                    listOfNotNull(
-                assertTrue(lines.contains("BazClassGenerated"))
+                        "$KAPT3_STUBS_PATH/baz/BazClass.java",
-            }
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-        }
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
 
-        //move annotation to nested class
+                checkAggregatingResource { lines ->
-        project.projectFile("BazClass.kt").modify {
+                    assertEquals(2, lines.size)
-            """
+                    assertTrue(lines.contains("WithAnnotationGenerated"))
+                    assertTrue(lines.contains("BazClassGenerated"))
+                }
+            }
+
+            //move annotation to nested class
+            newBazClass.modify {
+                """
                 package baz
 
                 class BazClass() {
                     @example.ExampleAnnotation
-                    class BazNested {}                 
+                    class BazNested {}
                 }
-            """.trimIndent()
+                """.trimIndent()
-        }
-        project.build("build", options = buildOptions) {
-            assertSuccessful()
-            assertEquals(
-                setOf(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/baz/BazClass.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
-            )
-
-            checkAggregatingResource { lines ->
-                assertEquals(2, lines.size)
-                assertTrue(lines.contains("WithAnnotationGenerated"))
-                assertTrue(lines.contains("BazNestedGenerated"))
             }
-        }
 
-        //change file without annotations to check that nested class is aggregated
+            build("assemble") {
-        project.projectFile("noAnnotations.kt").modify { current -> "$current\nfun otherFunction2() {}" }
+                assertEquals(
+                    listOfNotNull(
+                        "$KAPT3_STUBS_PATH/baz/BazClass.java",
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
 
-        project.build("build", options = buildOptions) {
+                checkAggregatingResource { lines ->
-            assertSuccessful()
+                    assertEquals(2, lines.size)
-
+                    assertTrue(lines.contains("WithAnnotationGenerated"))
-            assertEquals(
+                    assertTrue(lines.contains("BazNestedGenerated"))
-                setOf(
+                }
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/NoAnnotationsKt.java").canonicalPath,
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
-                    fileInWorkingDir("build/generated/source/kapt/main/bar/WithAnnotationGenerated.java").canonicalPath.takeUnless { isBinary },
-                    fileInWorkingDir("build/generated/source/kapt/main/BazClass/BazNestedGenerated.java").canonicalPath.takeUnless { isBinary },
-                ).filterNotNull().toSet(), getProcessedSources(output)
-            )
-
-            checkAggregatingResource { lines ->
-                assertEquals(2, lines.size)
-                assertTrue(lines.contains("WithAnnotationGenerated"))
-                assertTrue(lines.contains("BazNestedGenerated"))
             }
-        }
 
-        // make sure that changing the origin of isolating that produced
+            //change file without annotations to check that nested class is aggregated
-        project.projectFile("withAnnotation.kt").modify { current -> current.substringBeforeLast("}") + "\nfun otherFunction() {} }" }
+            noAnnotationsSourceFile.modify { current -> "$current\nfun otherFunction2() {}" }
-        project.build("build", options = buildOptions) {
-            assertSuccessful()
 
-            assertEquals(
+            build("assemble") {
-                setOf(
+                assertEquals(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/bar/WithAnnotation.java").canonicalPath,
+                    listOfNotNull(
-                    fileInWorkingDir("build/tmp/kapt3/stubs/main/error/NonExistentClass.java").canonicalPath,
+                        "$KAPT3_STUBS_PATH/bar/NoAnnotationsKt.java",
-                    fileInWorkingDir("build/generated/source/kapt/main/BazClass/BazNestedGenerated.java").canonicalPath.takeUnless { isBinary },
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
-                ).filterNotNull().toSet(), getProcessedSources(output)
+                        "build/generated/source/kapt/main/bar/WithAnnotationGenerated.java".takeUnless { isBinary },
-            )
+                        "build/generated/source/kapt/main/BazClass/BazNestedGenerated.java".takeUnless { isBinary },
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
 
-            checkAggregatingResource { lines ->
+                checkAggregatingResource { lines ->
-                assertEquals(2, lines.size)
+                    assertEquals(2, lines.size)
-                assertTrue(lines.contains("WithAnnotationGenerated"))
+                    assertTrue(lines.contains("WithAnnotationGenerated"))
-                assertTrue(lines.contains("BazNestedGenerated"))
+                    assertTrue(lines.contains("BazNestedGenerated"))
+                }
+            }
+
+            // make sure that changing the origin of isolating that produced
+            javaSourcesDir().resolve("bar/withAnnotation.kt")
+                .modify { current -> current.substringBeforeLast("}") + "\nfun otherFunction() {} }" }
+            build("assemble") {
+                assertEquals(
+                    listOfNotNull(
+                        "$KAPT3_STUBS_PATH/bar/WithAnnotation.java",
+                        "$KAPT3_STUBS_PATH/error/NonExistentClass.java",
+                        "build/generated/source/kapt/main/BazClass/BazNestedGenerated.java".takeUnless { isBinary },
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
+                )
+
+                checkAggregatingResource { lines ->
+                    assertEquals(2, lines.size)
+                    assertTrue(lines.contains("WithAnnotationGenerated"))
+                    assertTrue(lines.contains("BazNestedGenerated"))
+                }
             }
         }
     }
-
+}
-}

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,17 +1,9 @@
-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()
     mavenCentral()
@@ -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"