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)