Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / svg / tests_svg_ii.lucb

#==============================================================================================
#
#   tests_svg_ii - region r56 against the reference build: the SVG II elements
#
#   DESCRIPTION:
#       Runs the cases of tests_svg_ii_cases (a local oracle's output: the reference Ladybird
#       build on the same documents) through the port and compares, line by line, with f32
#       bits allowed test_libm_ulps apart:
#
#           grad      every gradient: units, spread method, transform, the linear and radial
#                     geometry and the stops through the href chain
#           pattern   every pattern: units, transform, x/y/width/height, the content element
#           maskclip  every mask and clipPath: units, the active viewBox, the masking area
#           fe        every filter and filter primitive: their attribute reflections
#           use       every use: x, y, its transform, the instance root, the use-element shadow
#                     tree; again after the referenced #ref is removed
#           text      every text content element: positioning, contents, the reflected lists,
#                     a textPath's path
#           a, image, fo  the SVG a, image and foreignObject reflections
#
#       The documents are tests_html_elements' (heap documents of type HTML, parsed with
#       scripting disabled, without a browsing context), as the oracle's.
#
#==============================================================================================

# mark: Output helpers ==========================================================================

## An element's local name and `#id` when it has one, or "none".
func test_svg_ii_put_name(out: ak.StringBuilder*, element: DomElement*?):
    if element == none:
        ak.string_builder_append(out, "none")
        return
    let present = element else trap("an element")
    let local_name = dom_element_local_name(present)
    ak.string_builder_append_string_view(out, ak.fly_string_bytes_as_string_view(&local_name))
    if let id = dom_element_get_attribute(present, html_attribute_names_id):
        ak.string_builder_append(out, "#")
        test_svg_put_string(out, id)

## A number-percentage: its value's bits and `%` or `n`.
func test_svg_ii_put_numpct(out: ak.StringBuilder*, value: SvgNumberPercentage):
    ak.string_builder_append(out, " ")
    test_svg_put_f32(out, svg_number_percentage_value(&value))
    ak.string_builder_append(out, "%" if svg_number_percentage_is_percentage(&value) else "n")

## `label` and an optional transform's six values, or `none`.
func test_svg_ii_put_optional_matrix(out: ak.StringBuilder*, label: str, matrix: gfx.AffineTransform?):
    ak.string_builder_append(out, label)
    if let present = matrix:
        for value in present.m_values:
            test_svg_put_word_f32(out, value)
        ak.string_builder_append(out, "\n")
    else:
        ak.string_builder_append(out, " none\n")

## `label`, a viewBox and a newline.
func test_svg_ii_put_view_box(out: ak.StringBuilder*, label: str, view_box: SvgViewBox?):
    ak.string_builder_append(out, label)
    ak.string_builder_append(out, " ")
    test_svg_put_view_box(out, view_box)
    ak.string_builder_append(out, "\n")

## `label` and an SVGAnimatedLength's base value, unit and animated value.
func test_svg_ii_put_length(out: ak.StringBuilder*, label: str, length: SvgAnimatedLength*):
    ak.string_builder_append(out, label)
    test_svg_put_word_f32(out, svg_length_value(svg_animated_length_base_val(length)))
    test_svg_append(out, f" {svg_length_unit_type(svg_animated_length_base_val(length))}")
    test_svg_put_word_f32(out, svg_length_value(svg_animated_length_anim_val(length)))
    ak.string_builder_append(out, "\n")

## `label [string]`.
func test_svg_ii_put_bracketed(out: ak.StringBuilder*, label: str, value: ak.String):
    ak.string_builder_append(out, label)
    ak.string_builder_append(out, " [")
    test_svg_put_string(out, value)
    ak.string_builder_append(out, "]\n")

## A filter primitive's standard attributes (x, y, width, height, result).
func test_svg_ii_put_standard_attributes[T](out: ak.StringBuilder*, attributes: SvgFilterPrimitiveStandardAttributes[T]*, element: SvgElement*):
    test_svg_ii_put_length(out, "  x", svg_filter_primitive_standard_attributes_x(attributes, element))
    test_svg_ii_put_length(out, "  y", svg_filter_primitive_standard_attributes_y(attributes, element))
    test_svg_ii_put_length(out, "  width", svg_filter_primitive_standard_attributes_width(attributes, element))
    test_svg_ii_put_length(out, "  height", svg_filter_primitive_standard_attributes_height(attributes, element))
    test_svg_ii_put_bracketed(out, "  result", svg_animated_string_base_val(svg_filter_primitive_standard_attributes_result(attributes, element)))

## The text of an element's name line (local name, #id).
func test_svg_ii_put_name_line(out: ak.StringBuilder*, element: DomElement*):
    test_svg_ii_put_name(out, element)
    ak.string_builder_append(out, "\n")

# mark: grad, pattern, maskclip ==================================================================

## for_each_color_stop's callback of the grad mode: ` <offset>`.
func test_svg_ii_put_stop(context: void*, stop: SvgStopElement*):
    test_svg_put_word_f32((ak.StringBuilder*)context, svg_stop_element_stop_offset(stop))

## The grad mode.
func test_svg_ii_run_gradients(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let gradient = as_if_svg_gradient_element(node) else continue
        test_svg_ii_put_name(out, gradient.dom_element())
        test_svg_append(out, f" units {(i32)svg_gradient_element_gradient_units(gradient)} spread {(i32)svg_gradient_element_spread_method(gradient)}\n")
        test_svg_ii_put_optional_matrix(out, "  transform", svg_gradient_element_gradient_transform(gradient))
        if let linear = as_if_svg_linear_gradient_element(node):
            ak.string_builder_append(out, "  linear")
            test_svg_ii_put_numpct(out, svg_linear_gradient_element_start_x(linear))
            test_svg_ii_put_numpct(out, svg_linear_gradient_element_start_y(linear))
            test_svg_ii_put_numpct(out, svg_linear_gradient_element_end_x(linear))
            test_svg_ii_put_numpct(out, svg_linear_gradient_element_end_y(linear))
            ak.string_builder_append(out, "\n")
        if let radial = as_if_svg_radial_gradient_element(node):
            ak.string_builder_append(out, "  radial")
            test_svg_ii_put_numpct(out, svg_radial_gradient_element_start_circle_x(radial))
            test_svg_ii_put_numpct(out, svg_radial_gradient_element_start_circle_y(radial))
            test_svg_ii_put_numpct(out, svg_radial_gradient_element_start_circle_radius(radial))
            test_svg_ii_put_numpct(out, svg_radial_gradient_element_end_circle_x(radial))
            test_svg_ii_put_numpct(out, svg_radial_gradient_element_end_circle_y(radial))
            test_svg_ii_put_numpct(out, svg_radial_gradient_element_end_circle_radius(radial))
            ak.string_builder_append(out, "\n")
        ak.string_builder_append(out, "  stops")
        svg_gradient_element_for_each_color_stop(gradient, test_svg_ii_put_stop, out)
        ak.string_builder_append(out, "\n  href ")
        let href = svg_svguri_reference_mixin_href(&gradient.svguri_reference_mixin, gradient.svg_element(), SvgSupportsXLinkHref.yes)
        test_svg_put_string(out, svg_animated_string_base_val(href))
        ak.string_builder_append(out, "\n")

## The pattern mode.
func test_svg_ii_run_patterns(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let pattern = as_if_svg_pattern_element(node) else continue
        test_svg_ii_put_name(out, pattern.dom_element())
        test_svg_append(out, f" units {(i32)svg_pattern_element_pattern_units(pattern)} content {(i32)svg_pattern_element_pattern_content_units(pattern)}\n")
        test_svg_ii_put_optional_matrix(out, "  transform", svg_pattern_element_pattern_transform(pattern))
        ak.string_builder_append(out, "  rect")
        test_svg_ii_put_numpct(out, svg_pattern_element_pattern_x(pattern))
        test_svg_ii_put_numpct(out, svg_pattern_element_pattern_y(pattern))
        test_svg_ii_put_numpct(out, svg_pattern_element_pattern_width(pattern))
        test_svg_ii_put_numpct(out, svg_pattern_element_pattern_height(pattern))
        ak.string_builder_append(out, "\n  content ")
        var content: DomElement*? = none
        if let content_element = svg_pattern_element_pattern_content_element(pattern):
            content = content_element.dom_element()
        test_svg_ii_put_name(out, content)
        ak.string_builder_append(out, "\n")
        test_svg_ii_put_length(out, "  x", svg_pattern_element_x(pattern))
        test_svg_ii_put_length(out, "  y", svg_pattern_element_y(pattern))
        test_svg_ii_put_length(out, "  width", svg_pattern_element_width(pattern))
        test_svg_ii_put_length(out, "  height", svg_pattern_element_height(pattern))
        test_svg_ii_put_view_box(out, "  viewbox", svg_fit_to_view_box_view_box(&pattern.svg_fit_to_view_box))

## The maskclip mode: the masks, then the clip paths.
func test_svg_ii_run_masks_and_clips(document: DomDocument*, out: ak.StringBuilder*):
    let target = gfx.CssPixelRect(m_location = gfx.CssPixelPoint(m_x = gfx.CssPixels.from_int(10), m_y = gfx.CssPixels.from_int(20)),
                                  m_size = gfx.CssPixelSize(m_width = gfx.CssPixels.from_int(100), m_height = gfx.CssPixels.from_int(50)))
    for node in dom_node_subtree(document.dom_node()):
        let mask = as_if_svg_mask_element(node) else continue
        test_svg_ii_put_name(out, mask.dom_element())
        test_svg_append(out, f" units {(i32)svg_mask_element_mask_units(mask)} content {(i32)svg_mask_element_mask_content_units(mask)}\n")
        test_svg_ii_put_view_box(out, "  active", svg_graphics_element_active_view_box(mask.svg_graphics_element()))
        let area = svg_mask_element_resolve_masking_area(mask, target)
        test_svg_append(out, f"  area {area.m_location.m_x.m_value} {area.m_location.m_y.m_value} {area.m_size.m_width.m_value} {area.m_size.m_height.m_value}\n")
    for node in dom_node_subtree(document.dom_node()):
        let clip = as_if_svg_clip_path_element(node) else continue
        test_svg_ii_put_name(out, clip.dom_element())
        test_svg_append(out, f" units {(i32)svg_clip_path_element_clip_path_units(clip)}\n")
        test_svg_ii_put_view_box(out, "  active", svg_graphics_element_active_view_box(clip.svg_graphics_element()))

# mark: fe =======================================================================================

## `label <bits> <bits>` of two numbers.
func test_svg_ii_put_pair(out: ak.StringBuilder*, label: str, first: f32, second: f32):
    ak.string_builder_append(out, label)
    test_svg_put_word_f32(out, first)
    test_svg_put_word_f32(out, second)
    ak.string_builder_append(out, "\n")

## The fe mode's lines of one filter primitive (none for an element that is not one).
func test_svg_ii_put_filter_primitive(node: DomNode*, out: ak.StringBuilder*):
    if let blend = as_if_svg_svgfe_blend_element(node):
        test_svg_ii_put_name_line(out, blend.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_blend_element_in1(blend)))
        test_svg_ii_put_bracketed(out, "  in2", svg_animated_string_base_val(svg_svgfe_blend_element_in2(blend)))
        test_svg_append(out, f"  mode {(i32)svg_svgfe_blend_element_mode(blend)} {svg_animated_enumeration_base_val(svg_svgfe_blend_element_mode_for_bindings(blend))}\n")
        test_svg_ii_put_standard_attributes(out, &blend.svg_filter_primitive_standard_attributes, blend.svg_element())
    elif let matrix = as_if_svg_svgfe_color_matrix_element(node):
        test_svg_ii_put_name_line(out, matrix.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_color_matrix_element_in1(matrix)))
        test_svg_append(out, f"  type {svg_animated_enumeration_base_val(svg_svgfe_color_matrix_element_type(matrix))}\n")
        test_svg_ii_put_bracketed(out, "  values", svg_animated_string_base_val(svg_svgfe_color_matrix_element_values(matrix)))
        test_svg_ii_put_standard_attributes(out, &matrix.svg_filter_primitive_standard_attributes, matrix.svg_element())
    elif let transfer = as_if_svg_svgfe_component_transfer_element(node):
        test_svg_ii_put_name_line(out, transfer.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_component_transfer_element_in1(transfer)))
        test_svg_ii_put_standard_attributes(out, &transfer.svg_filter_primitive_standard_attributes, transfer.svg_element())
    elif let composite = as_if_svg_svgfe_composite_element(node):
        test_svg_ii_put_name_line(out, composite.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_composite_element_in1(composite)))
        test_svg_ii_put_bracketed(out, "  in2", svg_animated_string_base_val(svg_svgfe_composite_element_in2(composite)))
        ak.string_builder_append(out, "  k")
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_composite_element_k1(composite)))
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_composite_element_k2(composite)))
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_composite_element_k3(composite)))
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_composite_element_k4(composite)))
        test_svg_append(out, f"\n  operator {(i32)svg_svgfe_composite_element_to(composite)} {svg_animated_enumeration_base_val(svg_svgfe_composite_element_to_for_bindings(composite))}\n")
        test_svg_ii_put_standard_attributes(out, &composite.svg_filter_primitive_standard_attributes, composite.svg_element())
    elif let displacement = as_if_svg_svgfe_displacement_map_element(node):
        test_svg_ii_put_name_line(out, displacement.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_displacement_map_element_in1(displacement)))
        test_svg_ii_put_bracketed(out, "  in2", svg_animated_string_base_val(svg_svgfe_displacement_map_element_in2(displacement)))
        ak.string_builder_append(out, "  scale")
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_displacement_map_element_scale(displacement)))
        let x_channel = svg_animated_enumeration_base_val(svg_svgfe_displacement_map_element_x_channel_selector(displacement))
        let y_channel = svg_animated_enumeration_base_val(svg_svgfe_displacement_map_element_y_channel_selector(displacement))
        test_svg_append(out, f"\n  channels {x_channel} {y_channel}\n")
        test_svg_ii_put_standard_attributes(out, &displacement.svg_filter_primitive_standard_attributes, displacement.svg_element())
    elif let shadow = as_if_svg_svgfe_drop_shadow_element(node):
        test_svg_ii_put_name_line(out, shadow.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_drop_shadow_element_in1(shadow)))
        test_svg_ii_put_pair(out, "  d", svg_animated_number_base_val(svg_svgfe_drop_shadow_element_dx(shadow)), svg_animated_number_base_val(svg_svgfe_drop_shadow_element_dy(shadow)))
        test_svg_ii_put_pair(out, "  std", svg_animated_number_base_val(svg_svgfe_drop_shadow_element_std_deviation_x(shadow)), svg_animated_number_base_val(svg_svgfe_drop_shadow_element_std_deviation_y(shadow)))
        test_svg_ii_put_standard_attributes(out, &shadow.svg_filter_primitive_standard_attributes, shadow.svg_element())
        svg_svgfe_drop_shadow_element_set_std_deviation(shadow, 1.25, 0.1)
        ak.string_builder_append(out, "  set [")
        test_svg_put_string(out, dom_element_get_attribute_value(shadow.dom_element(), svg_attribute_names_std_deviation))
        ak.string_builder_append(out, "]")
        test_svg_ii_put_pair(out, "", svg_animated_number_base_val(svg_svgfe_drop_shadow_element_std_deviation_x(shadow)), svg_animated_number_base_val(svg_svgfe_drop_shadow_element_std_deviation_y(shadow)))
    elif let flood = as_if_svg_svgfe_flood_element(node):
        test_svg_ii_put_name_line(out, flood.dom_element())
        test_svg_ii_put_standard_attributes(out, &flood.svg_filter_primitive_standard_attributes, flood.svg_element())
    elif let blur = as_if_svg_svgfe_gaussian_blur_element(node):
        test_svg_ii_put_name_line(out, blur.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_gaussian_blur_element_in1(blur)))
        ak.string_builder_append(out, "  std")
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_gaussian_blur_element_std_deviation_x(blur)))
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_gaussian_blur_element_std_deviation_y(blur)))
        test_svg_append(out, f" edge {svg_animated_enumeration_base_val(svg_svgfe_gaussian_blur_element_edge_mode(blur))}\n")
        test_svg_ii_put_standard_attributes(out, &blur.svg_filter_primitive_standard_attributes, blur.svg_element())
    elif let image = as_if_svg_svgfe_image_element(node):
        test_svg_ii_put_name_line(out, image.dom_element())
        let href = svg_svguri_reference_mixin_href(&image.svguri_reference_mixin, image.svg_element(), SvgSupportsXLinkHref.yes)
        test_svg_ii_put_bracketed(out, "  href", svg_animated_string_base_val(href))
        let bitmap = svg_svgfe_image_element_current_image_bitmap(image)
        ak.string_builder_append(out, "  bitmap none\n" if bitmap == none else "  bitmap yes\n")
        test_svg_ii_put_standard_attributes(out, &image.svg_filter_primitive_standard_attributes, image.svg_element())
    elif let merge = as_if_svg_svgfe_merge_element(node):
        test_svg_ii_put_name_line(out, merge.dom_element())
        test_svg_ii_put_standard_attributes(out, &merge.svg_filter_primitive_standard_attributes, merge.svg_element())
    elif let merge_node = as_if_svg_svgfe_merge_node_element(node):
        test_svg_ii_put_name_line(out, merge_node.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_merge_node_element_in1(merge_node)))
    elif let morphology = as_if_svg_svgfe_morphology_element(node):
        test_svg_ii_put_name_line(out, morphology.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_morphology_element_in1(morphology)))
        test_svg_append(out, f"  operator {(i32)svg_svgfe_morphology_element_morphology_operator(morphology)} {svg_animated_enumeration_base_val(svg_svgfe_morphology_element_to_for_bindings(morphology))}\n")
        test_svg_ii_put_pair(out, "  radius", svg_animated_number_base_val(svg_svgfe_morphology_element_radius_x(morphology)), svg_animated_number_base_val(svg_svgfe_morphology_element_radius_y(morphology)))
        test_svg_ii_put_standard_attributes(out, &morphology.svg_filter_primitive_standard_attributes, morphology.svg_element())
    elif let offset = as_if_svg_svgfe_offset_element(node):
        test_svg_ii_put_name_line(out, offset.dom_element())
        test_svg_ii_put_bracketed(out, "  in", svg_animated_string_base_val(svg_svgfe_offset_element_in1(offset)))
        test_svg_ii_put_pair(out, "  d", svg_animated_number_base_val(svg_svgfe_offset_element_dx(offset)), svg_animated_number_base_val(svg_svgfe_offset_element_dy(offset)))
        test_svg_ii_put_standard_attributes(out, &offset.svg_filter_primitive_standard_attributes, offset.svg_element())
    elif let turbulence = as_if_svg_svgfe_turbulence_element(node):
        test_svg_ii_put_name_line(out, turbulence.dom_element())
        test_svg_ii_put_pair(out, "  frequency", svg_animated_number_base_val(svg_svgfe_turbulence_element_base_frequency_x(turbulence)), svg_animated_number_base_val(svg_svgfe_turbulence_element_base_frequency_y(turbulence)))
        test_svg_append(out, f"  octaves {svg_animated_integer_base_val(svg_svgfe_turbulence_element_num_octaves(turbulence))} seed")
        test_svg_put_word_f32(out, svg_animated_number_base_val(svg_svgfe_turbulence_element_seed(turbulence)))
        let stitch = svg_animated_enumeration_base_val(svg_svgfe_turbulence_element_stitch_tiles(turbulence))
        let turbulence_type = svg_animated_enumeration_base_val(svg_svgfe_turbulence_element_type(turbulence))
        test_svg_append(out, f"\n  stitch {stitch} type {turbulence_type}\n")
        test_svg_ii_put_standard_attributes(out, &turbulence.svg_filter_primitive_standard_attributes, turbulence.svg_element())

## The fe mode: the filters, then every filter primitive.
func test_svg_ii_run_filters(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let filter = as_if_svg_filter_element(node) else continue
        test_svg_ii_put_name(out, filter.dom_element())
        test_svg_append(out, f" units {svg_animated_enumeration_base_val(svg_filter_element_filter_units(filter))} primitive {svg_animated_enumeration_base_val(svg_filter_element_primitive_units(filter))}\n")
        test_svg_ii_put_length(out, "  x", svg_filter_element_x(filter))
        test_svg_ii_put_length(out, "  width", svg_filter_element_width(filter))
    for node in dom_node_subtree(document.dom_node()):
        test_svg_ii_put_filter_primitive(node, out)

# mark: use, text, a, image, fo ==================================================================

## The use mode's lines of every use element, each headed `label`.
func test_svg_ii_put_uses(document: DomDocument*, out: ak.StringBuilder*, label: str):
    for node in dom_node_subtree(document.dom_node()):
        let use = as_if_svg_use_element(node) else continue
        ak.string_builder_append(out, label)
        ak.string_builder_append(out, " ")
        test_svg_ii_put_name_line(out, use.dom_element())
        test_svg_ii_put_length(out, "  x", svg_use_element_x(use))
        test_svg_ii_put_length(out, "  y", svg_use_element_y(use))
        test_svg_ii_put_optional_matrix(out, "  matrix", svg_graphics_element_element_transform(use.svg_graphics_element()))
        ak.string_builder_append(out, "  instance ")
        var instance: DomElement*? = none
        if let instance_root = svg_use_element_instance_root(use):
            instance = instance_root.dom_element()
        test_svg_ii_put_name(out, instance)
        let shadow = dom_element_shadow_root(use.dom_element()) else trap("a use element has its shadow root")
        let sheets = dom_shadow_root_uses_document_style_sheets(shadow)
        test_svg_append(out, f"\n  shadow {tree_node_child_count(shadow.dom_node())} sheets {1 if sheets else 0}\n")
        # shadow->for_each_in_subtree_of_type<DOM::Element>(...)
        for shadow_node in dom_node_subtree(shadow.dom_node()):
            if not is_dom_element(shadow_node):
                continue
            let element = (DomElement*)shadow_node
            ak.string_builder_append(out, "    ")
            test_svg_ii_put_name(out, element)
            if let width = dom_element_get_attribute(element, html_attribute_names_width):
                ak.string_builder_append(out, " width=")
                test_svg_put_string(out, width)
            ak.string_builder_append(out, "\n")

## The use mode: the use elements, then again after #ref is removed.
func test_svg_ii_run_uses(document: DomDocument*, out: ak.StringBuilder*):
    test_svg_ii_put_uses(document, out, "use")
    if let reference = dom_parent_node_get_element_by_id(document.dom_parent_node(), test_svg_name("ref")):
        dom_node_remove(reference.dom_node())
        test_svg_ii_put_uses(document, out, "removed")

## `  name` and the text positions: ` n<f64 bits>` for a number, ` l<serialization>` for a length-percentage.
func test_svg_ii_put_positions(out: ak.StringBuilder*, name: str, positions: const ak.Vector[SvgTextPositioningPosition]*):
    ak.string_builder_append(out, "  ")
    ak.string_builder_append(out, name)
    for position in ak.vector_span_const(positions):
        match position:
            .number(number):
                ak.string_builder_append(out, " n")
                test_svg_put_f64(out, css_syntax.number_value(&number))
            .css_length_percentage(length_percentage):
                ak.string_builder_append(out, " l")
                test_svg_put_string(out, css_percentage_or_to_string(&length_percentage.percentage_or, css_syntax.SerializationMode.normal))
    ak.string_builder_append(out, "\n")

## `  list name` and a reflected length list's values and units.
func test_svg_ii_put_length_list(out: ak.StringBuilder*, name: str, list: SvgAnimatedLengthList*):
    ak.string_builder_append(out, "  list ")
    ak.string_builder_append(out, name)
    for item in svg_list_items(&svg_animated_length_list_base_val(list).svg_list):
        test_svg_put_word_f32(out, svg_length_value(item))
        test_svg_append(out, f"/{svg_length_unit_type(item)}")
    ak.string_builder_append(out, "\n")

## The text mode.
func test_svg_ii_run_text(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let text = as_if_svg_text_content_element(node) else continue
        test_svg_ii_put_name(out, text.dom_element())
        let chars = svg_text_content_element_get_number_of_chars(text) else trap("getNumberOfChars threw")
        let contents = svg_text_content_element_text_contents(text)
        test_svg_append(out, f" chars {chars} [")
        test_svg_put_string(out, ak.utf16_string_base_to_utf8(&contents.utf16_string_base))
        ak.string_builder_append(out, "]\n")
        if let positioning = as_if_svg_text_positioning_element(node):
            let values = svg_text_positioning_element_text_positioning(positioning)
            test_svg_ii_put_positions(out, "x", &values.x)
            test_svg_ii_put_positions(out, "y", &values.y)
            test_svg_ii_put_positions(out, "dx", &values.dx)
            test_svg_ii_put_positions(out, "dy", &values.dy)
            test_svg_ii_put_length_list(out, "x", svg_text_positioning_element_x(positioning))
            test_svg_ii_put_length_list(out, "y", svg_text_positioning_element_y(positioning))
            test_svg_ii_put_length_list(out, "dx", svg_text_positioning_element_dx(positioning))
            test_svg_ii_put_length_list(out, "dy", svg_text_positioning_element_dy(positioning))
            ak.string_builder_append(out, "  rotate")
            for item in svg_list_items(&svg_animated_number_list_base_val(svg_text_positioning_element_rotate(positioning)).svg_list):
                test_svg_put_word_f32(out, svg_number_value(item))
            ak.string_builder_append(out, "\n")
        if let text_path = as_if_svg_text_path_element(node):
            ak.string_builder_append(out, "  path ")
            var path: DomElement*? = none
            if let path_or_shape = svg_text_path_element_path_or_shape(text_path):
                path = path_or_shape.dom_element()
            test_svg_ii_put_name(out, path)
            ak.string_builder_append(out, "\n")

## The a mode.
func test_svg_ii_run_anchors(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let a = as_if_svg_svga_element(node) else continue
        test_svg_ii_put_name_line(out, a.dom_element())
        test_svg_ii_put_bracketed(out, "  target", svg_animated_string_base_val(svg_svga_element_target(a)))
        let rel_list = svg_svga_element_rel_list(a)
        test_svg_append(out, f"  rel {dom_token_list_length(rel_list)} [")
        test_svg_put_string(out, dom_token_list_value(rel_list))
        let activation = dom_event_target_has_activation_behavior(a.dom_event_target())
        test_svg_append(out, f"]\n  tabindex {dom_element_default_tab_index_value(a.dom_element())} activation {1 if activation else 0}\n")
        let href = svg_svguri_reference_mixin_href(&a.svguri_reference_mixin, a.svg_element(), SvgSupportsXLinkHref.yes)
        test_svg_ii_put_bracketed(out, "  href", svg_animated_string_base_val(href))

## The image mode.
func test_svg_ii_run_images(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let image = as_if_svg_image_element(node) else continue
        test_svg_ii_put_name_line(out, image.dom_element())
        test_svg_ii_put_length(out, "  x", svg_image_element_x(image))
        test_svg_ii_put_length(out, "  y", svg_image_element_y(image))
        test_svg_ii_put_length(out, "  width", svg_image_element_width(image))
        test_svg_ii_put_length(out, "  height", svg_image_element_height(image))
        let box = svg_image_element_bounding_box(image)
        ak.string_builder_append(out, "  box")
        test_svg_put_word_f32(out, box.m_location.m_x)
        test_svg_put_word_f32(out, box.m_location.m_y)
        test_svg_put_word_f32(out, box.m_size.m_width)
        test_svg_put_word_f32(out, box.m_size.m_height)
        let available = svg_image_element_is_image_available_impl(&image.image_provider)
        test_svg_append(out, f"\n  available {1 if available else 0}\n")

## The fo mode.
func test_svg_ii_run_foreign_objects(document: DomDocument*, out: ak.StringBuilder*):
    for node in dom_node_subtree(document.dom_node()):
        let foreign_object = as_if_svg_foreign_object_element(node) else continue
        test_svg_ii_put_name_line(out, foreign_object.dom_element())
        test_svg_ii_put_length(out, "  x", svg_foreign_object_element_x(foreign_object))
        test_svg_ii_put_length(out, "  height", svg_foreign_object_element_height(foreign_object))

# mark: Running the cases ========================================================================

## Runs every case whose mode is one of `modes` and compares with the reference build.
func test_svg_ii_run_modes(modes: const str[]):
    web_initialize_strings()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    var failures = 0
    var count = 0
    # The documents and their trees live in the VM's heap (the test's own allocator is a small
    # fixed buffer).
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        for test_case in &test_svg_ii_cases:
            var selected = false
            for mode in modes:
                if test_case.mode == mode:
                    selected = true
            if not selected:
                continue
            count += 1
            var out = ak.string_builder_new()
            let document = test_html_elements_parse(realm, test_case.html)
            match test_case.mode:
                "grad": test_svg_ii_run_gradients(document, &out)
                "pattern": test_svg_ii_run_patterns(document, &out)
                "maskclip": test_svg_ii_run_masks_and_clips(document, &out)
                "fe": test_svg_ii_run_filters(document, &out)
                "use": test_svg_ii_run_uses(document, &out)
                "text": test_svg_ii_run_text(document, &out)
                "a": test_svg_ii_run_anchors(document, &out)
                "image": test_svg_ii_run_images(document, &out)
                "fo": test_svg_ii_run_foreign_objects(document, &out)
                _: trap("unknown mode")
            let actual = ak.string_builder_to_string_without_validation(&out)
            let view = ak.string_bytes_as_string_view(&actual)
            let text = (str)ak.string_view_bytes(&view)
            if test_svg_outputs_match(text, test_case.expected):
                continue
            failures += 1
            print(f"{test_case.mode} {test_case.html}\nexpected:\n{test_case.expected}actual:\n{text}")
    assert(count > 0, "no cases of the modes")
    assert(failures == 0, "cases differ from the reference build")

# mark: Oracle tests =============================================================================

test "SVG gradients and patterns: units, spread, transforms, geometry and stops through the href chain as the reference build":
    test_svg_ii_run_modes(["grad", "pattern"])

test "SVG masks, clip paths, filters and filter primitives: units, viewBoxes and attribute reflections as the reference build":
    test_svg_ii_run_modes(["maskclip", "fe"])

test "SVG use elements: the use-element shadow tree, references, cycles and removal as the reference build":
    test_svg_ii_run_modes(["use"])

test "SVG text, tspan and textPath, a, image and foreignObject as the reference build":
    test_svg_ii_run_modes(["text", "a", "image", "fo"])