Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / dom / tests_node.lucb

#==============================================================================================
#
#   tests_node - tests of DOM::Node, ParentNode, ChildNode and NodeOperations (region r15)
#
#   DESCRIPTION:
#       Ladybird has no unit tests for these files (its DOM is tested through Tests/LibWeb/Text,
#       which needs scripting), so these pin the C++ behaviour of the functions that run before
#       the regions they call into are ported: the node-type predicates and NodeType values,
#       the default bodies of Node's virtuals, the unique-id directory, the dirty flags and
#       links, the removing steps, the namespace lookups of nodes without an element, the
#       children vector, registered observers, slottables and converting one node.
#
#       The nodes are built by hand (zeroed, vtable and class id set, node type and node
#       document filled), since constructing a cell needs the realm and heap of region r14,
#       and the tree links are written directly, since TreeNode is region r13.
#
#==============================================================================================

# mark: Test nodes ==============================================================================

## A zeroed cell of class `info` with its vtable, class id and node type set, outside any heap.
func test_node(info: const ak.ClassInfo*, type_: DomNodeType, document: DomDocument*?) -> DomNode*:
    let bytes = memory.allocate(info.size, 16) else trap("out of memory")
    memory.set(bytes, 0)
    let node = (DomNode*)bytes.data
    let cell = node.cell()
    cell.vtable = (const gc.CellVTable*)info.vtable
    cell.class_id = info.first_id
    node.m_type = type_
    node.m_document = document
    return node

## A test Document (its own node document).
func test_document() -> DomDocument*:
    let document = (DomDocument*)test_node(&dom_document_class, DomNodeType.document_node, none)
    document.dom_node().m_document = document
    return document

## `child` appended to `parent` by writing the TreeNode links (TreeNode<T>::append_child).
func test_link_child(parent: DomNode*, child: DomNode*):
    child.tree_node.m_parent = parent
    child.tree_node.m_previous_sibling = parent.tree_node.m_last_child
    if let last = parent.tree_node.m_last_child:
        last.tree_node.m_next_sibling = child
    else:
        parent.tree_node.m_first_child = child
    parent.tree_node.m_last_child = child

# mark: Node types ==============================================================================

test "node_type answers the DOM's NodeType constants":
    let document = test_document()
    assert(dom_node_node_type(test_node(&dom_element_class, DomNodeType.element_node, document)) == 1)
    assert(dom_node_node_type(test_node(&dom_attr_class, DomNodeType.attribute_node, document)) == 2)
    assert(dom_node_node_type(test_node(&dom_text_class, DomNodeType.text_node, document)) == 3)
    assert(dom_node_node_type(test_node(&dom_cdata_section_class, DomNodeType.cdata_section_node, document)) == 4)
    assert(dom_node_node_type(test_node(&dom_processing_instruction_class, DomNodeType.processing_instruction_node, document)) == 7)
    assert(dom_node_node_type(test_node(&dom_comment_class, DomNodeType.comment_node, document)) == 8)
    assert(dom_node_node_type(document.dom_node()) == 9)
    assert(dom_node_node_type(test_node(&dom_document_type_class, DomNodeType.document_type_node, document)) == 10)
    assert(dom_node_node_type(test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)) == 11)

test "the node-type predicates follow Node.h":
    let document = test_document()
    let element = test_node(&dom_element_class, DomNodeType.element_node, document)
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    let cdata = test_node(&dom_cdata_section_class, DomNodeType.cdata_section_node, document)
    let comment = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    let pi = test_node(&dom_processing_instruction_class, DomNodeType.processing_instruction_node, document)
    let attr = test_node(&dom_attr_class, DomNodeType.attribute_node, document)
    let doctype = test_node(&dom_document_type_class, DomNodeType.document_type_node, document)
    let fragment = test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)

    assert(dom_node_is_element(element) and not dom_node_is_element(text))
    # A CDATA section is a Text node, but not an exclusive Text node.
    assert(dom_node_is_text(text) and dom_node_is_text(cdata) and not dom_node_is_text(comment))
    assert(dom_node_is_exclusive_text(text) and not dom_node_is_exclusive_text(cdata))
    assert(dom_node_is_cdata_section(cdata) and not dom_node_is_cdata_section(text))
    assert(dom_node_is_character_data(text) and dom_node_is_character_data(cdata) and dom_node_is_character_data(comment) and dom_node_is_character_data(pi))
    assert(not dom_node_is_character_data(element) and not dom_node_is_character_data(attr) and not dom_node_is_character_data(doctype))
    assert(dom_node_is_parent_node(element) and dom_node_is_parent_node(document.dom_node()) and dom_node_is_parent_node(fragment))
    assert(not dom_node_is_parent_node(text) and not dom_node_is_parent_node(doctype))
    assert(dom_node_is_slottable(element) and dom_node_is_slottable(text) and dom_node_is_slottable(cdata))
    assert(not dom_node_is_slottable(comment) and not dom_node_is_slottable(pi))
    assert(dom_node_is_attribute(attr) and dom_node_is_document_type(doctype) and dom_node_is_document_fragment(fragment))
    assert(dom_node_is_comment(comment) and dom_node_is_document(document.dom_node()))
    assert(dom_node_type(pi) == DomNodeType.processing_instruction_node)

test "Node's virtual type queries default to false, is_dom_node to true":
    let document = test_document()
    let comment = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    assert(dom_node_is_dom_node(comment))
    assert(not dom_node_is_shadow_root(comment))
    assert(not dom_node_is_html_element(comment))
    assert(not dom_node_is_svg_element(comment))
    assert(not dom_node_requires_svg_container(comment))
    assert(not dom_node_is_navigable_container(comment))
    assert(not dom_node_is_lazy_loading(comment))
    assert(not dom_node_is_html_ol_ul_menu_element(comment))
    assert(dom_node_is_child_allowed(comment, document.dom_node()))
    assert(dom_node_alternative_text(comment) == none)

# mark: Unique ids ==============================================================================

test "unique ids are handed out in order and found until released":
    let document = test_document()
    let first = test_node(&dom_text_class, DomNodeType.text_node, document)
    let second = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    first.m_unique_id = dom_allocate_unique_id(first)
    second.m_unique_id = dom_allocate_unique_id(second)
    assert(dom_node_unique_id(second) == dom_node_unique_id(first) + 1)
    assert(dom_node_from_unique_id(dom_node_unique_id(first)) == first)
    assert(dom_node_from_unique_id(dom_node_unique_id(second)) == second)

    dom_deallocate_unique_id(dom_node_unique_id(first))
    assert(dom_node_from_unique_id(dom_node_unique_id(first)) == none)
    assert(dom_node_from_unique_id(dom_node_unique_id(second)) == second)

    # Node::finalize releases the node's id.
    dom_node_finalize_impl(second.cell())
    assert(dom_node_from_unique_id(dom_node_unique_id(second)) == none)

# mark: Documents, identity and connection ======================================================

test "ownerDocument is null for a document and the node document otherwise":
    let document = test_document()
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    assert(dom_node_owner_document(document.dom_node()) == none)
    assert(dom_node_owner_document(text) == document)
    assert(dom_node_document(text) == document)
    assert(dom_node_document_const(document.dom_node()) == document)

test "isSameNode and compareDocumentPosition with itself":
    let document = test_document()
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    let comment = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    assert(dom_node_is_same_node(text, text))
    assert(not dom_node_is_same_node(text, comment))
    assert(not dom_node_is_same_node(text, none))
    assert(dom_node_compare_document_position(text, text) == (u16)DomNodeDocumentPosition.document_position_equal)

test "isEqualNode is false for null":
    let document = test_document()
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    assert(not dom_node_is_equal_node(text, none))
    assert(dom_node_is_equal_node(text, text))

test "connection and the editable-subtree flag":
    let document = test_document()
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    assert(not dom_node_is_connected(text))
    dom_node_set_is_connected(text, true)
    assert(dom_node_is_connected(text))
    assert(not dom_node_in_editable_subtree(text))

# mark: Dirty flags and layout links ============================================================

test "the dirty-flag accessors":
    let document = test_document()
    let node = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    assert(not dom_node_needs_style_update(node) and not dom_node_child_needs_style_update(node))
    dom_node_set_child_needs_style_update(node, true)
    dom_node_set_entire_subtree_needs_style_update(node, true)
    dom_node_set_child_needs_layout_tree_update(node, true)
    assert(dom_node_child_needs_style_update(node) and dom_node_entire_subtree_needs_style_update(node))
    assert(dom_node_child_needs_layout_tree_update(node) and not dom_node_needs_layout_tree_update(node))

    # Setting a flag to the value it has returns before touching the document.
    dom_node_set_needs_style_update(node, false)
    dom_node_set_needs_layout_tree_update(node, false, DomSetNeedsLayoutTreeUpdateReason.none_)
    assert(not dom_node_needs_style_update(node) and not dom_node_needs_layout_tree_update(node))

    # Node::set_needs_style_update_internal sets the flag whatever its argument is (Node.h:362).
    dom_node_set_needs_style_update_internal(node, false)
    assert(dom_node_needs_style_update(node))

test "layout node and paintable links":
    let document = test_document()
    let node = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    let layout_node = (LayoutNode*)(memory.allocate(64, 16) else trap("out of memory")).data
    let paintable = (PaintPaintable*)(memory.allocate(64, 16) else trap("out of memory")).data

    dom_node_set_layout_node(node, layout_node)
    dom_node_set_paintable(node, paintable)
    assert(dom_node_unsafe_layout_node(node) == layout_node and dom_node_unsafe_paintable(node) == paintable)
    dom_node_detach_layout_node(node)
    assert(dom_node_unsafe_layout_node_const(node) == none and dom_node_unsafe_paintable_const(node) == paintable)
    dom_node_clear_paintable(node)
    assert(dom_node_unsafe_paintable(node) == none)

    dom_node_set_layout_node(node, layout_node)
    dom_node_set_paintable(node, paintable)
    dom_node_clear_layout_node_and_paintable(node)
    assert(dom_node_unsafe_layout_node(node) == none and dom_node_unsafe_paintable(node) == none)

test "the removing steps disconnect and drop the layout node and paintable":
    let document = test_document()
    let node = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    dom_node_set_is_connected(node, true)
    node.m_in_editable_subtree = true
    dom_node_set_layout_node(node, (LayoutNode*)(memory.allocate(64, 16) else trap("out of memory")).data)
    dom_node_set_paintable(node, (PaintPaintable*)(memory.allocate(64, 16) else trap("out of memory")).data)
    dom_node_removed_from(node, DomNodeIsSubtreeRoot.yes, document.dom_node(), document.dom_node())
    assert(not dom_node_is_connected(node) and not dom_node_in_editable_subtree(node))
    assert(dom_node_unsafe_layout_node(node) == none and dom_node_unsafe_paintable(node) == none)

# mark: Text content and node values ============================================================

test "textContent and nodeValue are null for documents and doctypes":
    let document = test_document()
    let doctype = test_node(&dom_document_type_class, DomNodeType.document_type_node, document)
    assert(dom_node_text_content(document.dom_node()) == none)
    assert(dom_node_text_content(doctype) == none)
    assert(dom_node_node_value(document.dom_node()) == none)
    assert(dom_node_node_value(doctype) == none)
    # Setting the nodeValue of a node that is neither an Attr nor CharacterData does nothing.
    dom_node_set_node_value(doctype, ak.string_from_str("ignored")) else trap("set_node_value failed")

test "the descendant text content of a node without Text descendants is empty":
    let document = test_document()
    let fragment = test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)
    test_link_child(fragment, test_node(&dom_comment_class, DomNodeType.comment_node, document))
    let content = dom_node_descendant_text_content(fragment)
    assert(ak.utf16_string_base_is_empty(&content.utf16_string_base))
    # childTextContent of a node that is not a ParentNode is empty.
    let child_content = dom_node_child_text_content(test_node(&dom_comment_class, DomNodeType.comment_node, document))
    assert(ak.utf16_string_base_is_empty(&child_content.utf16_string_base))
    # normalize() without exclusive Text descendants changes nothing.
    dom_node_normalize(fragment) else trap("normalize failed")

test "length is 0 for doctypes and attributes":
    let document = test_document()
    assert(dom_node_length(test_node(&dom_document_type_class, DomNodeType.document_type_node, document)) == 0)
    assert(dom_node_length(test_node(&dom_attr_class, DomNodeType.attribute_node, document)) == 0)

test "only Text nodes can be uninteresting whitespace":
    let document = test_document()
    assert(not dom_node_is_uninteresting_whitespace_node(test_node(&dom_comment_class, DomNodeType.comment_node, document)))

# mark: Namespaces ==============================================================================

test "doctypes and fragments locate no namespace and no prefix":
    let document = test_document()
    let doctype = test_node(&dom_document_type_class, DomNodeType.document_type_node, document)
    let fragment = test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)
    assert(dom_node_locate_a_namespace(doctype, ak.string_from_str("xml")) == none)
    assert(dom_node_lookup_namespace_uri(fragment, none) == none)
    assert(dom_node_lookup_prefix(doctype, ak.string_from_str("http://www.w3.org/1999/xhtml")) == none)
    # lookupPrefix() of the null or empty namespace is null before looking at the node.
    assert(dom_node_lookup_prefix(fragment, none) == none)
    assert(dom_node_lookup_prefix(fragment, ak.string_from_str("")) == none)
    # The default namespace is null, the empty string counts as null.
    assert(dom_node_is_default_namespace(doctype, none))
    assert(dom_node_is_default_namespace(doctype, ak.string_from_str("")))
    assert(not dom_node_is_default_namespace(doctype, ak.string_from_str("http://www.w3.org/1999/xhtml")))

test "optional string comparisons behave as AK's Optional operator==":
    assert(dom_node_optional_fly_strings_equal(none, none))
    assert(not dom_node_optional_fly_strings_equal(ak.fly_string_from_str("a"), none))
    assert(not dom_node_optional_fly_strings_equal(none, ak.fly_string_from_str("a")))
    assert(dom_node_optional_fly_strings_equal(ak.fly_string_from_str("a"), ak.fly_string_from_str("a")))
    assert(not dom_node_optional_fly_strings_equal(ak.fly_string_from_str("a"), ak.fly_string_from_str("b")))
    assert(dom_node_optional_string_is(ak.string_from_str("xml"), "xml"))
    assert(not dom_node_optional_string_is(none, "xml"))
    assert(dom_node_optional_strings_equal(none, none) and not dom_node_optional_strings_equal(ak.string_from_str(""), none))
    assert(dom_node_optional_fly_string_equals_optional_string(ak.fly_string_from_str("svg"), ak.string_from_str("svg")))
    assert(not dom_node_optional_fly_string_equals_optional_string(none, ak.string_from_str("")))
    assert(dom_node_optional_string_equals(ak.string_from_str("v"), ak.string_from_str("v")))
    assert(not dom_node_optional_string_equals(none, ak.string_from_str("v")))

# mark: Children, observers and slottables ======================================================

test "children_as_vector lists the children in tree order":
    let document = test_document()
    let fragment = test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)
    var empty = dom_node_children_as_vector(fragment)
    assert(ak.vector_size(&empty) == 0)
    let first = test_node(&dom_text_class, DomNodeType.text_node, document)
    let second = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    let third = test_node(&dom_text_class, DomNodeType.text_node, document)
    test_link_child(fragment, first)
    test_link_child(fragment, second)
    test_link_child(fragment, third)
    var children = dom_node_children_as_vector(fragment)
    assert(ak.vector_size(&children) == 3)
    assert(*ak.vector_at(&children, 0) == first and *ak.vector_at(&children, 1) == second and *ak.vector_at(&children, 2) == third)

test "getElementById of a disconnected node without elements finds nothing":
    let document = test_document()
    let fragment = test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)
    test_link_child(fragment, test_node(&dom_text_class, DomNodeType.text_node, document))
    test_link_child(fragment, test_node(&dom_comment_class, DomNodeType.comment_node, document))
    assert(dom_parent_node_get_element_by_id((DomParentNode*)fragment, ak.fly_string_from_str("main")) == none)

test "registered observers are appended to a list made on first use":
    let document = test_document()
    let node = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    assert(dom_node_registered_observer_list_const(node) == none)
    let first = (DomRegisteredObserver*)(memory.allocate(64, 16) else trap("out of memory")).data
    let second = (DomRegisteredObserver*)(memory.allocate(64, 16) else trap("out of memory")).data
    dom_node_add_registered_observer(node, first)
    dom_node_add_registered_observer(node, second)
    let list = dom_node_registered_observer_list_const(node) else trap("no registered observer list")
    assert(ak.vector_size(list) == 2)
    assert(*ak.vector_at(list, 0) == first and *ak.vector_at(list, 1) == second)
    assert(*dom_node_registered_observer_list(node) == list)

test "as_slottable wraps elements and text nodes":
    let document = test_document()
    let element = test_node(&dom_element_class, DomNodeType.element_node, document)
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    match dom_node_as_slottable(element):
        .dom_element(slottable_element):
            assert(slottable_element.dom_node() == element)
        .dom_text(_):
            trap("an element became a Text slottable")
    match dom_node_as_slottable(text):
        .dom_text(slottable_text):
            assert(slottable_text.dom_node() == text)
        .dom_element(_):
            trap("a Text node became an Element slottable")

test "the ParentNode backward-structural-changes flag":
    let document = test_document()
    let fragment = (DomParentNode*)test_node(&dom_document_fragment_class, DomNodeType.document_fragment_node, document)
    assert(not dom_parent_node_has_child_affected_by_backward_structural_changes(fragment))
    dom_parent_node_set_has_child_affected_by_backward_structural_changes(fragment, true)
    assert(dom_parent_node_has_child_affected_by_backward_structural_changes(fragment))

# mark: Generic helpers and node operations =====================================================

## A find_in_shadow_including_ancestry predicate: is it the node in the context?
func test_is_context_node(context: void*?, node: DomNode*) -> bool:
    return context == (void*?)node

test "find_in_shadow_including_ancestry tries the node itself first":
    let document = test_document()
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    assert(dom_node_find_in_shadow_including_ancestry(text, ak.Function1[DomNode*, bool](call = test_is_context_node, context = text)) == text)

test "a doctype is a doctype-or-followed-by-one, null is not":
    let document = test_document()
    assert(not dom_node_is_doctype_or_has_following_doctype(none))
    assert(dom_node_is_doctype_or_has_following_doctype(test_node(&dom_document_type_class, DomNodeType.document_type_node, document)))

test "converting one node into a node answers that node":
    let document = test_document()
    let comment = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    var nodes: ak.Vector[DomNodeOrUtf16String]
    ak.vector_append_t(&nodes, DomNodeOrUtf16String.dom_node(comment))
    let converted = dom_convert_nodes_to_single_node(nodes, document) else trap("convert_nodes_to_single_node failed")
    assert(converted == comment)

test "ChildNode's nodes-contain check looks only at nodes":
    let document = test_document()
    let comment = test_node(&dom_comment_class, DomNodeType.comment_node, document)
    let text = test_node(&dom_text_class, DomNodeType.text_node, document)
    var nodes: ak.Vector[DomNodeOrUtf16String]
    ak.vector_append_t(&nodes, DomNodeOrUtf16String.utf16_string(ak.utf16_string_from_str("text")))
    ak.vector_append_t(&nodes, DomNodeOrUtf16String.dom_node(comment))
    assert(dom_child_node_nodes_contain(nodes, comment))
    assert(not dom_child_node_nodes_contain(nodes, text))