dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / svg / tests_svg_2.lucb
#==============================================================================================
#
# tests_svg_2 - region r55: the SVG DOM's lists, lengths, numbers and lifetimes
#
# DESCRIPTION:
# Focused tests of the parts tests_svg's oracle cases do not reach, pinned to the C++
# logic (Ladybird has no unit tests for these files): SVGList's operations and its
# DOMExceptions, SVGLength and SVGNumber's read-only setters, SVGAnimatedEnumeration's
# TypeError, the viewBox reflection (SVGAnimatedRect, nulled while absent or invalid), the
# element factory's SVG classes and mixin tables, and a garbage collection with every
# ported SVG cell alive.
#
#==============================================================================================
# mark: Helpers ===================================================================================
## The name of the DOMException a failed call left pending.
func test_svg_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")
## Whether the pending exception is a DOMException of that name.
func test_svg_threw(name: str) -> bool:
let thrown = test_svg_take_dom_exception_name()
return ak.fly_string_eq_string_view(&thrown, ak.sv(name))
# mark: SVGList ===================================================================================
test "SVGList: length, getItem, insertItemBefore, replaceItem, removeItem, appendItem, initialize and clear":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let one = svg_number_create(realm, 1.0, SvgNumberReadOnly.no)
let two = svg_number_create(realm, 2.0, SvgNumberReadOnly.no)
let three = svg_number_create(realm, 3.0, SvgNumberReadOnly.no)
var items = ak.Vector[SvgNumber*]()
ak.vector_append_t(&items, one)
let list = svg_number_list_create_vector(realm, items, SvgReadOnlyList.no)
let svg_list = &list.svg_list
assert(svg_list_length(svg_list) == 1 and svg_list_number_of_items(svg_list) == 1)
# appendItem, insertItemBefore (an index past the end appends), replaceItem.
assert((svg_list_append_item(svg_list, two) else trap("appendItem")) == two)
assert((svg_list_insert_item_before(svg_list, three, 0) else trap("insertItemBefore")) == three)
assert((svg_list_insert_item_before(svg_list, one, 99) else trap("insertItemBefore")) == one)
assert(svg_list_length(svg_list) == 4)
assert((svg_list_get_item(svg_list, 0) else trap("getItem")) == three)
assert((svg_list_get_item(svg_list, 3) else trap("getItem")) == one)
assert((svg_list_replace_item(svg_list, two, 3) else trap("replaceItem")) == two)
assert(svg_list_items(svg_list)[3] == two)
# removeItem answers the removed item.
assert((svg_list_remove_item(svg_list, 0) else trap("removeItem")) == three)
assert(svg_list_length(svg_list) == 3)
assert(svg_list_items(svg_list)[0] == one)
# Out of range indices throw IndexSizeError.
var failed = false
_ = svg_list_get_item(svg_list, 3) catch:
failed = true
recover one
assert(failed and test_svg_threw("IndexSizeError"))
failed = false
_ = svg_list_replace_item(svg_list, one, 7) catch:
failed = true
recover one
assert(failed and test_svg_threw("IndexSizeError"))
failed = false
_ = svg_list_remove_item(svg_list, 3) catch:
failed = true
recover one
assert(failed and test_svg_threw("IndexSizeError"))
# initialize replaces the items with one, clear empties the list.
assert((svg_list_initialize(svg_list, two) else trap("initialize")) == two)
assert(svg_list_length(svg_list) == 1)
svg_list_clear(svg_list) else trap("clear")
assert(svg_list_length(svg_list) == 0)
test "SVGList: a read-only list throws NoModificationAllowedError from every modification but getItem":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let length = svg_length_create(realm, 1, 5.0, SvgLengthReadOnly.yes)
var items = ak.Vector[SvgLength*]()
ak.vector_append_t(&items, length)
let list = svg_length_list_create_vector(realm, items, SvgReadOnlyList.yes)
let svg_list = &list.svg_list
assert(svg_list_read_only(svg_list) == SvgReadOnlyList.yes)
assert((svg_list_get_item(svg_list, 0) else trap("getItem")) == length)
var failures = 0
_ = svg_list_append_item(svg_list, length) catch:
failures += 1
recover length
assert(test_svg_threw("NoModificationAllowedError"))
_ = svg_list_insert_item_before(svg_list, length, 0) catch:
failures += 1
recover length
assert(test_svg_threw("NoModificationAllowedError"))
_ = svg_list_replace_item(svg_list, length, 0) catch:
failures += 1
recover length
assert(test_svg_threw("NoModificationAllowedError"))
_ = svg_list_remove_item(svg_list, 0) catch:
failures += 1
recover length
assert(test_svg_threw("NoModificationAllowedError"))
_ = svg_list_initialize(svg_list, length) catch:
failures += 1
recover length
assert(test_svg_threw("NoModificationAllowedError"))
svg_list_clear(svg_list) catch:
failures += 1
recover ()
assert(test_svg_threw("NoModificationAllowedError"))
assert(failures == 6)
assert(svg_list_length(svg_list) == 1)
# The empty-list constructor of each list type.
let transforms = svg_transform_list_create_svg_read_only_list(realm, SvgReadOnlyList.no)
assert(svg_list_length(&transforms.svg_list) == 0)
let transform = svg_svg_transform_create(realm)
assert((svg_list_append_item(&transforms.svg_list, transform) else trap("appendItem")) == transform)
assert(svg_svg_transform_type(transform) == SvgTransformType.unknown and svg_svg_transform_angle(transform) == 0.0)
# mark: Values ====================================================================================
test "SVGLength, SVGNumber and SVGAnimatedEnumeration: setters and their exceptions":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
# Setting a length makes it a unitless <number>.
let length = svg_length_create(realm, (u8)svg_length_svg_lengthtype_px, 3.0, SvgLengthReadOnly.no)
svg_length_set_value(length, 4.5) else trap("set_value")
assert(svg_length_value(length) == 4.5 and svg_length_unit_type(length) == (u8)svg_length_svg_lengthtype_number)
let read_only_length = svg_length_create(realm, (u8)svg_length_svg_lengthtype_px, 3.0, SvgLengthReadOnly.yes)
var failed = false
svg_length_set_value(read_only_length, 4.5) catch:
failed = true
recover ()
assert(failed and test_svg_threw("NoModificationAllowedError"))
assert(svg_length_value(read_only_length) == 3.0 and svg_length_unit_type(read_only_length) == (u8)svg_length_svg_lengthtype_px)
let number = svg_number_create(realm, 1.0, SvgNumberReadOnly.no)
svg_number_set_value(number, -2.0) else trap("set_value")
assert(svg_number_value(number) == -2.0)
let read_only_number = svg_number_create(realm, 1.0, SvgNumberReadOnly.yes)
failed = false
svg_number_set_value(read_only_number, -2.0) catch:
failed = true
recover ()
assert(failed and test_svg_threw("NoModificationAllowedError"))
# An animated length's two lengths are distinct; animVal is read only.
let animated = svg_animated_length_create(realm, length, read_only_length)
assert(svg_animated_length_base_val(animated) == length and svg_animated_length_anim_val(animated) == read_only_length)
# baseVal 0 is a TypeError; others are kept.
let enumeration = svg_animated_enumeration_create(realm, 2)
svg_animated_enumeration_set_base_val(enumeration, 3) else trap("set_base_val")
assert(svg_animated_enumeration_base_val(enumeration) == 3 and svg_animated_enumeration_anim_val(enumeration) == 3)
failed = false
svg_animated_enumeration_set_base_val(enumeration, 0) catch:
failed = true
recover ()
assert(failed)
match idl_take_pending_exception():
.idl_simple_exception(exception): assert(exception.type_ == IdlSimpleExceptionType.type_error)
_: trap("expected a TypeError")
assert(svg_animated_enumeration_base_val(enumeration) == 3)
# mark: Elements ==================================================================================
test "SVG elements: the factory's classes, their mixin tables, the viewBox reflection and a collection":
web_initialize_strings()
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let document = test_html_elements_parse(realm, "<!DOCTYPE html><svg viewBox='1 2 3 4'><view id=v viewBox='0 0 5 5'></view><g><rect/><circle/><ellipse/><line/><polyline/><polygon/><path d='M0 0'/></g><defs/><desc/><title/><metadata/><script></script></svg>")
let svg = as_svg_svgsvg_element(test_html_elements_first(document, "svg"))
assert(is_svg_graphics_element(svg) and is_svg_element(svg))
assert(dom_node_requires_svg_container(svg.dom_node()) == false and dom_node_is_svg_container(svg.dom_node()))
assert(dom_node_is_svg_svg_element(svg.dom_node()) and dom_node_is_svg_element(svg.dom_node()) and dom_node_is_svg_graphics_element(svg.dom_node()))
assert(svg.svg_fit_to_view_box.vtable == &svg_svgsvg_element_svg_fit_to_view_box_vtable)
assert(svg.svg_fit_to_view_box.class_id == svg.cell().class_id)
assert(svg.svg_element().global_event_handlers.vtable == &svg_svgsvg_element_global_event_handlers_vtable)
assert(svg.svg_element().element.aria_mixin.vtable == &svg_svgsvg_element_aria_mixin_vtable)
# GlobalEventHandlers answers the element as its event target.
let target = html_global_event_handlers_global_event_handlers_to_event_target(&svg.svg_element().global_event_handlers, ak.fly_string_from_str("click")) else trap("an event target")
assert(target == svg.dom_event_target())
for tag in ["rect", "circle", "ellipse", "line", "polyline", "polygon", "path"]:
let element = test_html_elements_first(document, tag)
assert(is_svg_geometry_element(element))
assert(dom_node_requires_svg_container(element.dom_node()))
assert(is_svg_svgg_element(test_html_elements_first(document, "g")) and dom_node_is_svg_g_element(test_html_elements_first(document, "g").dom_node()))
assert(is_svg_defs_element(test_html_elements_first(document, "defs")))
assert(is_svg_desc_element(test_html_elements_first(document, "desc")))
assert(is_svg_title_element(test_html_elements_first(document, "title")))
assert(is_svg_metadata_element(test_html_elements_first(document, "metadata")))
# (A connected style element needs a window: the CSP check of its style block.)
let style = dom_create_element(document, svg_tag_names_style, namespace_svg) else trap("MUST: create_element")
assert(is_svg_style_element(style) and dom_node_is_svg_style_element(style.dom_node()))
let style_element = as_svg_style_element(style)
assert(svg_style_element_as_element_impl(&style_element.style_element_base) == style)
let script = as_svg_script_element(test_html_elements_first(document, "script"))
assert(svg_script_element_is_parser_inserted(script) and not script.m_already_processed)
let view = as_svg_view_element(test_html_elements_first(document, "view"))
assert(dom_node_is_svg_view_element(view.dom_node()))
# ownerSVGElement and viewportElement.
let rect = as_svg_element(test_html_elements_first(document, "rect"))
assert(svg_element_owner_svg_element(rect) == svg)
assert(svg_element_viewport_element(rect) == svg.svg_element())
assert(svg_element_owner_svg_element(svg.svg_element()) == none)
# The viewBox reflection: the base and animated rects, nulled while the attribute is absent or invalid.
let reflection = svg_fit_to_view_box_view_box_for_bindings(&svg.svg_fit_to_view_box)
let base_rect = svg_animated_rect_base_val(reflection) else trap("a reflected viewBox")
assert(geometry_dom_rect_read_only_x(base_rect) == 1.0 and geometry_dom_rect_read_only_y(base_rect) == 2.0)
assert(geometry_dom_rect_read_only_width(base_rect) == 3.0 and geometry_dom_rect_read_only_height(base_rect) == 4.0)
let anim_rect = svg_animated_rect_anim_val(reflection) else trap("a reflected viewBox")
assert(anim_rect != base_rect and geometry_dom_rect_read_only_height(anim_rect) == 4.0)
dom_element_set_attribute_value(svg.dom_element(), svg_attribute_names_view_box, ak.string_from_str("nonsense"))
assert(svg_animated_rect_base_val(reflection) == none and svg_fit_to_view_box_view_box(&svg.svg_fit_to_view_box) == none)
dom_element_set_attribute_value(svg.dom_element(), svg_attribute_names_view_box, ak.string_from_str("0 0 10 20"))
let reset_rect = svg_animated_rect_base_val(reflection) else trap("a reflected viewBox")
assert(reset_rect == base_rect and geometry_dom_rect_read_only_height(reset_rect) == 20.0)
dom_element_remove_attribute(svg.dom_element(), svg_attribute_names_view_box)
assert(svg_animated_rect_base_val(reflection) == none)
# The parsed viewBox is kept while the reflection is nulled (as the donor's).
assert(svg_fit_to_view_box_view_box(&svg.svg_fit_to_view_box) != none)
# The active view element: its viewBox wins.
svg_svgsvg_element_set_active_view_element(svg, view)
let active = svg_graphics_element_active_view_box(svg.svg_graphics_element()) else trap("an active viewBox")
assert(active.width == 5.0 and active.height == 5.0)
# The lazily made animated values survive a collection, as the document does.
let class_name = svg_element_class_name(svg.svg_element())
let path_length = svg_geometry_element_path_length(as_svg_geometry_element(rect))
let href = svg_svguri_reference_mixin_href(&script.svguri_reference_mixin, script.svg_element(), SvgSupportsXLinkHref.yes)
gc.heap_collect_garbage(vm_heap(vm))
assert(svg_element_class_name(svg.svg_element()) == class_name)
assert(svg_geometry_element_path_length(as_svg_geometry_element(rect)) == path_length)
assert(svg_animated_number_base_val(path_length) == 0.0)
assert(svg_svguri_reference_mixin_href(&script.svguri_reference_mixin, script.svg_element(), SvgSupportsXLinkHref.yes) == href)
assert(svg_fit_to_view_box_view_box_for_bindings(&svg.svg_fit_to_view_box) == reflection)
assert(svg_geometry_element_get_total_length(as_svg_geometry_element(rect)) == 0.0)