Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / html / tests_form_controls.lucb

#==============================================================================================
#
#   tests_form_controls - regions r24/r25's form controls end to end, against the reference build
#
#   DESCRIPTION:
#       Runs the cases of tests_form_controls_cases (a local oracle's output: the reference
#       Ladybird build on the same inputs) through the port and compares:
#
#           input      every input's type, value (sanitized), checkedness and flags after parsing
#           set        the value setter of each value mode, then the inputs
#           attr       setting or removing an attribute (value, checked, type, multiple, min,
#                      max, step), then the inputs
#           num        valueAsNumber, the minimum, maximum, allowed value step and step base,
#                      reversed ranges and the suffering-from states of constraint validation
#           step       stepUp()/stepDown()
#           setnum     valueAsNumber's setter
#           numstr     converting a number to a string, per type
#           strnum     converting a string to a number, per type
#           checked    the checked setter and radio button groups
#           select     a select's selectedIndex, value, type, length, size, selected options and
#                      its list of options (index, selectedness, disabled, label, text, value)
#           selectset  selectedIndex and value's setters
#           optsel     an option's selected setter (the selectedness setting algorithm)
#           textarea   a textarea's value, defaultValue, textLength, cols, rows and maxLength
#           taset      a textarea's value setter
#           selection  setSelectionRange on an input or a textarea (and the stringifier)
#           rangetext  setRangeText in each selection mode
#           meter      a meter's value, minimum, maximum, boundaries, optimum and value state
#           progress   a progress element's value, maximum and position
#           button     a button's type, submit-buttonness, value and command
#           validity   suffering from being missing and mutability of textareas and selects
#           role       the default ARIA role (as its enum value)
#           shadow     the user-agent shadow tree (tags, attributes, pseudo-elements, inline
#                      styles and text)
#
#       Documents are web_test_create_document's (page/tests_page) of type HTML, parsed with
#       scripting disabled (tests_html_elements' helpers). A case's markup may instead be a
#       detached spec, "@<tag> <attributes>[|<children>]": the element is made with
#       DOM::create_element and never inserted, so it has no user-agent shadow tree.
#
#==============================================================================================

# mark: Helpers ==================================================================================

## Appends `text` as one line: \n, \r, \t and \\ escaped (the oracle's esc).
func test_form_controls_append_escaped(builder: ak.StringBuilder*, text: ak.StringView):
    for byte in ak.string_view_bytes(&text):
        if byte == '\n':
            ak.string_builder_append(builder, "\\n")
        elif byte == '\r':
            ak.string_builder_append(builder, "\\r")
        elif byte == '\t':
            ak.string_builder_append(builder, "\\t")
        elif byte == '\\':
            ak.string_builder_append(builder, "\\\\")
        else:
            ak.string_builder_append_u8(builder, byte)

## Appends a String escaped.
func test_form_controls_append_string(builder: ak.StringBuilder*, text: ak.String):
    test_form_controls_append_escaped(builder, ak.string_bytes_as_string_view(&text))

## Appends a Utf16String escaped.
func test_form_controls_append_utf16(builder: ak.StringBuilder*, text: ak.Utf16String):
    test_form_controls_append_string(builder, ak.utf16_string_base_to_utf8_but_should_be_ported_to_utf16(&text.utf16_string_base))

## Appends a double as AK's "{}" formats it.
func test_form_controls_append_number(builder: ak.StringBuilder*, value: f64):
    ak.format_f64(builder, value)

## Appends an optional double, or "none".
func test_form_controls_append_optional(builder: ak.StringBuilder*, value: f64?):
    if let number = value:
        ak.format_f64(builder, number)
    else:
        ak.string_builder_append(builder, "none")

## Appends "1" or "0".
func test_form_controls_append_bool(builder: ak.StringBuilder*, value: bool):
    ak.string_builder_append(builder, "1" if value else "0")

## Appends an integer.
func test_form_controls_append_integer(builder: ak.StringBuilder*, value: i64):
    ak.format_i64(builder, value)

## Appends "exception <name>" for the pending exception of a failed ExceptionOr.
func test_form_controls_append_exception(builder: ak.StringBuilder*):
    ak.string_builder_append(builder, "exception ")
    match idl_take_pending_exception():
        .idl_dom_exception(exception):
            html_parser_append_fly_string(builder, idl_dom_exception_name(exception))
        _:
            ak.string_builder_append(builder, "simple")
    ak.string_builder_append(builder, "\n")

## A Utf16String of a test string.
func test_form_controls_utf16(text: str) -> ak.Utf16String:
    return ak.utf16_string_from_utf8_string_view(ak.sv(text))

## The document of a case and its detached subject element (the oracle's Subject).
struct TestFormControlsSubject:
    var document: DomDocument*
    var detached: DomElement*?

## The attributes of "name=value name=\"a value\" name", set in order on `element`.
func test_form_controls_set_attributes(element: DomElement*, text: str):
    let bytes = text.bytes
    var i: usize = 0
    while i < bytes.length:
        while i < bytes.length and bytes[i] == ' ':
            i += 1
        if i >= bytes.length:
            break
        let name_start = i
        while i < bytes.length and bytes[i] != ' ' and bytes[i] != '=':
            i += 1
        let name = (str)bytes[name_start..<i]
        var value: str = ""
        if i < bytes.length and bytes[i] == '=':
            i += 1
            if i < bytes.length and bytes[i] == '"':
                i += 1
                let value_start = i
                while i < bytes.length and bytes[i] != '"':
                    i += 1
                value = (str)bytes[value_start..<i]
                i += 1
            else:
                let value_start = i
                while i < bytes.length and bytes[i] != ' ':
                    i += 1
                value = (str)bytes[value_start..<i]
        dom_element_set_attribute_value(element, ak.fly_string_from_str(name), ak.string_from_str(value))

## The subject of a case's markup: a parsed document, or for "@<tag> <attributes>[|<children>]" a
## <tag> made with DOM::create_element in a document parsed from "<div>children</div>", its
## attributes set in order and the div's children moved into it (never inserted, so without a
## user-agent shadow tree).
func test_form_controls_make_subject(realm: Realm*, spec: str) -> TestFormControlsSubject:
    let bytes = spec.bytes
    if bytes.length == 0 or bytes[0] != '@':
        return TestFormControlsSubject(document = test_html_elements_parse(realm, spec), detached = none)
    var bar = bytes.length
    for (index, byte) in bytes.indexed():
        if byte == '|':
            bar = index
            break
    let head = (str)bytes[1..<bar]
    let children = (str)bytes[bar + 1..] if bar < bytes.length else ""
    var builder = ak.string_builder_new()
    ak.string_builder_append(&builder, "<div>")
    ak.string_builder_append(&builder, children)
    ak.string_builder_append(&builder, "</div>")
    let markup = ak.string_builder_to_string_without_validation(&builder)
    let document = test_html_elements_parse(realm, ak.string_view_text(ak.string_bytes_as_string_view(&markup)))
    let head_bytes = head.bytes
    var space = head_bytes.length
    for (index, byte) in head_bytes.indexed():
        if byte == ' ':
            space = index
            break
    let element = dom_create_element(document, ak.fly_string_from_str((str)head_bytes[..<space]), namespace_html) else trap("MUST: create_element")
    if space < head_bytes.length:
        test_form_controls_set_attributes(element, (str)head_bytes[space + 1..])
    let div = test_html_elements_first(document, "div")
    while let child = div.dom_node().tree_node.m_first_child:
        _ = dom_node_append_child(element.dom_node(), child) else trap("MUST: append_child")
    return TestFormControlsSubject(document = document, detached = element)

## The subject element: the detached one (or its first <tag> descendant), or the document's first <tag>.
func test_form_controls_subject_element(subject: const TestFormControlsSubject*, tag: str) -> DomElement*:
    if let detached = subject.detached:
        let name = ak.fly_string_from_str(tag)
        let local_name = dom_element_local_name(detached)
        if ak.fly_string_eq_fly_string(&local_name, &name):
            return detached
        for node in dom_node_subtree(detached.dom_node()):
            if let element = as_if_dom_element(node):
                let element_name = dom_element_local_name(element)
                if ak.fly_string_eq_fly_string(&element_name, &name):
                    return element
        trap("no element of that name")
    return test_html_elements_first(subject.document, tag)

## The subject's first input or textarea, as its text control.
func test_form_controls_first_text_control(subject: const TestFormControlsSubject*) -> HtmlFormAssociatedTextControlElement*:
    if let detached = subject.detached:
        if let input = as_if_html_input_element(detached):
            return &input.form_associated_text_control_element
        return &as_html_text_area_element(detached).form_associated_text_control_element
    for node in dom_node_subtree(subject.document.dom_node()):
        if let input = as_if_html_input_element(node):
            return &input.form_associated_text_control_element
        if let textarea = as_if_html_text_area_element(node):
            return &textarea.form_associated_text_control_element
    trap("no text control")

## The subject's inputs: the detached one, or every input of the document in tree order.
func test_form_controls_inputs(subject: const TestFormControlsSubject*) -> ak.Vector[HtmlInputElement*]:
    var list = ak.Vector[HtmlInputElement*]()
    if let detached = subject.detached:
        ak.vector_append_t(&list, as_html_input_element(detached))
        return list
    for node in dom_node_subtree(subject.document.dom_node()):
        if let input = as_if_html_input_element(node):
            ak.vector_append_t(&list, input)
    return list

## A detached `<input type="type">` (the oracle's `make_subject("@input type=" + type)`).
func test_form_controls_detached_input_of_type(realm: Realm*, type_: str) -> TestFormControlsSubject:
    var builder = ak.string_builder_new()
    ak.string_builder_append(&builder, "@input type=")
    ak.string_builder_append(&builder, type_)
    let spec = ak.string_builder_to_string_without_validation(&builder)
    return test_form_controls_make_subject(realm, ak.string_view_text(ak.string_bytes_as_string_view(&spec)))

## Parses a decimal integer argument.
func test_form_controls_integer(text: str) -> i64:
    let view = ak.sv(text)
    return ak.string_view_to_number_i64(&view) else trap("not an integer")

## Parses a floating-point argument (std::stod).
func test_form_controls_double(text: str) -> f64:
    let view = ak.sv(text)
    return ak.string_view_to_number_f64(&view) else trap("not a number")

# mark: Dumps ====================================================================================

## Every input's type, value, checkedness, indeterminateness and dirty value flag.
func test_form_controls_dump_inputs(out: ak.StringBuilder*, subject: const TestFormControlsSubject*):
    var inputs = test_form_controls_inputs(subject)
    for input in ak.vector_span(&inputs):
        ak.string_builder_append(out, "type=")
        test_form_controls_append_escaped(out, html_input_element_type(input))
        ak.string_builder_append(out, " value=")
        test_form_controls_append_utf16(out, html_input_element_value(input))
        ak.string_builder_append(out, " checked=")
        test_form_controls_append_bool(out, html_input_element_checked(input))
        ak.string_builder_append(out, " indeterminate=")
        test_form_controls_append_bool(out, html_input_element_indeterminate(input))
        ak.string_builder_append(out, " dirty=")
        test_form_controls_append_bool(out, input.m_dirty_value)
        ak.string_builder_append(out, "\n")

## Every input's checkedness on one line.
func test_form_controls_dump_checked(out: ak.StringBuilder*, subject: const TestFormControlsSubject*):
    var inputs = test_form_controls_inputs(subject)
    for input in ak.vector_span(&inputs):
        test_form_controls_append_bool(out, html_input_element_checked(input))
    ak.string_builder_append(out, "\n")

## A select's state and its list of options.
func test_form_controls_dump_select(out: ak.StringBuilder*, select: HtmlSelectElement*):
    ak.string_builder_append(out, "selectedIndex=")
    test_form_controls_append_integer(out, (i64)html_select_element_selected_index(select))
    ak.string_builder_append(out, " value=")
    test_form_controls_append_utf16(out, html_select_element_value(select))
    ak.string_builder_append(out, " type=")
    test_form_controls_append_string(out, html_select_element_type(select))
    ak.string_builder_append(out, " length=")
    test_form_controls_append_integer(out, (i64)html_select_element_length(select))
    ak.string_builder_append(out, " size=")
    test_form_controls_append_integer(out, (i64)html_select_element_size(select))
    ak.string_builder_append(out, " selectedOptions=")
    test_form_controls_append_integer(out, (i64)dom_html_collection_length(html_select_element_selected_options(select)))
    ak.string_builder_append(out, "\n")
    var options = html_select_element_list_of_options(select)
    for maybe_option in ak.vector_span(&options):
        let option = maybe_option else trap("null option")
        ak.string_builder_append(out, "option index=")
        test_form_controls_append_integer(out, (i64)html_option_element_index(option))
        ak.string_builder_append(out, " selected=")
        test_form_controls_append_bool(out, html_option_element_selected(option))
        ak.string_builder_append(out, " disabled=")
        test_form_controls_append_bool(out, html_option_element_disabled(option))
        ak.string_builder_append(out, " label=")
        test_form_controls_append_string(out, html_option_element_label(option))
        ak.string_builder_append(out, " text=")
        test_form_controls_append_utf16(out, html_option_element_text(option))
        ak.string_builder_append(out, " value=")
        test_form_controls_append_utf16(out, html_option_element_value(option))
        ak.string_builder_append(out, "\n")

## A textarea's value, default value, text length, cols, rows, maxLength and dirty value flag.
func test_form_controls_dump_textarea(out: ak.StringBuilder*, textarea: HtmlTextAreaElement*):
    ak.string_builder_append(out, "value=")
    test_form_controls_append_utf16(out, html_text_area_element_value(textarea))
    ak.string_builder_append(out, " defaultValue=")
    test_form_controls_append_utf16(out, html_text_area_element_default_value(textarea))
    ak.string_builder_append(out, " textLength=")
    test_form_controls_append_integer(out, (i64)html_text_area_element_text_length(textarea))
    ak.string_builder_append(out, " cols=")
    test_form_controls_append_integer(out, (i64)html_text_area_element_cols(textarea))
    ak.string_builder_append(out, " rows=")
    test_form_controls_append_integer(out, (i64)html_text_area_element_rows(textarea))
    ak.string_builder_append(out, " maxLength=")
    test_form_controls_append_integer(out, (i64)html_text_area_element_max_length(textarea))
    ak.string_builder_append(out, " dirty=")
    test_form_controls_append_bool(out, textarea.m_dirty_value)
    ak.string_builder_append(out, "\n")

## A text control's relevant value, selection, direction and selected text.
func test_form_controls_dump_selection(out: ak.StringBuilder*, control: HtmlFormAssociatedTextControlElement*):
    ak.string_builder_append(out, "value=")
    test_form_controls_append_utf16(out, html_form_associated_text_control_element_relevant_value(control))
    ak.string_builder_append(out, " start=")
    test_form_controls_append_integer(out, (i64)html_form_associated_text_control_element_selection_start(control))
    ak.string_builder_append(out, " end=")
    test_form_controls_append_integer(out, (i64)html_form_associated_text_control_element_selection_end(control))
    ak.string_builder_append(out, " direction=")
    if let direction = html_form_associated_text_control_element_selection_direction(control):
        test_form_controls_append_string(out, direction)
    else:
        ak.string_builder_append(out, "null")
    ak.string_builder_append(out, " selected=")
    if let selected = html_form_associated_text_control_element_selected_text_for_stringifier(control):
        test_form_controls_append_utf16(out, selected)
    else:
        ak.string_builder_append(out, "none")
    ak.string_builder_append(out, "\n")

## Dumps a node of a shadow tree: an element's tag (svg-prefixed), its pseudo-element, sorted
## attributes and inline style, or a text node's data.
func test_form_controls_dump_shadow_node(out: ak.StringBuilder*, node: DomNode*, level: usize):
    parser_test_dump_indent(out, level)
    if let element = as_if_dom_element(node):
        ak.string_builder_append(out, "<")
        if let namespace_uri = dom_element_namespace_uri(element):
            if ak.fly_string_eq_fly_string(&namespace_uri, &namespace_svg):
                ak.string_builder_append(out, "svg ")
        html_parser_append_fly_string(out, dom_element_local_name(element))
        ak.string_builder_append(out, ">")
        if let pseudo = dom_element_use_pseudo_element(element):
            ak.string_builder_append(out, " ::")
            ak.string_builder_append_string_view(out, css_data.pseudo_element_name(pseudo))
        ak.string_builder_append(out, "\n")
        var lines = ak.Vector[ak.String]()
        for attribute in dom_element_attribute_span(element):
            var line = ak.string_builder_new()
            html_parser_append_fly_string(&line, dom_attr_local_name(attribute))
            ak.string_builder_append(&line, "=\"")
            test_form_controls_append_string(&line, dom_attr_value(attribute))
            ak.string_builder_append(&line, "\"")
            ak.vector_append_t(&lines, ak.string_builder_to_string_without_validation(&line))
        ak.quick_sort_t_collection_t_less_than(ak.vector_span(&lines), ak.Function2[const ak.String*, const ak.String*, bool](call = test_form_controls_string_less, context = none))
        for line in ak.vector_span(&lines):
            parser_test_dump_indent(out, level + 1)
            html_parser_append_string(out, line)
            ak.string_builder_append(out, "\n")
        if let inline_style = dom_element_inline_style(element):
            parser_test_dump_indent(out, level + 1)
            ak.string_builder_append(out, "style: ")
            test_form_controls_append_string(out, css_style_declaration_serialized(inline_style.css_style_declaration()))
            ak.string_builder_append(out, "\n")
        for child in dom_node_children(node):
            test_form_controls_dump_shadow_node(out, child, level + 1)
        return
    if let text = as_if_dom_text(node):
        ak.string_builder_append(out, "\"")
        test_form_controls_append_utf16(out, dom_character_data_data(text.dom_character_data()))
        ak.string_builder_append(out, "\"\n")
        return
    ak.string_builder_append(out, "?\n")

## std::sort's order of the attribute lines (bytes).
func test_form_controls_string_less(context: void*?, a: const ak.String*, b: const ak.String*) -> bool:
    _ = context
    return ak.string_cmp(a, b) < 0

# mark: Running a case ===========================================================================

## The port's output for one case, in the oracle's format.
func test_form_controls_run(realm: Realm*, test_case: const TestFormControlsCase*) -> ak.String:
    var out = ak.string_builder_new()
    let mode = test_case.mode
    let arguments = test_case.arguments
    if mode == "input":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        test_form_controls_dump_inputs(&out, &subject)
    elif mode == "set":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        html_input_element_set_value(input, test_form_controls_utf16(arguments[1])) catch:
            test_form_controls_append_exception(&out)
        test_form_controls_dump_inputs(&out, &subject)
    elif mode == "attr":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        let name = ak.fly_string_from_str(arguments[1])
        if arguments[2] == "!":
            dom_element_remove_attribute(input.dom_element(), name)
        else:
            dom_element_set_attribute_value(input.dom_element(), name, ak.string_from_str(arguments[2]))
        test_form_controls_dump_inputs(&out, &subject)
    elif mode == "num":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        let base = &input.html_element_base.form_associated_element
        ak.string_builder_append(&out, "valueAsNumber=")
        test_form_controls_append_number(&out, html_input_element_value_as_number(input))
        ak.string_builder_append(&out, " min=")
        test_form_controls_append_optional(&out, html_input_element_min(input))
        ak.string_builder_append(&out, " max=")
        test_form_controls_append_optional(&out, html_input_element_max(input))
        ak.string_builder_append(&out, " step=")
        test_form_controls_append_optional(&out, html_input_element_allowed_value_step(input))
        ak.string_builder_append(&out, " stepBase=")
        test_form_controls_append_number(&out, html_input_element_step_base(input))
        ak.string_builder_append(&out, " reversed=")
        test_form_controls_append_bool(&out, html_input_element_has_reversed_range(input))
        ak.string_builder_append(&out, " underflow=")
        test_form_controls_append_bool(&out, html_input_element_suffering_from_an_underflow_impl(base))
        ak.string_builder_append(&out, " overflow=")
        test_form_controls_append_bool(&out, html_input_element_suffering_from_an_overflow_impl(base))
        ak.string_builder_append(&out, " stepMismatch=")
        test_form_controls_append_bool(&out, html_input_element_suffering_from_a_step_mismatch_impl(base))
        ak.string_builder_append(&out, " typeMismatch=")
        test_form_controls_append_bool(&out, html_input_element_suffering_from_a_type_mismatch_impl(base))
        ak.string_builder_append(&out, " patternMismatch=")
        test_form_controls_append_bool(&out, html_input_element_suffering_from_a_pattern_mismatch_impl(base))
        ak.string_builder_append(&out, " missing=")
        test_form_controls_append_bool(&out, html_input_element_suffering_from_being_missing_impl(base))
        ak.string_builder_append(&out, "\n")
    elif mode == "step":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        let n = (i32)test_form_controls_integer(arguments[2])
        if arguments[1] == "up":
            html_input_element_step_up(input, n) catch:
                test_form_controls_append_exception(&out)
        else:
            html_input_element_step_down(input, n) catch:
                test_form_controls_append_exception(&out)
        test_form_controls_dump_inputs(&out, &subject)
    elif mode == "setnum":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        html_input_element_set_value_as_number(input, test_form_controls_double(arguments[1])) catch:
            test_form_controls_append_exception(&out)
        test_form_controls_dump_inputs(&out, &subject)
    elif mode == "numstr":
        let subject = test_form_controls_detached_input_of_type(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        test_form_controls_append_utf16(&out, html_input_element_convert_number_to_string(input, test_form_controls_double(arguments[1])))
        ak.string_builder_append(&out, "\n")
    elif mode == "strnum":
        let subject = test_form_controls_detached_input_of_type(realm, arguments[0])
        let input = as_html_input_element(test_form_controls_subject_element(&subject, "input"))
        test_form_controls_append_optional(&out, html_input_element_convert_string_to_number_string_view(input, ak.sv(arguments[1])))
        ak.string_builder_append(&out, "\n")
    elif mode == "checked":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        var inputs = test_form_controls_inputs(&subject)
        html_input_element_set_checked_binding(ak.vector_span(&inputs)[(usize)test_form_controls_integer(arguments[1])], arguments[2] == "1")
        test_form_controls_dump_checked(&out, &subject)
    elif mode == "select":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        test_form_controls_dump_select(&out, as_html_select_element(test_form_controls_subject_element(&subject, "select")))
    elif mode == "selectset":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let select = as_html_select_element(test_form_controls_subject_element(&subject, "select"))
        if arguments[1] == "index":
            html_select_element_set_selected_index(select, (i32)test_form_controls_integer(arguments[2])) else trap("MUST: set_selected_index")
        else:
            html_select_element_set_value(select, test_form_controls_utf16(arguments[2])) else trap("MUST: set_value")
        test_form_controls_dump_select(&out, select)
    elif mode == "optsel":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let select = as_html_select_element(test_form_controls_subject_element(&subject, "select"))
        var options = html_select_element_list_of_options(select)
        let option = ak.vector_span(&options)[(usize)test_form_controls_integer(arguments[1])] else trap("null option")
        html_option_element_set_selected(option, arguments[2] == "1")
        test_form_controls_dump_select(&out, select)
    elif mode == "textarea":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        test_form_controls_dump_textarea(&out, as_html_text_area_element(test_form_controls_subject_element(&subject, "textarea")))
    elif mode == "taset":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let textarea = as_html_text_area_element(test_form_controls_subject_element(&subject, "textarea"))
        html_text_area_element_set_value(textarea, test_form_controls_utf16(arguments[1]))
        test_form_controls_dump_textarea(&out, textarea)
    elif mode == "selection":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let control = test_form_controls_first_text_control(&subject)
        var direction: ak.String? = none
        if arguments[3] != "!":
            direction = ak.string_from_str(arguments[3])
        html_form_associated_text_control_element_set_selection_range(control, (u32)test_form_controls_integer(arguments[1]), (u32)test_form_controls_integer(arguments[2]), direction) catch:
            test_form_controls_append_exception(&out)
        test_form_controls_dump_selection(&out, control)
    elif mode == "rangetext":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let control = test_form_controls_first_text_control(&subject)
        var selection_mode = BindSelectionMode.preserve
        if arguments[4] == "select":
            selection_mode = BindSelectionMode.select
        elif arguments[4] == "start":
            selection_mode = BindSelectionMode.start
        elif arguments[4] == "end":
            selection_mode = BindSelectionMode.end
        html_form_associated_text_control_element_set_range_text_binding_u32(control, test_form_controls_utf16(arguments[1]), (u32)test_form_controls_integer(arguments[2]), (u32)test_form_controls_integer(arguments[3]), selection_mode) catch:
            test_form_controls_append_exception(&out)
        test_form_controls_dump_selection(&out, control)
    elif mode == "meter":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let meter = as_html_meter_element(test_form_controls_subject_element(&subject, "meter"))
        ak.string_builder_append(&out, "value=")
        test_form_controls_append_number(&out, html_meter_element_value(meter))
        ak.string_builder_append(&out, " min=")
        test_form_controls_append_number(&out, html_meter_element_min(meter))
        ak.string_builder_append(&out, " max=")
        test_form_controls_append_number(&out, html_meter_element_max(meter))
        ak.string_builder_append(&out, " low=")
        test_form_controls_append_number(&out, html_meter_element_low(meter))
        ak.string_builder_append(&out, " high=")
        test_form_controls_append_number(&out, html_meter_element_high(meter))
        ak.string_builder_append(&out, " optimum=")
        test_form_controls_append_number(&out, html_meter_element_optimum(meter))
        ak.string_builder_append(&out, " state=")
        test_form_controls_append_integer(&out, (i64)(u8)html_meter_element_value_state(meter))
        ak.string_builder_append(&out, "\n")
    elif mode == "progress":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let progress = as_html_progress_element(test_form_controls_subject_element(&subject, "progress"))
        ak.string_builder_append(&out, "value=")
        test_form_controls_append_number(&out, html_progress_element_value(progress))
        ak.string_builder_append(&out, " max=")
        test_form_controls_append_number(&out, html_progress_element_max(progress))
        ak.string_builder_append(&out, " position=")
        test_form_controls_append_number(&out, html_progress_element_position(progress))
        ak.string_builder_append(&out, "\n")
    elif mode == "button":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let button = as_html_button_element(test_form_controls_subject_element(&subject, "button"))
        ak.string_builder_append(&out, "type=")
        test_form_controls_append_string(&out, html_button_element_type_for_bindings(button))
        ak.string_builder_append(&out, " submit=")
        test_form_controls_append_bool(&out, html_form_associated_element_is_submit_button(&button.html_element_base.form_associated_element))
        ak.string_builder_append(&out, " value=")
        test_form_controls_append_utf16(&out, html_button_element_value(button))
        ak.string_builder_append(&out, " command=")
        test_form_controls_append_string(&out, html_button_element_command(button))
        ak.string_builder_append(&out, "\n")
    elif mode == "validity":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let element = test_form_controls_subject_element(&subject, arguments[1])
        let form_associated = as_if_form_associated_element(element) else trap("not form-associated")
        ak.string_builder_append(&out, "missing=")
        test_form_controls_append_bool(&out, html_form_associated_element_suffering_from_being_missing(form_associated))
        ak.string_builder_append(&out, " mutable=")
        test_form_controls_append_bool(&out, html_form_associated_element_is_mutable(form_associated))
        ak.string_builder_append(&out, "\n")
    elif mode == "role":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let element = test_form_controls_subject_element(&subject, arguments[1])
        if let role = aria_mixin_default_role(&element.aria_mixin):
            test_form_controls_append_integer(&out, (i64)(i32)role)
            ak.string_builder_append(&out, "\n")
        else:
            ak.string_builder_append(&out, "none\n")
    elif mode == "shadow":
        let subject = test_form_controls_make_subject(realm, arguments[0])
        let element = test_form_controls_subject_element(&subject, arguments[1])
        if let shadow_root = dom_element_shadow_root(element):
            for child in dom_node_children(shadow_root.dom_node()):
                test_form_controls_dump_shadow_node(&out, child, 0)
        else:
            ak.string_builder_append(&out, "no shadow root\n")
    else:
        trap("unknown mode")
    return ak.string_builder_to_string_without_validation(&out)

## Runs every case of `mode`, printing each mismatch, and fails if any.
func test_form_controls_run_mode(mode: 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_form_controls_cases:
            if test_case.mode != mode:
                continue
            count += 1
            let actual = test_form_controls_run(realm, test_case)
            if ak.string_eq_string_view(&actual, ak.sv(test_case.expected)):
                continue
            failures += 1
            let view = ak.string_bytes_as_string_view(&actual)
            print(f"{mode} {test_case.arguments[0]} {test_case.arguments[1]} {test_case.arguments[2]}\nexpected:\n{test_case.expected}actual:\n{(str)ak.string_view_bytes(&view)}")
    assert(count > 0, "no cases of the mode")
    assert(failures == 0, "cases differ from the reference build")

# mark: Tests ====================================================================================

test "HTMLInputElement: value sanitization of every type, checkedness and the parsed value attribute":
    test_form_controls_run_mode("input")

test "HTMLInputElement: the value setter in the value, default, default/on and filename modes":
    test_form_controls_run_mode("set")

test "HTMLInputElement: attribute changes (value, checked, type, multiple, min, max, step)":
    test_form_controls_run_mode("attr")

test "HTMLInputElement: valueAsNumber, min/max/step, step base and the suffering-from states":
    test_form_controls_run_mode("num")

test "HTMLInputElement: stepUp() and stepDown()":
    test_form_controls_run_mode("step")

test "HTMLInputElement: the valueAsNumber setter":
    test_form_controls_run_mode("setnum")

test "HTMLInputElement: converting numbers to strings per type":
    test_form_controls_run_mode("numstr")

test "HTMLInputElement: converting strings to numbers per type":
    test_form_controls_run_mode("strnum")

test "HTMLInputElement: checked setter and radio button groups":
    test_form_controls_run_mode("checked")

test "HTMLSelectElement: the list of options, selectedness, selectedIndex, value and type":
    test_form_controls_run_mode("select")

test "HTMLSelectElement: the selectedIndex and value setters":
    test_form_controls_run_mode("selectset")

test "HTMLOptionElement: the selected setter runs the selectedness setting algorithm":
    test_form_controls_run_mode("optsel")

test "HTMLTextAreaElement: value, defaultValue, textLength, cols, rows and maxLength":
    test_form_controls_run_mode("textarea")

test "HTMLTextAreaElement: the value setter":
    test_form_controls_run_mode("taset")

test "FormAssociatedTextControlElement: setSelectionRange on inputs and textareas":
    test_form_controls_run_mode("selection")

test "FormAssociatedTextControlElement: setRangeText in each selection mode":
    test_form_controls_run_mode("rangetext")

test "HTMLMeterElement: the gauge's values and value state":
    test_form_controls_run_mode("meter")

test "HTMLProgressElement: value, max and position":
    test_form_controls_run_mode("progress")

test "HTMLButtonElement: type, submit button, value and command":
    test_form_controls_run_mode("button")

test "textarea and select: suffering from being missing and mutability":
    test_form_controls_run_mode("validity")

test "default ARIA roles of the form controls":
    test_form_controls_run_mode("role")

test "scenario: the user-agent shadow trees of inputs, textareas, meters and progress bars, as the reference build":
    test_form_controls_run_mode("shadow")