@mikrojs/firmware 0.0.7

package/components/mikrojs/test/modules_extended_test.cpp

@@ -0,0 +1,137 @@
+#include <string.h>
+
+#include "mikrojs.h"
+#include "private.h"
+#include "quickjs.h"
+#include "unity.h"
+
+TEST_CASE("import.meta.dirname for absolute path module", "[modules]") {
+    const auto mik_rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(mik_rt);
+
+    const char* code = "globalThis.__dirname = import.meta.dirname;";
+    JSValue ret = MIK_EvalModuleContent(ctx, "/appfs/lib/main.js", code, strlen(code));
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+    JS_FreeValue(ctx, ret);
+
+    mik__execute_jobs(ctx);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue dirname = JS_GetPropertyStr(ctx, global, "__dirname");
+    TEST_ASSERT_TRUE_MESSAGE(JS_IsString(dirname), "Expected __dirname to be a string");
+
+    const char* str = JS_ToCString(ctx, dirname);
+    TEST_ASSERT_EQUAL_STRING("/appfs/lib", str);
+    JS_FreeCString(ctx, str);
+
+    JS_FreeValue(ctx, dirname);
+    JS_FreeValue(ctx, global);
+    MIK_FreeRuntime(mik_rt);
+}
+
+TEST_CASE("import.meta.basename for absolute path module", "[modules]") {
+    const auto mik_rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(mik_rt);
+
+    const char* code = "globalThis.__basename = import.meta.basename;";
+    JSValue ret = MIK_EvalModuleContent(ctx, "/appfs/lib/main.js", code, strlen(code));
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+    JS_FreeValue(ctx, ret);
+
+    mik__execute_jobs(ctx);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue basename = JS_GetPropertyStr(ctx, global, "__basename");
+    TEST_ASSERT_TRUE_MESSAGE(JS_IsString(basename), "Expected __basename to be a string");
+
+    const char* str = JS_ToCString(ctx, basename);
+    TEST_ASSERT_EQUAL_STRING("main.js", str);
+    JS_FreeCString(ctx, str);
+
+    JS_FreeValue(ctx, basename);
+    JS_FreeValue(ctx, global);
+    MIK_FreeRuntime(mik_rt);
+}
+
+TEST_CASE("import.meta.path for absolute path module", "[modules]") {
+    const auto mik_rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(mik_rt);
+
+    const char* code = "globalThis.__path = import.meta.path;";
+    JSValue ret = MIK_EvalModuleContent(ctx, "/appfs/lib/main.js", code, strlen(code));
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+    JS_FreeValue(ctx, ret);
+
+    mik__execute_jobs(ctx);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue path = JS_GetPropertyStr(ctx, global, "__path");
+    TEST_ASSERT_TRUE_MESSAGE(JS_IsString(path), "Expected __path to be a string");
+
+    const char* str = JS_ToCString(ctx, path);
+    TEST_ASSERT_EQUAL_STRING("/appfs/lib/main.js", str);
+    JS_FreeCString(ctx, str);
+
+    JS_FreeValue(ctx, path);
+    JS_FreeValue(ctx, global);
+    MIK_FreeRuntime(mik_rt);
+}
+
+TEST_CASE("import.meta.url has file:// prefix", "[modules]") {
+    const auto mik_rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(mik_rt);
+
+    const char* code = "globalThis.__url = import.meta.url;";
+    JSValue ret = MIK_EvalModuleContent(ctx, "/appfs/main.js", code, strlen(code));
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+    JS_FreeValue(ctx, ret);
+
+    mik__execute_jobs(ctx);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue url = JS_GetPropertyStr(ctx, global, "__url");
+    const char* str = JS_ToCString(ctx, url);
+    TEST_ASSERT_EQUAL_STRING("file:///appfs/main.js", str);
+    JS_FreeCString(ctx, str);
+
+    JS_FreeValue(ctx, url);
+    JS_FreeValue(ctx, global);
+    MIK_FreeRuntime(mik_rt);
+}
+
+TEST_CASE("native:* internal import blocked from user code", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    // User code at "/appfs/main.js" should NOT be able to import native:sys
+    char* result = mik_module_normalizer(ctx, "/appfs/main.js", "native:sys", nullptr);
+    TEST_ASSERT_NULL_MESSAGE(result, "native:sys should be blocked from user code");
+
+    // But a built-in module should be allowed to import native:sys
+    result = mik_module_normalizer(ctx, "mikrojs/sys", "native:sys", nullptr);
+    TEST_ASSERT_NOT_NULL_MESSAGE(result, "native:sys should be allowed from mikrojs/ modules");
+    TEST_ASSERT_EQUAL_STRING("native:sys", result);
+    js_free(ctx, result);
+
+    // native: modules should also be allowed to import other native:* modules
+    result = mik_module_normalizer(ctx, "native:sys", "native:stdio", nullptr);
+    TEST_ASSERT_NOT_NULL_MESSAGE(result, "native:stdio should be allowed from native: modules");
+    js_free(ctx, result);
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Module normalization: root file with no dir", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    // Edge case: base has no directory component
+    char* result = mik_module_normalizer(ctx, "main.js", "./utils.js", nullptr);
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_STRING("utils.js", result);
+    js_free(ctx, result);
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}

package/components/mikrojs/test/modules_test.cpp

@@ -0,0 +1,131 @@
+#include <string.h>
+
+#include "mikrojs.h"
+#include "private.h"
+#include "quickjs.h"
+#include "unity.h"
+
+static void assert_normalizes_to(JSContext* ctx, const char* base, const char* name,
+                                 const char* expected) {
+    char* result = mik_module_normalizer(ctx, base, name, nullptr);
+    TEST_ASSERT_NOT_NULL_MESSAGE(result, "mik_module_normalizer returned NULL");
+    TEST_ASSERT_EQUAL_STRING(expected, result);
+    js_free(ctx, result);
+}
+
+TEST_CASE("Bare module names pass through unchanged", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    assert_normalizes_to(ctx, "main.js", "mikrojs/fs", "mikrojs/fs");
+    assert_normalizes_to(ctx, "main.js", "lodash", "lodash");
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Relative ./import resolves against base dirname", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    assert_normalizes_to(ctx, "lib/foo.js", "./bar.js", "lib/bar.js");
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Parent ../traversal resolves correctly", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    assert_normalizes_to(ctx, "lib/sub/foo.js", "../bar.js", "lib/bar.js");
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Multiple ../traversals resolve correctly", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    assert_normalizes_to(ctx, "a/b/c/foo.js", "../../bar.js", "a/bar.js");
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Root-level relative import", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    assert_normalizes_to(ctx, "foo.js", "./bar.js", "bar.js");
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+TEST_CASE("Simple module eval works", "[modules]") {
+    const auto mik_rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(mik_rt);
+
+    const char* code = "var result = 1 + 2;";
+    JSValue ret = MIK_EvalModuleContent(ctx, "/test/main.js", code, strlen(code));
+    TEST_ASSERT_FALSE(JS_IsException(ret));
+    JS_FreeValue(ctx, ret);
+
+    MIK_FreeRuntime(mik_rt);
+}
+
+TEST_CASE("Module import.meta.main is true for entry module", "[modules]") {
+    const auto mik_rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(mik_rt);
+
+    const char* code = "globalThis.__isMain = import.meta.main;";
+    JSValue ret = MIK_EvalModuleContent(ctx, "/test/main.js", code, strlen(code));
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+    JS_FreeValue(ctx, ret);
+
+    /* Execute pending jobs so the module body runs */
+    mik__execute_jobs(ctx);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue is_main = JS_GetPropertyStr(ctx, global, "__isMain");
+    TEST_ASSERT_TRUE_MESSAGE(JS_IsBool(is_main), "Expected __isMain to be a boolean");
+    TEST_ASSERT_EQUAL(1, JS_ToBool(ctx, is_main));
+    JS_FreeValue(ctx, is_main);
+    JS_FreeValue(ctx, global);
+
+    MIK_FreeRuntime(mik_rt);
+}
+
+TEST_CASE("Bytecode roundtrip: compile then load", "[modules]") {
+    JSRuntime* rt = JS_NewRuntime();
+    JSContext* ctx = JS_NewContext(rt);
+
+    const char* code = "var x = 40 + 2;";
+
+    /* Compile to bytecode */
+    JSValue compiled = JS_Eval(ctx, code, strlen(code), "test.js",
+                               JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(compiled), "Compilation should succeed");
+
+    size_t bytecode_len;
+    uint8_t* bytecode = JS_WriteObject(ctx, &bytecode_len, compiled, JS_WRITE_OBJ_BYTECODE);
+    JS_FreeValue(ctx, compiled);
+    TEST_ASSERT_NOT_NULL_MESSAGE(bytecode, "JS_WriteObject should produce bytecode");
+    TEST_ASSERT_TRUE_MESSAGE(bytecode_len > 0, "Bytecode should not be empty");
+
+    /* Load from bytecode */
+    JSValue loaded = JS_ReadObject(ctx, bytecode, bytecode_len, JS_READ_OBJ_BYTECODE);
+    js_free(ctx, bytecode);
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(loaded), "JS_ReadObject should succeed");
+    TEST_ASSERT_TRUE_MESSAGE(JS_VALUE_GET_TAG(loaded) == JS_TAG_MODULE, "Should be a module");
+
+    /* Execute */
+    JSValue result = JS_EvalFunction(ctx, loaded);
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(result), "JS_EvalFunction should succeed");
+    JS_FreeValue(ctx, result);
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}

package/components/mikrojs/test/pins_test.cpp

@@ -0,0 +1,47 @@
+#include "../mik_pin.cpp"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "quickjs.h"
+#include "unity.h"
+
+#define PIN CONFIG_MIKROJS_TEST_GPIO_PIN
+TEST_CASE("Test write output", "[gpio]") {
+    mik_gpio_set_pin_mode(PIN, GPIO_MODE_OUTPUT);
+    mik_gpio_digital_write(PIN, 0);
+    vTaskDelay(100 / portTICK_PERIOD_MS);
+    mik_gpio_digital_write(PIN, 1);
+}
+
+TEST_CASE("digitalRead returns a value after write", "[gpio]") {
+    mik_gpio_reset_pin(PIN);
+    mik_gpio_set_pin_mode(PIN, GPIO_MODE_INPUT_OUTPUT);
+    mik_gpio_digital_write(PIN, 1);
+    TEST_ASSERT_EQUAL_INT(1, mik_gpio_digital_read(PIN));
+    mik_gpio_digital_write(PIN, 0);
+    TEST_ASSERT_EQUAL_INT(0, mik_gpio_digital_read(PIN));
+}
+
+#define ADC_PIN CONFIG_MIKROJS_TEST_ADC_PIN
+
+TEST_CASE("analogRead returns a value in range", "[gpio]") {
+    TEST_ASSERT_EQUAL(ESP_OK, mik_adc_ensure_init());
+    int raw = mik_adc_read_raw(ADC_PIN, ADC_ATTEN_DB_12);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, raw);
+    TEST_ASSERT_LESS_OR_EQUAL(4095, raw);
+}
+
+TEST_CASE("analogReadMillivolts returns a value", "[gpio]") {
+    TEST_ASSERT_EQUAL(ESP_OK, mik_adc_ensure_init());
+    int mv = mik_adc_read_millivolts(ADC_PIN, ADC_ATTEN_DB_12);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, mv);
+}
+
+TEST_CASE("analogRead works with all attenuations", "[gpio]") {
+    TEST_ASSERT_EQUAL(ESP_OK, mik_adc_ensure_init());
+    adc_atten_t attens[] = {ADC_ATTEN_DB_0, ADC_ATTEN_DB_2_5, ADC_ATTEN_DB_6, ADC_ATTEN_DB_12};
+    for (int i = 0; i < 4; i++) {
+        int raw = mik_adc_read_raw(ADC_PIN, attens[i]);
+        TEST_ASSERT_GREATER_OR_EQUAL(0, raw);
+        TEST_ASSERT_LESS_OR_EQUAL(4095, raw);
+    }
+}

package/components/mikrojs/test/pwm_test.cpp

@@ -0,0 +1,166 @@
+#include "../mik_pwm.cpp"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+
+#define PWM_PIN CONFIG_MIKROJS_TEST_PWM_PIN
+
+TEST_CASE("PWM channel alloc and release", "[pwm]") {
+    int ch = mik__pwm_alloc_channel();
+    TEST_ASSERT_GREATER_OR_EQUAL(0, ch);
+    mik__pwm_free_channel(ch);
+}
+
+TEST_CASE("PWM timer alloc shares same frequency", "[pwm]") {
+    int t1 = mik__pwm_alloc_timer(5000);
+    int t2 = mik__pwm_alloc_timer(5000);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, t1);
+    TEST_ASSERT_EQUAL(t1, t2);  // same frequency shares timer
+    mik__pwm_free_timer(t1);
+    mik__pwm_free_timer(t2);
+}
+
+TEST_CASE("PWM timer alloc different frequencies", "[pwm]") {
+    int t1 = mik__pwm_alloc_timer(5000);
+    int t2 = mik__pwm_alloc_timer(1000);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, t1);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, t2);
+    TEST_ASSERT_NOT_EQUAL(t1, t2);  // different frequency = different timer
+    mik__pwm_free_timer(t1);
+    mik__pwm_free_timer(t2);
+}
+
+TEST_CASE("PWM best resolution for common frequencies", "[pwm]") {
+    /* 5 kHz → 80 MHz / 5000 = 16000, log2(16000) ≈ 13 */
+    ledc_timer_bit_t res = mik__pwm_best_resolution(5000);
+    TEST_ASSERT_GREATER_OR_EQUAL(10, res);
+    TEST_ASSERT_LESS_OR_EQUAL(LEDC_TIMER_14_BIT, res);
+
+    /* 1 MHz → 80 MHz / 1000000 = 80, log2(80) ≈ 6 */
+    res = mik__pwm_best_resolution(1000000);
+    TEST_ASSERT_GREATER_OR_EQUAL(4, res);
+    TEST_ASSERT_LESS_OR_EQUAL(8, res);
+}
+
+TEST_CASE("PWM duty to raw conversion", "[pwm]") {
+    /* 13-bit resolution: max = 8191 */
+    TEST_ASSERT_EQUAL(0, mik__pwm_duty_to_raw(0.0, LEDC_TIMER_13_BIT));
+    TEST_ASSERT_EQUAL(8191, mik__pwm_duty_to_raw(1.0, LEDC_TIMER_13_BIT));
+
+    uint32_t half = mik__pwm_duty_to_raw(0.5, LEDC_TIMER_13_BIT);
+    TEST_ASSERT_GREATER_OR_EQUAL(4090, half);
+    TEST_ASSERT_LESS_OR_EQUAL(4100, half);
+}
+
+TEST_CASE("PWM channel exhaustion", "[pwm]") {
+    int channels[MIK_PWM_MAX_CHANNELS];
+    for (int i = 0; i < MIK_PWM_MAX_CHANNELS; i++) {
+        channels[i] = mik__pwm_alloc_channel();
+        TEST_ASSERT_GREATER_OR_EQUAL(0, channels[i]);
+    }
+    /* Next alloc should fail */
+    TEST_ASSERT_EQUAL(-1, mik__pwm_alloc_channel());
+
+    /* Release all */
+    for (int i = 0; i < MIK_PWM_MAX_CHANNELS; i++) {
+        mik__pwm_free_channel(channels[i]);
+    }
+    /* Should be able to alloc again */
+    int ch = mik__pwm_alloc_channel();
+    TEST_ASSERT_GREATER_OR_EQUAL(0, ch);
+    mik__pwm_free_channel(ch);
+}
+
+TEST_CASE("PWM LEDC set duty produces output", "[pwm]") {
+    int ch = mik__pwm_alloc_channel();
+    int timer = mik__pwm_alloc_timer(5000);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, ch);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, timer);
+
+    ledc_timer_bit_t resolution = mik__pwm_best_resolution(5000);
+
+    ledc_timer_config_t timer_cfg = {};
+    timer_cfg.speed_mode = LEDC_LOW_SPEED_MODE;
+    timer_cfg.duty_resolution = resolution;
+    timer_cfg.timer_num = static_cast<ledc_timer_t>(timer);
+    timer_cfg.freq_hz = 5000;
+    timer_cfg.clk_cfg = LEDC_AUTO_CLK;
+    TEST_ASSERT_EQUAL(ESP_OK, ledc_timer_config(&timer_cfg));
+
+    ledc_channel_config_t ch_cfg = {};
+    ch_cfg.gpio_num = PWM_PIN;
+    ch_cfg.speed_mode = LEDC_LOW_SPEED_MODE;
+    ch_cfg.channel = static_cast<ledc_channel_t>(ch);
+    ch_cfg.timer_sel = static_cast<ledc_timer_t>(timer);
+    ch_cfg.duty = mik__pwm_duty_to_raw(0.5, resolution);
+    ch_cfg.hpoint = 0;
+    TEST_ASSERT_EQUAL(ESP_OK, ledc_channel_config(&ch_cfg));
+
+    /* Let it run briefly */
+    vTaskDelay(pdMS_TO_TICKS(50));
+
+    /* Stop and release */
+    ledc_stop(LEDC_LOW_SPEED_MODE, static_cast<ledc_channel_t>(ch), 0);
+    mik__pwm_free_channel(ch);
+    mik__pwm_free_timer(timer);
+}
+
+TEST_CASE("PWM fade completes", "[pwm]") {
+    int ch = mik__pwm_alloc_channel();
+    int timer = mik__pwm_alloc_timer(5000);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, ch);
+    TEST_ASSERT_GREATER_OR_EQUAL(0, timer);
+
+    ledc_timer_bit_t resolution = mik__pwm_best_resolution(5000);
+
+    ledc_timer_config_t timer_cfg = {};
+    timer_cfg.speed_mode = LEDC_LOW_SPEED_MODE;
+    timer_cfg.duty_resolution = resolution;
+    timer_cfg.timer_num = static_cast<ledc_timer_t>(timer);
+    timer_cfg.freq_hz = 5000;
+    timer_cfg.clk_cfg = LEDC_AUTO_CLK;
+    TEST_ASSERT_EQUAL(ESP_OK, ledc_timer_config(&timer_cfg));
+
+    ledc_channel_config_t ch_cfg = {};
+    ch_cfg.gpio_num = PWM_PIN;
+    ch_cfg.speed_mode = LEDC_LOW_SPEED_MODE;
+    ch_cfg.channel = static_cast<ledc_channel_t>(ch);
+    ch_cfg.timer_sel = static_cast<ledc_timer_t>(timer);
+    ch_cfg.duty = 0;
+    ch_cfg.hpoint = 0;
+    TEST_ASSERT_EQUAL(ESP_OK, ledc_channel_config(&ch_cfg));
+
+    /* Install fade and run a short fade */
+    ledc_fade_func_install(0);
+
+    std::atomic<bool> fade_done{false};
+
+    ledc_cbs_t cbs = {};
+    cbs.fade_cb = [](const ledc_cb_param_t* param, void* arg) -> bool {
+        if (param->event == LEDC_FADE_END_EVT) {
+            static_cast<std::atomic<bool>*>(arg)->store(true, std::memory_order_release);
+        }
+        return false;
+    };
+    ledc_cb_register(LEDC_LOW_SPEED_MODE, static_cast<ledc_channel_t>(ch), &cbs, &fade_done);
+
+    uint32_t target = mik__pwm_duty_to_raw(1.0, resolution);
+    TEST_ASSERT_EQUAL(ESP_OK,
+                      ledc_set_fade_with_time(LEDC_LOW_SPEED_MODE,
+                                              static_cast<ledc_channel_t>(ch), target, 100));
+    TEST_ASSERT_EQUAL(ESP_OK,
+                      ledc_fade_start(LEDC_LOW_SPEED_MODE, static_cast<ledc_channel_t>(ch),
+                                      LEDC_FADE_NO_WAIT));
+
+    /* Wait for fade to complete (max 500ms) */
+    for (int i = 0; i < 50; i++) {
+        if (fade_done.load(std::memory_order_acquire)) break;
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    TEST_ASSERT_TRUE(fade_done.load(std::memory_order_acquire));
+
+    /* Cleanup */
+    ledc_stop(LEDC_LOW_SPEED_MODE, static_cast<ledc_channel_t>(ch), 0);
+    mik__pwm_free_channel(ch);
+    mik__pwm_free_timer(timer);
+}