Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / web_idl / tests_web_idl.lucb

#==============================================================================================
#
#   tests_web_idl - tests of WebIDL: DOMException, ExceptionOr, ConvertToInt (region r14)
#
#   DESCRIPTION:
#       Ladybird has no unit tests for WebIDL; these pin the reference build's answers: the
#       DOMException legacy codes of every error name, the named factories, the formatter,
#       throwing and taking WebIDL exceptions through the VM's pending-exception slot,
#       QuotaExceededError's constructor checks, ConvertToInt for every integer type with and
#       without [Clamp] and [EnforceRange] (tests_convert_to_int_vectors, recorded from the
#       reference build), IntegerPart and the JS::Value encodings ConvertToInt reads.
#
#==============================================================================================

# mark: DOMException ============================================================================

## The DOMException error names and their legacy codes, as WebIDL::get_legacy_code_for_name of
## the reference build answers them (0: no legacy code).
let dom_exception_legacy_codes: (str, u16)[34] = [
    ("IndexSizeError", 1), ("HierarchyRequestError", 3), ("WrongDocumentError", 4), ("InvalidCharacterError", 5),
    ("NoModificationAllowedError", 7), ("NotFoundError", 8), ("NotSupportedError", 9), ("InUseAttributeError", 10),
    ("InvalidStateError", 11), ("SyntaxError", 12), ("InvalidModificationError", 13), ("NamespaceError", 14),
    ("InvalidAccessError", 15), ("TypeMismatchError", 17), ("SecurityError", 18), ("NetworkError", 19),
    ("AbortError", 20), ("URLMismatchError", 21), ("QuotaExceededError", 22), ("TimeoutError", 23),
    ("InvalidNodeTypeError", 24), ("DataCloneError", 25), ("EncodingError", 0), ("NotReadableError", 0),
    ("UnknownError", 0), ("ConstraintError", 0), ("DataError", 0), ("TransactionInactiveError", 0),
    ("ReadOnlyError", 0), ("VersionError", 0), ("OperationError", 0), ("NotAllowedError", 0),
    ("ValidationError", 0), ("Bogus", 0),
]

test "the legacy code of every DOMException name":
    for entry in dom_exception_legacy_codes:
        assert(idl_get_legacy_code_for_name(ak.fly_string_from_str(entry.0)) == entry.1, entry.0)

## The name a named factory gives its DOMException.
func test_dom_exception_name_is(exception: IdlDomException*, name: str) -> bool:
    let exception_name = idl_dom_exception_name(exception)
    return ak.fly_string_eq_string_view(&exception_name, ak.sv(name))

test "the named factories: name, message and code":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let message = ak.utf16_string_from_str("Invalid node type for insertion")
    let exception = idl_hierarchy_request_error_create(realm, message)
    assert(test_dom_exception_name_is(exception, "HierarchyRequestError"))
    let exception_message = idl_dom_exception_message(exception)
    assert(ak.utf16_fly_string_eq_string_view(&exception_message, ak.sv("Invalid node type for insertion")))
    assert(idl_dom_exception_code(exception) == 3)
    assert(exception.serializable.vtable == &idl_dom_exception_serializable_vtable)

    let empty = ak.utf16_string_from_str("")
    assert(test_dom_exception_name_is(idl_index_size_error_create(realm, empty), "IndexSizeError"))
    assert(test_dom_exception_name_is(idl_wrong_document_error_create(realm, empty), "WrongDocumentError"))
    assert(test_dom_exception_name_is(idl_invalid_character_error_create(realm, empty), "InvalidCharacterError"))
    assert(test_dom_exception_name_is(idl_no_modification_allowed_error_create(realm, empty), "NoModificationAllowedError"))
    assert(test_dom_exception_name_is(idl_not_found_error_create(realm, empty), "NotFoundError"))
    assert(test_dom_exception_name_is(idl_not_supported_error_create(realm, empty), "NotSupportedError"))
    assert(test_dom_exception_name_is(idl_in_use_attribute_error_create(realm, empty), "InUseAttributeError"))
    assert(test_dom_exception_name_is(idl_invalid_state_error_create(realm, empty), "InvalidStateError"))
    assert(test_dom_exception_name_is(idl_syntax_error_create(realm, empty), "SyntaxError"))
    assert(test_dom_exception_name_is(idl_invalid_modification_error_create(realm, empty), "InvalidModificationError"))
    assert(test_dom_exception_name_is(idl_namespace_error_create(realm, empty), "NamespaceError"))
    assert(test_dom_exception_name_is(idl_invalid_access_error_create(realm, empty), "InvalidAccessError"))
    assert(test_dom_exception_name_is(idl_type_mismatch_error_create(realm, empty), "TypeMismatchError"))
    assert(test_dom_exception_name_is(idl_security_error_create(realm, empty), "SecurityError"))
    assert(test_dom_exception_name_is(idl_network_error_create(realm, empty), "NetworkError"))
    assert(test_dom_exception_name_is(idl_abort_error_create(realm, empty), "AbortError"))
    assert(test_dom_exception_name_is(idl_url_mismatch_error_create(realm, empty), "URLMismatchError"))
    assert(test_dom_exception_name_is(idl_timeout_error_create(realm, empty), "TimeoutError"))
    assert(test_dom_exception_name_is(idl_invalid_node_type_error_create(realm, empty), "InvalidNodeTypeError"))
    assert(test_dom_exception_name_is(idl_data_clone_error_create(realm, empty), "DataCloneError"))
    assert(test_dom_exception_name_is(idl_encoding_error_create(realm, empty), "EncodingError"))
    assert(test_dom_exception_name_is(idl_not_readable_error_create(realm, empty), "NotReadableError"))
    assert(test_dom_exception_name_is(idl_unknown_error_create(realm, empty), "UnknownError"))
    assert(test_dom_exception_name_is(idl_constraint_error_create(realm, empty), "ConstraintError"))
    assert(test_dom_exception_name_is(idl_data_error_create(realm, empty), "DataError"))
    assert(test_dom_exception_name_is(idl_transaction_inactive_error_create(realm, empty), "TransactionInactiveError"))
    assert(test_dom_exception_name_is(idl_read_only_error_create(realm, empty), "ReadOnlyError"))
    assert(test_dom_exception_name_is(idl_version_error_create(realm, empty), "VersionError"))
    assert(test_dom_exception_name_is(idl_operation_error_create(realm, empty), "OperationError"))
    assert(test_dom_exception_name_is(idl_not_allowed_error_create(realm, empty), "NotAllowedError"))

test "DOMException::create(realm) and construct_impl (message first)":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let plain = idl_dom_exception_create(realm)
    assert(ak.fly_string_is_empty(&plain.m_name))
    assert(idl_dom_exception_code(plain) == 0)
    let constructed = idl_dom_exception_construct_impl(realm, ak.utf16_string_from_str("gone"), ak.fly_string_from_str("NotFoundError"))
    assert(test_dom_exception_name_is(constructed, "NotFoundError"))
    assert(idl_dom_exception_code(constructed) == 8)

test "the formatters: \"[name]: message\" and a simple exception's message":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let exception = idl_not_found_error_create(realm, ak.utf16_string_from_str("Child does not belong to this node"))
    let formatted = idl_dom_exception_to_string(exception)
    assert(ak.string_eq_string_view(&formatted, ak.sv("[NotFoundError]: Child does not belong to this node")))
    let as_exception = idl_exception_to_string(.idl_dom_exception(exception))
    assert(ak.string_equals(&as_exception, &formatted))
    let simple = idl_exception_to_string(.idl_simple_exception(IdlSimpleException(type_ = IdlSimpleExceptionType.type_error, message = .string_view(ak.sv("Not an object")))))
    assert(ak.string_eq_string_view(&simple, ak.sv("Not an object")))
    let owned = idl_exception_to_string(.idl_simple_exception(IdlSimpleException(type_ = IdlSimpleExceptionType.range_error, message = .string(ak.string_from_str("Index out of range")))))
    assert(ak.string_eq_string_view(&owned, ak.sv("Index out of range")))

# mark: ExceptionOr =============================================================================

## A function returning ExceptionOr<i32>: 7, or a NotFoundError when `fail`.
func test_exception_or(realm: Realm*, fail: bool) -> i32!:
    if fail:
        return try idl_throw(.idl_dom_exception(idl_not_found_error_create(realm, ak.utf16_string_from_str("missing"))))
    return 7

## TRY() through a caller.
func test_exception_or_caller(realm: Realm*, fail: bool) -> i32!:
    let value = try test_exception_or(realm, fail)
    return value + 1

test "ExceptionOr: a thrown exception propagates with webidl_exception and is taken from the VM":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let value = test_exception_or_caller(realm, false) else trap("unexpected exception")
    assert(value == 8)
    assert(not vm_has_pending_exception(vm))

    let failed = test_exception_or_caller(realm, true) catch failure:
        assert(failure.code == webidl_exception)
        recover -1
    assert(failed == -1)
    assert(vm_has_pending_exception(vm))
    match idl_take_pending_exception():
        .idl_dom_exception(exception):
            assert(test_dom_exception_name_is(exception, "NotFoundError"))
            assert(idl_dom_exception_code(exception) == 8)
        _:
            trap("expected a DOMException")
    assert(not vm_has_pending_exception(vm))

test "ExceptionOr: a SimpleException":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let thrown = web_test_throw(.idl_simple_exception(IdlSimpleException(type_ = IdlSimpleExceptionType.type_error, message = .string_view(ak.sv("Not a function"))))) catch failure:
        assert(failure.code == webidl_exception)
        recover true
    assert(thrown)
    match idl_take_pending_exception():
        .idl_simple_exception(simple):
            assert(simple.type_ == IdlSimpleExceptionType.type_error)
            let message = idl_simple_exception_message(&simple)
            assert(ak.string_eq_string_view(&message, ak.sv("Not a function")))
        _:
            trap("expected a SimpleException")

## `return WebIDL::SimpleException { RangeError, message };` from a function returning ExceptionOr<i32>.
func test_throw_simple() -> i32!:
    return try idl_throw_simple(IdlSimpleExceptionType.range_error, .string_view(ak.sv("Index out of range")))

test "idl_throw_simple stores a SimpleException":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let value = test_throw_simple() catch failure:
        assert(failure.code == webidl_exception)
        recover -1
    assert(value == -1)
    match idl_take_pending_exception():
        .idl_simple_exception(simple):
            assert(simple.type_ == IdlSimpleExceptionType.range_error)
            let message = idl_simple_exception_message(&simple)
            assert(ak.string_eq_string_view(&message, ak.sv("Index out of range")))
        _:
            trap("expected a SimpleException")

# mark: QuotaExceededError ======================================================================

## The message of the pending RangeError that `construct_impl` with `options` throws.
func test_quota_error_message(realm: Realm*, options: IdlQuotaExceededErrorOptions) -> ak.String:
    let thrown: IdlQuotaExceededError*? = idl_quota_exceeded_error_construct_impl(realm, ak.utf16_string_from_str(""), options) catch failure:
        assert(failure.code == js_exception)
        recover none
    assert(thrown == none)
    match idl_take_pending_exception():
        .idl_simple_exception(simple):
            assert(simple.type_ == IdlSimpleExceptionType.range_error)
            return idl_simple_exception_message(&simple)
        _:
            trap("expected a RangeError")

test "QuotaExceededError: name, code, quota and requested, and the constructor's RangeErrors":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let created = idl_quota_exceeded_error_create_utf16_string(realm, ak.utf16_string_from_str("full"))
    assert(test_dom_exception_name_is(created.idl_dom_exception(), "QuotaExceededError"))
    assert(idl_dom_exception_code(created.idl_dom_exception()) == 22)
    assert(idl_quota_exceeded_error_quota(created) == none and idl_quota_exceeded_error_requested(created) == none)
    assert(created.dom_exception.serializable.vtable == &idl_quota_exceeded_error_serializable_vtable)
    let unnamed = idl_quota_exceeded_error_create(realm)
    assert(ak.fly_string_is_empty(&unnamed.dom_exception.m_name))

    let constructed = idl_quota_exceeded_error_construct_impl(realm, ak.utf16_string_from_str("over"), IdlQuotaExceededErrorOptions(quota = 10.0, requested = 12.5)) else trap("unexpected exception")
    assert(idl_quota_exceeded_error_quota(constructed) == 10.0)
    assert(idl_quota_exceeded_error_requested(constructed) == 12.5)
    let equal = idl_quota_exceeded_error_construct_impl(realm, ak.utf16_string_from_str(""), IdlQuotaExceededErrorOptions(quota = 3.0, requested = 3.0)) else trap("unexpected exception")
    assert(idl_quota_exceeded_error_quota(equal) == 3.0)

    let negative_quota = test_quota_error_message(realm, IdlQuotaExceededErrorOptions(quota = -1.0, requested = none))
    assert(ak.string_eq_string_view(&negative_quota, ak.sv("Quota cannot be less than 0")))
    let negative_requested = test_quota_error_message(realm, IdlQuotaExceededErrorOptions(quota = none, requested = -0.5))
    assert(ak.string_eq_string_view(&negative_requested, ak.sv("Requested cannot be less than 0")))
    let below_quota = test_quota_error_message(realm, IdlQuotaExceededErrorOptions(quota = 5.0, requested = 4.0))
    assert(ak.string_eq_string_view(&below_quota, ak.sv("Requested cannot be less than quota")))

# mark: ConvertToInt ============================================================================

test "ConvertToInt matches the reference build for every integer type, [Clamp] and [EnforceRange]":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    for case_ in convert_to_int_cases:
        let enforce_range = IdlEnforceRange.yes if case_.enforce_range else IdlEnforceRange.no
        let clamp = IdlClamp.yes if case_.clamp else IdlClamp.no
        let result = idl_convert_to_int(vm, js_value_from_f64(case_.input), case_.type_, enforce_range, clamp) catch failure:
            assert(failure.code == js_exception)
            match idl_take_pending_exception():
                .idl_simple_exception(simple):
                    assert(simple.type_ == IdlSimpleExceptionType.type_error)
                    let message = idl_simple_exception_message(&simple)
                    if not ak.string_eq_string_view(&message, ak.sv(case_.error_)):
                        trap(f"convert_to_int({case_.input}): {case_.error_}")
                _:
                    trap("expected a TypeError")
            continue
        if case_.error_.length != 0:
            trap(f"convert_to_int({case_.input}) should have thrown {case_.error_}")
        if result != case_.expected:
            trap(f"convert_to_int({case_.input}) = {result}, expected {case_.expected}")

test "ToNumber of undefined, null and booleans in ConvertToInt":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    assert((idl_convert_to_int(vm, js_undefined(), IdlIntegerType.long) else trap("throws")) == 0.0)
    assert((idl_convert_to_int(vm, js_null(), IdlIntegerType.long) else trap("throws")) == 0.0)
    assert((idl_convert_to_int(vm, js_value_from_bool(true), IdlIntegerType.octet) else trap("throws")) == 1.0)
    assert((idl_convert_to_int(vm, js_value_from_bool(false), IdlIntegerType.octet) else trap("throws")) == 0.0)
    let thrown = idl_convert_to_int(vm, js_undefined(), IdlIntegerType.long, IdlEnforceRange.yes) catch failure:
        recover -1.0
    assert(thrown == -1.0)
    _ = idl_take_pending_exception()

test "IntegerPart":
    assert(idl_integer_part(1.9) == 1.0)
    assert(idl_integer_part(-1.9) == -1.0)
    assert(idl_integer_part(0.0) == 0.0)
    assert(idl_integer_part(-0.5) == 0.0 and math.signbit(idl_integer_part(-0.5)))
    assert(idl_integer_part(1.0e300) == 1.0e300)

test "JS::modulo keeps the sign of the divisor":
    assert(js_modulo(-1.0, 256.0) == 255.0)
    assert(js_modulo(300.0, 256.0) == 44.0)
    assert(js_modulo(-1.0, 18446744073709551616.0) == 18446744073709551616.0)

# mark: JS::Value ===============================================================================

test "JS::Value encodings match LibJS's NaN boxing":
    assert(js_value_from_f64(1.0).nan_boxed_value.m_value.encoded == 0x7ffa000000000001)
    assert(js_value_from_f64(-0.0).nan_boxed_value.m_value.encoded == 0x8000000000000000)
    assert(js_value_from_f64(0.5).nan_boxed_value.m_value.encoded == 0x3fe0000000000000)
    assert(js_value_from_f64(2147483648.0).nan_boxed_value.m_value.encoded == 0x41e0000000000000)
    assert(js_value_from_f64(-2147483648.0).nan_boxed_value.m_value.encoded == 0x7ffa000080000000)
    assert(js_value_from_f64(math.nan).nan_boxed_value.m_value.encoded == 0x7ff8000000000000)
    assert(js_undefined().nan_boxed_value.m_value.encoded == 0x7ffe000000000000)
    assert(js_null().nan_boxed_value.m_value.encoded == 0x7fff000000000000)
    assert(js_value_from_bool(true).nan_boxed_value.m_value.encoded == 0x7ff9000000000001)
    assert(js_value_from_bool(false).nan_boxed_value.m_value.encoded == 0x7ff9000000000000)
    assert(js_value_is_int32(js_value_from_f64(-7.0)) and js_value_as_double(js_value_from_f64(-7.0)) == -7.0)
    assert(js_value_is_double(js_value_from_f64(0.25)) and js_value_as_double(js_value_from_f64(0.25)) == 0.25)
    assert(js_value_is_number(js_value_from_f64(math.nan)) and not js_value_is_number(js_undefined()))
    assert(js_value_is_undefined(js_undefined()) and not js_value_is_undefined(js_null()))
    assert(js_value_is_boolean(js_value_from_bool(true)) and not js_value_is_object(js_null()))

test "Tracing is off by default and can be turned on":
    assert(not idl_g_enable_idl_tracing)
    idl_set_enable_idl_tracing(true)
    assert(idl_g_enable_idl_tracing)
    idl_set_enable_idl_tracing(false)