dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / 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"])