From 1d1645fd2db8d7432c033a377ee638c545159b81 Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Fri, 24 Nov 2023 04:35:47 +0100 Subject: [PATCH] [kotlin-test] Setup KMP project for kotlin-test, targets and source sets KT-61969 --- libraries/kotlin.test/build.gradle.kts | 641 ++++++------------------ libraries/kotlin.test/gradle.properties | 3 + 2 files changed, 152 insertions(+), 492 deletions(-) create mode 100644 libraries/kotlin.test/gradle.properties diff --git a/libraries/kotlin.test/build.gradle.kts b/libraries/kotlin.test/build.gradle.kts index 01fdc4d93fd..c687570287e 100644 --- a/libraries/kotlin.test/build.gradle.kts +++ b/libraries/kotlin.test/build.gradle.kts @@ -1,518 +1,175 @@ -import org.gradle.kotlin.dsl.support.serviceOf -import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType -import plugins.configureDefaultPublishing -import plugins.configureKotlinPomAttributes -import groovy.util.Node -import groovy.util.NodeList -import org.jetbrains.kotlin.gradle.targets.js.KotlinJsCompilerAttribute -import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetAttribute +@file:Suppress("UNUSED_VARIABLE") + +import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl + plugins { - id("org.jetbrains.kotlin.multiplatform") apply false - base + kotlin("multiplatform") `maven-publish` signing } -open class ComponentsFactoryAccess -@javax.inject.Inject -constructor(val factory: SoftwareComponentFactory) +description = "Kotlin Test Library" +base.archivesName = "kotlin-test" -val componentFactory = objects.newInstance().factory +configureJvmToolchain(JdkMajorVersion.JDK_1_8) - -val jvmApi by configurations.creating { - isCanBeConsumed = true - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.jvm) - } -} - -val jvmRuntime by configurations.creating { - isCanBeConsumed = true - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-runtime")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.jvm) - } - extendsFrom(jvmApi) -} - -val jsApiVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.js) - attribute(KotlinJsCompilerAttribute.jsCompilerAttribute, KotlinJsCompilerAttribute.ir) - } -} -val jsRuntimeVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-runtime")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.js) - attribute(KotlinJsCompilerAttribute.jsCompilerAttribute, KotlinJsCompilerAttribute.ir) - } - extendsFrom(jsApiVariant) -} - -val wasmApiVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm) - attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.js) - } -} -val wasmRuntimeVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-runtime")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm) - attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.js) - } - extendsFrom(wasmApiVariant) -} - -val wasmWasiApiVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm) - attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.wasi) - } -} -val wasmWasiRuntimeVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-runtime")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm) - attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.wasi) - } - extendsFrom(wasmWasiApiVariant) -} - -val nativeApiVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.native) - } -} - -val commonVariant by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.common) - } -} - -fun Configuration.sourcesConsumingConfiguration() { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION)) - attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType.SOURCES)) - } -} - -val kotlinTestCommonSources by configurations.creating { - sourcesConsumingConfiguration() -} - -val kotlinTestJvmSources by configurations.creating { - sourcesConsumingConfiguration() -} - -dependencies { - jvmApi(project(":kotlin-stdlib")) - jsApiVariant("$group:kotlin-test-js:$version") - wasmApiVariant("$group:kotlin-test-wasm-js:$version") - wasmWasiApiVariant("$group:kotlin-test-wasm-wasi:$version") - commonVariant(project(":kotlin-test:kotlin-test-common")) - commonVariant(project(":kotlin-test:kotlin-test-annotations-common")) - kotlinTestCommonSources(project(":kotlin-test:kotlin-test-common")) - kotlinTestJvmSources(project(":kotlin-test:kotlin-test-jvm")) -} - -artifacts { - val jvmJar = tasks.getByPath(":kotlin-test:kotlin-test-jvm:jar") - add(jvmApi.name, jvmJar) - add(jvmRuntime.name, jvmJar) -} - -val combinedSourcesJar by tasks.registering(Jar::class) { - dependsOn(kotlinTestCommonSources) - dependsOn(kotlinTestJvmSources) - archiveClassifier.set("sources") - val archiveOperations = serviceOf() - into("common") { - from({ archiveOperations.zipTree(kotlinTestCommonSources.singleFile) }) { - exclude("META-INF/**") - } - } - into("jvm") { - from({ archiveOperations.zipTree(kotlinTestJvmSources.singleFile) }) { - exclude("META-INF/**") - } - } -} - -val combinedJvmSourcesJar by configurations.creating { - isCanBeConsumed = true - isCanBeResolved = false -} - -artifacts { - add(combinedJvmSourcesJar.name, combinedSourcesJar) -} - -val rootComponent = componentFactory.adhoc("root").apply { - addVariantsFromConfiguration(jvmApi) { - mapToMavenScope("compile") - } - addVariantsFromConfiguration(jvmRuntime) { - mapToMavenScope("runtime") - } - addVariantsFromConfiguration(jsApiVariant) { mapToOptional() } - addVariantsFromConfiguration(jsRuntimeVariant) { mapToOptional() } - addVariantsFromConfiguration(wasmApiVariant) { mapToOptional() } - addVariantsFromConfiguration(wasmRuntimeVariant) { mapToOptional() } - addVariantsFromConfiguration(wasmWasiApiVariant) { mapToOptional() } - addVariantsFromConfiguration(wasmWasiRuntimeVariant) { mapToOptional() } - addVariantsFromConfiguration(nativeApiVariant) { mapToOptional() } - addVariantsFromConfiguration(commonVariant) { mapToOptional() } -} - - -val kotlinTestCapability = "$group:kotlin-test:$version" // add to variants with explicit capabilities when the default one is needed, too +val kotlinTestCapability = "$group:${base.archivesName.get()}:$version" // add to variants with explicit capabilities when the default one is needed, too val baseCapability = "$group:kotlin-test-framework:$version" val implCapability = "$group:kotlin-test-framework-impl:$version" -val jvmTestFrameworks = listOf("junit", "junit5", "testng") +enum class JvmTestFramework { + JUnit, + JUnit5, + TestNG; -val frameworkCapabilities = mutableSetOf() - -jvmTestFrameworks.forEach { framework -> - val (apiVariant, runtimeVariant) = listOf("api", "runtime").map { usage -> - configurations.create("${framework}${usage.capitalize()}Variant") { - isCanBeConsumed = true - isCanBeResolved = false - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-$usage")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.jvm) - } - outgoing.capability(baseCapability) // C0 - outgoing.capability( - "$group:kotlin-test-framework-$framework:$version".also { frameworkCapabilities.add(it) } - ) // C0 - } - } - runtimeVariant.extendsFrom(apiVariant) - dependencies { - apiVariant("$group:kotlin-test-$framework:$version") - } - rootComponent.addVariantsFromConfiguration(apiVariant) { mapToOptional() } - rootComponent.addVariantsFromConfiguration(runtimeVariant) { mapToOptional() } - - val (apiElements, runtimeElements) = listOf("api", "runtime").map { usage -> - configurations.create("${framework}${usage.capitalize()}") { - isCanBeConsumed = true - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-$usage")) - } - outgoing.capability(implCapability) // CC - outgoing.capability("$group:kotlin-test-$framework:$version") // CC - } - } - runtimeElements.extendsFrom(apiElements) - dependencies { - apiElements("$group:kotlin-test:$version") - when(framework) { - "junit" -> { - apiElements("junit:junit:4.13.2") - } - "junit5" -> { - apiElements("org.junit.jupiter:junit-jupiter-api:5.6.3") - runtimeElements("org.junit.jupiter:junit-jupiter-engine:5.6.3") - } - "testng" -> { - apiElements("org.testng:testng:6.13.1") - } - } - } - - artifacts { - val jar = tasks.getByPath(":kotlin-test:kotlin-test-$framework:jar") - add(apiElements.name, jar) - add(runtimeElements.name, jar) - } - - componentFactory.adhoc(framework).apply { - addVariantsFromConfiguration(apiElements) { - mapToMavenScope("compile") - } - addVariantsFromConfiguration(runtimeElements) { - mapToMavenScope("runtime") - } - }.let { components.add(it) } + fun lowercase() = name.lowercase() } +val jvmTestFrameworks = JvmTestFramework.values().toList() -/** - * When a consumer's dependency requires a specific test framework (like with auto framework selection), their configurations requesting - * "common" artifacts (such as `*DependenciesMetadata` in MPP) should choose this variant anyway. Otherwise, choosing this variant - * (from a "pure", capability-less dependency on `kotlin-test` appearing transitively in the dependency graph) along with some - * capability-providing *platform* variant leads to incompatible variants being chosen together, causing dependency resolution errors, - * see KTIJ-6098 - */ -commonVariant.apply { - frameworkCapabilities.forEach(outgoing::capability) - outgoing.capability(kotlinTestCapability) -} +kotlin { -val (jsApi, jsRuntime) = listOf("api", "runtime").map { usage -> - configurations.create("js${usage.capitalize()}") { - isCanBeConsumed = true - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-$usage")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.js) - attribute(KotlinJsCompilerAttribute.jsCompilerAttribute, KotlinJsCompilerAttribute.ir) - } - } -} -jsRuntime.extendsFrom(jsApi) - -dependencies { - jsApi(project(":kotlin-stdlib")) -} - -artifacts { - val jsJar = tasks.getByPath(":kotlin-test:kotlin-test-js-ir:jsJar") - add(jsApi.name, jsJar) - add(jsRuntime.name, jsJar) -} - -val jsComponent = componentFactory.adhoc("js").apply { - addVariantsFromConfiguration(jsApi) { - mapToMavenScope("compile") - } - addVariantsFromConfiguration(jsRuntime) { - mapToMavenScope("runtime") - } -} - -val (wasmJsApi, wasmJsRuntime) = listOf("api", "runtime").map { usage -> - configurations.create("wasmJs${usage.capitalize()}") { - isCanBeConsumed = true - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-$usage")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm) - attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.js) - } - } -} -wasmJsRuntime.extendsFrom(wasmJsApi) - -val (wasmWasiApi, wasmWasiRuntime) = listOf("api", "runtime").map { usage -> - configurations.create("wasmWasi${usage.capitalize()}") { - isCanBeConsumed = true - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-$usage")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm) - attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.wasi) - } - } -} -wasmWasiRuntime.extendsFrom(wasmWasiApi) - -dependencies { - wasmJsApi(project(":kotlin-stdlib")) - wasmWasiApi(project(":kotlin-stdlib")) -} - -artifacts { - val wasmKlib = tasks.getByPath(":kotlin-test:kotlin-test-wasm-js:wasmJar") - add(wasmJsApi.name, wasmKlib) { - extension = "klib" - } - add(wasmJsRuntime.name, wasmKlib) { - extension = "klib" - } - val wasmWasiKlib = tasks.getByPath(":kotlin-test:kotlin-test-wasm-wasi:wasmJar") - add(wasmWasiApi.name, wasmWasiKlib) { - extension = "klib" - } - add(wasmWasiRuntime.name, wasmWasiKlib) { - extension = "klib" - } -} - -val wasmComponent = componentFactory.adhoc("wasmJs").apply { - addVariantsFromConfiguration(wasmJsApi) { - mapToMavenScope("compile") - } - addVariantsFromConfiguration(wasmJsRuntime) { - mapToMavenScope("runtime") - } -} - -val wasmWasiComponent = componentFactory.adhoc("wasmWasi").apply { - addVariantsFromConfiguration(wasmWasiApi) { - mapToMavenScope("compile") - } - addVariantsFromConfiguration(wasmWasiRuntime) { - mapToMavenScope("runtime") - } -} - -val commonMetadata by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.common) - } -} -val annotationsMetadata by configurations.creating { - isCanBeConsumed = false - isCanBeResolved = true - attributes { - attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api")) - attribute(KotlinPlatformType.attribute, KotlinPlatformType.common) - } -} -dependencies { - commonMetadata(project(":kotlin-stdlib")) - annotationsMetadata(project(":kotlin-stdlib")) -} -artifacts { - add(commonMetadata.name, tasks.getByPath(":kotlin-test:kotlin-test-common:jar")) - add(annotationsMetadata.name, tasks.getByPath(":kotlin-test:kotlin-test-annotations-common:jar")) -} -val commonMetadataComponent = componentFactory.adhoc("common").apply { - addVariantsFromConfiguration(commonMetadata) { - mapToMavenScope("compile") - } -} -val annotationsMetadataComponent = componentFactory.adhoc("annotations-common").apply { - addVariantsFromConfiguration(annotationsMetadata) { - mapToMavenScope("compile") - } -} - -val emptyJavadocJar by tasks.creating(Jar::class) { - archiveClassifier.set("javadoc") -} - -configureDefaultPublishing() - -publishing { - publications { - val mainPublication = register("main", MavenPublication::class) { - from(rootComponent) - artifact(combinedSourcesJar) - artifact(emptyJavadocJar) - // Remove all optional dependencies from the root pom - pom.withXml { - val dependenciesNode = (asNode().get("dependencies") as NodeList).filterIsInstance().single() - val optionalDependencies = (dependenciesNode.get("dependency") as NodeList).filterIsInstance().filter { - ((it.get("optional") as NodeList).singleOrNull() as Node?)?.text() == "true" + jvm { + compilations { + all { + compileTaskProvider.configure { + compilerOptions { + freeCompilerArgs.empty() // avoid common options set from the root project + } } - optionalDependencies.forEach { dependenciesNode.remove(it) } } - configureKotlinPomAttributes(project, "Kotlin Test Multiplatform library") - suppressAllPomMetadataWarnings() - } - configureSbom( - "Main", "kotlin-test", - setOf(jvmRuntime.name, commonVariant.name), mainPublication - ) - jvmTestFrameworks.forEach { framework -> - val publication = register(framework, MavenPublication::class) { - artifactId = "kotlin-test-$framework" - from(components[framework]) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-$framework:sourcesJar") as Jar) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-$framework:javadocJar") as Jar) - configureKotlinPomAttributes(project, "Kotlin Test Support for $framework") - suppressAllPomMetadataWarnings() + val main by getting + val test by getting + jvmTestFrameworks.forEach { framework -> + val frameworkMain = create("$framework") { + associateWith(main) + } + create("${framework}Test") { + associateWith(frameworkMain) + } } - configureSbom( - framework.capitalize(), "kotlin-test-$framework", - setOf("${framework}Api", commonVariant.name), publication - ) + test.associateWith(getByName("JUnit")) } - val kotlinTestJsPublication = register("js", MavenPublication::class) { - artifactId = "kotlin-test-js" - from(jsComponent) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-js-ir:jsSourcesJar") as org.gradle.jvm.tasks.Jar) - configureKotlinPomAttributes(project, "Kotlin Test for JS", packaging = "klib") + } + js { + if (!kotlinBuildProperties.isTeamcityBuild) { + browser {} } - configureSbom( - "Js", "kotlin-test-js", - setOf(jsRuntime.name, commonVariant.name), kotlinTestJsPublication - ) - val kotlinTestWasmJsPublication = register("wasmJs", MavenPublication::class) { - artifactId = "kotlin-test-wasm-js" - from(wasmComponent) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-wasm-js:sourcesJar") as Jar) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-wasm-js:emptyJavadocJar") as Jar) - configureKotlinPomAttributes(project, "Kotlin Test for Wasm JS", packaging = "klib") + nodejs {} + compilations["main"].compilerOptions.configure { + freeCompilerArgs.add("-Xir-module-name=kotlin-test") } - configureSbom( - "WasmJs", "kotlin-test-wasm-js", - setOf(wasmJsRuntime.name, commonVariant.name), kotlinTestWasmJsPublication - ) - val kotlinTestWasmWasiPublication = register("wasmWasi", MavenPublication::class) { - artifactId = "kotlin-test-wasm-wasi" - from(wasmWasiComponent) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-wasm-wasi:sourcesJar") as Jar) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-wasm-wasi:emptyJavadocJar") as Jar) - configureKotlinPomAttributes(project, "Kotlin Test for Wasm WASI", packaging = "klib") + } + @OptIn(ExperimentalWasmDsl::class) + wasmJs { + nodejs() + compilations["main"].compilerOptions.configure { + freeCompilerArgs.add("-Xir-module-name=kotlin-test") } - configureSbom( - "WasmWasi", "kotlin-test-wasm-wasi", - setOf(wasmWasiRuntime.name, commonVariant.name), kotlinTestWasmWasiPublication - ) - val kotlinTestCommonPublication = register("common", MavenPublication::class) { - artifactId = "kotlin-test-common" - from(commonMetadataComponent) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-common:sourcesJar") as Jar) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-common:javadocJar") as Jar) - configureKotlinPomAttributes(project, "Kotlin Test Common") + } + @OptIn(ExperimentalWasmDsl::class) + wasmWasi { + nodejs() + compilations["main"].compilerOptions.configure { + freeCompilerArgs.add("-Xir-module-name=kotlin-test") } - configureSbom( - "Common", "kotlin-test-common", - setOf(commonMetadata.name), kotlinTestCommonPublication - ) - val annotationsCommonPublication = register("annotationsCommon", MavenPublication::class) { - artifactId = "kotlin-test-annotations-common" - from(annotationsMetadataComponent) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-annotations-common:sourcesJar") as Jar) - artifact(tasks.getByPath(":kotlin-test:kotlin-test-annotations-common:javadocJar") as Jar) - configureKotlinPomAttributes(project, "Kotlin Test Common") + } + + targets.all { + compilations.all { + compileTaskProvider.configure { + compilerOptions { + optIn.add("kotlin.contracts.ExperimentalContracts") + freeCompilerArgs.addAll( + "-Xallow-kotlin-package", + "-Xexpect-actual-classes", + ) + } + } + } + } + + sourceSets { + val commonMain by getting { + dependencies { + api(kotlinStdlib()) + } + } + val annotationsCommonMain by creating { + dependsOn(commonMain) + kotlin.srcDir("annotations-common/src/main/kotlin") + } + val assertionsCommonMain by creating { + dependsOn(commonMain) + kotlin.srcDir("common/src/main/kotlin") + } + val commonTest by getting { + kotlin.srcDir("annotations-common/src/test/kotlin") + kotlin.srcDir("common/src/test/kotlin") + } + val jvmMain by getting { + dependsOn(assertionsCommonMain) + kotlin.srcDir("jvm/src/main/kotlin") + } + val jvmTest by getting { + kotlin.srcDir("jvm/src/test/kotlin") + } + val jvmJUnit by getting { + dependsOn(annotationsCommonMain) + kotlin.srcDir("junit/src/main/kotlin") + resources.srcDir("junit/src/main/resources") + dependencies { + api("junit:junit:4.13.2") + } + } + val jvmJUnitTest by getting { + kotlin.srcDir("junit/src/test/kotlin") + } + val jvmJUnit5 by getting { + dependsOn(annotationsCommonMain) + kotlin.srcDir("junit5/src/main/kotlin") + resources.srcDir("junit5/src/main/resources") + dependencies { + compileOnly("org.junit.jupiter:junit-jupiter-api:5.0.0") + } + } + val jvmJUnit5Test by getting { + kotlin.srcDir("junit5/src/test/kotlin") + dependencies { + runtimeOnly(libs.junit.jupiter.engine) + } + } + val jvmTestNG by getting { + dependsOn(annotationsCommonMain) + kotlin.srcDir("testng/src/main/kotlin") + resources.srcDir("testng/src/main/resources") + dependencies { + api("org.testng:testng:6.13.1") + } + } + val jvmTestNGTest by getting { + kotlin.srcDir("testng/src/test/kotlin") + } + val jsMain by getting { + dependsOn(assertionsCommonMain) + dependsOn(annotationsCommonMain) + kotlin.srcDir("js/src/main/kotlin") + } + val jsTest by getting { + kotlin.srcDir("js/src/test/kotlin") + } + val wasmCommonMain by creating { + dependsOn(assertionsCommonMain) + dependsOn(annotationsCommonMain) + kotlin.srcDir("wasm/src/main/kotlin") + } + val wasmJsMain by getting { + dependsOn(wasmCommonMain) + kotlin.srcDir("wasm/js/src/main/kotlin") + } + val wasmWasiMain by getting { + dependsOn(wasmCommonMain) + kotlin.srcDir("wasm/wasi/src/main/kotlin") } - configureSbom( - "AnnotationsCommon", "kotlin-test-annotations-common", - setOf(annotationsMetadata.name), annotationsCommonPublication - ) } } - -tasks.withType { - enabled = "common" !in (publication.get() as MavenPublication).artifactId -} diff --git a/libraries/kotlin.test/gradle.properties b/libraries/kotlin.test/gradle.properties new file mode 100644 index 00000000000..a649b09eb74 --- /dev/null +++ b/libraries/kotlin.test/gradle.properties @@ -0,0 +1,3 @@ +kotlin.internal.mpp.createDefaultMultiplatformPublications=false +kotlin.internal.mpp.createArchiveTasksForCustomCompilations=true +kotlin.mpp.applyDefaultHierarchyTemplate=false \ No newline at end of file