@mikrojs/firmware 0.0.7

package/components/mikrojs/test/sys_test.cpp

@@ -0,0 +1,165 @@
+#include "mikrojs.h"
+#include "private.h"
+#include "quickjs.h"
+#include "unity.h"
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static JSValue eval_module(const char* code) {
+    JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test", code, strlen(code));
+    if (!JS_IsException(ret)) {
+        JS_FreeValue(ctx, ret);
+        mik__execute_jobs(ctx);
+    }
+    return ret;
+}
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+TEST_CASE("native:sys evalScript evaluates global code", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { evalScript } from "native:sys";
+        globalThis.__evalResult = evalScript("2 + 2");
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    // evalScript returns a promise (due to JS_EVAL_FLAG_ASYNC), execute jobs
+    mik__execute_jobs(ctx);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue result = JS_GetPropertyStr(ctx, global, "__evalResult");
+
+    // The result is a Promise, we need to check if it resolved
+    // For simple expressions, after executing jobs it should be available
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsUndefined(result), "evalScript should produce a result");
+    JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, global);
+
+    teardown();
+}
+
+TEST_CASE("native:sys memoryUsage returns object with heapTotal and heapUsed", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { memoryUsage } from "native:sys";
+        const mem = memoryUsage();
+        globalThis.__hasTotal = "heapTotal" in mem;
+        globalThis.__hasUsed = "heapUsed" in mem;
+        globalThis.__totalIsNum = typeof mem.heapTotal === "number";
+        globalThis.__usedIsNum = typeof mem.heapUsed === "number";
+        globalThis.__totalGtZero = mem.heapTotal > 0;
+        globalThis.__usedGtZero = mem.heapUsed > 0;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue v;
+    v = JS_GetPropertyStr(ctx, global, "__hasTotal");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "memoryUsage should have heapTotal");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__hasUsed");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "memoryUsage should have heapUsed");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__totalIsNum");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "heapTotal should be a number");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__usedIsNum");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "heapUsed should be a number");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__totalGtZero");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "heapTotal should be > 0");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__usedGtZero");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "heapUsed should be > 0");
+    JS_FreeValue(ctx, v);
+
+    JS_FreeValue(ctx, global);
+
+    teardown();
+}
+
+TEST_CASE("native:sys exports are not uninitialized", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { evalScript, memoryUsage, gc, setTime, uptime, restart } from "native:sys";
+        globalThis.__allFunctions =
+            typeof evalScript === "function" &&
+            typeof memoryUsage === "function" &&
+            typeof gc === "function" &&
+            typeof setTime === "function" &&
+            typeof uptime === "function" &&
+            typeof restart === "function";
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Importing native:sys should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue v = JS_GetPropertyStr(ctx, global, "__allFunctions");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v),
+                             "All native:sys exports should be functions, not uninitialized");
+    JS_FreeValue(ctx, v);
+    JS_FreeValue(ctx, global);
+
+    teardown();
+}
+
+TEST_CASE("native:sys uptime returns a positive number", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { uptime } from "native:sys";
+        const t = uptime();
+        globalThis.__isObj = typeof t === "object" && t !== null;
+        globalThis.__isPositive = typeof t.boot === "number" && t.boot >= 0;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "uptime() should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue v;
+    v = JS_GetPropertyStr(ctx, global, "__isObj");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "uptime should return an object");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__isPositive");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "uptime().boot should be a positive number");
+    JS_FreeValue(ctx, v);
+
+    JS_FreeValue(ctx, global);
+
+    teardown();
+}
+
+TEST_CASE("native:sys gc does not crash", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { gc } from "native:sys";
+        gc();
+        globalThis.__gcDone = true;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "gc() should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue done = JS_GetPropertyStr(ctx, global, "__gcDone");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, done), "gc should complete without error");
+    JS_FreeValue(ctx, done);
+    JS_FreeValue(ctx, global);
+
+    teardown();
+}

package/components/mikrojs/test/text_encoding_test.cpp

@@ -0,0 +1,224 @@
+#include "mikrojs.h"
+#include "quickjs.h"
+#include "unity.h"
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static JSValue eval(const char* code) {
+    return JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+}
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+TEST_CASE("TextEncoder is a constructor", "[runtime]") {
+    setup();
+
+    JSValue r = eval("typeof TextEncoder");
+    const char* type = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("function", type);
+    JS_FreeCString(ctx, type);
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+TEST_CASE("TextDecoder is a constructor", "[runtime]") {
+    setup();
+
+    JSValue r = eval("typeof TextDecoder");
+    const char* type = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("function", type);
+    JS_FreeCString(ctx, type);
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+TEST_CASE("TextEncoder.encode produces Uint8Array with correct bytes", "[runtime]") {
+    setup();
+
+    JSValue r = eval(R"(
+        const enc = new TextEncoder();
+        const arr = enc.encode("hello");
+        globalThis.__len = arr.length;
+        globalThis.__b0 = arr[0];
+        globalThis.__b4 = arr[4];
+        arr instanceof Uint8Array;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r), "encode should not throw");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, r), "Result should be a Uint8Array");
+    JS_FreeValue(ctx, r);
+
+    int32_t len, b0, b4;
+    JSValue v;
+
+    v = eval("globalThis.__len");
+    JS_ToInt32(ctx, &len, v);
+    JS_FreeValue(ctx, v);
+    TEST_ASSERT_EQUAL_INT32(5, len);
+
+    v = eval("globalThis.__b0");
+    JS_ToInt32(ctx, &b0, v);
+    JS_FreeValue(ctx, v);
+    TEST_ASSERT_EQUAL_INT32('h', b0);
+
+    v = eval("globalThis.__b4");
+    JS_ToInt32(ctx, &b4, v);
+    JS_FreeValue(ctx, v);
+    TEST_ASSERT_EQUAL_INT32('o', b4);
+
+    teardown();
+}
+
+TEST_CASE("TextDecoder.decode converts Uint8Array to string", "[runtime]") {
+    setup();
+
+    JSValue r = eval(R"(
+        const dec = new TextDecoder();
+        const arr = new Uint8Array([72, 101, 108, 108, 111]);
+        dec.decode(arr);
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r), "decode should not throw");
+    const char* str = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("Hello", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+TEST_CASE("TextEncoder/TextDecoder roundtrip", "[runtime]") {
+    setup();
+
+    JSValue r = eval(R"(
+        const enc = new TextEncoder();
+        const dec = new TextDecoder();
+        dec.decode(enc.encode("mikrojs rocks"));
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r), "roundtrip should not throw");
+    const char* str = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("mikrojs rocks", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+TEST_CASE("TextDecoder.decode rejects non-Uint8Array", "[runtime]") {
+    setup();
+
+    JSValue r = eval(R"(
+        try {
+            const dec = new TextDecoder();
+            dec.decode("not a typed array");
+            false;
+        } catch (e) {
+            e instanceof TypeError;
+        }
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r), "Should not throw at top level");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, r), "Should have caught a TypeError");
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+/* ---- btoa / atob ---- */
+
+TEST_CASE("btoa encodes ASCII string", "[runtime]") {
+    setup();
+    JSValue r = eval("btoa('Hello')");
+    const char* str = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("SGVsbG8=", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, r);
+    teardown();
+}
+
+TEST_CASE("atob decodes base64 string", "[runtime]") {
+    setup();
+    JSValue r = eval("atob('SGVsbG8=')");
+    const char* str = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("Hello", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, r);
+    teardown();
+}
+
+TEST_CASE("btoa/atob roundtrip", "[runtime]") {
+    setup();
+    JSValue r = eval("atob(btoa('mikrojs'))");
+    const char* str = JS_ToCString(ctx, r);
+    TEST_ASSERT_EQUAL_STRING("mikrojs", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, r);
+    teardown();
+}
+
+TEST_CASE("btoa handles padding correctly", "[runtime]") {
+    setup();
+    JSValue r1 = eval("btoa('a')");
+    const char* s1 = JS_ToCString(ctx, r1);
+    TEST_ASSERT_EQUAL_STRING("YQ==", s1);
+    JS_FreeCString(ctx, s1);
+    JS_FreeValue(ctx, r1);
+
+    JSValue r2 = eval("btoa('ab')");
+    const char* s2 = JS_ToCString(ctx, r2);
+    TEST_ASSERT_EQUAL_STRING("YWI=", s2);
+    JS_FreeCString(ctx, s2);
+    JS_FreeValue(ctx, r2);
+    teardown();
+}
+
+TEST_CASE("atob throws on invalid input", "[runtime]") {
+    setup();
+    JSValue r = eval(R"(
+        try { atob('!!!'); false; }
+        catch (e) { e instanceof SyntaxError; }
+    )");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, r), "Should throw SyntaxError on invalid base64");
+    JS_FreeValue(ctx, r);
+    teardown();
+}
+
+TEST_CASE("TextEncoder.encode handles multibyte UTF-8", "[runtime]") {
+    setup();
+
+    // "é" is 2 bytes in UTF-8 (0xC3, 0xA9)
+    JSValue r = eval(R"(
+        const enc = new TextEncoder();
+        const arr = enc.encode("\u00e9");
+        globalThis.__mbLen = arr.length;
+        globalThis.__mb0 = arr[0];
+        globalThis.__mb1 = arr[1];
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r), "encode multibyte should not throw");
+    JS_FreeValue(ctx, r);
+
+    int32_t len, b0, b1;
+    JSValue v;
+
+    v = eval("globalThis.__mbLen");
+    JS_ToInt32(ctx, &len, v);
+    JS_FreeValue(ctx, v);
+    TEST_ASSERT_EQUAL_INT32(2, len);
+
+    v = eval("globalThis.__mb0");
+    JS_ToInt32(ctx, &b0, v);
+    JS_FreeValue(ctx, v);
+    TEST_ASSERT_EQUAL_INT32(0xC3, b0);
+
+    v = eval("globalThis.__mb1");
+    JS_ToInt32(ctx, &b1, v);
+    JS_FreeValue(ctx, v);
+    TEST_ASSERT_EQUAL_INT32(0xA9, b1);
+
+    teardown();
+}

package/components/mikrojs/test/timers_js_test.cpp

@@ -0,0 +1,244 @@
+#include "mikrojs.h"
+#include "quickjs.h"
+#include "unity.h"
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static JSValue eval(const char* code) {
+    return JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+}
+
+static int32_t eval_int(const char* code) {
+    int32_t num;
+    JSValue val = eval(code);
+    JS_ToInt32(ctx, &num, val);
+    JS_FreeValue(ctx, val);
+    return num;
+}
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+TEST_CASE("setTimeout fires callback", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.fired = false;
+        setTimeout(() => { globalThis.fired = true; }, 0);
+    )");
+    JS_FreeValue(ctx, r);
+
+    MIK_Loop(rt);
+
+    JSValue fired = eval("globalThis.fired");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, fired), "setTimeout callback should have fired");
+    JS_FreeValue(ctx, fired);
+
+    teardown();
+}
+
+TEST_CASE("clearTimeout cancels a pending timer", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.fired = false;
+        const id = setTimeout(() => { globalThis.fired = true; }, 0);
+        clearTimeout(id);
+    )");
+    JS_FreeValue(ctx, r);
+
+    MIK_Loop(rt);
+
+    JSValue fired = eval("globalThis.fired");
+    TEST_ASSERT_FALSE_MESSAGE(JS_ToBool(ctx, fired),
+                              "Callback should not fire after clearTimeout");
+    JS_FreeValue(ctx, fired);
+
+    teardown();
+}
+
+TEST_CASE("setInterval fires repeatedly", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.count = 0;
+        setInterval(() => { globalThis.count++; }, 0);
+    )");
+    JS_FreeValue(ctx, r);
+
+    for (int i = 0; i < 5; i++) {
+        MIK_Loop(rt);
+    }
+
+    int32_t count = eval_int("globalThis.count");
+    TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(5, count,
+                                               "setInterval should fire on each loop iteration");
+
+    teardown();
+}
+
+TEST_CASE("clearInterval stops an interval", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.count = 0;
+        globalThis.intervalId = setInterval(() => { globalThis.count++; }, 0);
+    )");
+    JS_FreeValue(ctx, r);
+
+    // Run a few loops to accumulate some ticks
+    for (int i = 0; i < 3; i++) {
+        MIK_Loop(rt);
+    }
+
+    JSValue r2 = eval("clearInterval(globalThis.intervalId);");
+    JS_FreeValue(ctx, r2);
+
+    int32_t count_after_clear = eval_int("globalThis.count");
+
+    // Run more loops — count should not increase
+    for (int i = 0; i < 3; i++) {
+        MIK_Loop(rt);
+    }
+
+    int32_t count_final = eval_int("globalThis.count");
+    TEST_ASSERT_EQUAL_INT32_MESSAGE(count_after_clear, count_final,
+                                    "Count should not increase after clearInterval");
+
+    teardown();
+}
+
+TEST_CASE("setTimeout passes extra arguments to callback", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.result = 0;
+        setTimeout((a, b) => { globalThis.result = a + b; }, 0, 17, 25);
+    )");
+    JS_FreeValue(ctx, r);
+
+    MIK_Loop(rt);
+
+    int32_t result = eval_int("globalThis.result");
+    TEST_ASSERT_EQUAL_INT32_MESSAGE(42, result,
+                                    "Callback should receive extra args passed to setTimeout");
+
+    teardown();
+}
+
+TEST_CASE("clearTimeout on non-existent ID is a no-op", "[timers]") {
+    setup();
+
+    // Should not throw or crash
+    JSValue r = eval("clearTimeout(99999);");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r),
+                              "clearTimeout with invalid ID should not throw");
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+TEST_CASE("setTimeout throws RangeError when passing too many args", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        try {
+            setTimeout(() => {}, 0, 1, 2, 3, 4, 5);
+            false;
+        } catch (e) {
+            e instanceof RangeError;
+        }
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(r), "Should not throw at top level");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, r), "Should have caught a RangeError");
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}
+
+TEST_CASE("setTimeout with non-zero delay does not fire immediately", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.fired = false;
+        setTimeout(() => { globalThis.fired = true; }, 1000);
+    )");
+    JS_FreeValue(ctx, r);
+
+    // Run the loop once — the 1000ms timer should not fire yet
+    MIK_Loop(rt);
+
+    JSValue fired = eval("globalThis.fired");
+    TEST_ASSERT_FALSE_MESSAGE(JS_ToBool(ctx, fired),
+                              "setTimeout with 1000ms delay should not fire immediately");
+    JS_FreeValue(ctx, fired);
+
+    teardown();
+}
+
+TEST_CASE("setInterval with non-zero delay does not fire immediately", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.count = 0;
+        setInterval(() => { globalThis.count++; }, 500);
+    )");
+    JS_FreeValue(ctx, r);
+
+    // Run the loop once — the 500ms interval should not fire yet
+    MIK_Loop(rt);
+
+    int32_t count = eval_int("globalThis.count");
+    TEST_ASSERT_EQUAL_INT32_MESSAGE(0, count,
+                                    "setInterval with 500ms delay should not fire immediately");
+
+    teardown();
+}
+
+TEST_CASE("clearInterval inside callback does not crash", "[timers]") {
+    setup();
+
+    JSValue r = eval(R"(
+        globalThis.result = "";
+        var id = setInterval(() => {
+            globalThis.result += "tick";
+            clearInterval(id);
+        }, 0);
+    )");
+    JS_FreeValue(ctx, r);
+
+    // Run several loops — the callback should fire once and then stop.
+    // Before the fix this would crash (use-after-free) because clearInterval
+    // freed JSValues while the copied dueTimers vector still referenced them.
+    for (int i = 0; i < 5; i++) {
+        MIK_Loop(rt);
+    }
+
+    JSValue val = eval("globalThis.result");
+    const char* str = JS_ToCString(ctx, val);
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("tick", str,
+                                      "Callback should fire exactly once before clearInterval stops it");
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, val);
+
+    teardown();
+}
+
+TEST_CASE("setTimeout returns a numeric timer ID", "[timers]") {
+    setup();
+
+    JSValue r = eval("setTimeout(() => {}, 0)");
+    TEST_ASSERT_TRUE_MESSAGE(JS_IsNumber(r), "setTimeout should return a number");
+
+    int32_t id;
+    JS_ToInt32(ctx, &id, r);
+    TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(0, id, "Timer ID should be > 0");
+    JS_FreeValue(ctx, r);
+
+    teardown();
+}

package/components/mikrojs/test/timers_test.cpp

@@ -0,0 +1,79 @@
+/* Include standalone library source directly for testing internal functions */
+#include "../../../../packages/@mikrojs/native/src/timers.cpp"
+
+#include "quickjs.h"
+#include "unity.h"
+
+JSValue __timer_test__noop(JSContext* ctx, JSValue new_target, int argc, JSValue* argv) {
+    return JS_UNDEFINED;
+}
+
+TEST_CASE("init and destroy", "[timers]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+    MIKTimerRegistry* timers = MIK_NewTimerRegistry();
+
+    JSValue argv[0];
+    JSValue argc = JS_NewUint32(ctx, 0);
+    JSValue cb = JS_NewCFunction(ctx, __timer_test__noop, "callme", 0);
+
+    uint32_t timer_id;
+
+    timer_id = MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 1000, false);
+    TEST_ASSERT_EQUAL_UINT32(1, timer_id);
+
+    timer_id = MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 1000, false);
+    TEST_ASSERT_EQUAL_UINT32(2, timer_id);
+    JS_FreeValue(ctx, cb);
+    MIK_Timer_ClearAll(timers, ctx);
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Supports removing existing timers", "[timers]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+    MIKTimerRegistry* timers = MIK_NewTimerRegistry();
+
+    JSValue argv[0];
+    JSValue argc = JS_NewUint32(ctx, 0);
+    JSValue cb = JS_NewCFunction(ctx, __timer_test__noop, "callme", 0);
+
+    auto const timer_id_1 = MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 1000, false);
+    auto const timer_id_2 = MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 1000, false);
+
+    TEST_ASSERT_EQUAL_INT(timers->entries.size(), 2);
+    MIK_Timer_UnSchedule(timers, ctx, timer_id_1);
+    TEST_ASSERT_EQUAL_INT(timers->entries.size(), 1);
+    MIK_Timer_UnSchedule(timers, ctx, timer_id_2);
+    TEST_ASSERT_EQUAL_INT(timers->entries.size(), 0);
+    JS_FreeValue(ctx, cb);
+    MIK_Timer_ClearAll(timers, ctx);
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Supports getting due deadline from timers", "[timers]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+    MIKTimerRegistry* timers = MIK_NewTimerRegistry();
+
+    JSValue argv[0];
+    JSValue argc = JS_NewUint32(ctx, 0);
+    JSValue cb = JS_NewCFunction(ctx, __timer_test__noop, "callme", 0);
+
+    MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 10, false, 0);
+    MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 100, false, 0);
+    MIK_Timer_Schedule(timers, ctx, cb, argc, argv, 200, false, 0);
+
+    TEST_ASSERT_EQUAL_INT(timers->entries.size(), 3);
+    TEST_ASSERT_EQUAL(MIK_Timer_CountDue(timers, 0), 0);
+    TEST_ASSERT_EQUAL(MIK_Timer_CountDue(timers, 50), 1);
+    TEST_ASSERT_EQUAL(MIK_Timer_CountDue(timers, 99), 1);
+    TEST_ASSERT_EQUAL(MIK_Timer_CountDue(timers, 100), 2);
+    TEST_ASSERT_EQUAL(MIK_Timer_CountDue(timers, 200), 3);
+    JS_FreeValue(ctx, cb);
+    MIK_Timer_ClearAll(timers, ctx);
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}