[Wasm] Add wasi kotlin.test target gradle buildscript

gradle/verification-metadata.xml

@@ -65,7 +65,8 @@
          <trust group="org.jetbrains.kotlin" name="kotlin-test-js-runner" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
          <trust group="org.jetbrains.kotlin" name="kotlin-test-junit" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
          <trust group="org.jetbrains.kotlin" name="kotlin-test-junit5" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
-         <trust group="org.jetbrains.kotlin" name="kotlin-test-wasm" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
+         <trust group="org.jetbrains.kotlin" name="kotlin-test-wasm-js" version="1.9.2?[0-9](-.+)?" regex="true"/>
+         <trust group="org.jetbrains.kotlin" name="kotlin-test-wasm-wasi" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
          <trust group="org.jetbrains.kotlin" name="kotlin-tooling-core" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
          <trust group="org.jetbrains.kotlin" name="kotlin-tooling-metadata" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>
          <trust group="org.jetbrains.kotlin" name="kotlin-util-io" version="1.9.[2,3]?[0-9](-.+)?" regex="true"/>

libraries/kotlin.test/build.gradle.kts

@@ -5,6 +5,7 @@ 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
 
 plugins {
     id("org.jetbrains.kotlin.multiplatform") apply false
@@ -63,6 +64,7 @@ val wasmApiVariant by configurations.creating {
     attributes {
         attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api"))
         attribute(KotlinPlatformType.attribute, KotlinPlatformType.wasm)
+        attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, KotlinWasmTargetAttribute.js)
     }
 }
 val wasmRuntimeVariant by configurations.creating {
@@ -71,10 +73,31 @@ val wasmRuntimeVariant by configurations.creating {
     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
@@ -113,7 +136,8 @@ val kotlinTestJvmSources by configurations.creating {
 dependencies {
     jvmApi(project(":kotlin-stdlib"))
     jsApiVariant("$group:kotlin-test-js:$version")
-    wasmApiVariant("$group:kotlin-test-wasm:$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"))
@@ -163,6 +187,8 @@ val rootComponent = componentFactory.adhoc("root").apply {
     addVariantsFromConfiguration(jsRuntimeVariant) { mapToOptional() }
     addVariantsFromConfiguration(wasmApiVariant) { mapToOptional() }
     addVariantsFromConfiguration(wasmRuntimeVariant) { mapToOptional() }
+    addVariantsFromConfiguration(wasmWasiApiVariant) { mapToOptional() }
+    addVariantsFromConfiguration(wasmWasiRuntimeVariant) { mapToOptional() }
     addVariantsFromConfiguration(nativeApiVariant) { mapToOptional() }
     addVariantsFromConfiguration(commonVariant) { mapToOptional() }
 }
@@ -308,37 +334,68 @@ val jsComponent = componentFactory.adhoc("js").apply {
     }
 }
 
-val (wasmApi, wasmRuntime) = listOf("api", "runtime").map { usage ->
-    configurations.create("wasm${usage.capitalize()}") {
+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)
         }
     }
 }
-wasmRuntime.extendsFrom(wasmApi)
+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 {
-    wasmApi(project(":kotlin-stdlib-wasm-js"))
+    wasmJsApi(project(":kotlin-stdlib-wasm-js"))
+    wasmWasiApi(project(":kotlin-stdlib-wasm-wasi"))
 }
 
 artifacts {
-    val wasmKlib = tasks.getByPath(":kotlin-test:kotlin-test-wasm:wasmJar")
-    add(wasmApi.name, wasmKlib) {
+    val wasmKlib = tasks.getByPath(":kotlin-test:kotlin-test-wasm-js:wasmJar")
+    add(wasmJsApi.name, wasmKlib) {
         extension = "klib"
     }
-    add(wasmRuntime.name, wasmKlib) {
+    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("wasm").apply {
-    addVariantsFromConfiguration(wasmApi) {
+val wasmComponent = componentFactory.adhoc("wasmJs").apply {
+    addVariantsFromConfiguration(wasmJsApi) {
         mapToMavenScope("compile")
     }
-    addVariantsFromConfiguration(wasmRuntime) {
+    addVariantsFromConfiguration(wasmJsRuntime) {
+        mapToMavenScope("runtime")
+    }
+}
+
+val wasmWasiComponent = componentFactory.adhoc("wasmWasi").apply {
+    addVariantsFromConfiguration(wasmWasiApi) {
+        mapToMavenScope("compile")
+    }
+    addVariantsFromConfiguration(wasmWasiRuntime) {
         mapToMavenScope("runtime")
     }
 }
@@ -430,16 +487,27 @@ publishing {
             "Js", "kotlin-test-js",
             setOf(jsRuntime.name, commonVariant.name), kotlinTestJsPublication
         )
-        val kotlinTestWasmPublication = register("wasm", MavenPublication::class) {
-            artifactId = "kotlin-test-wasm"
+        val kotlinTestWasmJsPublication = register("wasmJs", MavenPublication::class) {
+            artifactId = "kotlin-test-wasm-js"
             from(wasmComponent)
-            artifact(tasks.getByPath(":kotlin-test:kotlin-test-wasm:sourcesJar") as Jar)
-            artifact(tasks.getByPath(":kotlin-test:kotlin-test-wasm:emptyJavadocJar") as Jar)
-            configureKotlinPomAttributes(project, "Kotlin Test for WASM", packaging = "klib")
+            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")
         }
         configureSbom(
-            "Wasm", "kotlin-test-wasm",
-            setOf(wasmRuntime.name, commonVariant.name), kotlinTestWasmPublication
+            "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")
+        }
+        configureSbom(
+            "WasmWasi", "kotlin-test-wasm-wasi",
+            setOf(wasmWasiRuntime.name, commonVariant.name), kotlinTestWasmWasiPublication
         )
         val kotlinTestCommonPublication = register("common", MavenPublication::class) {
             artifactId = "kotlin-test-common"

libraries/kotlin.test/wasm/build.gradle.kts

@@ -1,63 +0,0 @@
-import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
-
-plugins {
-    kotlin("multiplatform")
-}
-
-val commonMainSources by task<Sync> {
-    from(
-        "$rootDir/libraries/kotlin.test/common/src",
-        "$rootDir/libraries/kotlin.test/annotations-common/src"
-    )
-    into("$buildDir/commonMainSources")
-}
-
-kotlin {
-    @Suppress("DEPRECATION")
-    @OptIn(org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl::class)
-    wasm("wasm") {
-        nodejs()
-    }
-
-    sourceSets {
-        named("commonMain") {
-            dependencies {
-                api(project(":kotlin-stdlib-wasm-js"))
-            }
-            kotlin.srcDir(commonMainSources.get().destinationDir)
-        }
-
-        named("wasmMain") {
-            dependencies {
-                api(project(":kotlin-stdlib-wasm-js"))
-            }
-            kotlin.srcDirs("$rootDir/libraries/kotlin.test/wasm/src")
-            kotlin.srcDirs("$rootDir/libraries/kotlin.test/wasm/js/main/kotlin/kotlin/test")
-        }
-    }
-}
-
-tasks.withType<KotlinCompile<*>>().configureEach {
-    kotlinOptions.freeCompilerArgs += listOf(
-        "-Xallow-kotlin-package",
-        "-opt-in=kotlin.ExperimentalMultiplatform",
-        "-opt-in=kotlin.contracts.ExperimentalContracts",
-        "-Xwasm-target=wasm-js"
-    )
-}
-
-tasks.named("compileKotlinWasm", KotlinCompile::class.java) {
-    kotlinOptions.freeCompilerArgs += "-Xir-module-name=kotlin-test"
-    dependsOn(commonMainSources)
-}
-
-tasks.register<Jar>("sourcesJar") {
-    dependsOn(commonMainSources)
-    archiveClassifier.set("sources")
-    from(kotlin.sourceSets["commonMain"].kotlin)
-    from(kotlin.sourceSets["wasmMain"].kotlin)
-}
-
-tasks.register<Jar>("emptyJavadocJar") {
-    archiveClassifier.set("javadoc")
-}

libraries/kotlin.test/wasm/js/build.gradle.kts

@@ -0,0 +1,14 @@
+import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetAttribute
+
+plugins {
+    kotlin("multiplatform")
+}
+
+configureWasmKotlinTest(
+    wasmTargetParameter = "wasm-js",
+    wasmTargetAttribute = KotlinWasmTargetAttribute.js,
+    targetSourceDir = "$rootDir/libraries/kotlin.test/wasm/js/src",
+    stdDependencyName = ":kotlin-stdlib-wasm-js"
+) { extensionBody ->
+    kotlin(extensionBody)
+}

libraries/kotlin.test/wasm/wasi/build.gradle.kts

@@ -0,0 +1,14 @@
+import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetAttribute
+
+plugins {
+    kotlin("multiplatform")
+}
+
+configureWasmKotlinTest(
+    wasmTargetParameter = "wasm-wasi",
+    wasmTargetAttribute = KotlinWasmTargetAttribute.wasi,
+    targetSourceDir = "$rootDir/libraries/kotlin.test/wasm/wasi/src",
+    stdDependencyName = ":kotlin-stdlib-wasm-wasi"
+) { extensionBody ->
+    kotlin(extensionBody)
+}

libraries/stdlib/wasm/wasi/build.gradle.kts

@@ -8,8 +8,6 @@ plugins {
 
 description = "Kotlin Standard Library for experimental WebAssembly WASI platform"
 
-D8RootPlugin.apply(rootProject).version = v8Version
-
 val targetDependentSources = listOf("builtins/kotlin", "src/kotlin", "src/kotlinx").map {
     "$rootDir/libraries/stdlib/wasm/wasi/$it"
 }

repo/artifacts-tests/src/test/resources/org/jetbrains/kotlin/kotlin-test-wasm-js/kotlin-test-wasm-js.pom

@@ -8,11 +8,11 @@
   <!-- do_not_remove: published-with-gradle-metadata -->
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.jetbrains.kotlin</groupId>
-  <artifactId>kotlin-test-wasm</artifactId>
+  <artifactId>kotlin-test-wasm-js</artifactId>
   <version>ArtifactsTest.version</version>
   <packaging>klib</packaging>
-  <name>Kotlin Test Wasm</name>
-  <description>Kotlin Test for WASM</description>
+  <name>Kotlin Test Wasm Js</name>
+  <description>Kotlin Test for Wasm JS</description>
   <url>https://kotlinlang.org/</url>
   <licenses>
     <license>
@@ -35,9 +35,9 @@
   <dependencies>
     <dependency>
       <groupId>org.jetbrains.kotlin</groupId>
-      <artifactId>kotlin-stdlib-wasm</artifactId>
+      <artifactId>kotlin-stdlib-wasm-js</artifactId>
       <version>ArtifactsTest.version</version>
       <scope>compile</scope>
     </dependency>
   </dependencies>
-</project>
+</project>

repo/artifacts-tests/src/test/resources/org/jetbrains/kotlin/kotlin-test-wasm-wasi/kotlin-test-wasm-wasi.pom

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <!-- This module was also published with a richer model, Gradle metadata,  -->
+  <!-- which should be used instead. Do not delete the following line which  -->
+  <!-- is to indicate to Gradle or any Gradle module metadata file consumer  -->
+  <!-- that they should prefer consuming it instead. -->
+  <!-- do_not_remove: published-with-gradle-metadata -->
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.jetbrains.kotlin</groupId>
+  <artifactId>kotlin-test-wasm-wasi</artifactId>
+  <version>ArtifactsTest.version</version>
+  <packaging>klib</packaging>
+  <name>Kotlin Test Wasm Wasi</name>
+  <description>Kotlin Test for Wasm WASI</description>
+  <url>https://kotlinlang.org/</url>
+  <licenses>
+    <license>
+      <name>The Apache License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+    </license>
+  </licenses>
+  <developers>
+    <developer>
+      <name>Kotlin Team</name>
+      <organization>JetBrains</organization>
+      <organizationUrl>https://www.jetbrains.com</organizationUrl>
+    </developer>
+  </developers>
+  <scm>
+    <connection>scm:git:https://github.com/JetBrains/kotlin.git</connection>
+    <developerConnection>scm:git:https://github.com/JetBrains/kotlin.git</developerConnection>
+    <url>https://github.com/JetBrains/kotlin</url>
+  </scm>
+  <dependencies>
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-stdlib-wasm-wasi</artifactId>
+      <version>ArtifactsTest.version</version>
+      <scope>compile</scope>
+    </dependency>
+  </dependencies>
+</project>

repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmKotlinTest.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+import org.gradle.api.Project
+import org.gradle.api.tasks.Sync
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetAttribute
+
+private fun Project.createCommonMainSources() = tasks.register("commonMainSources", Sync::class.java) {
+    from(
+        "$rootDir/libraries/kotlin.test/common/src",
+        "$rootDir/libraries/kotlin.test/annotations-common/src",
+        "$rootDir/libraries/kotlin.test/wasm/src"
+    )
+    into("$buildDir/commonMainSources")
+}
+
+fun Project.configureWasmKotlinTest(
+    wasmTargetParameter: String,
+    wasmTargetAttribute: KotlinWasmTargetAttribute,
+    targetSourceDir: String,
+    stdDependencyName: String,
+    withKotlinMPP: (KotlinMultiplatformExtension.() -> Unit) -> Unit
+) {
+    val commonMainSources = createCommonMainSources()
+
+    withKotlinMPP {
+        @Suppress("DEPRECATION")
+        @OptIn(org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl::class)
+        wasm("wasm") {
+            nodejs()
+            attributes {
+                attribute(KotlinWasmTargetAttribute.wasmTargetAttribute, wasmTargetAttribute)
+            }
+        }
+
+        sourceSets {
+            sourceSets.named("commonMain") {
+                dependencies {
+                    api(project(stdDependencyName))
+                }
+                kotlin.srcDir(commonMainSources.get().destinationDir)
+            }
+
+            sourceSets.named("wasmMain") {
+                dependencies {
+                    api(project(stdDependencyName))
+                }
+                kotlin.srcDir(targetSourceDir)
+            }
+        }
+
+        tasks.register<Jar>("sourcesJar") {
+            dependsOn(commonMainSources)
+            archiveClassifier.set("sources")
+            from(sourceSets["commonMain"].kotlin)
+            from(sourceSets["wasmMain"].kotlin)
+        }
+    }
+
+    tasks.withType<KotlinCompile<*>>().configureEach {
+        kotlinOptions.freeCompilerArgs += listOf(
+            "-Xallow-kotlin-package",
+            "-opt-in=kotlin.ExperimentalMultiplatform",
+            "-opt-in=kotlin.contracts.ExperimentalContracts",
+            "-Xwasm-target=$wasmTargetParameter"
+        )
+    }
+
+    tasks.named("compileKotlinWasm", KotlinCompile::class.java) {
+        kotlinOptions.freeCompilerArgs += "-Xir-module-name=kotlin-test"
+        dependsOn(commonMainSources)
+    }
+
+    tasks.register<Jar>("emptyJavadocJar") {
+        archiveClassifier.set("javadoc")
+    }
+}

settings.gradle

@@ -599,7 +599,8 @@ if (buildProperties.inJpsBuildIdeaSync) {
             ":kotlin-test:kotlin-test-js-ir",
             ":kotlin-test:kotlin-test-js:kotlin-test-js-it",
             ":kotlin-test:kotlin-test-js-ir:kotlin-test-js-ir-it",
-            ":kotlin-test:kotlin-test-wasm",
+            ":kotlin-test:kotlin-test-wasm-js",
+            ":kotlin-test:kotlin-test-wasm-wasi",
             ":native:native.tests"
 
     if (!stdlibMpp) include ":kotlin-stdlib-js", ":kotlin-stdlib-js-ir"
@@ -628,7 +629,8 @@ if (buildProperties.inJpsBuildIdeaSync) {
     project(':kotlin-test:kotlin-test-js-ir').projectDir = "$rootDir/libraries/kotlin.test/js-ir" as File
     project(':kotlin-test:kotlin-test-js:kotlin-test-js-it').projectDir = "$rootDir/libraries/kotlin.test/js/it" as File
     project(':kotlin-test:kotlin-test-js-ir:kotlin-test-js-ir-it').projectDir = "$rootDir/libraries/kotlin.test/js-ir/it" as File
-    project(':kotlin-test:kotlin-test-wasm').projectDir = "$rootDir/libraries/kotlin.test/wasm" as File
+    project(':kotlin-test:kotlin-test-wasm-js').projectDir = "$rootDir/libraries/kotlin.test/wasm/js" as File
+    project(':kotlin-test:kotlin-test-wasm-wasi').projectDir = "$rootDir/libraries/kotlin.test/wasm/wasi" as File
     project(':native:native.tests').projectDir = "$rootDir/native/native.tests" as File
 }
 include ":compiler:android-tests"

wasm/wasm.tests/build.gradle.kts

@@ -89,8 +89,8 @@ sourceSets {
 fun Test.setupWasmStdlib() {
     dependsOn(":kotlin-stdlib-wasm-js:compileKotlinWasm")
     systemProperty("kotlin.wasm.stdlib.path", "libraries/stdlib/wasm/js/build/classes/kotlin/wasm/main")
-    dependsOn(":kotlin-test:kotlin-test-wasm:compileKotlinWasm")
-    systemProperty("kotlin.wasm.kotlin.test.path", "libraries/kotlin.test/wasm/build/classes/kotlin/wasm/main")
+    dependsOn(":kotlin-test:kotlin-test-wasm-js:compileKotlinWasm")
+    systemProperty("kotlin.wasm.kotlin.test.path", "libraries/kotlin.test/wasm/js/build/classes/kotlin/wasm/main")
 }
 
 fun Test.setupGradlePropertiesForwarding() {