Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / dom / tests_events.lucb

#==============================================================================================
#
#   tests_events - tests of DOM events, EventTarget, AbortSignal and the native-call seam (r19)
#
#   DESCRIPTION:
#       Ladybird has no unit tests for these files (its DOM events are tested through
#       Tests/LibWeb/Text, which needs scripting), so these pin the C++ behaviour of what runs
#       before the regions the event code calls into are ported: EventTarget's construction
#       (alone and as the base of a node, made in a realm), adding and removing event listeners
#       (options, de-duplication, abort signals), the event handler map, dispatchEvent()'s
#       errors, the event flags, the event path and composedPath(), CustomEvent, the
#       invoke/inner-invoke filtering, AbortSignal's algorithms, reasons and dependent signals,
#       AbortController, JS::NativeFunction called through JS::call, completions, object
#       values, the GC edges, HighResolutionTime's coarsening and the UI event names.
#
#       Not reachable yet (they trap in other regions' stubs, so they cannot run here): creating
#       an Event through realm.create (HTML::relevant_global_object, r29), dispatching
#       (DOM::retarget, r18), calling a listener (principal_realm_settings_object and
#       prepare_to_run_script, r29) and therefore signal_abort, which fires `abort`. Events are
#       built here as the Event constructor builds them, without the time stamp.
#
#==============================================================================================

# mark: Helpers =================================================================================

## An Event built as Event::Event(realm, type, init) builds it, without the time stamp (which
## needs the relevant global object's settings, region r29).
func test_event(realm: Realm*, type_: str, bubbles: bool = false, cancelable: bool = false) -> DomEvent*:
    let event = (DomEvent*)web_allocate_cell(realm, &dom_event_class)
    bind_platform_object_construct_realm(event.bind_platform_object(), realm)
    event.m_type = ak.fly_string_from_str(type_)
    event.m_bubbles = bubbles
    event.m_cancelable = cancelable
    event.m_initialized = true
    web_initialize_cell(event.cell(), realm)
    return event

## What a test native function saw when it was called.
struct TestNativeCall:
    var calls: i32
    var argument_count: usize
    var argument: JsValue
    var this_value: JsValue
    var realm: Realm*?
    var fail: bool

## A native function behaviour recording its call into a TestNativeCall.
func test_native_behaviour(context: void*?, vm: Vm*) -> JsValue!:
    let seen = (TestNativeCall*)(context else trap("no captures"))
    seen.calls += 1
    seen.argument_count = vm_argument_count(vm)
    seen.argument = vm_argument(vm, 0)
    seen.this_value = vm_this_value(vm)
    seen.realm = vm_current_realm(vm)
    if seen.fail:
        try vm_throw_completion(vm, IdlSimpleExceptionType.type_error, .string_view(ak.sv("listener failed")))
    return js_value_from_bool(true)

## A WebIDL callback whose object is a native function recording into `seen`. Its callback context
## would be the realm's principal settings object (region r29); the realm cell stands in for it,
## which only the callback's edges read.
func test_callback(realm: Realm*, seen: TestNativeCall*) -> IdlCallbackType*:
    let function = js_native_function_create(realm, JsNativeFunctionBehaviour(call = test_native_behaviour, context = seen), 1, ak.utf16_fly_string_new(), realm)
    let callback = (IdlCallbackType*)web_allocate_cell(realm, &idl_callback_type_class)
    idl_callback_type_construct_html_environment_settings_obje(callback, (JsObject*)function, (HtmlEnvironmentSettingsObject*)realm)
    web_initialize_cell(callback.cell(), realm)
    return callback

## An IDLEventListener over a recording native function.
func test_listener(realm: Realm*, seen: TestNativeCall*) -> DomIdlEventListener*:
    return dom_idl_event_listener_create(realm, test_callback(realm, seen))

## A DOM node of class `info` made in `realm` through Node's constructor (Node::Node, which runs
## EventTarget::EventTarget) and EventTarget's initialize. The concrete classes' constructors
## are other regions' (Document r17, DocumentFragment r18; Element's traps in r13b's ARIAMixin);
## the node document is a hand-built one (r15's test_document), outside the heap.
func test_realm_node(realm: Realm*, info: const ak.ClassInfo*, type_: DomNodeType, document: DomDocument*) -> DomNode*:
    let node = (DomNode*)web_allocate_cell(realm, info)
    dom_node_construct_realm(node, realm, document, type_)
    gc.heap_undefer_gc(gc.cell_heap(node.cell()))
    dom_event_target_initialize_impl(node.js_cell(), realm)
    return node

## The options of add_event_listener: capture, passive, once and signal.
func test_add_options(capture: bool = false, passive: bool? = none, once: bool = false, signal: DomAbortSignal*? = none) -> DomAddEventListenerOptionsOrBool:
    return .dom_add_event_listener_options(DomAddEventListenerOptions(event_listener_options = DomEventListenerOptions(capture = capture), passive = passive, once = once, signal = signal))

## The raw encoding of a JS value (JsValue holds a union, so it has no ==).
func test_bits(value: JsValue) -> u64:
    return value.nan_boxed_value.m_value.encoded

# mark: EventTarget =============================================================================

test "new EventTarget(): realm.create runs EventTarget's constructor and initialize":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    assert(target.cell().vtable == (const gc.CellVTable*)&dom_event_target_vtable)
    assert(target.cell().class_id == dom_event_target_class.first_id)
    assert(bind_platform_object_realm(target.bind_platform_object()) == realm)
    assert(target.m_data == none)
    assert(not dom_event_target_has_event_listeners(target))
    var list = dom_event_target_event_listener_list(target)
    assert(ak.vector_is_empty(&list))
    assert(dom_event_target_is_dom_event_target(target))
    assert(not dom_event_target_is_focusable(target))
    assert(not dom_event_target_has_activation_behavior(target))
    assert(dom_event_target_get_parent(target, test_event(realm, "x")) == none)

test "addEventListener: a listener per (type, callback, capture), in order, with its options":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    var seen_a = TestNativeCall()
    var seen_b = TestNativeCall()
    let a = test_listener(realm, &seen_a)
    let b = test_listener(realm, &seen_b)
    let click = ak.fly_string_from_str("click")
    let wheel = ak.fly_string_from_str("wheel")

    dom_event_target_add_event_listener(target, click, a, .bool_(false))
    dom_event_target_add_event_listener(target, click, a, .bool_(false))
    dom_event_target_add_event_listener(target, click, a, .bool_(true))
    dom_event_target_add_event_listener(target, click, b, test_add_options(once = true, passive = true))
    dom_event_target_add_event_listener(target, wheel, a, test_add_options())
    # A null callback adds nothing.
    dom_event_target_add_event_listener(target, click, none, .bool_(false))

    var list = dom_event_target_event_listener_list(target)
    assert(ak.vector_size(&list) == 4)
    let first = *ak.vector_at(&list, 0) else trap("no listener")
    assert(ak.fly_string_eq_fly_string(&first.type_, &click) and first.callback == a and not first.capture and not first.once)
    # The default passive value is false except for touch and wheel events on a window or the
    # nodes of a document's top; this target is neither.
    assert(first.passive == false)
    let second = *ak.vector_at(&list, 1) else trap("no listener")
    assert(second.callback == a and second.capture)
    let third = *ak.vector_at(&list, 2) else trap("no listener")
    assert(third.callback == b and third.once and third.passive == true)
    let fourth = *ak.vector_at(&list, 3) else trap("no listener")
    assert(ak.fly_string_eq_fly_string(&fourth.type_, &wheel) and fourth.passive == false)
    assert(dom_event_target_has_event_listener(target, click))
    assert(not dom_event_target_has_event_listener(target, ak.fly_string_from_str("keyup")))

    # removeEventListener matches type, callback and the flattened capture.
    dom_event_target_remove_event_listener(target, click, a, .dom_event_listener_options(DomEventListenerOptions(capture = true)))
    list = dom_event_target_event_listener_list(target)
    assert(ak.vector_size(&list) == 3)
    assert(second.removed)
    dom_event_target_remove_event_listener(target, click, b, .bool_(true))
    list = dom_event_target_event_listener_list(target)
    assert(ak.vector_size(&list) == 3)
    dom_event_target_remove_event_listener_without_options(target, click, b)
    dom_event_target_remove_event_listener_without_options(target, click, a)
    dom_event_target_remove_event_listener_without_options(target, wheel, a)
    assert(not dom_event_target_has_event_listeners(target))
    assert(seen_a.calls == 0 and seen_b.calls == 0)

test "add_event_listener_without_options adds a bubbling listener; the list is a copy":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    var seen = TestNativeCall()
    let listener = test_listener(realm, &seen)
    dom_event_target_add_event_listener_without_options(target, ak.fly_string_from_str("load"), listener)
    var copy = dom_event_target_event_listener_list(target)
    ak.vector_clear(&copy)
    assert(dom_event_target_has_event_listeners(target))
    var list = dom_event_target_event_listener_list(target)
    let entry = *ak.vector_at(&list, 0) else trap("no listener")
    assert(not entry.capture and not entry.once and entry.signal == none)

test "a listener with an aborted signal is not added; a signal's abort algorithm removes it":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    var seen = TestNativeCall()
    let listener = test_listener(realm, &seen)
    let type_ = ak.fly_string_from_str("message")

    let aborted = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    dom_abort_signal_set_reason(aborted, js_value_from_bool(true))
    dom_event_target_add_event_listener(target, type_, listener, test_add_options(signal = aborted))
    assert(not dom_event_target_has_event_listeners(target))

    let signal = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    dom_event_target_add_event_listener(target, type_, listener, test_add_options(signal = signal))
    assert(dom_event_target_has_event_listener(target, type_))
    assert(ak.ordered_hash_map_size(&signal.m_abort_algorithms) == 1)

    # Step 1 of the abort steps: run every abort algorithm (signal_abort would then fire `abort`).
    for algorithm in ak.ordered_hash_map_begin(&signal.m_abort_algorithms):
        ak.function0_call(&algorithm.value.function)
    assert(not dom_event_target_has_event_listeners(target))

test "dispatchEvent() throws InvalidStateError for an event being dispatched or not initialized":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    let event = test_event(realm, "x")
    event.m_dispatch = true
    var result = dom_event_target_dispatch_event_binding(target, event) catch failure:
        assert(failure.code == webidl_exception)
        recover false
    assert(not result)
    var message = idl_exception_to_string(vm_take_pending_exception(vm))
    assert(ak.string_eq_string_view(&message, ak.sv("[InvalidStateError]: The event is already being dispatched.")))

    event.m_dispatch = false
    event.m_initialized = false
    result = dom_event_target_dispatch_event_binding(target, event) catch failure:
        assert(failure.code == webidl_exception)
        recover false
    assert(not result)
    message = idl_exception_to_string(vm_take_pending_exception(vm))
    assert(ak.string_eq_string_view(&message, ak.sv("[InvalidStateError]: Cannot dispatch an uninitialized event.")))

test "the event handler map: no handler reads null; deactivating or clearing an absent one does nothing":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    let name = ak.fly_string_from_str("abort")
    assert(dom_event_target_event_handler_attribute(target, name) == none)
    dom_event_target_set_event_handler_attribute(target, name, none)
    dom_event_target_deactivate_event_handler(target, name)
    let data = target.m_data else trap("no data")
    assert(ak.hash_map_is_empty(&data.event_handler_map))

    # A handler whose value is a callback reads back as that callback.
    var seen = TestNativeCall()
    let callback = test_callback(realm, &seen)
    let handler = heap_allocate_html_event_handler_callback_type(vm_heap(vm), callback)
    _ = ak.hash_map_set(&data.event_handler_map, name, handler)
    assert(dom_event_target_get_current_value_of_event_handler(target, name) == callback)
    dom_event_target_deactivate_event_handler(target, name)
    assert(dom_event_target_event_handler_attribute(target, name) == none)

test "the Window event handler sets":
    ui_events_event_names_initialize_strings()
    assert(dom_is_window_reflecting_body_element_event_handler(ak.fly_string_from_str("scroll")))
    assert(dom_is_window_reflecting_body_element_event_handler(ak.fly_string_from_str("resize")))
    assert(not dom_is_window_reflecting_body_element_event_handler(ak.fly_string_from_str("click")))
    assert(not dom_is_window_event_handler(ak.fly_string_from_str("click")))

test "an EventTarget's listeners and their callbacks survive collections":
    web_test_clobber_stack()
    run_listeners_survive_collections()

noinline func run_listeners_survive_collections():
    let vm = web_test_create_vm()
    let context = make_test_realm_context(vm)
    let weaks = make_test_target_with_listener(vm, context)
    web_test_clobber_stack()
    gc.heap_collect_garbage(vm_heap(vm))
    assert(web_test_alive(&weaks.0))
    assert(web_test_alive(&weaks.1))
    _ = vm_pop_execution_context(vm)
    web_test_destroy_vm(vm)

## A target kept alive from the C heap, with one listener over a native function; Weaks of the
## listener and of its callback's native function.
noinline func make_test_target_with_listener(vm: Vm*, context: JsExecutionContext*) -> (gc.Weak[DomEventListener], gc.Weak[JsNativeFunction]):
    let realm = context.realm else trap("no realm")
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    vm_keep_alive(vm, target)
    let seen = new TestNativeCall() else trap("out of memory")
    let listener = test_listener(realm, seen)
    dom_event_target_add_event_listener_without_options(target, ak.fly_string_from_str("x"), listener)
    var list = dom_event_target_event_listener_list(target)
    let entry = *ak.vector_at(&list, 0) else trap("no listener")
    let function = (JsNativeFunction*)dom_idl_event_listener_callback(listener).callback
    return (gc.make_weak[DomEventListener](entry), gc.make_weak[JsNativeFunction](function))

# mark: Nodes ===================================================================================

test "a node made in a realm is an EventTarget; listeners on an ancestor are found":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let document = test_document()
    let fragment = test_realm_node(realm, &dom_document_fragment_class, DomNodeType.document_fragment_node, document)
    let element = test_realm_node(realm, &dom_element_class, DomNodeType.element_node, document)
    assert(bind_platform_object_realm(element.bind_platform_object()) == realm)
    assert(element.cell().vtable == (const gc.CellVTable*)&dom_element_vtable)
    assert(dom_node_document(element) == document)
    tree_node_append_child(fragment, element)
    assert(tree_node_parent(element) == fragment)

    var seen = TestNativeCall()
    let type_ = ak.fly_string_from_str("custom")
    dom_event_target_add_event_listener(fragment.dom_event_target(), type_, test_listener(realm, &seen), .bool_(true))
    assert(dom_node_has_inclusive_ancestor_with_event_listener(element, type_))
    assert(dom_event_target_has_event_listener(fragment.dom_event_target(), type_))
    assert(not dom_event_target_has_event_listeners(element.dom_event_target()))

    # The event path of the element: the element itself, then its parent (dispatch builds it
    # through Node's get the parent; the path is appended here as dispatch appends it).
    let event = test_event(realm, "custom", bubbles = true)
    var no_touch_targets: ak.Vector[DomEventTarget*?]
    dom_event_append_to_path(event, element.dom_event_target(), element.dom_event_target(), none, &no_touch_targets, false)
    dom_event_append_to_path(event, fragment.dom_event_target(), none, none, &no_touch_targets, false)
    let path = dom_event_path(event)
    assert(ak.vector_size(path) == 2)
    assert(not ak.vector_at(path, 0).invocation_target_in_shadow_tree and not ak.vector_at(path, 1).root_of_closed_tree)
    assert(ak.vector_at(path, 1).index == 1)

    # In the capturing pass the parent's capturing listener is found (calling it is region r29's
    # principal_realm_settings_object away); the element has none.
    var threw = false
    dom_event_set_current_target(event, element.dom_event_target())
    var element_listeners = dom_event_target_event_listener_list(element.dom_event_target())
    assert(not dom_event_dispatcher_inner_invoke(event, &element_listeners, DomEventPhase.capturing_phase, false, &threw))

# mark: Event ===================================================================================

test "Event: cancellation, propagation flags and initEvent":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let event = test_event(realm, "x", bubbles = true)
    assert(dom_event_is_dom_event(event) and not dom_event_is_mouse_event(event) and not dom_event_is_pointer_event(event))
    assert(dom_event_event_phase(event) == 0)

    # preventDefault() only cancels a cancelable event outside a passive listener.
    dom_event_prevent_default(event)
    assert(not dom_event_default_prevented(event) and dom_event_return_value(event))
    event.m_cancelable = true
    dom_event_set_in_passive_listener(event, true)
    dom_event_prevent_default(event)
    assert(not dom_event_cancelled(event))
    dom_event_set_in_passive_listener(event, false)
    dom_event_set_return_value(event, true)
    assert(not dom_event_cancelled(event))
    dom_event_set_return_value(event, false)
    assert(dom_event_default_prevented(event) and not dom_event_return_value(event))

    # cancelBubble can only be set; stopImmediatePropagation() sets both flags.
    dom_event_set_cancel_bubble(event, false)
    assert(not dom_event_cancel_bubble(event))
    dom_event_set_cancel_bubble(event, true)
    assert(dom_event_should_stop_propagation(event) and not dom_event_should_stop_immediate_propagation(event))
    dom_event_stop_immediate_propagation(event)
    assert(dom_event_should_stop_immediate_propagation(event))

    # initEvent() does nothing while dispatching, and otherwise reinitializes the event.
    event.m_is_trusted = true
    event.m_dispatch = true
    dom_event_init_event(event, ak.string_from_str("y"), false, false)
    assert(ak.fly_string_eq_string_view(&event.m_type, ak.sv("x")))
    event.m_dispatch = false
    dom_event_set_target(event, dom_event_target_construct_impl(realm) else trap("construct_impl failed"))
    dom_event_init_event(event, ak.string_from_str("y"), false, true)
    assert(ak.fly_string_eq_string_view(&event.m_type, ak.sv("y")))
    assert(not dom_event_bubbles(event) and dom_event_cancelable(event))
    assert(not dom_event_cancelled(event) and not dom_event_should_stop_propagation(event) and not dom_event_should_stop_immediate_propagation(event))
    assert(not dom_event_is_trusted(event) and dom_event_target(event) == none and dom_event_initialized(event))

test "composedPath() hides the closed shadow trees the current target is not in":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let event = test_event(realm, "x")
    var targets: ak.Vector[DomEventTarget*]
    for _ in 0..<4:
        ak.vector_append_t(&targets, dom_event_target_construct_impl(realm) else trap("construct_impl failed"))
    let t = ak.vector_span(&targets)

    var empty = dom_event_composed_path(event)
    assert(ak.vector_is_empty(&empty))

    # The path of an event from inside a closed shadow tree, as dispatch appends it (innermost
    # first): t[0] in the tree, t[1] its closed shadow root, t[2] the host, t[3] the document.
    var no_touch_targets: ak.Vector[DomEventTarget*?]
    for target in t:
        dom_event_append_to_path(event, target, none, none, &no_touch_targets, false)
    ak.vector_at(&event.m_path, 1).root_of_closed_tree = true

    # From outside the closed tree, the tree and its root are hidden.
    dom_event_set_current_target(event, t[3])
    var path = dom_event_composed_path(event)
    assert(ak.vector_size(&path) == 2)
    assert(*ak.vector_at(&path, 0) == t[2] and *ak.vector_at(&path, 1) == t[3])

    # From inside it, or at its root, everything is visible.
    dom_event_set_current_target(event, t[0])
    path = dom_event_composed_path(event)
    assert(ak.vector_size(&path) == 4)
    for i in 0..<4:
        assert(*ak.vector_at(&path, (usize)i) == t[(usize)i])
    dom_event_set_current_target(event, t[1])
    path = dom_event_composed_path(event)
    assert(ak.vector_size(&path) == 4)
    assert(*ak.vector_at(&path, 0) == t[0] and *ak.vector_at(&path, 3) == t[3])

test "append_to_path copies the touch targets and numbers the entries":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let event = test_event(realm, "x")
    let a = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    let b = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    var touch_targets: ak.Vector[DomEventTarget*?]
    ak.vector_append_t(&touch_targets, b)
    dom_event_append_to_path(event, a, a, b, &touch_targets, true)
    ak.vector_clear(&touch_targets)
    dom_event_append_to_path(event, b, none, none, &touch_targets, false)
    let first = ak.vector_at(&event.m_path, 0)
    assert(first.invocation_target == a and first.shadow_adjusted_target == a and first.related_target == b)
    assert(ak.vector_size(&first.touch_target_list) == 1 and first.slot_in_closed_tree and not first.root_of_closed_tree)
    assert(first.index == 0 and ak.vector_at(&event.m_path, 1).index == 1)
    dom_event_set_touch_target_list(event, &first.touch_target_list)
    ak.vector_clear(&first.touch_target_list)
    assert(ak.vector_size(dom_event_touch_target_list(event)) == 1)
    dom_event_clear_path(event)
    dom_event_clear_touch_target_list(event)
    assert(ak.vector_is_empty(dom_event_path(event)) and ak.vector_is_empty(dom_event_touch_target_list(event)))

test "CustomEvent: detail defaults to null; initCustomEvent sets it unless dispatching":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let init = dom_custom_event_init_default()
    assert(js_value_is_null(init.detail))
    let event = (DomCustomEvent*)web_allocate_cell(realm, &dom_custom_event_class)
    bind_platform_object_construct_realm(event.bind_platform_object(), realm)
    dom_custom_event_init_fields(event)
    web_initialize_cell(event.cell(), realm)
    assert(is_dom_event(event) and is_dom_custom_event(event))
    assert(js_value_is_null(dom_custom_event_detail(event)))
    dom_custom_event_init_custom_event(event, ak.string_from_str("ping"), true, true, js_value_from_f64(42.0))
    assert(js_value_as_double(dom_custom_event_detail(event)) == 42.0)
    assert(dom_event_bubbles(event.dom_event()) and dom_event_cancelable(event.dom_event()))
    event.dom_event().m_dispatch = true
    dom_custom_event_init_custom_event(event, ak.string_from_str("pong"), false, false, js_null())
    assert(js_value_as_double(dom_custom_event_detail(event)) == 42.0)

# mark: Dispatch ================================================================================

test "inner invoke: removed listeners, other types and the other phase are skipped":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let target = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    var seen = TestNativeCall()
    let listener = test_listener(realm, &seen)
    let event = test_event(realm, "x")
    dom_event_set_current_target(event, target)
    dom_event_target_add_event_listener(target, ak.fly_string_from_str("x"), listener, .bool_(true))
    dom_event_target_add_event_listener(target, ak.fly_string_from_str("y"), listener, .bool_(false))
    var listeners = dom_event_target_event_listener_list(target)
    var threw = false

    # The capturing listener of type x is found in the bubbling phase but not called.
    assert(dom_event_dispatcher_inner_invoke(event, &listeners, DomEventPhase.bubbling_phase, false, &threw))
    # A removed listener is not even found.
    let capturing = *ak.vector_at(&listeners, 0) else trap("no listener")
    capturing.removed = true
    assert(not dom_event_dispatcher_inner_invoke(event, &listeners, DomEventPhase.capturing_phase, false, &threw))
    assert(seen.calls == 0 and not threw)

test "invoke: the target is the last shadow-adjusted target up to the struct; stop propagation returns":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let a = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    let b = dom_event_target_construct_impl(realm) else trap("construct_impl failed")
    let event = test_event(realm, "x")
    var touch_targets: ak.Vector[DomEventTarget*?]
    ak.vector_append_t(&touch_targets, a)
    dom_event_append_to_path(event, a, a, none, &touch_targets, false)
    dom_event_append_to_path(event, b, none, a, &touch_targets, false)
    var threw = false
    dom_event_dispatcher_invoke(ak.vector_at(&event.m_path, 1), event, DomEventPhase.bubbling_phase, &threw)
    assert(dom_event_target(event) == a and dom_event_related_target(event) == a)
    assert(dom_event_current_target(event) == b)
    assert(ak.vector_size(dom_event_touch_target_list(event)) == 1)

    dom_event_set_current_target(event, none)
    dom_event_stop_propagation(event)
    dom_event_dispatcher_invoke(ak.vector_at(&event.m_path, 0), event, DomEventPhase.capturing_phase, &threw)
    assert(dom_event_current_target(event) == none)

# mark: AbortSignal and AbortController =========================================================

test "AbortSignal: abort algorithms are numbered from 1 and removed by id; none once aborted":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let signal = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    assert(not dom_abort_signal_aborted(signal))
    assert(js_value_is_undefined(dom_abort_signal_reason(signal)))
    assert(dom_abort_signal_add_abort_algorithm(signal, ak.Function0[unit]()) == 1)
    assert(dom_abort_signal_add_abort_algorithm(signal, ak.Function0[unit]()) == 2)
    dom_abort_signal_remove_abort_algorithm(signal, 1)
    assert(ak.ordered_hash_map_size(&signal.m_abort_algorithms) == 1)
    assert(ak.ordered_hash_map_contains_k(&signal.m_abort_algorithms, 2))
    dom_abort_signal_set_reason(signal, js_null())
    assert(dom_abort_signal_aborted(signal))
    assert(dom_abort_signal_add_abort_algorithm(signal, ak.Function0[unit]()) == none)
    # signal_abort of an aborted signal does nothing.
    dom_abort_signal_signal_abort(signal, js_value_from_bool(true))
    assert(js_value_is_null(dom_abort_signal_reason(signal)))

## throw_if_aborted, answering false when nothing was thrown.
func test_throw_if_aborted(signal: DomAbortSignal*) -> bool!:
    try dom_abort_signal_throw_if_aborted(signal)
    return false

test "AbortSignal::throw_if_aborted throws the reason as a JS completion":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let signal = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    assert(not (test_throw_if_aborted(signal) else trap("not aborted, so nothing is thrown")))
    dom_abort_signal_set_reason(signal, js_value_from_f64(7.0))
    let thrown = test_throw_if_aborted(signal) catch failure:
        assert(failure.code == js_exception)
        recover true
    assert(thrown)
    let completion = vm_take_throw_completion(vm)
    assert(js_completion_is_error(&completion))
    assert(js_value_as_double(js_completion_value(&completion)) == 7.0)

test "AbortSignal.abort(): an AbortError DOMException reason by default":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let context = js_execution_context_create()
    context.realm = web_test_create_realm(vm)
    vm_push_execution_context(vm, context)
    defer _ = vm_pop_execution_context(vm)

    let with_reason = dom_abort_signal_abort(vm, js_value_from_f64(3.0)) else trap("abort failed")
    assert(js_value_as_double(dom_abort_signal_reason(with_reason)) == 3.0)

    let signal = dom_abort_signal_abort(vm, js_undefined()) else trap("abort failed")
    assert(dom_abort_signal_aborted(signal))
    let reason = dom_abort_signal_reason(signal)
    assert(js_value_is_object(reason))
    let exception = as_idl_dom_exception((gc.Cell*)js_value_as_object(reason))
    let text = idl_dom_exception_to_string(exception)
    assert(ak.string_eq_string_view(&text, ak.sv("[AbortError]: Aborted without reason")))

test "AbortSignal.any(): dependent signals follow their source signals":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let context = js_execution_context_create()
    let realm = web_test_create_realm(vm)
    context.realm = realm
    vm_push_execution_context(vm, context)
    defer _ = vm_pop_execution_context(vm)

    let a = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    let b = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    var signals: ak.Vector[DomAbortSignal*?]
    ak.vector_append_t(&signals, a)
    ak.vector_append_t(&signals, b)
    let dependent = dom_abort_signal_any(vm, signals) else trap("any failed")
    assert(dom_abort_signal_dependent(dependent) and not dom_abort_signal_aborted(dependent))
    assert(ak.vector_size(&dependent.m_source_signals) == 2)
    assert(ak.vector_size(&a.m_dependent_signals) == 1 and *ak.vector_at(&a.m_dependent_signals, 0) == dependent)

    # A dependent of a dependent depends on the sources directly.
    var of_dependent: ak.Vector[DomAbortSignal*?]
    ak.vector_append_t(&of_dependent, dependent)
    let second = dom_abort_signal_create_dependent_abort_signal(realm, of_dependent) else trap("create failed")
    var sources = dom_abort_signal_source_signals(second)
    assert(ak.vector_size(&sources) == 2 and *ak.vector_at(&sources, 0) == a and *ak.vector_at(&sources, 1) == b)
    assert(ak.vector_size(&b.m_dependent_signals) == 2)
    assert(ak.vector_is_empty(&dependent.m_dependent_signals))

    # An aborted signal in the list makes an aborted, independent signal with its reason.
    dom_abort_signal_set_reason(b, js_value_from_f64(9.0))
    let aborted = dom_abort_signal_create_dependent_abort_signal(realm, signals) else trap("create failed")
    assert(js_value_as_double(dom_abort_signal_reason(aborted)) == 9.0)
    assert(not dom_abort_signal_dependent(aborted) and ak.vector_is_empty(&aborted.m_source_signals))

test "new AbortController(): a controller with a new signal":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let controller = dom_abort_controller_construct_impl(realm) else trap("construct_impl failed")
    let signal = dom_abort_controller_signal(controller)
    assert(is_dom_abort_signal(signal) and not dom_abort_signal_aborted(signal))
    assert(bind_platform_object_realm(signal.bind_platform_object()) == realm)

test "an abort reason held only as a JS value survives collections":
    web_test_clobber_stack()
    run_abort_reason_survives()

noinline func run_abort_reason_survives():
    let vm = web_test_create_vm()
    let context = make_test_realm_context(vm)
    let weak = make_test_signal_with_reason(vm, context)
    web_test_clobber_stack()
    gc.heap_collect_garbage(vm_heap(vm))
    assert(web_test_alive(&weak))
    _ = vm_pop_execution_context(vm)
    web_test_destroy_vm(vm)

## A signal kept alive from the C heap whose reason is a new DOMException; a Weak of the exception.
noinline func make_test_signal_with_reason(vm: Vm*, context: JsExecutionContext*) -> gc.Weak[IdlDomException]:
    let realm = context.realm else trap("no realm")
    let signal = dom_abort_signal_construct_impl(realm) else trap("construct_impl failed")
    vm_keep_alive(vm, signal)
    let exception = idl_abort_error_create(realm, ak.utf16_string_from_str("reason"))
    dom_abort_signal_set_reason(signal, js_value_from_object((JsObject*)exception))
    return gc.make_weak[IdlDomException](exception)

# mark: Native functions, completions and values ================================================

test "JS::call of a native function: arguments, this value, realm and the context stack":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    var seen = TestNativeCall()
    let function = js_native_function_create(realm, JsNativeFunctionBehaviour(call = test_native_behaviour, context = &seen), 1, ak.utf16_fly_string_new(), realm)
    assert(js_object_is_function((JsObject*)function))
    assert(js_object_shape_realm((JsObject*)function) == realm)
    assert(not js_object_is_function(realm_global_object(realm)))
    assert(js_object_shape_realm(realm_global_object(realm)) == realm)

    # [[Call]] needs a running execution context (the caller's).
    let caller = js_execution_context_create()
    vm_push_execution_context(vm, caller)
    defer _ = vm_pop_execution_context(vm)
    let arguments: JsValue[2] = [js_value_from_f64(1.5), js_null()]
    let result = js_call(vm, (JsFunctionObject*)function, js_value_from_bool(false), arguments) else trap("call failed")
    assert(js_value_is_boolean(result) and js_value_as_bool(result))
    assert(seen.calls == 1 and seen.argument_count == 2 and js_value_as_double(seen.argument) == 1.5)
    assert(js_value_is_boolean(seen.this_value) and not js_value_as_bool(seen.this_value))
    assert(seen.realm == realm)
    assert(vm_running_execution_context(vm) == caller)

    # Past the arguments a native function reads undefined; a failure pops its context too.
    seen.fail = true
    let no_arguments: JsValue[1] = [js_undefined()]
    let failed = js_call(vm, (JsFunctionObject*)function, js_undefined(), no_arguments[0..<0]) catch failure:
        assert(failure.code == js_exception)
        recover js_null()
    assert(js_value_is_null(failed))
    assert(seen.argument_count == 0 and js_value_is_undefined(seen.argument))
    assert(vm_running_execution_context(vm) == caller)
    _ = vm_take_pending_exception(vm)

test "completions and the throw completion of a DOMException":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let normal = js_completion_from_value(js_value_from_f64(2.0))
    assert(js_completion_type(&normal) == JsCompletionType.normal and not js_completion_is_abrupt(&normal) and not js_completion_is_error(&normal))
    let thrown = js_throw_completion(js_null())
    assert(js_completion_is_abrupt(&thrown) and js_completion_is_error(&thrown))
    let exception = idl_not_found_error_create(realm, ak.utf16_string_from_str("gone"))
    let completion = throw_completion(exception)
    assert(js_completion_is_error(&completion))
    assert(js_value_as_object(js_completion_value(&completion)) == (JsObject*)exception)

    # A WebIDL exception left pending becomes the throw completion of its DOMException.
    let threw = web_test_throw(.idl_dom_exception(exception)) catch: recover false
    assert(not threw)
    let taken = vm_take_throw_completion(vm)
    assert(js_value_as_object(js_completion_value(&taken)) == (JsObject*)exception)

test "JS values of objects: tagged cells, null for none; nullish and booleans":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let global = realm_global_object(realm)
    let value = js_value_from_object(global)
    assert(js_value_is_object(value) and not js_value_is_nullish(value))
    assert(js_value_as_object(value) == global)
    assert(test_bits(value) == (0xfff9 << 48) | ((u64)(usize)global & 0x0000ffffffffffff))
    assert(js_value_is_null(js_value_from_object(none)))
    assert(js_value_is_nullish(js_null()) and js_value_is_nullish(js_undefined()))
    assert(not js_value_is_nullish(js_value_from_bool(false)) and not js_value_is_nullish(js_value_from_f64(0.0)))
    assert(js_value_as_bool(js_value_from_bool(true)) and not js_value_as_bool(js_value_from_bool(false)))

# mark: HighResolutionTime and UI event names ===================================================

test "coarsen time: 100 microseconds, or 5 for cross-origin isolated":
    assert(high_resolution_time_coarsen_time(1234.56789) == math.floor(1234.56789 / 0.1) * 0.1)
    assert(high_resolution_time_coarsen_time(0.09) == 0.0)
    assert(high_resolution_time_coarsen_time(1234.56789, HtmlCanUseCrossOriginIsolatedApIs.yes) == math.floor(1234.56789 / 0.005) * 0.005)
    let before = high_resolution_time_unsafe_shared_current_time()
    let after = high_resolution_time_unsafe_shared_current_time()
    assert(after >= before and before > 0.0)
    assert(high_resolution_time_wall_clock_unsafe_current_time() > 1.6e12)

test "the UI event names are interned":
    ui_events_event_names_initialize_strings()
    assert(ak.fly_string_eq_string_view(&ui_events_event_names_keydown, ak.sv("keydown")))
    assert(ak.fly_string_eq_string_view(&ui_events_event_names_pointerrawupdate, ak.sv("pointerrawupdate")))
    let resize = ak.fly_string_from_str("resize")
    assert(ak.fly_string_eq_fly_string(&ui_events_event_names_resize, &resize))