Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / external / lib_js / tests_stand_ins.lucb

#==============================================================================================
#
#   tests_stand_ins - the phase-1 strings, arrays and conversions of external/lib_js
#
#   DESCRIPTION:
#       A JS string value holds its PrimitiveString under LibJS's STRING_TAG; SameValue and a
#       Map's ValueTraits compare strings by their code units; Array::create_from keeps its
#       elements in order with their length; ToString, ToUint32 and ToLength answer as the
#       spec says for the values that exist before phase 3 (test262's expectations).
#
#       Copyright (c) 2026 the luce-browser authors.
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

test "JS stand-ins: strings are values, compare by content and key a Map by content":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let a = js_primitive_string_create_string(vm, ak.string_from_str("swsh"))
    let b = js_primitive_string_create_fly_string(vm, ak.fly_string_from_str("swsh"))
    let c = js_primitive_string_create_string(vm, ak.string_from_str("ornate"))
    assert(js_value_is_string(a) and js_value_is_string(b) and not js_value_is_object(a))
    assert(not js_value_is_string(js_value_from_f64(1.0)) and not js_value_is_string(js_null()))
    let text = js_value_as_string_utf8_string(b)
    assert(ak.string_eq_string_view(&text, ak.sv("swsh")))
    assert(js_same_value(a, b) and not js_same_value(a, c))
    assert(js_value_traits_hash(a) == js_value_traits_hash(b))

    let map = js_map_create(realm)
    js_map_map_set(map, a, js_value_from_f64(1.0))
    js_map_map_set(map, b, js_value_from_f64(2.0))
    js_map_map_set(map, c, js_value_from_f64(3.0))
    assert(js_map_map_size(map) == 2, "two equal strings are one key")
    let value = js_map_map_get(map, a) else trap("no entry")
    assert(js_value_as_double(value) == 2.0)

test "JS stand-ins: Array::create_from, its length and its indexed properties":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let values: JsValue[3] = [js_value_from_f64(7.0), js_value_from_f64(300.0), js_value_from_f64(65536.0)]
    let array = js_array_create_from(realm, values[0..<3])
    let object = (JsObject*)array
    assert(js_value_is_object(js_value_from_object(object)))
    let length = js_value_to_length(js_object_get_length(object) else trap("length"), vm) else trap("to_length")
    assert(length == 3)
    assert(js_value_as_double(js_object_get_without_side_effects_index(object, 1)) == 300.0)
    assert(js_value_is_undefined(js_object_get_without_side_effects_index(object, 3)))
    let empty = js_array_create_from(realm, values[0..<0])
    let empty_length = js_value_to_length(js_object_get_length((JsObject*)empty) else trap("length"), vm) else trap("to_length")
    assert(empty_length == 0)

test "JS stand-ins: ToString, ToUint32 and ToLength of numbers, booleans, null, undefined and strings":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    _ = realm
    let cases: (JsValue, str)[9] = [(js_value_from_f64(42.0), "42"), (js_value_from_f64(-0.0), "0"), (js_value_from_f64(-7.0), "-7"),
                                    (js_value_from_f64(1e15), "1000000000000000"), (js_value_from_bool(true), "true"), (js_value_from_bool(false), "false"),
                                    (js_null(), "null"), (js_undefined(), "undefined"), (js_primitive_string_create_string(vm, ak.string_from_str("styleset")), "styleset")]
    for (value, expected) in cases:
        let text = js_value_to_string(value, vm) else trap("to_string")
        assert(ak.string_eq_string_view(&text, ak.sv(expected)))
    let infinity = js_value_to_string(js_value_from_f64(-math.infinity), vm) else trap("to_string")
    assert(ak.string_eq_string_view(&infinity, ak.sv("-Infinity")))

    let u32_cases: (f64, u32)[7] = [(0.0, 0), (-1.0, 4294967295), (4294967301.0, 5), (2.9, 2), (-2.9, 4294967294), (math.nan, 0), (math.infinity, 0)]
    for (number, expected) in u32_cases:
        assert((js_value_to_u32(js_value_from_f64(number), vm) else trap("to_u32")) == expected)

    let length_cases: (f64, u64)[5] = [(-3.0, 0), (2.5, 2), (math.nan, 0), (math.infinity, 9007199254740991), (1e300, 9007199254740991)]
    for (number, expected) in length_cases:
        assert((js_value_to_length(js_value_from_f64(number), vm) else trap("to_length")) == expected)

## An Infra map of `entries`.
func test_infra_map(entries: const (str, InfraJsonTopLevel)[]) -> InfraJsonTopLevel:
    var map = InfraJsonObject()
    for (key, value) in entries:
        _ = ak.ordered_hash_map_set(&map.value, ak.string_from_str(key), value)
    return InfraJsonTopLevel.infra_json_object(map)

## An Infra string, number, boolean or null.
func test_infra_base(value: InfraJsonBaseValue) -> InfraJsonTopLevel:
    return InfraJsonTopLevel.json_value(InfraJsonValue.json_base_value(value))

test "JS stand-ins: Infra values serialize through JSON.stringify (a CSP report's shape)":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    var list: ak.Vector[InfraJsonBaseValue]
    ak.vector_append_t(&list, InfraJsonBaseValue.bool_(true))
    ak.vector_append_t(&list, InfraJsonBaseValue.empty)
    ak.vector_append_t(&list, InfraJsonBaseValue.u16_(7))
    let report: (str, InfraJsonTopLevel)[5] = [("document-uri", test_infra_base(InfraJsonBaseValue.string(ak.string_from_str("https://example.com/")))),
                                               ("status-code", test_infra_base(InfraJsonBaseValue.u16_(200))),
                                               ("flags", InfraJsonTopLevel.json_value(InfraJsonValue.vector(list))),
                                               ("quote\"line\n\u{1}", test_infra_base(InfraJsonBaseValue.string(ak.string_from_str("tab\there \\ é")))),
                                               ("line-number", test_infra_base(InfraJsonBaseValue.u32_(4294967295)))]
    let top: (str, InfraJsonTopLevel)[1] = [("csp-report", test_infra_map(report))]
    let json = infra_serialize_an_infra_value_to_a_json_string(realm, test_infra_map(top))
    let expected = "{\"csp-report\":{\"document-uri\":\"https://example.com/\",\"status-code\":200,\"flags\":[true,null,7],\"quote\\\"line\\n\\u0001\":\"tab\\there \\\\ é\",\"line-number\":4294967295}}"
    assert(ak.string_eq_string_view(&json, ak.sv(expected)))

test "JS stand-ins: an object's keys are its array indices in order, then its other keys as created; undefined is left out":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let object = (JsObject*)js_object_create(realm)
    for key in ["b", "10", "a", "2", "01"]:
        js_object_create_data_property_or_throw(object, ak.string_from_str(key), js_primitive_string_create_string(vm, ak.string_from_str(key)))
    js_object_create_data_property_or_throw(object, ak.string_from_str("gone"), js_undefined())
    js_object_create_data_property_or_throw(object, ak.string_from_str("a"), js_value_from_f64(math.nan))
    let json = (js_json_stringify(realm, js_value_from_object(object)) else trap("stringify")) else trap("undefined")
    assert(ak.string_eq_string_view(&json, ak.sv("{\"2\":\"2\",\"10\":\"10\",\"b\":\"b\",\"a\":null,\"01\":\"01\"}")))
    assert((js_json_stringify(realm, js_undefined()) else trap("stringify")) == none)