Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / tests_html_elements_2.lucb

#==============================================================================================
#
#   tests_html_elements_2 - focused tests of region r27's element classes
#
#   DESCRIPTION:
#       Ladybird has no unit tests for these files (they are tested through Tests/LibWeb
#       Layout/Text pages), so these pin the C++ behaviour that the oracle cases of
#       tests_html_elements do not reach: which class the ElementFactory makes for each name
#       and its mixin tables, the is_html_*_element virtuals, the cached heading level, the link
#       colors <body> sets on its document, <a>/<area>'s relList, text and download preference,
#       <map>'s areas, <marquee>'s reflection setters, <script>'s async, supports and
#       mark_as_ready, <canvas>'s reflected size, bitmap size, presenting and font computation
#       context, and HTMLDocument's construction.
#
#       Documents are web_test_create_document's (the real Document constructor in a settings
#       realm); everything is allocated in the VM's heap. <canvas>, HTMLDocument, <frame>,
#       <iframe> and <object> stop in other regions' stubs when created by the factory
#       (Page::register_canvas_element and NavigableContainer's constructor: r28; Document's
#       ListOfAvailableImages: r26), so <canvas> and HTMLDocument are allocated and constructed
#       without initialize, and the navigable containers wait for r28.
#
#==============================================================================================

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

## A VM, its settings realm and a document of type HTML.
func test_elements_setup() -> (Vm*, Realm*, DomDocument*):
    web_initialize_strings()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    return (vm, realm, web_test_create_document(realm, DocumentDomDocumentType.html))

## The element the ElementFactory makes for the HTML name `local_name`.
func test_elements_create(document: DomDocument*, local_name: str) -> DomElement*:
    return dom_create_element(document, ak.fly_string_from_str(local_name), namespace_html) else trap("create_element")

## `child` appended to `parent` through the DOM.
func test_elements_append(parent: DomNode*, child: DomNode*):
    _ = dom_node_append_child(parent, child) else trap("append_child")

## Sets an attribute through the DOM (its change steps run).
func test_elements_set(element: DomElement*, name: ak.FlyString, value: str):
    dom_element_set_attribute_value(element, name, ak.string_from_str(value))

## Whether an element's attribute `name` is `text`.
func test_elements_attribute_is(element: DomElement*, name: ak.FlyString, text: str) -> bool:
    let value = dom_element_get_attribute_value(element, name)
    return ak.string_eq_string_view(&value, ak.sv(text))

## Whether a Utf16String holds `text`.
func test_elements_utf16_is(string: ak.Utf16String, text: str) -> bool:
    return ak.utf16_string_base_eq_string_view(&string.utf16_string_base, ak.sv(text))

## The class the cell was made of.
func test_elements_class(element: DomElement*) -> const ak.ClassInfo*:
    return element.cell().vtable.class_info

## A Color from its RGB.
func test_elements_rgb(r: u8, g: u8, b: u8) -> gfx.Color:
    return gfx.Color(m_value = 0xff000000 | ((u32)r << 16) | ((u32)g << 8) | (u32)b)

# mark: The element classes =====================================================================

## A name and the class the ElementFactory makes for it.
struct TestElementsClassCase:
    let name: str
    let info: const ak.ClassInfo*

test "the ElementFactory makes r27's element classes, whose constructors move the mixin tables":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let cases: TestElementsClassCase[33] = [
            TestElementsClassCase(name = "html", info = &html_html_element_class),
            TestElementsClassCase(name = "head", info = &html_head_element_class),
            TestElementsClassCase(name = "body", info = &html_body_element_class),
            TestElementsClassCase(name = "div", info = &html_div_element_class),
            TestElementsClassCase(name = "span", info = &html_span_element_class),
            TestElementsClassCase(name = "p", info = &html_paragraph_element_class),
            TestElementsClassCase(name = "h1", info = &html_heading_element_class),
            TestElementsClassCase(name = "h6", info = &html_heading_element_class),
            TestElementsClassCase(name = "pre", info = &html_pre_element_class),
            TestElementsClassCase(name = "listing", info = &html_pre_element_class),
            TestElementsClassCase(name = "xmp", info = &html_pre_element_class),
            TestElementsClassCase(name = "br", info = &html_htmlbr_element_class),
            TestElementsClassCase(name = "hr", info = &html_htmlhr_element_class),
            TestElementsClassCase(name = "font", info = &html_font_element_class),
            TestElementsClassCase(name = "data", info = &html_data_element_class),
            TestElementsClassCase(name = "time", info = &html_time_element_class),
            TestElementsClassCase(name = "param", info = &html_param_element_class),
            TestElementsClassCase(name = "ins", info = &html_mod_element_class),
            TestElementsClassCase(name = "del", info = &html_mod_element_class),
            TestElementsClassCase(name = "q", info = &html_quote_element_class),
            TestElementsClassCase(name = "blockquote", info = &html_quote_element_class),
            TestElementsClassCase(name = "a", info = &html_anchor_element_class),
            TestElementsClassCase(name = "area", info = &html_area_element_class),
            TestElementsClassCase(name = "map", info = &html_map_element_class),
            TestElementsClassCase(name = "marquee", info = &html_marquee_element_class),
            TestElementsClassCase(name = "frameset", info = &html_frame_set_element_class),
            TestElementsClassCase(name = "embed", info = &html_embed_element_class),
            TestElementsClassCase(name = "script", info = &html_script_element_class),
            TestElementsClassCase(name = "center", info = &html_element_class),
            TestElementsClassCase(name = "h3", info = &html_heading_element_class),
            TestElementsClassCase(name = "h2", info = &html_heading_element_class),
            TestElementsClassCase(name = "h4", info = &html_heading_element_class),
            TestElementsClassCase(name = "h5", info = &html_heading_element_class),
        ]
        for test_case in &cases:
            let element = test_elements_create(document, test_case.name)
            assert(test_elements_class(element) == test_case.info, test_case.name)
            let html = (HtmlElement*)element
            assert(element.aria_mixin.vtable.class_info == test_case.info)
            assert(element.slottable_mixin.vtable.class_info == test_case.info)
            assert(element.animatable.vtable.class_info == test_case.info)
            assert(html.global_event_handlers.vtable.class_info == test_case.info)
            assert(html.form_associated_element.vtable.class_info == test_case.info)

        # The WindowEventHandlers base of <body> and <frameset>, the HTMLHyperlinkElementUtils base of <a> and <area>.
        let body = as_html_body_element(test_elements_create(document, "body"))
        assert(body.window_event_handlers.vtable == &html_body_element_window_event_handlers_vtable)
        assert(body.window_event_handlers.class_id == body.cell().class_id)
        let frameset = as_html_frame_set_element(test_elements_create(document, "frameset"))
        assert(frameset.window_event_handlers.vtable == &html_frame_set_element_window_event_handlers_vtable)
        let anchor = as_html_anchor_element(test_elements_create(document, "a"))
        assert(anchor.html_hyperlink_element_utils.vtable == &html_anchor_element_html_hyperlink_element_utils_vtable)
        assert(html_anchor_element_hyperlink_element_utils_element_impl(&anchor.html_hyperlink_element_utils) == anchor.dom_element())
        let area = as_html_area_element(test_elements_create(document, "area"))
        assert(html_area_element_hyperlink_element_utils_element_const_impl(&area.html_hyperlink_element_utils) == area.dom_element())

        # The script element's member initializers.
        let script = as_html_script_element(test_elements_create(document, "script"))
        assert(script.m_force_async and not script.m_already_started and script.m_source_line_number == 1)
        assert(script.m_script_type == HtmlScriptElementScriptType.null)
        assert(script.m_crossorigin == HtmlCorsSettingAttribute.no_cors)
        assert(script.m_referrer_policy == ReferrerPolicyReferrerPolicy.empty_string)
        _ = realm

test "the is_html_*_element virtuals of r27's classes":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        assert(dom_node_is_html_html_element(test_elements_create(document, "html").dom_node()))
        assert(dom_node_is_html_head_element(test_elements_create(document, "head").dom_node()))
        assert(dom_node_is_html_body_element(test_elements_create(document, "body").dom_node()))
        assert(dom_node_is_html_div_element(test_elements_create(document, "div").dom_node()))
        assert(dom_node_is_html_span_element(test_elements_create(document, "span").dom_node()))
        assert(dom_node_is_html_heading_element(test_elements_create(document, "h4").dom_node()))
        assert(dom_node_is_html_br_element(test_elements_create(document, "br").dom_node()))
        assert(dom_node_is_html_anchor_element(test_elements_create(document, "a").dom_node()))
        assert(dom_node_is_html_area_element(test_elements_create(document, "area").dom_node()))
        assert(dom_node_is_html_embed_element(test_elements_create(document, "embed").dom_node()))
        assert(dom_node_is_html_frameset_element(test_elements_create(document, "frameset").dom_node()))
        assert(dom_node_is_html_script_element(test_elements_create(document, "script").dom_node()))
        let p = test_elements_create(document, "p").dom_node()
        assert(not dom_node_is_html_div_element(p) and not dom_node_is_html_span_element(p) and not dom_node_is_html_heading_element(p))

# mark: Behaviour ===============================================================================

test "<h1>-<h6>: the heading level is the computed heading level, cached per DOM tree version":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let html = test_elements_create(document, "html")
        test_elements_append(document.dom_node(), html.dom_node())
        let body = test_elements_create(document, "body")
        test_elements_append(html.dom_node(), body.dom_node())
        let h3 = as_html_heading_element(test_elements_create(document, "h3"))
        test_elements_append(body.dom_node(), h3.dom_node())
        assert(html_heading_element_heading_level(h3) == 3)
        assert(h3.m_dom_tree_version_for_cached_heading_level == dom_document_dom_tree_version(document))
        assert(h3.m_cached_heading_level == 3)
        let h6 = as_html_heading_element(test_elements_create(document, "h6"))
        test_elements_append(body.dom_node(), h6.dom_node())
        assert(html_heading_element_heading_level(h6) == 6)

test "<body>'s link, alink and vlink set the document's link colors; its event handler targets":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let body = test_elements_create(document, "body")
        assert(dom_document_normal_link_color(document) == none)
        test_elements_set(body, html_attribute_names_link, "red")
        test_elements_set(body, html_attribute_names_alink, "#00ff00")
        test_elements_set(body, html_attribute_names_vlink, "blue")
        assert((dom_document_normal_link_color(document) else trap("no link color")) == test_elements_rgb(255, 0, 0))
        assert((dom_document_active_link_color(document) else trap("no alink color")) == test_elements_rgb(0, 255, 0))
        assert((dom_document_visited_link_color(document) else trap("no vlink color")) == test_elements_rgb(0, 0, 255))
        # A whitespace-only legacy color is not a color: the link color stays.
        test_elements_set(body, html_attribute_names_link, "transparent")
        assert((dom_document_normal_link_color(document) else trap("no link color")) == test_elements_rgb(255, 0, 0))

        # An event handler that is not window-reflecting targets the body itself; the window-reflecting
        # ones and every WindowEventHandlers one target the document's window (none here).
        let html_body = (HtmlElement*)body
        assert(html_global_event_handlers_global_event_handlers_to_event_target(&html_body.global_event_handlers, html_event_names_click) == body.dom_event_target())
        assert(html_global_event_handlers_global_event_handlers_to_event_target(&html_body.global_event_handlers, html_event_names_load) == none)
        let typed_body = as_html_body_element(body)
        assert(html_window_event_handlers_window_event_handlers_to_event_target(&typed_body.window_event_handlers) == none)

test "<a> and <area>: relList, text, download preference, the tab index and the reflected attributes":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let anchor = as_html_anchor_element(test_elements_create(document, "a"))
        test_elements_set(anchor.dom_element(), html_attribute_names_rel, "noopener  nofollow")
        let rel_list = html_anchor_element_rel_list(anchor)
        assert(html_anchor_element_rel_list(anchor) == rel_list)
        assert(dom_token_list_length(rel_list) == 2)
        # The rel attribute's changes reach the token list.
        test_elements_set(anchor.dom_element(), html_attribute_names_rel, "external")
        assert(dom_token_list_length(rel_list) == 1)
        let rel = html_anchor_element_rel(anchor)
        assert(ak.string_eq_string_view(&rel, ak.sv("external")))
        let target = html_anchor_element_target(anchor)
        assert(ak.string_is_empty(&target))

        assert(not html_anchor_element_has_download_preference(anchor))
        test_elements_set(anchor.dom_element(), html_attribute_names_download, "file.txt")
        assert(html_anchor_element_has_download_preference(anchor))
        let download = html_anchor_element_download(anchor)
        assert(ak.string_eq_string_view(&download, ak.sv("file.txt")))
        assert(html_anchor_element_default_tab_index_value_impl(anchor.dom_element()) == 0)
        assert(dom_element_tab_index(anchor.dom_element()) == 0)

        # text is the descendant text content; setting it replaces the children with one text node.
        html_anchor_element_set_text(anchor, ak.utf16_string_from_utf8_string_view(ak.sv("go")))
        assert(test_elements_utf16_is(html_anchor_element_text(anchor), "go"))
        let span = test_elements_create(document, "span")
        test_elements_append(anchor.dom_node(), span.dom_node())
        html_anchor_element_set_text(anchor, ak.utf16_string_from_utf8_string_view(ak.sv("there")))
        assert(test_elements_utf16_is(html_anchor_element_text(anchor), "there"))
        assert(tree_node_first_child(anchor.dom_node()) == tree_node_last_child(anchor.dom_node()))

        let area = as_html_area_element(test_elements_create(document, "area"))
        let area_rel_list = html_area_element_rel_list(area)
        assert(dom_token_list_length(area_rel_list) == 0)
        test_elements_set(area.dom_element(), html_attribute_names_rel, "a b c")
        assert(dom_token_list_length(area_rel_list) == 3)
        assert(html_area_element_default_tab_index_value_impl(area.dom_element()) == 0)

test "<map>'s areas collection holds its area descendants":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let map = as_html_map_element(test_elements_create(document, "map"))
        let areas = html_map_element_areas(map)
        assert(html_map_element_areas(map) == areas)
        assert(dom_html_collection_length(areas) == 0)
        test_elements_append(map.dom_node(), test_elements_create(document, "area").dom_node())
        let div = test_elements_create(document, "div")
        test_elements_append(map.dom_node(), div.dom_node())
        test_elements_append(div.dom_node(), test_elements_create(document, "area").dom_node())
        test_elements_append(div.dom_node(), test_elements_create(document, "a").dom_node())
        assert(dom_html_collection_length(areas) == 2)

test "<marquee>'s scrollAmount and scrollDelay setters write the attributes, with their limits":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let marquee = as_html_marquee_element(test_elements_create(document, "marquee"))
        html_marquee_element_set_scroll_amount(marquee, 12)
        assert(test_elements_attribute_is(marquee.dom_element(), html_attribute_names_scrollamount, "12"))
        assert(html_marquee_element_scroll_amount(marquee) == 12)
        html_marquee_element_set_scroll_amount(marquee, 3000000000)
        assert(test_elements_attribute_is(marquee.dom_element(), html_attribute_names_scrollamount, "6"))
        html_marquee_element_set_scroll_delay(marquee, 2147483647)
        assert(html_marquee_element_scroll_delay(marquee) == 2147483647)
        html_marquee_element_set_scroll_delay(marquee, 2147483648)
        assert(test_elements_attribute_is(marquee.dom_element(), html_attribute_names_scrolldelay, "85"))

## The steps a script element runs when its result is ready (the context counts the runs).
func test_elements_count_steps(context: void*?):
    let count = (i32*)(context else trap("no counter"))
    *count += 1

test "<script>: async, supports, the source line, the Range hooks and marking as ready":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let script = as_html_script_element(test_elements_create(document, "script"))
        assert(html_script_element_async(script))
        html_script_element_set_async(script, true)
        assert(not script.m_force_async and dom_element_has_attribute(script.dom_element(), html_attribute_names_async))
        assert(html_script_element_async(script))
        html_script_element_set_async(script, false)
        assert(not dom_element_has_attribute(script.dom_element(), html_attribute_names_async))
        assert(not html_script_element_async(script))
        # An async attribute added through the DOM unsets force async too.
        html_script_element_set_force_async(script, true)
        test_elements_set(script.dom_element(), html_attribute_names_async, "")
        assert(not script.m_force_async)

        assert(html_script_element_supports(vm, ak.sv("classic")) and html_script_element_supports(vm, ak.sv("module")) and html_script_element_supports(vm, ak.sv("importmap")))
        assert(not html_script_element_supports(vm, ak.sv("speculationrules")) and not html_script_element_supports(vm, ak.sv("Classic")))

        html_script_element_set_source_line_number(script, 42)
        assert(script.m_source_line_number == 42)
        html_script_element_set_already_started(script, true)
        html_script_element_unmark_as_already_started(script)
        assert(not script.m_already_started)
        html_script_element_set_parser_document(script, document)
        assert(html_script_element_is_parser_inserted(script))
        html_script_element_unmark_as_parser_inserted(script)
        assert(not html_script_element_is_parser_inserted(script))

        # text() is the child text content; textContent the descendant text content.
        test_elements_append(script.dom_node(), dom_document_create_text_node(document, ak.utf16_string_from_utf8_string_view(ak.sv("let x;"))).dom_node())
        match html_script_element_text(script):
            .utf16_string(text):
                assert(test_elements_utf16_is(text, "let x;"))
            _:
                assert(false, "text() is a string")

        # Marking as ready stores the result, runs the steps once and drops them, and stops delaying the load event.
        var count = 0
        script.m_steps_to_run_when_the_result_is_ready = ak.Function0[unit](call = test_elements_count_steps, context = &count)
        html_script_element_begin_delaying_document_load_event(script, document)
        assert(script.m_document_load_event_delayer != none)
        html_script_element_mark_as_ready(script, HtmlScriptElementResult.html_null(HtmlNull(empty_ = 0)))
        assert(count == 1)
        assert(not ak.function0_is_set(&script.m_steps_to_run_when_the_result_is_ready))
        assert(script.m_document_load_event_delayer == none)
        assert(html_script_element_result_is_null(script.m_result))

        # Cloning copies already started.
        html_script_element_set_already_started(script, true)
        let copy = as_html_script_element(test_elements_create(document, "script"))
        html_script_element_cloned_impl(script.dom_node(), copy.dom_node(), false) else trap("cloned")
        assert(copy.m_already_started)

        # An unconnected script is not prepared (step 8), and keeps its state.
        html_script_element_prepare_script(copy)
        assert(copy.m_script_type == HtmlScriptElementScriptType.null)
        _ = realm

## A <canvas> allocated and constructed without initialize (Page::register_canvas_element is
## region r28's).
func test_elements_canvas(realm: Realm*, document: DomDocument*) -> HtmlCanvasElement*:
    let canvas = (HtmlCanvasElement*)web_allocate_cell(realm, &html_canvas_element_class)
    html_canvas_element_construct(canvas, document, test_html_qualified_name("canvas"))
    return canvas

## HTMLCanvasElement::finalize unregisters the canvas from its page (region r28's stub): before the
## VM is destroyed, the canvas gets HTMLElement's table, whose finalize is Node's.
func test_elements_forget_canvas(canvas: HtmlCanvasElement*):
    canvas.cell().vtable = (const gc.CellVTable*)&html_element_vtable

test "<canvas>: the reflected size, the bitmap size and its limits, presenting without a context":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let canvas = test_elements_canvas(realm, document)
        defer test_elements_forget_canvas(canvas)
        assert(html_canvas_element_context_is_empty(canvas))
        assert(html_canvas_element_width(canvas) == 300 and html_canvas_element_height(canvas) == 150)
        let default_size = html_canvas_element_bitmap_size_for_canvas(canvas)
        assert(default_size.m_width == 300 and default_size.m_height == 150)
        let minimum_size = html_canvas_element_bitmap_size_for_canvas(canvas, 400, 10)
        assert(minimum_size.m_width == 400 and minimum_size.m_height == 150)

        html_canvas_element_set_width(canvas, 640)
        assert(test_elements_attribute_is(canvas.dom_element(), html_attribute_names_width, "640"))
        assert(html_canvas_element_width(canvas) == 640)
        html_canvas_element_set_height(canvas, 3000000000)
        assert(test_elements_attribute_is(canvas.dom_element(), html_attribute_names_height, "150"))

        # More than 16384 * 16384 pixels is refused.
        test_elements_set(canvas.dom_element(), html_attribute_names_width, "20000")
        test_elements_set(canvas.dom_element(), html_attribute_names_height, "20000")
        let refused = html_canvas_element_bitmap_size_for_canvas(canvas)
        assert(refused.m_width == 0 and refused.m_height == 0)
        test_elements_set(canvas.dom_element(), html_attribute_names_height, "16384")
        test_elements_set(canvas.dom_element(), html_attribute_names_width, "16384")
        let largest = html_canvas_element_bitmap_size_for_canvas(canvas)
        assert(largest.m_width == 16384 and largest.m_height == 16384)

        # No context: no surface, and presenting a dirty canvas clears the flag and does nothing else.
        assert(html_canvas_element_surface(canvas) == none)
        html_canvas_element_set_canvas_content_dirty(canvas)
        html_canvas_element_present(canvas)
        assert(not canvas.m_canvas_content_dirty and canvas.m_external_content_source == none)
        let source = html_canvas_element_ensure_external_content_source(canvas)
        assert(html_canvas_element_ensure_external_content_source(canvas) == source)

        # An unknown context type is the empty alternative.
        match html_canvas_element_get_context(canvas, ak.string_from_str("bitmaprenderer"), js_undefined()) else trap("get_context"):
            .empty:
                assert(html_canvas_element_context_is_empty(canvas))
            _:
                assert(false, "an unknown context type makes no context")

        # A canvas that is not connected resolves fonts against the default 10px canvas font.
        let context = html_canvas_element_canvas_font_computation_context(canvas)
        assert(gfx.css_pixels_to_int_const(&context.length_resolution_context.font_metrics.font_size) == 10)
        assert(context.abstract_element != none)

test "HTMLDocument: construction moves the GlobalEventHandlers table; create's default URL":
    let (vm, realm, document) = test_elements_setup()
    defer web_test_destroy_vm(vm)
    _ = document
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        # realm.create<HTMLDocument> without initialize (Document::initialize stops in region r26).
        let html_document = (HtmlDocument*)web_allocate_cell(realm, &html_document_class)
        html_document_construct(html_document, realm, web_url.about_blank())
        assert(html_document.document.global_event_handlers.vtable == &html_document_global_event_handlers_vtable)
        assert(html_document.cell().vtable.class_info == &html_document_class)
        assert(is_dom_document(html_document.dom_node()))
        let url = dom_document_url_string(html_document.dom_document())
        assert(ak.string_eq_string_view(&url, ak.sv("about:blank")))