Luce packages
LuceLuce BaseLuciaOS

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")