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))