Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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