Minimal testing setup for wasm / kjs interop

settings.gradle

 rootProject.name = "skiko-all"
 includeBuild("samples/SkiaJvmSample")
-includeBuild("skiko")
\ No newline at end of file
+includeBuild("skiko")

skiko/build.gradle.kts

@@ -114,7 +114,15 @@ kotlin {
     }
 
     js(IR) {
-        browser()
+        browser() {
+            testTask {
+                testLogging.showStandardStreams = true
+                dependsOn(project.tasks.named("wasmCompile"))
+                useKarma() {
+                    useChromeHeadless()
+                }
+            }
+        }
         binaries.executable()
     }
 
@@ -163,6 +171,14 @@ kotlin {
                 implementation(kotlin("test-junit"))
             }
         }
+
+        val jsTest by getting {
+            dependencies {
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0")
+                implementation(kotlin("test-js"))
+            }
+        }
+
         if (supportNative) {
             val macosX64Main by getting {
             }
@@ -328,6 +344,7 @@ project.tasks.register<Exec>("wasmCompile") {
         "-I$skiaDir/include",
         "-I$skiaDir/include/gpu",
         "-std=c++17",
+        "--bind",
         "-o", outJs,
         *libs.files.map { it.absolutePath }.toTypedArray(),
         *srcs

skiko/karma.config.d/wasm.js

+// see https://kotlinlang.org/docs/js-project-setup.html#webpack-configuration-file
+
+const path = require("path");
+
+config.browserConsoleLogOptions.level = "debug";
+
+const basePath = config.basePath;
+const projectPath = path.resolve(basePath, "..", "..", "..", "..", "..");
+const setupPath = path.resolve(projectPath, "src", "jsTest", "config");
+const wasmPath = path.resolve(projectPath, "build", "wasm")
+
+const debug = message => console.log(`[karma-config] ${message}`); 
+
+debug(`karma basePath: ${basePath}`);
+debug(`karma setupPath: ${setupPath}`);
+debug(`karma wasmPath: ${wasmPath}`);
+
+config.proxies = {
+    "/wasm/": wasmPath
+}
+
+config.files = [
+    path.resolve(setupPath, "wasmsetup.js"),
+    path.resolve(wasmPath, "skiko.js"),
+    {pattern: path.resolve(wasmPath, "skiko.wasm"), included: false, served: true, watched: false},
+].concat(config.files);
+
+
+const fs = require("fs");
+fs.writeFileSync("KARMA.txt", JSON.stringify(config, null, 4));

skiko/src/jsMain/cpp/wrapper.cc

 #include "GrBackendSurface.h"
 #include "GrDirectContext.h"
-#include <emscripten.h>
+#include <emscripten/bind.h>
+
+using namespace emscripten;
 
-EMSCRIPTEN_KEEPALIVE
 extern "C" void* init_surface() {
    return nullptr;
 }
 
-int main() {
-    printf("Hello from WASM\n");
-    //void* ctx = GrDirectContext::MakeGL().release();
-    //printf("Context is %p\n");
-    return 0;
+bool ping() {
+    return true;
 }
+
+EMSCRIPTEN_BINDINGS(Skiko) {
+    function("ping", &ping);
+};
+

skiko/src/jsTest/config/wasmsetup.js

+var Module = {};
+
+Module['locateFile'] = (path, scriptDirectory) => {
+    return "/wasm/skiko.wasm";
+};
+
+var ModulePromised = new Promise(function(resolve, reject) {
+    Module['onRuntimeInitialized'] = _ => {
+        resolve(Module);
+    };
+});

skiko/src/jsTest/kotlin/WasmTests.kt

+package org.jetbrains.skiko.wasm
+
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.promise
+import kotlin.coroutines.*
+import kotlin.js.Promise
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+external interface ModuleInterface {
+    fun ping(): Boolean
+}
+
+external val ModulePromised: Promise<ModuleInterface>
+
+suspend fun <T> Promise<T>.await(): T = suspendCoroutine { cont ->
+    then({ cont.resume(it) }, { cont.resumeWithException(it) })
+}
+
+private fun async(block: suspend () -> Unit): dynamic = GlobalScope.promise {
+    block()
+}
+
+private fun withModule(block: ModuleInterface.() -> Unit) = async {
+    val module = ModulePromised.await()
+    block.invoke(module)
+}
+
+class WasmTests {
+    @Test   
+    fun pingTest() = withModule {
+        assertTrue(this.ping())
+    }
+}
\ No newline at end of file