Refactor illegal target tests

Author: Abduqodiri Qurbonzoda

integration/src/main/kotlin/kotlinx/benchmark/integration/KotlinConfiguration.kt

@@ -3,27 +3,18 @@ package kotlinx.benchmark.integration
 class ProjectBuilder {
     private val configurations = mutableMapOf<String, BenchmarkConfiguration>()
     private val targets = mutableMapOf<String, BenchmarkTarget>()
-    private val kotlinConfig = KotlinConfiguration()
 
     fun configuration(name: String, configuration: BenchmarkConfiguration.() -> Unit = {}) {
         configurations[name] = BenchmarkConfiguration().apply(configuration)
     }
-    
     fun register(name: String, configuration: BenchmarkTarget.() -> Unit = {}) {
         targets[name] = BenchmarkTarget().apply(configuration)
     }
 
-    fun kotlin(configuration: KotlinConfiguration.() -> Unit) {
-        kotlinConfig.apply(configuration)
-    }
-
     fun build(original: String): String {
 
         val script =
             """
-kotlin {
-    ${kotlinConfig.lines().joinToString("\n    ")}
-}
 benchmark {
     configurations {
         ${configurations.flatMap { it.value.lines(it.key) }.joinToString("\n        ")}

integration/src/main/kotlin/kotlinx/benchmark/integration/ProjectBuilder.kt

@@ -5,90 +5,42 @@ import kotlin.test.*
 class InvalidTargetingTest : GradleTest() {
 
     @Test
-    fun testInvalidTargetForKotlinWASM() {
-        val runner = project("kotlin-multiplatform") {
-            configuration("invalidWasm") {
-                iterations = 1
-                iterationTime = 100
-                iterationTimeUnit = "ms"
-                reportFormat = "json"
-            }
-            register("wasmTest")
-            kotlin {
-                wasm("wasmTest") {
-                    nodejs()
-                }
-            }
-        }              
-
-        runner.runAndFail("invalidWasmBenchmark") {
-            assertOutputContains("Kotlin/WASM does not support targeting NodeJS for benchmarks.")
+    fun testWasmNodeJs() {
+        val runner = project("invalid-target/wasm-nodejs", true)
+        runner.runAndFail("wasmJsBenchmark") {
+            assertOutputContains("kotlinx-benchmark supports only d8() environment for Kotlin/Wasm.")
         }
     }
 
     @Test
-    fun testInvalidTargetForKotlinJS() {
-        val runner = project("kotlin-multiplatform") {
-            configuration("invalidJS") {
-                iterations = 1
-                iterationTime = 100
-                iterationTimeUnit = "ms"
-                reportFormat = "json"
-            }
-            register("jsTest")
-            kotlin {
-                js("jsTest", KotlinConfiguration.IR) {
-                    d8()
-                }
-            }
-        }              
-
-        runner.runAndFail("invalidJsBenchmark") {
-            assertOutputContains("Kotlin/JS does not support targeting D8 for benchmarks.")
+    fun testWasmBrowser() {
+        val runner = project("invalid-target/wasm-browser", true)
+        runner.runAndFail("wasmJsBenchmark") {
+            assertOutputContains("kotlinx-benchmark supports only d8() environment for Kotlin/Wasm.")
         }
     }
 
     @Test
-    fun testLegacyJsBackend() {
-        val runner = project("kotlin-multiplatform") {
-            configuration("legacyJS") {
-                iterations = 1
-                iterationTime = 100
-                iterationTimeUnit = "ms"
-                reportFormat = "json"
-            }
-            register("legacyJsTest")
-            kotlin {
-                js("legacyJsTest", KotlinConfiguration.LEGACY) {
-                    nodejs()
-                }
-            }
+    fun testJsD8() {
+        val runner = project("invalid-target/js-d8", true)
+        runner.runAndFail("jsBenchmark") {
+            assertOutputContains("kotlinx-benchmark supports only nodejs() environment for Kotlin/JS.")
         }
+    }
 
-        runner.runAndFail("legacyJsBenchmark") {
+    @Test
+    fun testJsLegacyBackend() {
+        val runner = project("invalid-target/js-legacy", true)
+        runner.runAndFail("jsBenchmark") {
             assertOutputContains("Legacy Kotlin/JS backend is not supported. Please migrate to the Kotlin/JS IR compiler backend.")
         }
     }
 
     @Test
-    fun testBrowserEnvironmentForKotlinJS() {
-        val runner = project("kotlin-multiplatform") {
-            configuration("invalidBrowserJS") {
-                iterations = 1
-                iterationTime = 100
-                iterationTimeUnit = "ms"
-                reportFormat = "json"
-            }
-            register("jsBrowserTest")
-            kotlin {
-                js("jsBrowserTest", KotlinConfiguration.IR) {
-                    browser()
-                }
-            }
-        }
-
-        runner.runAndFail("invalidBrowserJsBenchmark") {
-            assertOutputContains("The browser() environment is not supported for Kotlin/JS benchmarks. Please use nodejs().")
+    fun testJsBrowser() {
+        val runner = project("invalid-target/js-browser", true)
+        runner.runAndFail("jsBenchmark") {
+            assertOutputContains("kotlinx-benchmark supports only nodejs() environment for Kotlin/JS.")
         }
     }
 }

integration/src/test/kotlin/kotlinx/benchmark/integration/InvalidTargetingTest.kt

@@ -0,0 +1,11 @@
+kotlin {
+    js(IR) {
+        browser()
+    }
+}
+
+benchmark {
+    targets {
+        register("js")
+    }
+}

integration/src/test/resources/templates/invalid-target/js-browser/build.gradle

@@ -0,0 +1,11 @@
+kotlin {
+    js(IR) {
+        d8()
+    }
+}
+
+benchmark {
+    targets {
+        register("js")
+    }
+}

integration/src/test/resources/templates/invalid-target/js-d8/build.gradle

@@ -0,0 +1,11 @@
+kotlin {
+    js(LEGACY) {
+        nodejs()
+    }
+}
+
+benchmark {
+    targets {
+        register("js")
+    }
+}

integration/src/test/resources/templates/invalid-target/js-legacy/build.gradle

@@ -0,0 +1,11 @@
+kotlin {
+    wasm("wasmJs") {
+        browser()
+    }
+}
+
+benchmark {
+    targets {
+        register("wasmJs")
+    }
+}

integration/src/test/resources/templates/invalid-target/wasm-browser/build.gradle

@@ -0,0 +1,11 @@
+kotlin {
+    wasm("wasmJs") {
+        nodejs()
+    }
+}
+
+benchmark {
+    targets {
+        register("wasmJs")
+    }
+}

integration/src/test/resources/templates/invalid-target/wasm-nodejs/build.gradle

@@ -17,22 +17,29 @@ fun Project.createJsEngineBenchmarkExecTask(
     compilation: KotlinJsIrCompilation
 ) {
     val taskName = "${target.name}${config.capitalizedName()}${BenchmarksPlugin.BENCHMARK_EXEC_SUFFIX}"
+
     val compilationTarget = compilation.target
+    check(compilationTarget is KotlinJsIrTarget)
 
-    if (compilationTarget is KotlinJsSubTargetContainerDsl) {
-        compilationTarget.whenNodejsConfigured {
-            val execTask = createNodeJsExec(config, target, compilation, taskName)
-            tasks.getByName(config.prefixName(RUN_BENCHMARKS_TASKNAME)).dependsOn(execTask)
+    when (compilationTarget.platformType) {
+        KotlinPlatformType.wasm -> {
+            if (compilationTarget.isD8Configured) {
+                val execTask = createD8Exec(config, target, compilation, taskName)
+                tasks.getByName(config.prefixName(RUN_BENCHMARKS_TASKNAME)).dependsOn(execTask)
+            } else {
+                throw GradleException("kotlinx-benchmark supports only d8() environment for Kotlin/Wasm.")
+            }
         }
-        compilationTarget.whenBrowserConfigured {
-            throw GradleException("The browser() environment is not supported for Kotlin/JS benchmarks. Please use nodejs().")
+        KotlinPlatformType.js -> {
+            if (compilationTarget.isNodejsConfigured) {
+                val execTask = createNodeJsExec(config, target, compilation, taskName)
+                tasks.getByName(config.prefixName(RUN_BENCHMARKS_TASKNAME)).dependsOn(execTask)
+            } else {
+                throw GradleException("kotlinx-benchmark supports only nodejs() environment for Kotlin/JS.")
+            }
         }
-    }
-
-    if (compilationTarget is KotlinWasmSubTargetContainerDsl) {
-        compilationTarget.whenD8Configured {
-            val execTask = createD8Exec(config, target, compilation, taskName)
-            tasks.getByName(config.prefixName(RUN_BENCHMARKS_TASKNAME)).dependsOn(execTask)
+        else -> {
+            throw GradleException("Unsupported platforms type ${compilationTarget.platformType}")
         }
     }
 }
@@ -70,9 +77,6 @@ private fun Project.createNodeJsExec(
     compilation: KotlinJsIrCompilation,
     taskName: String
 ): TaskProvider<NodeJsExec> = NodeJsExec.create(compilation, taskName) {
-    if (compilation.target.platformType == KotlinPlatformType.wasm) {
-        throw GradleException("Kotlin/WASM does not support targeting NodeJS for benchmarks.")
-    }
     dependsOn(compilation.runtimeDependencyFiles)
     group = BenchmarksPlugin.BENCHMARKS_TASK_GROUP
     description = "Executes benchmark for '${target.name}' with NodeJS"
@@ -94,9 +98,6 @@ private fun Project.createD8Exec(
     compilation: KotlinJsIrCompilation,
     taskName: String
 ): TaskProvider<D8Exec> = D8Exec.create(compilation, taskName) {
-    if (compilation.target.platformType == KotlinPlatformType.js) {
-        throw GradleException("Kotlin/JS does not support targeting D8 for benchmarks.")
-    }
     dependsOn(compilation.runtimeDependencyFiles)
     group = BenchmarksPlugin.BENCHMARKS_TASK_GROUP
     description = "Executes benchmark for '${target.name}' with D8"