Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / tests_html_element_2.lucb

#==============================================================================================
#
#   tests_html_element_2 - tests of popover validity, attachInternals, the dataset, the nonce,
#                          the hyperlink URL decomposition, the event handler IDL attributes and
#                          the focus chain (region r22)
#
#   DESCRIPTION:
#       Pins the C++ behaviour of what runs before the regions these paths call into are
#       ported: the popover validity checks and their DOMExceptions on disconnected elements,
#       hidePopover() of a hidden popover, attachInternals()' NotSupportedError, DOMStringMap's
#       name-value pairs of the data-* attributes, HTMLOrSVGElement's [[CryptographicNonce]]
#       (change steps and cloning), the HTMLHyperlinkElementUtils getters without an href and
#       extracting an origin (a test includer stands in for a and area, region r27), the
#       GlobalEventHandlers IDL
#       attributes over EventTarget's handler map, the focus chain, and the early returns of
#       the focusing steps. The helpers are tests_html_element_1's.
#
#       Not reachable yet: the hyperlink getters with an href (encoding-parsing a URL needs the
#       document's base URL, region r28), showing a popover (its ToggleEvent and CloseWatcher
#       came with the P1 polish; not tested here), setting URL parts (update_href sets the href
#       attribute, whose change steps invalidate style in region r42), DOMStringMap's setter
#       (Value::to_string, phase 3), click() (a synthetic pointer event, phase 4) and the text
#       steps (layout). Region r23's tests collect garbage with HTML elements alive.
#
#==============================================================================================

# mark: Helpers =================================================================================

## The name of the DOMException a failed call left pending.
func test_html_take_dom_exception_name() -> ak.FlyString:
    match idl_take_pending_exception():
        .idl_dom_exception(exception): return idl_dom_exception_name(exception)
        _: trap("expected a DOMException")

# mark: Popovers ================================================================================

test "check popover validity: no popover attribute, disconnected elements, and the exceptions":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "section")

    let quiet = html_element_check_popover_validity(element, HtmlExpectedToBeShowing.no, HtmlThrowExceptions.no, none, HtmlIgnoreDomState.no) else trap("no exception without throwExceptions")
    assert(not quiet)
    var failed = false
    _ = html_element_check_popover_validity(element, HtmlExpectedToBeShowing.no, HtmlThrowExceptions.yes, none, HtmlIgnoreDomState.no) catch:
        failed = true
        recover false
    assert(failed)
    var name = test_html_take_dom_exception_name()
    assert(ak.fly_string_eq_string_view(&name, ak.sv("NotSupportedError")))

    test_html_set(element, html_attribute_names_popover, "auto")
    # A hidden popover expected to be showing is not valid, without an exception.
    let showing = html_element_check_popover_validity(element, HtmlExpectedToBeShowing.yes, HtmlThrowExceptions.yes, none, HtmlIgnoreDomState.no) else trap("no exception for a visibility mismatch")
    assert(not showing)
    # A disconnected element in a document that is not fully active is not valid.
    failed = false
    _ = html_element_check_popover_validity(element, HtmlExpectedToBeShowing.no, HtmlThrowExceptions.yes, none, HtmlIgnoreDomState.yes) catch:
        failed = true
        recover false
    assert(failed)
    name = test_html_take_dom_exception_name()
    assert(ak.fly_string_eq_string_view(&name, ak.sv("InvalidStateError")))

    # showPopover() fails the same way; hidePopover() of a hidden popover returns quietly.
    failed = false
    html_element_show_popover_for_bindings(element, HtmlShowPopoverOptions()) catch:
        failed = true
        recover ()
    assert(failed)
    name = test_html_take_dom_exception_name()
    assert(ak.fly_string_eq_string_view(&name, ak.sv("InvalidStateError")))
    html_element_hide_popover_for_bindings(element) else trap("hidePopover() of a hidden popover")

    # togglePopover(false) of a hidden popover checks validity with exceptions.
    failed = false
    _ = html_element_toggle_popover(element, .bool_(false)) catch:
        failed = true
        recover false
    assert(failed)
    name = test_html_take_dom_exception_name()
    assert(ak.fly_string_eq_string_view(&name, ak.sv("InvalidStateError")))
    assert(html_element_popover_visibility_state(element) == HtmlElementPopoverVisibilityState.hidden)

test "popover lists: positions, nearest open popovers and the topmost ancestor of an empty list":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let parent = test_html_create(document, "section")
    let child = test_html_create(document, "b")
    test_html_append(parent, child)
    test_html_set(parent, html_attribute_names_popover, "")
    assert(html_element_popover_stack_position(child) == 0)
    assert(html_element_nearest_inclusive_open_popover(child) == none)
    var empty: ak.Vector[HtmlElement*]
    assert(html_element_topmost_popover_ancestor(child.dom_node(), &empty, none, HtmlIsPopover.no) == none)
    html_element_close_entire_popover_list(&empty, HtmlFocusPreviousElement.no, HtmlFireEvents.no)
    # A showing auto popover is the nearest inclusive open popover of its descendants.
    parent.m_popover_visibility_state = HtmlElementPopoverVisibilityState.showing
    assert(html_element_nearest_inclusive_open_popover(child) == parent)
    parent.m_popover_visibility_state = HtmlElementPopoverVisibilityState.hidden

# mark: attachInternals and the dataset =========================================================

test "attachInternals: NotSupportedError for an element that is not a custom element":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "x-foo")
    var failed = false
    _ = html_element_attach_internals(element) catch:
        failed = true
        recover (HtmlElementInternals*)element
    assert(failed)
    let name = test_html_take_dom_exception_name()
    assert(ak.fly_string_eq_string_view(&name, ak.sv("NotSupportedError")))

test "dataset: one DOMStringMap whose pairs are the data-* attributes, camel-cased":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "section")
    let dataset = html_or_svg_element_dataset(&element.html_or_svg_element)
    assert(html_or_svg_element_dataset(&element.html_or_svg_element) == dataset)
    assert(dataset.m_associated_element == element.dom_element())
    assert(is_html_dom_string_map(dataset))

    test_html_set(element, ak.fly_string_from_str("data-foo-bar"), "1")
    test_html_set(element, html_attribute_names_title, "not data")
    test_html_set(element, ak.fly_string_from_str("data-x"), "2")
    test_html_set(element, ak.fly_string_from_str("data-Upper"), "3")
    test_html_set(element, ak.fly_string_from_str("data-a-1-"), "4")
    test_html_set(element, ak.fly_string_from_str("data-"), "5")
    var names = html_dom_string_map_supported_property_names_impl(dataset.bind_platform_object())
    let expected: str[4] = ["fooBar", "x", "a-1-", ""]
    assert(ak.vector_size(&names) == expected.length)
    for index in 0..<expected.length:
        assert(ak.fly_string_eq_string_view(ak.vector_at(&names, index), ak.sv(expected[index])), expected[index])
    let value = html_dom_string_map_determine_value_of_named_property(dataset, ak.fly_string_from_str("fooBar"))
    assert(ak.string_eq_string_view(&value, ak.sv("1")))

    # Deleting a name with no attribute removes nothing and succeeds.
    let result = html_dom_string_map_delete_value_impl(dataset.bind_platform_object(), ak.string_from_str("missingName")) else trap("delete_value")
    assert(result == BindPlatformObjectDidDeletionFail.no)
    assert(test_html_find_attribute(element.dom_element(), ak.fly_string_from_str("data-foo-bar")) != none)

test "the nonce: change steps set [[CryptographicNonce]], removal empties it, cloning copies it":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "section")
    test_html_set(element, html_attribute_names_nonce, "abc")
    var nonce = html_or_svg_element_nonce(&element.html_or_svg_element)
    assert(ak.string_eq_string_view(&nonce, ak.sv("abc")))
    # A namespaced nonce attribute does not change it.
    html_or_svg_element_attribute_changed(&element.html_or_svg_element, html_attribute_names_nonce, none, ak.string_from_str("other"), namespace_x_link)
    nonce = html_or_svg_element_nonce(&element.html_or_svg_element)
    assert(ak.string_eq_string_view(&nonce, ak.sv("abc")))

    let copy = test_html_create(document, "section")
    html_or_svg_element_cloned(&element.html_or_svg_element, copy.dom_node(), false) else trap("cloned")
    nonce = html_or_svg_element_nonce(&copy.html_or_svg_element)
    assert(ak.string_eq_string_view(&nonce, ak.sv("abc")))

    test_html_remove(element, html_attribute_names_nonce)
    nonce = html_or_svg_element_nonce(&element.html_or_svg_element)
    assert(ak.string_is_empty(&nonce))

# mark: HTMLHyperlinkElementUtils ===============================================================

## A test includer of HTMLHyperlinkElementUtils: the mixin and its element.
struct TestHtmlHyperlink:
    var utils: HtmlHyperlinkElementUtils
    var element: HtmlElement*

## hyperlink_element_utils_element of the test includer.
func test_html_hyperlink_element(this: HtmlHyperlinkElementUtils*) -> DomElement*:
    return ((TestHtmlHyperlink*)this).element.dom_element()

## The HTMLHyperlinkElementUtils table of the test includer.
let test_html_hyperlink_vtable: HtmlHyperlinkElementUtilsVTable = HtmlHyperlinkElementUtilsVTable(class_info = &html_element_class, hyperlink_element_utils_element = test_html_hyperlink_element, hyperlink_element_utils_element_const = test_html_hyperlink_element)

## Whether a String holds `text`.
func test_html_string_holds(string: ak.String, text: str) -> bool:
    return ak.string_eq_string_view(&string, ak.sv(text))

test "HTMLHyperlinkElementUtils: the getters without an href, and extracting an origin":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "x-link")
    var link = TestHtmlHyperlink(utils = HtmlHyperlinkElementUtils(vtable = &test_html_hyperlink_vtable), element = element)
    let utils = &link.utils

    # Without an href, the url is null.
    assert(test_html_string_holds(html_hyperlink_element_utils_href(utils), ""))
    assert(test_html_string_holds(html_hyperlink_element_utils_protocol(utils), ":"))
    assert(test_html_string_holds(html_hyperlink_element_utils_origin(utils), ""))
    assert(test_html_string_holds(html_hyperlink_element_utils_host(utils), ""))
    assert(html_hyperlink_element_utils_hyperlink_element_utils_extract_an_origin(utils) == none)

    # extract an origin reads the url as it is (setting one from an href goes through the
    # document's base URL, region r28's url_matches_about_srcdoc).
    utils.m_url = web_url.parser_basic_parse(ak.sv("https://user:pw@example.com:8080/a/b?q=1#frag"))
    let origin = html_hyperlink_element_utils_hyperlink_element_utils_extract_an_origin(utils) else trap("a url has an origin")
    assert(test_html_string_holds(web_url.origin_serialize(&origin), "https://example.com:8080"))

# mark: Event handler IDL attributes ============================================================

## The behaviour of the test event handler: nothing.
func test_html_handler_call(context: void*?, vm: Vm*) -> JsValue!:
    return js_undefined()

## A WebIDL callback over a native function.
func test_html_handler_callback(realm: Realm*) -> IdlCallbackType*:
    let function = js_native_function_create(realm, JsNativeFunctionBehaviour(call = test_html_handler_call, context = none), 1, ak.utf16_fly_string_new(), realm)
    return realm_create_idl_callback_type_realm(realm, (JsObject*)function, realm, IdlOperationReturnsPromise.no)

test "GlobalEventHandlers: onclick and onfocus set and read the element's event handlers":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "section")
    let handlers = &element.global_event_handlers
    assert(html_global_event_handlers_onclick(handlers) == none)
    let callback = test_html_handler_callback(realm)
    html_global_event_handlers_set_onclick(handlers, callback)
    assert(html_global_event_handlers_onclick(handlers) == callback)
    assert(html_global_event_handlers_onfocus(handlers) == none)
    html_global_event_handlers_set_onclick(handlers, none)
    assert(html_global_event_handlers_onclick(handlers) == none)

## A test includer of WindowEventHandlers: the mixin and the event target it forwards to.
struct TestHtmlWindowHandlers:
    var handlers: HtmlWindowEventHandlers
    var target: DomEventTarget*

## window_event_handlers_to_event_target of the test includer.
func test_html_window_handlers_target(this: HtmlWindowEventHandlers*) -> DomEventTarget*?:
    return ((TestHtmlWindowHandlers*)this).target

## The WindowEventHandlers table of the test includer.
let test_html_window_handlers_vtable: HtmlWindowEventHandlersVTable = HtmlWindowEventHandlersVTable(class_info = &html_element_class, window_event_handlers_to_event_target = test_html_window_handlers_target)

test "WindowEventHandlers: onafterprint and ongamepadconnected set and read the target's event handlers":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "section")
    var includer = TestHtmlWindowHandlers(handlers = HtmlWindowEventHandlers(vtable = &test_html_window_handlers_vtable), target = element.dom_event_target())
    let handlers = &includer.handlers
    let callback = test_html_handler_callback(realm)
    html_window_event_handlers_set_onafterprint(handlers, callback)
    html_window_event_handlers_set_ongamepadconnected(handlers, callback)
    assert(html_window_event_handlers_onafterprint(handlers) == callback)
    assert(html_window_event_handlers_ongamepadconnected(handlers) == callback)
    assert(html_window_event_handlers_onunload(handlers) == none)
    assert(dom_event_target_event_handler_attribute(element.dom_event_target(), gamepad_event_names_gamepadconnected) == callback)

# mark: LazyLoadingElement ======================================================================

## A test includer of LazyLoadingElement<T> (HTMLImageElement and HTMLIFrameElement are regions
## r26 and r27): the mixin and its element.
struct TestHtmlLazy: IsDomElement, HasHtmlLazyLoadingElement[TestHtmlLazy]:
    var lazy: HtmlLazyLoadingElement[TestHtmlLazy]
    var element: HtmlElement*

    func dom_element() -> DomElement*: return self.element.dom_element()

    func html_lazy_loading_element() -> HtmlLazyLoadingElement[TestHtmlLazy]*: return (HtmlLazyLoadingElement[TestHtmlLazy]*)&self.lazy

## Lazy load resumption steps that count their runs.
func test_html_lazy_steps(context: void*?):
    let count = (i32*)(context else trap("no counter"))
    *count += 1

test "LazyLoadingElement: the loading attribute's state and the lazy load resumption steps":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    var lazy = TestHtmlLazy(lazy = HtmlLazyLoadingElement[TestHtmlLazy](), element = test_html_create(document, "x-image"))
    assert(html_lazy_loading_element_lazy_loading_attribute(&lazy) == HtmlLazyLoading.eager)
    _ = test_html_put(lazy.element, html_attribute_names_loading, "LAZY")
    assert(html_lazy_loading_element_lazy_loading_attribute(&lazy) == HtmlLazyLoading.lazy)
    _ = test_html_put(lazy.element, html_attribute_names_loading, "eager")
    assert(html_lazy_loading_element_lazy_loading_attribute(&lazy) == HtmlLazyLoading.eager)

    var count: i32 = 0
    assert(html_lazy_loading_element_take_lazy_load_resumption_steps_internal(&lazy) == none)
    html_lazy_loading_element_set_lazy_load_resumption_steps(&lazy, ak.Function0[unit](call = test_html_lazy_steps, context = &count))
    let steps = html_lazy_loading_element_take_lazy_load_resumption_steps_internal(&lazy) else trap("the steps were set")
    assert(html_lazy_loading_element_take_lazy_load_resumption_steps_internal(&lazy) == none)
    ak.function0_call(&steps.function)
    assert(count == 1)

# mark: Focus ===================================================================================

test "the focus chain of an element and the focusing steps' early returns":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let element = test_html_create(document, "section")
    var chain = html_focus_chain(element.dom_node())
    assert(ak.vector_size(&chain) == 2)
    assert(*ak.vector_at(&chain, 0) == element.dom_node() and *ak.vector_at(&chain, 1) == document.dom_node())
    chain = html_focus_chain(document.dom_node())
    assert(ak.vector_size(&chain) == 1)
    chain = html_focus_chain(none)
    assert(ak.vector_is_empty(&chain))

    # No target and no fallback; a document without a browsing context; an inert target.
    html_run_focusing_steps(none)
    html_run_focusing_steps(none, element.dom_node())
    html_element_set_inert(element, true)
    html_run_focusing_steps(element.dom_node(), none, HtmlFocusTrigger.script)
    assert(dom_document_focused_area(document) == none)