dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / dom / tests_leaves_2.lucb
#==============================================================================================
#
# tests_leaves_2 - tests of ranges, traversal, node lists, mutation observers, slots and the
# small helpers of region r18
#
# DESCRIPTION:
# Pinned to the DOM standard algorithms as the C++ implements them: boundary-point
# positions, live ranges (set start/end, collapse, select, compare, contain, intersect,
# stringify, clone, the live-range set), TreeWalker over whatToShow, LiveNodeList and
# StaticNodeList, MutationObserver's option checks and registration, SlotRegistry's tree
# order, retargeting, the NodeFilter flag operators, ToInt32, the fullscreen error
# messages and Position.
#
# Trees are built with TreeNode's append_child (no mutation records: those need the
# document's page, region r17); the scenarios that mutate a document are listed in
# docs/regions/r18.md.
#
#==============================================================================================
# mark: Helpers =================================================================================
## A tree for range tests: <div>[ "abc", <p>[ "de" ], "fg" ]</div>, answered as (div, abc, p, de, fg).
func test_range_tree(realm: Realm*) -> (DomNode*, DomNode*, DomNode*, DomNode*, DomNode*):
let document = test_realm_document(realm)
let div = test_realm_element(realm, document, "div").dom_node()
let abc = test_text(realm, document, "abc").dom_node()
let p = test_realm_element(realm, document, "p").dom_node()
let de = test_text(realm, document, "de").dom_node()
let fg = test_text(realm, document, "fg").dom_node()
tree_node_append_child(div, abc)
tree_node_append_child(div, p)
tree_node_append_child(p, de)
tree_node_append_child(div, fg)
return (div, abc, p, de, fg)
## Whether `range` is a member of the live-range set.
func test_is_live(range: DomRange*) -> bool:
return ak.hash_table_contains_t(dom_range_live_ranges(), (DomRange*?)range)
# mark: Boundary points and ranges ==============================================================
test "the position of a boundary point relative to another":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
let before = DomRelativeBoundaryPointPosition.before
let after = DomRelativeBoundaryPointPosition.after
let equal = DomRelativeBoundaryPointPosition.equal
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = abc, offset = 1), DomBoundaryPoint(node = abc, offset = 2)) == before)
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = abc, offset = 2), DomBoundaryPoint(node = abc, offset = 2)) == equal)
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = fg, offset = 0), DomBoundaryPoint(node = de, offset = 2)) == after)
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = de, offset = 2), DomBoundaryPoint(node = fg, offset = 0)) == before)
# An ancestor's offset against a point inside a child: (div, 1) is before (p, 0); (div, 2) after it.
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = div, offset = 1), DomBoundaryPoint(node = de, offset = 0)) == before)
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = div, offset = 2), DomBoundaryPoint(node = de, offset = 0)) == after)
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = de, offset = 0), DomBoundaryPoint(node = div, offset = 2)) == before)
assert(dom_position_of_boundary_point_relative_to_other_boundary_point(DomBoundaryPoint(node = p, offset = 0), DomBoundaryPoint(node = div, offset = 1)) == after)
test "Range: a live range; set start/end, collapse, select, contain, intersect and stringify":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
let range = dom_range_create_dom_node(abc, 1, fg, 1)
let abstract_range = range.dom_abstract_range()
assert(test_is_live(range))
assert(not dom_abstract_range_collapsed(abstract_range))
assert(dom_range_common_ancestor_container(range) == div)
assert(test_utf16_is(dom_range_to_string(range), "bcdef"))
assert(dom_range_contains_node(range, p) and dom_range_contains_node(range, de))
assert(not dom_range_contains_node(range, abc) and not dom_range_contains_node(range, div))
assert(dom_range_partially_contains_node(range, abc) and dom_range_partially_contains_node(range, div) == false)
assert(dom_range_intersects_node(range, p) and dom_range_intersects_node(range, div))
assert((dom_range_compare_point(range, abc, 0) else trap("threw")) == -1)
assert((dom_range_compare_point(range, de, 1) else trap("threw")) == 0)
assert((dom_range_compare_point(range, fg, 2) else trap("threw")) == 1)
assert(dom_range_is_point_in_range(range, abc, 1) else trap("threw"))
assert(not (dom_range_is_point_in_range(range, abc, 0) else trap("threw")))
# Setting the start after the end moves the end too.
dom_range_set_start(range, fg, 2) else trap("threw")
assert(dom_abstract_range_end_container(abstract_range) == fg and dom_abstract_range_end_offset(abstract_range) == 2)
assert(dom_abstract_range_collapsed(abstract_range))
dom_range_select_node_contents(range, p) else trap("threw")
assert(dom_abstract_range_start_container(abstract_range) == p and dom_abstract_range_end_offset(abstract_range) == 1)
assert(test_utf16_is(dom_range_to_string(range), "de"))
dom_range_select_node(range, p) else trap("threw")
assert(dom_abstract_range_start_container(abstract_range) == div and dom_abstract_range_start_offset(abstract_range) == 1 and dom_abstract_range_end_offset(abstract_range) == 2)
dom_range_collapse(range, true)
assert(dom_abstract_range_end_offset(abstract_range) == 1 and dom_abstract_range_collapsed(abstract_range))
dom_range_set_end_after(range, fg) else trap("threw")
assert(dom_abstract_range_end_container(abstract_range) == div and dom_abstract_range_end_offset(abstract_range) == 3)
dom_range_set_start_before(range, abc) else trap("threw")
assert(dom_abstract_range_start_offset(abstract_range) == 0)
assert(test_utf16_is(dom_range_to_string(range), "abcdefg"))
let clone = dom_range_clone_range(range)
assert(clone != range and dom_abstract_range_eq(clone.dom_abstract_range(), abstract_range))
assert(test_is_live(clone))
test "Range: the boundary point errors and compareBoundaryPoints":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
let range = dom_range_create_dom_node(abc, 0, de, 1)
dom_range_set_start(range, abc, 4) catch:
assert(test_string_is(test_take_dom_exception_string(), "[IndexSizeError]: Node does not contain a child at offset 4"))
recover ()
dom_range_set_start_before(range, div) catch:
assert(test_string_is(test_take_dom_exception_string(), "[InvalidNodeTypeError]: Given node has no parent."))
recover ()
_ = dom_range_compare_boundary_points(range, 4, range) catch:
assert(test_string_is(test_take_dom_exception_string(), "[NotSupportedError]: Expected 'how' to be one of START_TO_START (0), START_TO_END (1), END_TO_END (2) or END_TO_START (3), got 4"))
recover 0
let other = dom_range_create_dom_node(p, 0, fg, 2)
assert((dom_range_compare_boundary_points(range, 0, other) else trap("threw")) == -1) # START_TO_START
assert((dom_range_compare_boundary_points(range, 1, other) else trap("threw")) == 1) # START_TO_END: this end (de, 1) after (p, 0)
assert((dom_range_compare_boundary_points(range, 2, other) else trap("threw")) == -1) # END_TO_END
assert((dom_range_compare_boundary_points(range, 3, other) else trap("threw")) == -1) # END_TO_START
let detached = test_realm_element(realm, test_realm_document(realm), "span").dom_node()
let elsewhere = dom_range_create_dom_node(detached, 0, detached, 0)
_ = dom_range_compare_boundary_points(range, 0, elsewhere) catch:
assert(test_string_is(test_take_dom_exception_string(), "[WrongDocumentError]: This range is not in the same tree as the source range."))
recover 0
assert(not dom_range_intersects_node(range, detached))
test "Range: the live-range offset mutators and for_each_contained":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
let range = dom_range_create_dom_node(div, 0, div, 3)
dom_range_increase_start_offset(range, 2)
dom_range_decrease_end_offset(range, 1)
assert(dom_abstract_range_start_offset(range.dom_abstract_range()) == 2 and dom_abstract_range_end_offset(range.dom_abstract_range()) == 2)
dom_range_set_start_node(range, abc)
dom_range_set_start_offset(range, 0)
dom_range_set_end_node(range, fg)
dom_range_set_end_offset(range, 2)
var contained: ak.Vector[DomNode*]
dom_range_for_each_contained(range, ak.Function1[DomNode*, ak.IterationDecision](call = test_collect_contained, context = &contained))
# The boundary text nodes are only partially contained.
assert(ak.vector_size(&contained) == 2)
assert(*ak.vector_at(&contained, 0) == p and *ak.vector_at(&contained, 1) == de)
## for_each_contained's callback in the test above: collects the nodes.
func test_collect_contained(context: void*?, node: DomNode*) -> ak.IterationDecision:
let contained = (ak.Vector[DomNode*]*)(context else trap("no vector"))
ak.vector_append_t(contained, node)
return ak.IterationDecision.continue_
test "StaticRange: DocumentType and Attr containers are rejected":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let document = test_realm_document(realm)
let text = test_text(realm, document, "x").dom_node()
var init = DomStaticRangeInit(start_container = text, start_offset = 0, end_container = text, end_offset = 1)
let range = dom_static_range_construct_impl(realm, &init) else trap("threw")
assert(dom_abstract_range_end_offset(range.dom_abstract_range()) == 1 and not test_is_live((DomRange*)range))
init.start_container = dom_document_type_create(document).dom_node()
_ = dom_static_range_construct_impl(realm, &init) catch:
assert(test_string_is(test_take_dom_exception_string(), "[InvalidNodeTypeError]: startContainer cannot be a DocumentType or Attribute node."))
recover range
# mark: Traversal ===============================================================================
test "TreeWalker: whatToShow selects the nodes; parent, children, siblings and document order":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
# SHOW_ELEMENT | SHOW_TEXT
let walker = dom_tree_walker_create(realm, div, 0x5, none)
assert(dom_tree_walker_current_node(walker) == div and dom_tree_walker_root(walker) == div)
assert((dom_tree_walker_next_node(walker) else trap("threw")) == abc)
assert((dom_tree_walker_next_node(walker) else trap("threw")) == p)
assert((dom_tree_walker_next_node(walker) else trap("threw")) == de)
assert((dom_tree_walker_next_node(walker) else trap("threw")) == fg)
assert((dom_tree_walker_next_node(walker) else trap("threw")) == none)
assert((dom_tree_walker_previous_node(walker) else trap("threw")) == de)
assert((dom_tree_walker_parent_node(walker) else trap("threw")) == p)
assert((dom_tree_walker_previous_sibling(walker) else trap("threw")) == abc)
assert((dom_tree_walker_next_sibling(walker) else trap("threw")) == p)
assert((dom_tree_walker_first_child(walker) else trap("threw")) == de)
# SHOW_TEXT only: the elements are skipped, their children still visited.
let texts = dom_tree_walker_create(realm, div, 0x4, none)
assert((dom_tree_walker_first_child(texts) else trap("threw")) == abc)
assert((dom_tree_walker_next_sibling(texts) else trap("threw")) == de)
assert((dom_tree_walker_next_sibling(texts) else trap("threw")) == fg)
assert((dom_tree_walker_last_child(texts) else trap("threw")) == none)
dom_tree_walker_set_current_node(texts, div)
assert((dom_tree_walker_last_child(texts) else trap("threw")) == fg)
assert((dom_tree_walker_parent_node(texts) else trap("threw")) == none)
# mark: Node lists ==============================================================================
## A LiveNodeList filter: Text nodes.
func test_is_text_filter(context: void*?, node: DomNode*) -> bool:
return dom_node_is_text(node)
## A first_matching filter: the node whose data is "de".
func test_is_de_filter(context: void*?, node: DomNode*) -> bool:
let text = as_if_dom_text(node) else return false
return test_utf16_is(dom_character_data_data(text.dom_character_data()), "de")
test "LiveNodeList and StaticNodeList":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
let descendants = dom_live_node_list_create(realm, div, DomLiveNodeListScope.descendants, ak.Function1[DomNode*, bool](call = test_is_text_filter, context = none))
let children = dom_live_node_list_create(realm, div, DomLiveNodeListScope.children, ak.Function1[DomNode*, bool](call = test_is_text_filter, context = none))
assert(dom_node_list_length(descendants) == 3 and dom_node_list_length(children) == 2)
assert(dom_node_list_item(descendants, 1) == de and dom_node_list_item(children, 1) == fg and dom_node_list_item(children, 2) == none)
let de_filter = ak.Function1[DomNode*, bool](call = test_is_de_filter, context = none)
assert(dom_live_node_list_first_matching((DomLiveNodeList*)descendants, de_filter) == de)
assert(dom_live_node_list_first_matching((DomLiveNodeList*)children, de_filter) == none)
# Live: a new text child shows up.
tree_node_append_child(div, test_text(realm, test_realm_document(realm), "h").dom_node())
assert(dom_node_list_length(children) == 3)
var nodes: ak.Vector[DomNode*?]
ak.vector_append_t(&nodes, p)
ak.vector_append_t(&nodes, abc)
let list = dom_static_node_list_create(realm, nodes)
assert(dom_node_list_length(list) == 2 and dom_node_list_item(list, 0) == p and dom_node_list_item(list, 2) == none)
# mark: Mutation observers ======================================================================
## observe() expected to throw a TypeError: its message.
func test_observe_type_error(observer: DomMutationObserver*, target: DomNode*, options: DomMutationObserverInit) -> ak.String:
dom_mutation_observer_observe(observer, target, options) catch:
match idl_take_pending_exception():
.idl_simple_exception(exception):
assert(exception.type_ == IdlSimpleExceptionType.type_error)
return idl_simple_exception_message(&exception)
_: trap("expected a TypeError")
trap("observe did not throw")
test "MutationObserver: observe's option checks, registration, re-observing and disconnect":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
let observer = dom_mutation_observer_construct_impl(realm, none) else trap("threw")
assert(test_string_is(test_observe_type_error(observer, div, DomMutationObserverInit()), "Options must have one of childList, attributes or characterData set to true."))
assert(test_string_is(test_observe_type_error(observer, div, DomMutationObserverInit(child_list = true, attributes = false, attribute_old_value = true)), "attributes must be true if attributeOldValue is true."))
var filter: ak.Vector[ak.String]
ak.vector_append_t(&filter, ak.string_from_str("id"))
assert(test_string_is(test_observe_type_error(observer, div, DomMutationObserverInit(child_list = true, attributes = false, attribute_filter = filter)), "attributes must be true if attributeFilter is present."))
assert(test_string_is(test_observe_type_error(observer, div, DomMutationObserverInit(child_list = true, character_data = false, character_data_old_value = true)), "characterData must be true if characterDataOldValue is true."))
# attributeOldValue alone implies attributes.
dom_mutation_observer_observe(observer, div, DomMutationObserverInit(attribute_old_value = true)) else trap("threw")
let registered_list = dom_node_registered_observer_list_const(div) else trap("not registered")
assert(ak.vector_size(registered_list) == 1)
let registered = *ak.vector_at(registered_list, 0)
assert(dom_registered_observer_observer(registered) == observer and not dom_registered_observer_is_transient(registered))
assert(dom_registered_observer_options(registered).attributes == true)
assert(ak.vector_size(dom_mutation_observer_node_list(observer)) == 1)
# Observing again replaces the options and removes this observer's transient observers.
let transient = dom_transient_registered_observer_create(observer, DomMutationObserverInit(child_list = true), registered)
dom_node_add_registered_observer(abc, transient.dom_registered_observer())
ak.vector_append_t(dom_mutation_observer_node_list(observer), gc.make_weak[DomNode](abc))
assert(dom_registered_observer_is_transient(transient.dom_registered_observer()))
dom_mutation_observer_observe(observer, div, DomMutationObserverInit(child_list = true)) else trap("threw")
assert(ak.vector_size(registered_list) == 1 and dom_registered_observer_options(registered).child_list)
assert(ak.vector_is_empty(dom_node_registered_observer_list_const(abc) else trap("no list")))
var records = dom_mutation_observer_take_records(observer)
assert(ak.vector_is_empty(&records))
dom_mutation_observer_disconnect(observer)
assert(ak.vector_is_empty(registered_list))
# mark: Slots ===================================================================================
test "SlotRegistry: slots kept in tree order; the first slot with a name":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let document = test_realm_document(realm)
let root = test_realm_element(realm, document, "div").dom_node()
let first = (HtmlSlotElement*)test_realm_node(realm, &html_slot_element_class, DomNodeType.element_node, document)
let second = (HtmlSlotElement*)test_realm_node(realm, &html_slot_element_class, DomNodeType.element_node, document)
let third = (HtmlSlotElement*)test_realm_node(realm, &html_slot_element_class, DomNodeType.element_node, document)
tree_node_append_child(root, first.dom_node())
tree_node_append_child(root, second.dom_node())
tree_node_append_child(root, third.dom_node())
let name = ak.fly_string_from_str("a")
dom_slot_set_slot_name(&second.slot, name)
dom_slot_set_slot_name(&third.slot, name)
var registry: DomSlotRegistry
assert(dom_slot_registry_is_empty(®istry))
dom_slot_registry_add(®istry, third)
dom_slot_registry_add(®istry, first)
dom_slot_registry_add(®istry, second)
assert(not dom_slot_registry_is_empty(®istry) and registry.m_slot_count == 3)
assert(gc.weak_ptr(ak.vector_at(®istry.m_slots, 0)) == first and gc.weak_ptr(ak.vector_at(®istry.m_slots, 1)) == second)
assert(dom_slot_registry_first_slot_with_name(®istry, name) == second)
assert(dom_slot_registry_first_slot_with_name(®istry, ak.fly_string_from_str("b")) == none)
# Adding a registered slot again moves it; removing it twice is harmless.
dom_slot_registry_add(®istry, second)
assert(registry.m_slot_count == 3)
dom_slot_registry_remove(®istry, second)
dom_slot_registry_remove(®istry, second)
assert(dom_slot_registry_first_slot_with_name(®istry, name) == third)
test "Slottable: names, the assigned slot, and nodes that are not slottable":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let document = test_realm_document(realm)
let text = test_text(realm, document, "t")
let comment = realm_create_dom_comment(realm, document, ak.utf16_string_from_str("c"))
let slot = (HtmlSlotElement*)test_realm_node(realm, &html_slot_element_class, DomNodeType.element_node, document)
assert(not dom_is_an_assigned_slottable(text.dom_node()) and not dom_is_an_assigned_slottable(comment.dom_node()))
dom_slottable_mixin_set_assigned_slot(&text.slottable_mixin, slot)
assert(dom_assigned_slot_for_node(text.dom_node()) == slot and dom_is_an_assigned_slottable(text.dom_node()))
dom_slottable_mixin_set_slottable_name(&text.slottable_mixin, ak.fly_string_from_str("n"))
assert(test_fly_is(dom_slottable_mixin_slottable_name(&text.slottable_mixin), "n"))
# Without a parent there is no slot to find.
assert(dom_find_a_slot(.dom_text(text)) == none)
# mark: Small helpers ===========================================================================
test "retarget: a node outside a shadow tree is itself; null stays null":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let (div, abc, p, de, fg) = test_range_tree(realm)
assert(dom_retarget(de.dom_event_target(), div.dom_event_target()) == de.dom_event_target())
assert(dom_retarget(none, div.dom_event_target()) == none)
test "NodeFilter::WhatToShow operators, ToInt32 and the fullscreen error messages":
let element_and_text = dom_bit_or(DomNodeFilterWhatToShow.show_element, DomNodeFilterWhatToShow.show_text)
assert(dom_has_flag(element_and_text, DomNodeFilterWhatToShow.show_text))
assert(not dom_has_flag(element_and_text, DomNodeFilterWhatToShow.show_comment))
assert(dom_has_any_flag(element_and_text, dom_bit_or(DomNodeFilterWhatToShow.show_comment, DomNodeFilterWhatToShow.show_element)))
assert(dom_bit_and(dom_bit_not(DomNodeFilterWhatToShow.show_element), element_and_text) == DomNodeFilterWhatToShow.show_text)
var flags = DomNodeFilterWhatToShow.show_element
_ = dom_xor_assign(&flags, element_and_text)
assert(flags == DomNodeFilterWhatToShow.show_text)
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
assert((dom_js_value_to_i32(vm, js_value_from_f64(4294967297.0)) else trap("threw")) == 1)
assert((dom_js_value_to_i32(vm, js_value_from_f64(2147483648.0)) else trap("threw")) == -2147483648)
assert((dom_js_value_to_i32(vm, js_value_from_f64(-1.9)) else trap("threw")) == -1)
assert((dom_js_value_to_i32(vm, js_value_from_f64(-4294967295.5)) else trap("threw")) == 1)
assert((dom_js_value_to_i32(vm, js_undefined()) else trap("threw")) == 0)
assert((dom_js_value_to_i32(vm, js_value_from_bool(true)) else trap("threw")) == 1)
let message = dom_request_fullscreen_error_to_string(DomRequestFullscreenError.no_transient_user_activation)
assert(ak.string_view_equals(&message, "No transient user activation available to consume"))
test "Position: equality and its string form":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let text = test_text(realm, test_realm_document(realm), "abc").dom_node()
let position = dom_position_create(realm, text, 2)
assert(dom_position_equals(position, dom_position_create(realm, text, 2)))
assert(not dom_position_equals(position, dom_position_create(realm, text, 1)))
let string = dom_position_to_string(position) else trap("threw")
let view = ak.string_bytes_as_string_view(&string)
assert(ak.string_view_starts_with_string_view(&view, ak.sv("DOM::Position(#text (0x")))
assert(ak.string_view_ends_with_string_view(&view, ak.sv(")), 2)")))