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