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