Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

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