Sebastian Sellmair
428 lines
15 KiB
Kotlin
428 lines
15 KiB
Kotlin
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
|
|
import org.jetbrains.kotlin.pill.PillExtension
|
|
|
|
plugins {
|
|
kotlin("jvm")
|
|
kotlin("plugin.serialization")
|
|
id("jps-compatible")
|
|
}
|
|
|
|
pill {
|
|
variant = PillExtension.Variant.FULL
|
|
}
|
|
|
|
testsJar()
|
|
|
|
kotlin.sourceSets.all {
|
|
languageSettings.optIn("org.jetbrains.kotlin.gradle.InternalKotlinGradlePluginApi")
|
|
}
|
|
|
|
val kotlinGradlePluginTest = project(":kotlin-gradle-plugin").sourceSets.named("test").map { it.output }
|
|
|
|
dependencies {
|
|
testImplementation(project(":kotlin-gradle-plugin")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:kotlin-gradle-plugin-common")
|
|
}
|
|
}
|
|
testImplementation(project(":kotlin-allopen")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:kotlin-allopen-common")
|
|
}
|
|
}
|
|
testImplementation(project(":kotlin-noarg")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:kotlin-noarg-common")
|
|
}
|
|
}
|
|
testImplementation(project(":kotlin-lombok")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:kotlin-lombok-common")
|
|
}
|
|
}
|
|
testImplementation(project(":kotlin-sam-with-receiver")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:kotlin-sam-with-receiver-common")
|
|
}
|
|
}
|
|
testImplementation(project(":kotlin-assignment")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:kotlin-assignment-common")
|
|
}
|
|
}
|
|
testImplementation(project(":atomicfu")) {
|
|
capabilities {
|
|
requireCapability("org.jetbrains.kotlin:atomicfu-common")
|
|
}
|
|
}
|
|
|
|
testImplementation(project(":kotlin-gradle-compiler-types"))
|
|
testImplementation(project(":kotlin-gradle-plugin-idea"))
|
|
testImplementation(testFixtures(project(":kotlin-gradle-plugin-idea")))
|
|
testImplementation(project(":kotlin-gradle-plugin-idea-proto"))
|
|
|
|
testImplementation(project(":kotlin-gradle-plugin-model"))
|
|
testImplementation(project(":kotlin-gradle-build-metrics"))
|
|
testImplementation(project(":kotlin-tooling-metadata"))
|
|
testImplementation(kotlinGradlePluginTest)
|
|
testImplementation(project(":kotlin-gradle-subplugin-example"))
|
|
testImplementation(project(":kotlin-test:kotlin-test-jvm"))
|
|
testImplementation(project(":kotlin-util-klib"))
|
|
|
|
testImplementation(project(":native:kotlin-native-utils"))
|
|
testImplementation(project(":native:kotlin-klib-commonizer-api"))
|
|
|
|
testImplementation(project(":kotlin-compiler-embeddable"))
|
|
testImplementation(commonDependency("org.jetbrains.intellij.deps:jdom"))
|
|
testImplementation(project(":compiler:cli-common"))
|
|
testImplementation(project(":compiler:build-tools:kotlin-build-statistics"))
|
|
// testCompileOnly dependency on non-shaded artifacts is needed for IDE support
|
|
// testRuntimeOnly on shaded artifact is needed for running tests with shaded compiler
|
|
testCompileOnly(project(":kotlin-gradle-plugin-test-utils-embeddable"))
|
|
testRuntimeOnly(project(":kotlin-gradle-plugin-test-utils-embeddable")) { isTransitive = false }
|
|
|
|
testImplementation(project(path = ":examples:annotation-processor-example"))
|
|
testImplementation(kotlinStdlib("jdk8"))
|
|
testImplementation(project(":kotlin-parcelize-compiler"))
|
|
testImplementation(commonDependency("org.jetbrains.intellij.deps", "trove4j"))
|
|
testImplementation(commonDependency("org.jetbrains.kotlinx", "kotlinx-serialization-json"))
|
|
testImplementation(libs.ktor.client.cio)
|
|
testImplementation(libs.ktor.client.mock)
|
|
testImplementation(libs.ktor.server.core)
|
|
testImplementation(libs.ktor.server.netty)
|
|
testImplementation(libs.ktor.server.test.host)
|
|
|
|
testImplementation(gradleApi())
|
|
testImplementation(gradleTestKit())
|
|
testImplementation(commonDependency("com.google.code.gson:gson"))
|
|
testApiJUnit5(vintageEngine = true, jupiterParams = true)
|
|
|
|
testRuntimeOnly(project(":compiler:tests-mutes"))
|
|
|
|
// Workaround for missing transitive import of the common(project `kotlin-test-common`
|
|
// for `kotlin-test-jvm` into the IDE:
|
|
testCompileOnly(project(":kotlin-test:kotlin-test-common")) { isTransitive = false }
|
|
testCompileOnly(commonDependency("org.jetbrains.intellij.deps:asm-all"))
|
|
}
|
|
|
|
// Aapt2 from Android Gradle Plugin 3.2 and below does not handle long paths on Windows.
|
|
val shortenTempRootName = project.providers.systemProperty("os.name").get().contains("Windows")
|
|
|
|
val splitGradleIntegrationTestTasks =
|
|
project.providers.gradleProperty("gradle.integration.tests.split.tasks").orNull?.toBoolean()
|
|
?: project.kotlinBuildProperties.isTeamcityBuild
|
|
|
|
tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
|
|
kotlinOptions.freeCompilerArgs += "-opt-in=kotlin.io.path.ExperimentalPathApi"
|
|
}
|
|
|
|
val cleanTestKitCacheTask = tasks.register<Delete>("cleanTestKitCache") {
|
|
group = "Build"
|
|
description = "Deletes temporary Gradle TestKit cache"
|
|
|
|
delete(project.buildDir.resolve("testKitCache"))
|
|
}
|
|
|
|
fun Test.includeMppAndAndroid(include: Boolean) = includeTestsWithPattern(include) {
|
|
addAll(listOf("*Multiplatform*", "*Mpp*", "*Android*"))
|
|
}
|
|
|
|
fun Test.includeNative(include: Boolean) = includeTestsWithPattern(include) {
|
|
addAll(listOf("org.jetbrains.kotlin.gradle.native.*", "*Commonizer*"))
|
|
}
|
|
|
|
fun Test.includeTestsWithPattern(include: Boolean, patterns: (MutableSet<String>).() -> Unit) {
|
|
if (splitGradleIntegrationTestTasks) {
|
|
val filter = if (include)
|
|
filter.includePatterns
|
|
else
|
|
filter.excludePatterns
|
|
filter.patterns()
|
|
}
|
|
}
|
|
|
|
fun Test.advanceGradleVersion() {
|
|
val gradleVersionForTests = "8.1.1"
|
|
systemProperty("kotlin.gradle.version.for.tests", gradleVersionForTests)
|
|
}
|
|
|
|
// additional configuration in tasks.withType<Test> below
|
|
projectTest(
|
|
"test",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
includeMppAndAndroid(false)
|
|
includeNative(false)
|
|
}
|
|
|
|
projectTest(
|
|
"testAdvanceGradleVersion",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
advanceGradleVersion()
|
|
includeMppAndAndroid(false)
|
|
includeNative(false)
|
|
}
|
|
|
|
projectTest(
|
|
"testKpmModelMapping",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
systemProperty("kotlin.gradle.kpm.enableModelMapping", "true")
|
|
includeMppAndAndroid(true)
|
|
includeNative(false)
|
|
}
|
|
|
|
projectTest(
|
|
"testAdvanceGradleVersionKpmModelMapping",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
systemProperty("kotlin.gradle.kpm.enableModelMapping", "true")
|
|
advanceGradleVersion()
|
|
includeMppAndAndroid(true)
|
|
includeNative(false)
|
|
}
|
|
|
|
if (splitGradleIntegrationTestTasks) {
|
|
projectTest(
|
|
"testNative",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
includeNative(true)
|
|
}
|
|
|
|
projectTest(
|
|
"testAdvanceGradleVersionNative",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
advanceGradleVersion()
|
|
includeNative(true)
|
|
}
|
|
|
|
projectTest(
|
|
"testMppAndAndroid",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
includeMppAndAndroid(true)
|
|
}
|
|
|
|
projectTest(
|
|
"testAdvanceGradleVersionMppAndAndroid",
|
|
shortenTempRootName = shortenTempRootName,
|
|
jUnitMode = JUnitMode.JUnit5
|
|
) {
|
|
advanceGradleVersion()
|
|
includeMppAndAndroid(true)
|
|
}
|
|
}
|
|
|
|
val KGP_TEST_TASKS_GROUP = "Kotlin Gradle Plugin Verification"
|
|
val memoryPerGradleTestWorkerMb = 6000
|
|
val maxParallelTestForks =
|
|
(totalMaxMemoryForTestsMb / memoryPerGradleTestWorkerMb).coerceIn(1, Runtime.getRuntime().availableProcessors())
|
|
|
|
val allParallelTestsTask = tasks.register<Test>("kgpAllParallelTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Runs all tests for Kotlin Gradle plugins except daemon ones"
|
|
|
|
maxParallelForks = maxParallelTestForks
|
|
|
|
useJUnitPlatform {
|
|
excludeTags("DaemonsKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
val jvmTestsTask = tasks.register<Test>("kgpJvmTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run tests for Kotlin/JVM part of Gradle plugin"
|
|
maxParallelForks = maxParallelTestForks
|
|
useJUnitPlatform {
|
|
includeTags("JvmKGP")
|
|
excludeTags("JsKGP", "NativeKGP", "DaemonsKGP", "OtherKGP", "MppKGP", "AndroidKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
val jsTestsTask = tasks.register<Test>("kgpJsTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run tests for Kotlin/JS part of Gradle plugin"
|
|
maxParallelForks = maxParallelTestForks
|
|
useJUnitPlatform {
|
|
includeTags("JsKGP")
|
|
excludeTags("JvmKGP", "NativeKGP", "DaemonsKGP", "OtherKGP", "MppKGP", "AndroidKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
val nativeTestsTask = tasks.register<Test>("kgpNativeTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run tests for Kotlin/Native part of Gradle plugin"
|
|
maxParallelForks = maxParallelTestForks
|
|
useJUnitPlatform {
|
|
includeTags("NativeKGP")
|
|
excludeTags("JvmKGP", "JsKGP", "DaemonsKGP", "OtherKGP", "MppKGP", "AndroidKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
// Daemon tests could run only sequentially as they could not be shared between parallel test builds
|
|
val daemonsTestsTask = tasks.register<Test>("kgpDaemonTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run only Gradle and Kotlin daemon tests for Kotlin Gradle Plugin"
|
|
maxParallelForks = 1
|
|
|
|
useJUnitPlatform {
|
|
includeTags("DaemonsKGP")
|
|
excludeTags("JvmKGP", "JsKGP", "NativeKGP", "OtherKGP", "MppKGP", "AndroidKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
val otherPluginsTestTask = tasks.register<Test>("kgpOtherTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run tests for all support plugins, such as kapt, allopen, etc"
|
|
maxParallelForks = maxParallelTestForks
|
|
useJUnitPlatform {
|
|
includeTags("OtherKGP")
|
|
excludeTags("JvmKGP", "JsKGP", "NativeKGP", "DaemonsKGP", "MppKGP", "AndroidKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
val mppTestsTask = tasks.register<Test>("kgpMppTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run Multiplatform Kotlin Gradle plugin tests"
|
|
maxParallelForks = maxParallelTestForks
|
|
useJUnitPlatform {
|
|
includeTags("MppKGP")
|
|
excludeTags("JvmKGP", "JsKGP", "NativeKGP", "DaemonsKGP", "OtherKGP", "AndroidKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
val androidTestsTask = tasks.register<Test>("kgpAndroidTests") {
|
|
group = KGP_TEST_TASKS_GROUP
|
|
description = "Run Android Kotlin Gradle plugin tests"
|
|
maxParallelForks = maxParallelTestForks
|
|
useJUnitPlatform {
|
|
includeTags("AndroidKGP")
|
|
excludeTags("JvmKGP", "JsKGP", "NativeKGP", "DaemonsKGP", "OtherKGP", "MppKGP")
|
|
includeEngines("junit-jupiter")
|
|
}
|
|
}
|
|
|
|
tasks.named<Task>("check") {
|
|
dependsOn("testAdvanceGradleVersion")
|
|
dependsOn(jvmTestsTask, jsTestsTask, nativeTestsTask, daemonsTestsTask, otherPluginsTestTask, mppTestsTask, androidTestsTask)
|
|
if (splitGradleIntegrationTestTasks) {
|
|
dependsOn("testAdvanceGradleVersionMppAndAndroid")
|
|
dependsOn("testMppAndAndroid")
|
|
dependsOn("testNative")
|
|
dependsOn("testAdvanceGradleVersionNative")
|
|
}
|
|
}
|
|
|
|
tasks.withType<Test> {
|
|
val noTestProperty = project.providers.gradleProperty("noTest")
|
|
onlyIf { !noTestProperty.isPresent }
|
|
|
|
dependsOn(":kotlin-gradle-plugin:validatePlugins")
|
|
dependsOnKotlinGradlePluginInstall()
|
|
dependsOn(":gradle:android-test-fixes:install")
|
|
dependsOn(":gradle:gradle-warnings-detector:install")
|
|
dependsOn(":gradle:kotlin-compiler-args-properties:install")
|
|
dependsOn(":examples:annotation-processor-example:install")
|
|
dependsOn(":kotlin-dom-api-compat:install")
|
|
|
|
systemProperty("kotlinVersion", rootProject.extra["kotlinVersion"] as String)
|
|
systemProperty("runnerGradleVersion", gradle.gradleVersion)
|
|
|
|
val installCocoapods = project.findProperty("installCocoapods") as String?
|
|
if (installCocoapods != null) {
|
|
systemProperty("installCocoapods", installCocoapods)
|
|
}
|
|
|
|
val jdk8Provider = project.getToolchainJdkHomeFor(JdkMajorVersion.JDK_1_8)
|
|
val jdk9Provider = project.getToolchainJdkHomeFor(JdkMajorVersion.JDK_9_0)
|
|
val jdk10Provider = project.getToolchainJdkHomeFor(JdkMajorVersion.JDK_10_0)
|
|
val jdk11Provider = project.getToolchainJdkHomeFor(JdkMajorVersion.JDK_11_0)
|
|
val jdk16Provider = project.getToolchainJdkHomeFor(JdkMajorVersion.JDK_16_0)
|
|
val jdk17Provider = project.getToolchainJdkHomeFor(JdkMajorVersion.JDK_17_0)
|
|
val mavenLocalRepo = project.providers.systemProperty("maven.repo.local").orNull
|
|
|
|
// Query required JDKs paths only on execution phase to avoid triggering auto-download on project configuration phase
|
|
// names should follow "jdk\\d+Home" regex where number is a major JDK version
|
|
doFirst {
|
|
systemProperty("jdk8Home", jdk8Provider.get())
|
|
systemProperty("jdk9Home", jdk9Provider.get())
|
|
systemProperty("jdk10Home", jdk10Provider.get())
|
|
systemProperty("jdk11Home", jdk11Provider.get())
|
|
systemProperty("jdk16Home", jdk16Provider.get())
|
|
systemProperty("jdk17Home", jdk17Provider.get())
|
|
if (mavenLocalRepo != null) {
|
|
systemProperty("maven.repo.local", mavenLocalRepo)
|
|
}
|
|
}
|
|
|
|
useAndroidSdk()
|
|
|
|
val shouldApplyJunitPlatform = name !in setOf(
|
|
allParallelTestsTask.name,
|
|
jvmTestsTask.name,
|
|
jsTestsTask.name,
|
|
nativeTestsTask.name,
|
|
daemonsTestsTask.name,
|
|
otherPluginsTestTask.name,
|
|
mppTestsTask.name,
|
|
androidTestsTask.name
|
|
)
|
|
if (shouldApplyJunitPlatform) {
|
|
maxHeapSize = "512m"
|
|
useJUnitPlatform {
|
|
includeEngines("junit-vintage")
|
|
}
|
|
}
|
|
|
|
testLogging {
|
|
// set options for log level LIFECYCLE
|
|
events("passed", "skipped", "failed", "standardOut")
|
|
showExceptions = true
|
|
exceptionFormat = TestExceptionFormat.FULL
|
|
showCauses = true
|
|
showStackTraces = true
|
|
|
|
// set options for log level DEBUG and INFO
|
|
debug {
|
|
events("started", "passed", "skipped", "failed", "standardOut", "standardError")
|
|
exceptionFormat = TestExceptionFormat.FULL
|
|
}
|
|
info.events = debug.events
|
|
info.exceptionFormat = debug.exceptionFormat
|
|
|
|
addTestListener(object : TestListener {
|
|
override fun afterSuite(desc: TestDescriptor, result: TestResult) {
|
|
if (desc.parent == null) { // will match the outermost suite
|
|
val output =
|
|
"Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
|
|
val startItem = "| "
|
|
val endItem = " |"
|
|
val repeatLength = startItem.length + output.length + endItem.length
|
|
println("\n" + ("-".repeat(repeatLength)) + "\n" + startItem + output + endItem + "\n" + ("-".repeat(repeatLength)))
|
|
}
|
|
}
|
|
|
|
override fun beforeSuite(suite: TestDescriptor) {}
|
|
override fun afterTest(testDescriptor: TestDescriptor, result: TestResult) {}
|
|
override fun beforeTest(testDescriptor: TestDescriptor) {}
|
|
})
|
|
}
|
|
}
|