@mentra/crust 3.3.0-dev.656 → 3.3.0-dev.659

package/android/src/main/cpp/quickjs/jni/quickjs_jni.h

@@ -1,40 +0,0 @@
-#ifndef QJS_KT_JNI_H
-#define QJS_KT_JNI_H
-
-#include <pthread.h>
-#include "cvector.h"
-#include "quickjs.h"
-#include "jni.h"
-
-/**
- * Global objects for the wrapped runtime.
- */
-typedef struct {
-    /**
-     * Some JS values, used by C functions.
-     */
-    cvector_vector_type(JSValue)managed_js_values;
-    /**
-     * Defined JS objects, keep them to support nested define.
-     */
-    cvector_vector_type(JSValue)defined_js_objects;
-    /**
-     * Promise resolve/reject functions.
-     */
-    cvector_vector_type(JSValue)created_js_functions;
-    /**
-     * Global JNI refs.
-     */
-    cvector_vector_type(jobject)global_object_refs;
-    /**
-     * Result promises of eval calls.
-     */
-    JSValue *evaluate_result_promise;
-    /**
-     * The mutex which is used to protect the JS stack in a multi-threaded environment.
-     * Scopes with a JS_UpdateStackTop() call are required to be locked.
-     */
-    pthread_mutex_t js_mutex;
-} Globals;
-
-#endif //QJS_KT_JNI_H

package/android/src/testNative/QuickJsLifecycleTest.kt

@@ -1,56 +0,0 @@
-package com.mentra.crust.jsc
-
-import com.dokar.quickjs.QuickJs
-import com.dokar.quickjs.binding.function
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withTimeout
-import java.util.concurrent.Executors
-
-/** Exercise actual JNI/Kotlin callbacks across independent runtime lifetimes. */
-fun main() = runBlocking {
-    var calls = 0
-    val survivor = QuickJs.create(Dispatchers.Unconfined)
-    survivor.function("hostCallback") { calls++; 42 }
-    val other = QuickJs.create(Dispatchers.Unconfined)
-    check(survivor.evaluate<Int>("hostCallback()") == 42)
-    other.close()
-    var failure: Throwable? = null
-    try {
-        withTimeout(1000) { check(survivor.evaluate<Int>("hostCallback()") == 42) }
-    } catch (error: Throwable) {
-        failure = error
-    }
-    check(failure == null) { "Closing another instance broke the survivor: $failure" }
-    check(calls == 2)
-    repeat(20) {
-        val temporary = QuickJs.create(Dispatchers.Unconfined)
-        temporary.close()
-        check(survivor.evaluate<Int>("hostCallback()") == 42)
-    }
-    val workers = Executors.newFixedThreadPool(4)
-    try {
-        val jobs = (1..40).map {
-            workers.submit {
-                val temporary = QuickJs.create(Dispatchers.Unconfined)
-                temporary.close()
-            }
-        }
-        jobs.forEach { it.get() }
-        check(survivor.evaluate<Int>("hostCallback()") == 42)
-    } finally {
-        workers.shutdownNow()
-    }
-    survivor.close()
-    val fresh = QuickJs.create(Dispatchers.Unconfined)
-    fresh.function("hostCallback") { 7 }
-    check(fresh.evaluate<Int>("hostCallback()") == 7)
-    fresh.close()
-    val older = QuickJs.create(Dispatchers.Unconfined)
-    val newer = QuickJs.create(Dispatchers.Unconfined)
-    newer.function("hostCallback") { 9 }
-    older.close()
-    check(newer.evaluate<Int>("hostCallback()") == 9)
-    newer.close()
-    println("PASS: callbacks survive across both close orders, churn, and clean restart")
-}