dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / dom / tests_element.lucb
#==============================================================================================
#
# tests_element - tests of DOM::Element and DOM::ElementFactory (region r16)
#
# DESCRIPTION:
# Ladybird has no unit tests for these files (Element is tested through
# Tests/LibWeb/Text, which needs scripting). The name-validity expectations come from
# running the donor's functions (Element.cpp's is_valid_* and CustomElementName.cpp,
# compiled against the reference build's AK); the rest pin the C++ behaviour of the
# functions that run before the regions they call into are ported: validate-and-extract's
# exceptions, the attribute queries of an element without attributes, classes, the
# style-invalidation bookkeeping, the structural flags, custom element states, dir,
# translation mode, scroll offsets, cached lang and ordinal values, an element's target,
# the interface names of the element factory and the mixins' way back to their element.
#
# Elements are built by hand (r15's test_node: zeroed, vtable and class id set), since
# constructing one still traps in region r19's EventTarget constructor; exceptions use
# region r14's test VM and realm.
#
#==============================================================================================
# mark: Test elements ===========================================================================
## A hand-built Element (r15's test_node), its mixins pointing at Element's tables as
## Element::Element sets them.
func test_element(document: DomDocument*?) -> DomElement*:
let element = (DomElement*)test_node(&dom_element_class, DomNodeType.element_node, document)
element.slottable_mixin.vtable = &dom_element_slottable_mixin_vtable
element.aria_mixin.vtable = &dom_element_aria_mixin_vtable
element.animatable.vtable = &dom_element_animatable_vtable
return element
## A FlyString for a test.
func test_fly(text: str) -> ak.FlyString:
return ak.fly_string_from_str(text)
## The validity flags of one name: (namespace prefix, attribute local name, element local name,
## custom element name), as the reference build answers them.
struct TestNameValidity:
var name: str
var namespace_prefix: bool
var attribute_local_name: bool
var element_local_name: bool
var custom_element_name: bool
## The pending DOMException as "[Name]: message".
func test_take_dom_exception_string() -> ak.String:
match idl_take_pending_exception():
.idl_dom_exception(exception): return idl_dom_exception_to_string(exception)
_: trap("expected a DOMException")
## validate_and_extract expected to throw: the exception as "[Name]: message".
func test_validate_and_extract_error(realm: Realm*, namespace_: ak.FlyString?, qualified_name: str, context: DomValidationContext) -> ak.String:
_ = dom_validate_and_extract(realm, namespace_, test_fly(qualified_name), context) catch failure:
assert(failure.code == webidl_exception)
return test_take_dom_exception_string()
trap("validate_and_extract did not throw")
# mark: Name validity ===========================================================================
test "the valid name checks answer as the reference build":
let cases: TestNameValidity[28] = [
TestNameValidity(name = "", namespace_prefix = false, attribute_local_name = false, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "a", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "div", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "xml:lang", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "a b", namespace_prefix = false, attribute_local_name = false, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "a/b", namespace_prefix = false, attribute_local_name = false, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "a>b", namespace_prefix = false, attribute_local_name = false, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "a=b", namespace_prefix = true, attribute_local_name = false, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "-x", namespace_prefix = true, attribute_local_name = true, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "_x", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = ":x", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "1x", namespace_prefix = true, attribute_local_name = true, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "été", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "x-y", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = true),
TestNameValidity(name = "my-element", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = true),
TestNameValidity(name = "My-element", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "my-Element", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "font-face", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "x\u{1}y", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "a.b-c_d:e", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = true),
TestNameValidity(name = "€", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "x\tz", namespace_prefix = false, attribute_local_name = false, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "x\u{a0}y", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "foo-baré", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = true),
TestNameValidity(name = "annotation-xml", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "a\u{c}b", namespace_prefix = false, attribute_local_name = false, element_local_name = false, custom_element_name = false),
TestNameValidity(name = "xmlns", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
TestNameValidity(name = "a:b:c", namespace_prefix = true, attribute_local_name = true, element_local_name = true, custom_element_name = false),
]
for case in cases:
let name = test_fly(case.name)
assert(dom_is_valid_namespace_prefix(name) == case.namespace_prefix, case.name)
assert(dom_is_valid_attribute_local_name(name) == case.attribute_local_name, case.name)
assert(dom_is_valid_element_local_name(name) == case.element_local_name, case.name)
assert(html_is_valid_custom_element_name(ak.string_from_str(case.name)) == case.custom_element_name, case.name)
test "validate_and_extract throws the DOM's errors":
web_initialize_strings()
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
var error_ = test_validate_and_extract_error(realm, none, " :y", DomValidationContext.element)
assert(ak.string_eq_string_view(&error_, ak.sv("[InvalidCharacterError]: Prefix not a valid namespace prefix.")))
error_ = test_validate_and_extract_error(realm, none, "a b", DomValidationContext.attribute)
assert(ak.string_eq_string_view(&error_, ak.sv("[InvalidCharacterError]: Local name not a valid attribute local name.")))
error_ = test_validate_and_extract_error(realm, none, "1x", DomValidationContext.element)
assert(ak.string_eq_string_view(&error_, ak.sv("[InvalidCharacterError]: Local name not a valid element local name.")))
# "1x" is a valid attribute local name, so only the element context rejects it; then the
# prefix without a namespace is the next error.
error_ = test_validate_and_extract_error(realm, none, "p:1x", DomValidationContext.attribute)
assert(ak.string_eq_string_view(&error_, ak.sv("[NamespaceError]: Prefix is non-null and namespace is null.")))
# The empty namespace is null.
error_ = test_validate_and_extract_error(realm, ak.fly_string_new(), "p:x", DomValidationContext.element)
assert(ak.string_eq_string_view(&error_, ak.sv("[NamespaceError]: Prefix is non-null and namespace is null.")))
error_ = test_validate_and_extract_error(realm, namespace_html, "xml:x", DomValidationContext.element)
assert(ak.string_eq_string_view(&error_, ak.sv("[NamespaceError]: Prefix is 'xml' and namespace is not the XML namespace.")))
error_ = test_validate_and_extract_error(realm, namespace_html, "xmlns", DomValidationContext.attribute)
assert(ak.string_eq_string_view(&error_, ak.sv("[NamespaceError]: Either qualifiedName or prefix is 'xmlns' and namespace is not the XMLNS namespace.")))
error_ = test_validate_and_extract_error(realm, namespace_xmlns, "x", DomValidationContext.attribute)
assert(ak.string_eq_string_view(&error_, ak.sv("[NamespaceError]: Namespace is the XMLNS namespace and neither qualifiedName nor prefix is 'xmlns'.")))
test "toggleAttribute rejects an invalid name with InvalidCharacterError":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let element = test_element(test_document())
element.bind_platform_object().m_realm = realm
let toggled = dom_element_toggle_attribute(element, test_fly("a b"), none) catch failure:
assert(failure.code == webidl_exception)
recover false
assert(not toggled)
let error_ = test_take_dom_exception_string()
assert(ak.string_eq_string_view(&error_, ak.sv("[InvalidCharacterError]: Attribute name must not be empty or contain invalid characters")))
# mark: Attributes and classes ==================================================================
test "an element without attributes answers every attribute query emptily":
let element = test_element(test_document())
let name = test_fly("id")
assert(dom_element_get_attribute(element, name) == none)
assert(dom_element_get_attribute_ns(element, none, name) == none)
let value = dom_element_get_attribute_value(element, name)
assert(ak.string_is_empty(&value))
assert(dom_element_get_attribute_node(element, name) == none)
assert(dom_element_get_attribute_node_ns(element, none, name) == none)
assert(not dom_element_has_attribute(element, name))
assert(not dom_element_has_attribute_ns(element, none, name))
assert(not dom_element_has_attributes(element))
assert(dom_element_attribute_list_size(element) == 0)
var names = dom_element_get_attribute_names(element)
assert(ak.vector_is_empty(&names))
# Removing from a missing attribute list does nothing.
dom_element_remove_attribute(element, name)
dom_element_remove_attribute_ns(element, none, name)
assert(element.m_attributes == none)
test "has_class compares case-sensitively or ignoring ASCII case":
let element = test_element(test_document())
ak.vector_append_t(&element.m_classes, test_fly("Foo"))
ak.vector_append_t(&element.m_classes, test_fly("bar"))
assert(dom_element_has_class(element, test_fly("Foo")))
assert(not dom_element_has_class(element, test_fly("foo")))
assert(dom_element_has_class(element, test_fly("foo"), ak.CaseSensitivity.case_insensitive))
assert(dom_element_has_class(element, test_fly("BAR"), ak.CaseSensitivity.case_insensitive))
assert(not dom_element_has_class(element, test_fly("baz"), ak.CaseSensitivity.case_insensitive))
var class_names = dom_element_class_names(element)
assert(ak.vector_size(&class_names) == 2)
test "removed attributes for style invalidation are remembered once and cleared":
let element = test_element(test_document())
let name = test_fly("title")
assert(not dom_element_has_removed_attribute_for_style_invalidation(element, name))
dom_element_remember_removed_attribute_for_style_invalidation(element, name)
dom_element_remember_removed_attribute_for_style_invalidation(element, name)
assert(dom_element_has_removed_attribute_for_style_invalidation(element, name))
assert(ak.vector_size(&element.m_removed_attributes_for_style_invalidation) == 1)
dom_element_clear_removed_attributes_for_style_invalidation(element)
assert(not dom_element_has_removed_attribute_for_style_invalidation(element, name))
# mark: Flags ===================================================================================
test "the structural flags and the parent's backward-structural-changes flag":
let document = test_document()
let parent = test_element(document)
let child = test_element(document)
test_link_child(parent.dom_node(), child.dom_node())
assert(not dom_element_affected_by_forward_structural_changes(child))
dom_element_set_affected_by_first_child_pseudo_class(child, true)
assert(dom_element_affected_by_forward_structural_changes(child))
dom_element_set_affected_by_first_child_pseudo_class(child, false)
dom_element_set_affected_by_indirect_sibling_combinator(child, true)
assert(dom_element_affected_by_forward_structural_changes(child))
assert(not dom_element_affected_by_backward_structural_changes(child))
assert(not dom_parent_node_has_child_affected_by_backward_structural_changes(parent.dom_parent_node()))
dom_element_set_affected_by_last_child_pseudo_class(child, true)
assert(dom_element_affected_by_backward_structural_changes(child))
assert(dom_parent_node_has_child_affected_by_backward_structural_changes(parent.dom_parent_node()))
# Clearing the flag does not clear the parent's.
dom_element_set_affected_by_last_child_pseudo_class(child, false)
assert(not dom_element_affected_by_backward_structural_changes(child))
assert(dom_parent_node_has_child_affected_by_backward_structural_changes(parent.dom_parent_node()))
# The write-once flags.
dom_element_set_affected_by_structural_pseudo_class_in_non_subject_position(child)
dom_element_set_affected_by_sibling_combinator_in_non_subject_position(child)
assert(dom_element_affected_by_structural_pseudo_class_in_non_subject_position(child))
assert(dom_element_affected_by_sibling_combinator_in_non_subject_position(child))
test "set_style_uses_tree_counting_function marks the parent element":
let document = test_document()
let parent = test_element(document)
let child = test_element(document)
test_link_child(parent.dom_node(), child.dom_node())
dom_element_set_style_uses_tree_counting_function(child)
assert(dom_element_style_uses_tree_counting_function(child))
assert(dom_element_child_style_uses_tree_counting_function(parent))
assert(not dom_element_style_uses_tree_counting_function(parent))
# Without a parent element only the element's own flag is set.
let orphan = test_element(document)
dom_element_set_style_uses_tree_counting_function(orphan)
assert(dom_element_style_uses_tree_counting_function(orphan))
test "custom element states: defined and custom":
let element = test_element(test_document())
assert(element.m_custom_element_state == DomCustomElementState.undefined)
assert(not dom_element_is_defined(element) and not dom_element_is_custom(element))
element.m_custom_element_state = DomCustomElementState.uncustomized
assert(dom_element_is_defined(element) and not dom_element_is_custom(element))
element.m_custom_element_state = DomCustomElementState.custom
assert(dom_element_is_defined(element) and dom_element_is_custom(element))
element.m_custom_element_state = DomCustomElementState.failed
assert(not dom_element_is_defined(element))
# Setting the state it already has does no invalidation.
dom_element_set_custom_element_state(element, DomCustomElementState.failed)
# mark: Direction, translation and cached values ================================================
test "directionality follows the dir attribute state":
let element = test_element(test_document())
element.m_dir = DomElementDir.ltr
assert(dom_element_directionality(element) == DomElementDirectionality.ltr)
element.m_dir = DomElementDir.rtl
assert(dom_element_directionality(element) == DomElementDirectionality.rtl)
# dir=auto with no text: the auto directionality is null, so 'ltr'.
element.m_dir = DomElementDir.auto
assert(dom_element_directionality(element) == DomElementDirectionality.ltr)
assert(not dom_element_is_auto_directionality_form_associated_element(element))
test "translation mode is translate-enabled without a translate attribute or parent":
let element = test_element(test_document())
assert(dom_element_translation_mode(element) == DomElementTranslationMode.translate_enabled)
test "scroll offsets of the element itself":
let element = test_element(test_document())
let initial = dom_element_scroll_offset(element, none)
assert(gfx.css_pixel_point_is_zero(&initial))
var offset: gfx.CssPixelPoint = ---
gfx.css_pixel_point_construct(&offset, gfx.css_pixels_from_int(3), gfx.css_pixels_from_int(-7))
dom_element_set_scroll_offset(element, none, offset)
let stored = dom_element_scroll_offset(element, none)
assert(gfx.css_pixel_point_x(&stored) == gfx.css_pixels_from_int(3))
assert(gfx.css_pixel_point_y(&stored) == gfx.css_pixels_from_int(-7))
test "lang answers its cached value, and the empty language as null":
let element = test_element(test_document())
element.m_lang_value = ak.string_from_str("en-GB")
let lang = dom_element_lang(element) else trap("expected a language")
assert(ak.string_eq_string_view(&lang, ak.sv("en-GB")))
element.m_lang_value = ak.string_new()
assert(dom_element_lang(element) == none)
test "ordinal_value answers its cached value":
let element = test_element(test_document())
element.m_ordinal_value = 5
assert(dom_element_ordinal_value(element) == 5)
test "an element's target: a given target, and _blank for tab-newline and '<'":
let element = test_element(test_document())
var target = dom_element_get_an_elements_target(element, ak.string_from_str("frame"))
assert(ak.string_eq_string_view(&target, ak.sv("frame")))
# The C++ checks for the three-character sequence "\t\n\r" (StringView::contains), then '<'.
target = dom_element_get_an_elements_target(element, ak.string_from_str("a\t\n\r<b"))
assert(ak.string_eq_string_view(&target, ak.sv("_blank")))
target = dom_element_get_an_elements_target(element, ak.string_from_str("a\t<b"))
assert(ak.string_eq_string_view(&target, ak.sv("a\t<b")))
target = dom_element_get_an_elements_target(element, ak.string_from_str("a\t\n\rb"))
assert(ak.string_eq_string_view(&target, ak.sv("a\t\n\rb")))
# mark: Mixins, pseudo-elements and the factory =================================================
test "the mixins find their element":
let element = test_element(test_document())
assert(dom_element_from_aria_mixin(&element.aria_mixin) == element)
assert(aria_mixin_to_element(&element.aria_mixin) == element)
assert(dom_slottable_mixin_slottable_as_node(&element.slottable_mixin) == element.dom_node())
test "an element without pseudo-element data":
let element = test_element(test_document())
assert(dom_element_get_pseudo_element(element, css_data.PseudoElement.before) == none)
assert(not dom_element_has_pseudo_elements(element))
assert(not dom_element_has_pseudo_element(element, css_data.PseudoElement.after))
assert(dom_element_computed_properties(element, css_data.PseudoElement.before) == none)
assert(dom_element_cascaded_properties(element, css_data.PseudoElement.before) == none)
assert(dom_element_get_pseudo_element_node(element, css_data.PseudoElement.marker) == none)
assert(dom_element_computed_properties(element) == none)
test "the local names of the HTML element interfaces":
let headings = dom_valid_local_names_for_given_html_element_interface(ak.sv("HTMLHeadingElement")) else trap("out of memory")
assert(headings.length == 6)
let mods = dom_valid_local_names_for_given_html_element_interface(ak.sv("HTMLModElement")) else trap("out of memory")
assert(mods.length == 2)
let pres = dom_valid_local_names_for_given_html_element_interface(ak.sv("HTMLPreElement")) else trap("out of memory")
assert(pres.length == 3)
let html_elements = dom_valid_local_names_for_given_html_element_interface(ak.sv("HTMLElement")) else trap("out of memory")
assert(html_elements.length == 51)
let unknown = dom_valid_local_names_for_given_html_element_interface(ak.sv("HTMLBlinkElement")) else trap("out of memory")
assert(unknown.length == 0)