dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / xml / tests_xml_document_builder.lucb
#==============================================================================================
#
# tests_xml_document_builder - region p2x: XML documents built over luce-xml
#
# DESCRIPTION:
# Runs the cases of tests_xml_document_builder_cases (a local oracle's output: the
# reference Ladybird build, LibXML over libxml2, on the same inputs) through the port and
# compares, in the oracle's modes:
#
# load load_xml_document's parse (CDATA and comments preserved, the HTML named
# characters of XHTML documents), the builder's error flag, the parse error
# and the error document it becomes
# build build_xml_document (comments dropped; no error document)
# svg SVGDecodedImageData's parse (scripting disabled)
# frag the XML fragment parsing algorithm in a document's document element
# entity resolve_named_html_entity
#
# The dump: one line per node, two spaces per level; an element as its namespace (short
# names for the well-known ones), qualified name and class, then its attributes in order;
# a template's contents under "content". Parse error messages are written "*" on both
# sides (libxml2's words are not luce-xml's). The cases where the port deviates on purpose
# (external/lib_xml/parser's header) are pinned by the tests after the table's.
#
# Documents are web_test_create_document's (page/tests_page): the real Document in a
# settings realm, of type XML, with no browsing context.
#
#==============================================================================================
# mark: The dump =================================================================================
## Appends "| " and `level` levels of indentation.
func test_xml_dump_indent(builder: ak.StringBuilder*, level: usize):
ak.string_builder_append(builder, "| ")
for _unused in 0..<level:
ak.string_builder_append(builder, " ")
## The short name the oracle writes for a namespace ("html ", "svg ", ..., "{uri} ").
func test_xml_dump_namespace(builder: ak.StringBuilder*, namespace_: ak.FlyString?):
let ns = namespace_ else return
if ak.fly_string_eq_fly_string(&ns, &namespace_html):
ak.string_builder_append(builder, "html ")
elif ak.fly_string_eq_fly_string(&ns, &namespace_svg):
ak.string_builder_append(builder, "svg ")
elif ak.fly_string_eq_fly_string(&ns, &namespace_math_ml):
ak.string_builder_append(builder, "math ")
elif ak.fly_string_eq_fly_string(&ns, &namespace_x_link):
ak.string_builder_append(builder, "xlink ")
elif ak.fly_string_eq_fly_string(&ns, &namespace_xml):
ak.string_builder_append(builder, "xml ")
elif ak.fly_string_eq_fly_string(&ns, &namespace_xmlns):
ak.string_builder_append(builder, "xmlns ")
else:
ak.string_builder_append(builder, "{")
ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&ns))
ak.string_builder_append(builder, "} ")
## `prefix:local_name`, or the local name alone.
func test_xml_dump_qualified(builder: ak.StringBuilder*, prefix: ak.FlyString?, local_name: ak.FlyString):
if let present = prefix:
ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&present))
ak.string_builder_append(builder, ":")
ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&local_name))
## Appends the UTF-8 form of `text`.
func test_xml_dump_utf16(builder: ak.StringBuilder*, text: ak.Utf16String):
ak.string_builder_append_utf16_view(builder, ak.utf16_string_base_utf16_view(&text.utf16_string_base))
## Dumps `node` and its subtree at `level`.
func test_xml_dump_node(builder: ak.StringBuilder*, node: DomNode*, level: usize):
test_xml_dump_indent(builder, level)
if let element = as_if_dom_element(node):
ak.string_builder_append(builder, "<")
test_xml_dump_namespace(builder, dom_element_namespace_uri(element))
test_xml_dump_qualified(builder, dom_element_prefix(element), dom_element_local_name(element))
ak.string_builder_append(builder, "> ")
ak.string_builder_append(builder, element.cell().vtable.class_info.name)
ak.string_builder_append(builder, "\n")
if let attributes = element.m_attributes:
for index in 0..<dom_named_node_map_length(attributes):
let attribute = dom_named_node_map_item(attributes, (u32)index) else trap("an attribute in range")
test_xml_dump_indent(builder, level + 1)
test_xml_dump_namespace(builder, dom_attr_namespace_uri(attribute))
test_xml_dump_qualified(builder, dom_attr_prefix(attribute), dom_attr_local_name(attribute))
ak.string_builder_append(builder, "=\"")
let value = dom_attr_value(attribute)
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&value))
ak.string_builder_append(builder, "\"\n")
if let template = as_if_html_template_element(element):
test_xml_dump_indent(builder, level + 1)
ak.string_builder_append(builder, "content\n")
for child in dom_node_children(html_template_element_content(template).dom_node()):
test_xml_dump_node(builder, child, level + 2)
for child in dom_node_children(node):
test_xml_dump_node(builder, child, level + 1)
return
if let section = as_if_dom_cdata_section(node):
ak.string_builder_append(builder, "<![CDATA[")
test_xml_dump_utf16(builder, dom_character_data_data(section.dom_character_data()))
ak.string_builder_append(builder, "]]>\n")
return
if let text = as_if_dom_text(node):
ak.string_builder_append(builder, "\"")
test_xml_dump_utf16(builder, dom_character_data_data(text.dom_character_data()))
ak.string_builder_append(builder, "\"\n")
return
if let comment = as_if_dom_comment(node):
ak.string_builder_append(builder, "<!-- ")
test_xml_dump_utf16(builder, dom_character_data_data(comment.dom_character_data()))
ak.string_builder_append(builder, " -->\n")
return
if let processing_instruction = as_if_dom_processing_instruction(node):
ak.string_builder_append(builder, "<?")
let target = dom_processing_instruction_target(processing_instruction)
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&target))
ak.string_builder_append(builder, " ")
test_xml_dump_utf16(builder, dom_character_data_data(processing_instruction.dom_character_data()))
ak.string_builder_append(builder, "?>\n")
return
if let doctype = as_if_dom_document_type(node):
ak.string_builder_append(builder, "<!DOCTYPE ")
let name = dom_document_type_name(doctype)
let public_id = dom_document_type_public_id(doctype)
let system_id = dom_document_type_system_id(doctype)
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&name))
ak.string_builder_append(builder, " \"")
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&public_id))
ak.string_builder_append(builder, "\" \"")
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&system_id))
ak.string_builder_append(builder, "\">\n")
return
ak.string_builder_append(builder, "?\n")
## Dumps every child of `node` at level 0.
func test_xml_dump_children(builder: ak.StringBuilder*, node: DomNode*):
for child in dom_node_children(node):
test_xml_dump_node(builder, child, 0)
# mark: The modes ================================================================================
## A line "name true|false".
func test_xml_put_flag(builder: ak.StringBuilder*, name: str, value: bool):
ak.string_builder_append(builder, name)
ak.string_builder_append(builder, " true\n" if value else " false\n")
## load_xml_document's run_xml_parser over `source` in a new XML document of `realm`: on a parse
## error, the document becomes its error document. Writes the flags and the error to `builder`.
func test_xml_load(realm: Realm*, source: str, builder: ak.StringBuilder*) -> DomDocument*:
let document = web_test_create_document(realm, DocumentDomDocumentType.xml)
let options = XmlParserOptions(preserve_cdata = true, preserve_comments = true, resolve_named_html_entity = resolve_named_html_entity)
let result = xml_parse_with_document_builder(document, ak.string_from_utf8(ak.sv(source)) else trap("UTF-8"), options)
test_xml_put_flag(builder, "has_error", result.builder_has_error)
if let parse_error = result.parse_error:
var message = ak.string_builder_new()
ak.string_builder_append(&message, "Failed to parse XML document: ")
ak.string_builder_append_string_view(&message, ak.string_bytes_as_string_view(&parse_error))
ak.string_builder_append(builder, "error ")
ak.string_builder_append_string_view(builder, ak.string_builder_string_view(&message))
ak.string_builder_append(builder, "\n")
convert_to_xml_error_document(document, ak.utf16_string_from_utf8_string_view(ak.string_builder_string_view(&message)))
return document
## Runs one case and answers its output (before normalization).
func test_xml_run(realm: Realm*, test_case: const TestXmlDocumentCase*) -> ak.String:
var builder = ak.string_builder_new()
let source = test_case.arguments[0]
if test_case.mode == "load":
let document = test_xml_load(realm, source, &builder)
test_xml_dump_children(&builder, document.dom_node())
elif test_case.mode == "build":
let document = web_test_create_document(realm, DocumentDomDocumentType.xml)
let data = ak.byte_buffer_copy_span_u8(source.bytes) else trap("out of memory")
test_xml_put_flag(&builder, "result", build_xml_document(document, data, none))
test_xml_dump_children(&builder, document.dom_node())
elif test_case.mode == "svg":
let document = web_test_create_document(realm, DocumentDomDocumentType.xml)
let options = XmlParserOptions(resolve_named_html_entity = resolve_named_html_entity)
let result = xml_parse_with_document_builder(document, ak.string_from_utf8(ak.sv(source)) else trap("UTF-8"), options, XmlScriptingSupport.disabled)
test_xml_put_flag(&builder, "has_error", result.builder_has_error)
if let parse_error = result.parse_error:
ak.string_builder_append(&builder, "error ")
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&parse_error))
ak.string_builder_append(&builder, "\n")
test_xml_dump_children(&builder, document.dom_node())
elif test_case.mode == "frag":
var ignored = ak.string_builder_new()
let document = test_xml_load(realm, source, &ignored)
let context = dom_document_document_element(document) else trap("VERIFY: the document element")
let nodes = xml_fragment_parser_parse_xml_fragment(context, ak.sv(test_case.arguments[1])) catch:
match idl_take_pending_exception():
.idl_dom_exception(exception):
ak.string_builder_append(&builder, "exception ")
let name = idl_dom_exception_name(exception)
ak.string_builder_append_string_view(&builder, ak.fly_string_bytes_as_string_view(&name))
ak.string_builder_append(&builder, " ")
let message = idl_dom_exception_message(exception)
ak.string_builder_append_utf16_view(&builder, ak.utf16_fly_string_view(&message))
ak.string_builder_append(&builder, "\n")
_:
ak.string_builder_append(&builder, "exception ?\n")
return ak.string_builder_to_string_without_validation(&builder)
for node in ak.vector_span_const(&nodes):
test_xml_dump_node(&builder, node else trap("a node"), 0)
elif test_case.mode == "entity":
if let resolved = resolve_named_html_entity(ak.sv(source)):
let resolved_view = ak.string_bytes_as_string_view(&resolved)
for code_point in (str)ak.string_view_bytes(&resolved_view):
test_xml_append_hex(&builder, (u32)code_point)
ak.string_builder_append(&builder, " ")
ak.string_builder_append(&builder, "\n")
else:
ak.string_builder_append(&builder, "none\n")
else:
trap("unknown mode")
return ak.string_builder_to_string_without_validation(&builder)
## Lowercase hexadecimal without leading zeros (the oracle's "%x").
func test_xml_append_hex(builder: ak.StringBuilder*, value: u32):
let digits = "0123456789abcdef".bytes
var text: u8[8]
var count: usize = 0
var rest = value
while true:
text[count] = digits[rest & 0xF]
rest = rest >> 4
count += 1
if rest == 0:
break
while count > 0:
count -= 1
ak.string_builder_append_u8(builder, text[count])
## gen_luce_cases.py's normalization: parse error messages become "*".
func test_xml_normalize(output: ak.String) -> ak.String:
var builder = ak.string_builder_new()
let view = ak.string_bytes_as_string_view(&output)
let marker = ak.sv("\"Failed to parse XML document: ")
let lines = ak.string_view_lines(&view)
for line in ak.vector_span_const(&lines):
if ak.string_view_starts_with_string_view(&line, ak.sv("error ")):
ak.string_builder_append(&builder, "error *")
elif let at = ak.string_view_find_string_view(&line, marker):
ak.string_builder_append_string_view(&builder, ak.string_view_substring_view_usize(&line, 0, at))
ak.string_builder_append_string_view(&builder, marker)
ak.string_builder_append(&builder, "*\"")
elif ak.string_view_starts_with_string_view(&line, ak.sv("exception SyntaxError ")) and not ak.string_view_equals(&line, "exception SyntaxError Document element has sibling nodes"):
ak.string_builder_append(&builder, "exception SyntaxError *")
else:
ak.string_builder_append_string_view(&builder, line)
ak.string_builder_append(&builder, "\n")
return ak.string_builder_to_string_without_validation(&builder)
## Runs every case of `mode`, printing each mismatch, and fails if any.
func test_xml_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_xml_document_cases:
if test_case.mode != mode:
continue
count += 1
let actual = test_xml_normalize(test_xml_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]}\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: The reference build's cases ==============================================================
test "resolve_named_html_entity matches the reference build":
test_xml_run_mode("entity")
test "scenario: XML documents as load_xml_document builds them, as the reference build's DOM trees":
test_xml_run_mode("load")
test "scenario: build_xml_document's documents and result, as the reference build's":
test_xml_run_mode("build")
test "scenario: SVG image documents (scripting disabled), as the reference build's DOM trees":
test_xml_run_mode("svg")
test "scenario: the XML fragment parsing algorithm, as the reference build's nodes and exceptions":
test_xml_run_mode("frag")