Introduce errors on incorrect target (#142)

Author: wldeh

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

@@ -0,0 +1,56 @@
+package kotlinx.benchmark.integration
+
+class KotlinConfiguration {
+
+    data class Target(val type: String, val name: String, val compiler: String, val environment: String)
+
+    private val targets = mutableListOf<Target>()
+
+    fun wasm(name: String, configuration: WasmTarget.() -> Unit) {
+        val wasmTarget = WasmTarget(name)
+        wasmTarget.configuration()
+        targets.add(Target("wasm", wasmTarget.name, "", wasmTarget.environment))
+    }
+
+    fun js(name: String, compiler: String = IR, configuration: JsTarget.() -> Unit) {
+        val jsTarget = JsTarget(name, compiler)
+        jsTarget.configuration()
+        targets.add(Target("js", jsTarget.name, jsTarget.compiler, jsTarget.environment))
+    }
+
+    fun lines(): List<String> {
+        return targets.map {
+            "${it.type}('${it.name}', ${it.compiler}) { ${it.environment}() }"
+        }
+    }
+
+    class WasmTarget(val name: String) {
+        var environment: String = ""
+
+        fun nodejs() {
+            environment = "nodejs"
+        }
+        fun browser() {
+            environment = "browser"
+        }
+    }
+
+    class JsTarget(val name: String, val compiler: String) {
+        var environment: String = ""
+
+        fun d8() {
+            environment = "d8"
+        }
+        fun nodejs() {
+            environment = "nodejs"
+        }
+        fun browser() {
+            environment = "browser"
+        }
+    }
+
+    companion object {
+        const val IR = "'IR'"
+        const val LEGACY = "'LEGACY'"
+    }
+}

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

@@ -3,18 +3,27 @@ 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/test/kotlin/kotlinx/benchmark/integration/InvalidTargetingTest.kt

@@ -0,0 +1,94 @@
+package kotlinx.benchmark.integration
+
+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.")
+        }
+    }
+
+    @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.")
+        }
+    }
+
+    @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()
+                }
+            }
+        }
+
+        runner.runAndFail("legacyJsBenchmark") {
+            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().")
+        }
+    }
+}

plugin/main/src/kotlinx/benchmark/gradle/JsEngineExecTasks.kt

@@ -20,15 +20,19 @@ fun Project.createJsEngineBenchmarkExecTask(
     val taskName = "${target.name}${config.capitalizedName()}${BenchmarksPlugin.BENCHMARK_EXEC_SUFFIX}"
     val compilationTarget = compilation.target
 
+    check(compilation is KotlinJsIrCompilation) { "Legacy Kotlin/JS backend is not supported. Please migrate to the Kotlin/JS IR compiler backend." }
+
     if (compilationTarget is KotlinJsSubTargetContainerDsl) {
         compilationTarget.whenNodejsConfigured {
             val execTask = createNodeJsExec(config, target, compilation, taskName)
             tasks.getByName(config.prefixName(RUN_BENCHMARKS_TASKNAME)).dependsOn(execTask)
         }
+        compilationTarget.whenBrowserConfigured {
+            throw GradleException("The browser() environment is not supported for Kotlin/JS benchmarks. Please use nodejs().")
+        }
     }
 
     if (compilationTarget is KotlinWasmSubTargetContainerDsl) {
-        check(compilation is KotlinJsIrCompilation) { "Legacy Kotlin/JS is does not supported by D8 engine" }
         compilationTarget.whenD8Configured {
             val execTask = createD8Exec(config, target, compilation, taskName)
             tasks.getByName(config.prefixName(RUN_BENCHMARKS_TASKNAME)).dependsOn(execTask)
@@ -69,6 +73,9 @@ private fun Project.createNodeJsExec(
     compilation: KotlinJsCompilation,
     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"
@@ -90,6 +97,9 @@ 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"