From a5c1febf88936706ca6ef6d028363574006e0a38 Mon Sep 17 00:00:00 2001 From: Yahor Berdnikau Date: Mon, 21 Feb 2022 11:31:35 +0100 Subject: [PATCH] Convert IncrementalJavaChangeIT test to new tests dsl ^KT-45745 In Progress --- .../gradle/IncrementalCompilationBaseIT.kt | 81 ++--- .../kotlin/gradle/IncrementalJavaChangeIT.kt | 287 +++++++++++++----- 2 files changed, 224 insertions(+), 144 deletions(-) diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalCompilationBaseIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalCompilationBaseIT.kt index e28e159b4fa..924c998467d 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalCompilationBaseIT.kt +++ b/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.jetbrains.kotlin.gradle.util.getFilesByNames -import org.jetbrains.kotlin.gradle.util.modify +import org.gradle.api.logging.LogLevel +import org.gradle.testkit.runner.BuildResult +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( - fileToModify: String, - modifyFileContents: (originalContents: String) -> String, - expectedCompiledFileNames: Collection, - ) { - 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, - ) { - 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() - } - } + override val defaultBuildOptions = super.defaultBuildOptions.copy( + incremental = true, + logLevel = LogLevel.DEBUG + ) } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt index f044a62eb6a..da41e33d0b6 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalJavaChangeIT.kt +++ b/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.junit.Test -import java.io.File +import org.gradle.util.GradleVersion +import org.jetbrains.kotlin.gradle.testbase.* +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() { - doTest( - trackedJavaClassInLib, changeMethodSignature, - expectedCompiledFileNames = listOf("TrackedJavaClassChild.kt", "useTrackedJavaClass.kt") // In app - ) + + @DisplayName("Lib: tracked method signature ABI change") + @GradleTest + 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 - override fun testNonAbiChangeInLib_changeMethodBody_tracked() { - doTest( - trackedJavaClassInLib, changeMethodBody, - expectedCompiledFileNames = emptyList() - ) + @DisplayName("Lib: tracked method body non-ABI change") + @GradleTest + override fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion) { + defaultProject(gradleVersion) { + 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 - override fun testAbiChangeInLib_changeMethodSignature() { - doTest( - javaClassInLib, changeMethodSignature, - assertResults = { + @DisplayName("Lib: tracked method signature ABI change") + @GradleTest + override fun testAbiChangeInLib_changeMethodSignature(gradleVersion: GradleVersion) { + defaultProject(gradleVersion) { + build("assemble") + + javaClassInLib.modify(changeMethodSignature) + + build("assemble") { // Fewer Kotlin files are recompiled - assertCompiledKotlinFiles( - File(project.projectDir, "app").getFilesByNames("JavaClassChild.kt", "useJavaClass.kt") + val expectedSources = sourceFilesRelativeToProject( + listOf("foo/JavaClassChild.kt", "foo/useJavaClass.kt"), + subProjectName = "app" ) + assertCompiledKotlinSources(expectedSources, output) } - ) + } } - @Test - override fun testNonAbiChangeInLib_changeMethodBody() { - doTest( - javaClassInLib, changeMethodBody, - assertResults = { + @DisplayName("Lib: method body non-ABI change") + @GradleTest + override fun testNonAbiChangeInLib_changeMethodBody(gradleVersion: GradleVersion) { + defaultProject(gradleVersion) { + 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) { - @Test - override fun testAbiChangeInLib_changeMethodSignature_tracked() { - doTest( - trackedJavaClassInLib, - changeMethodSignature, - expectedCompiledFileNames = listOf("TrackedJavaClassChild.kt", "useTrackedJavaClass.kt") // In app - ) +@DisplayName("Default incremental compilation with enabled precise java tracking") +class IncrementalJavaChangePreciseIT : IncrementalCompilationJavaChangesBase( + usePreciseJavaTracking = true +) { + @DisplayName("Lib: tracked method signature ABI change") + @GradleTest + 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 - override fun testNonAbiChangeInLib_changeMethodBody_tracked() { - doTest(trackedJavaClassInLib, changeMethodBody, expectedCompiledFileNames = emptyList()) + @DisplayName("Lib: tracked method body non-ABI change") + @GradleTest + 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) { - @Test - override fun testAbiChangeInLib_changeMethodSignature_tracked() { - doTest( - trackedJavaClassInLib, changeMethodSignature, - expectedCompiledFileNames = listOf( - "TrackedJavaClassChild.kt", "useTrackedJavaClass.kt", "useTrackedJavaClassFooMethodUsage.kt", // In app - "useTrackedJavaClassSameModule.kt" // In lib - ) - ) +@DisplayName("Default incremental compilation with disabled precise java tracking") +open class IncrementalJavaChangeDisablePreciseIT : IncrementalCompilationJavaChangesBase( + usePreciseJavaTracking = false +) { + @DisplayName("Lib: tracked method signature ABI change") + @GradleTest + 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", + "foo/useTrackedJavaClassFooMethodUsage.kt" + ), + subProjectName = "app" + ) + sourceFilesRelativeToProject( + listOf("bar/useTrackedJavaClassSameModule.kt"), + subProjectName = "lib" + ) + assertCompiledKotlinSources(expectedSources, output) + } + } } - @Test - override fun testNonAbiChangeInLib_changeMethodBody_tracked() { - doTest( - trackedJavaClassInLib, changeMethodBody, - expectedCompiledFileNames = listOf( - "TrackedJavaClassChild.kt", "useTrackedJavaClass.kt", "useTrackedJavaClassFooMethodUsage.kt", // In app - "useTrackedJavaClassSameModule.kt" // In lib - ) - ) + @DisplayName("Lib: tracked method body non-ABI change") + @GradleTest + override fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion) { + defaultProject(gradleVersion) { + build("assemble") + + 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 { - return super.defaultBuildOptions().copy(useFir = true) - } + override val defaultBuildOptions = super.defaultBuildOptions.copy(useFir = true) } -abstract class IncrementalCompilationJavaChangesBase(val usePreciseJavaTracking: Boolean?) : IncrementalCompilationBaseIT() { - override fun defaultProject() = Project("incrementalMultiproject") - override fun defaultBuildOptions() = super.defaultBuildOptions().copy(usePreciseJavaTracking = usePreciseJavaTracking) +@JvmGradlePluginTests +abstract class IncrementalCompilationJavaChangesBase( + val usePreciseJavaTracking: Boolean? +) : IncrementalCompilationBaseIT() { + override val defaultProjectName: String + get() = "incrementalMultiproject" - protected val javaClassInLib = "JavaClass.java" - protected val trackedJavaClassInLib = "TrackedJavaClass.java" + override val defaultBuildOptions = super.defaultBuildOptions.copy(usePreciseJavaTracking = usePreciseJavaTracking) + + 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 - open fun testAbiChangeInLib_changeMethodSignature() { - doTest( - javaClassInLib, changeMethodSignature, - expectedCompiledFileNames = listOf("JavaClassChild.kt", "useJavaClass.kt", "useJavaClassFooMethodUsage.kt") // In app - ) + @DisplayName("Lib: method signature ABI change") + @GradleTest + open fun testAbiChangeInLib_changeMethodSignature(gradleVersion: GradleVersion) { + defaultProject(gradleVersion) { + 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 - open fun testNonAbiChangeInLib_changeMethodBody() { - doTest( - javaClassInLib, changeMethodBody, - expectedCompiledFileNames = listOf("JavaClassChild.kt", "useJavaClass.kt", "useJavaClassFooMethodUsage.kt") // In app - ) + @DisplayName("Lib: method body non-ABI change") + @GradleTest + open fun testNonAbiChangeInLib_changeMethodBody(gradleVersion: GradleVersion) { + defaultProject(gradleVersion) { + 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 testNonAbiChangeInLib_changeMethodBody_tracked() + abstract fun testAbiChangeInLib_changeMethodSignature_tracked(gradleVersion: GradleVersion) + abstract fun testNonAbiChangeInLib_changeMethodBody_tracked(gradleVersion: GradleVersion) }