Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / tests_css_sheets.lucb

#==============================================================================================
#
#   tests_css_sheets - tests of style sheets, rule lists, rules, declarations and MediaList
#
#   DESCRIPTION:
#       Ladybird has no unit tests for CSSStyleSheet, CSSRuleList, the CSS rules or the
#       declaration blocks. The oracle cases (tests_css_sheets_cases) run the reference build's
#       parser and CSSOM on the same inputs (luce-browser-tools, oracles/luce-browser-engine/
#       css_sheets); the test below runs each through the port and compares the output: whole
#       sheets (each rule's class, type and cssText, recursively), Dump.cpp's dump of rules,
#       insertRule()/deleteRule()/addRule() on sheets and grouping rules with their
#       exceptions, selectorText of style and page rules, the namespace caches and the cascade
#       layer names. The focused tests after it cover what the oracle cases cannot reach yet.
#
#==============================================================================================

# mark: The oracle cases ========================================================================

## The parsing parameters of the cases: the realm only, as the oracle's internal CSS realm.
func test_css_sheets_params(realm: Realm*) -> CssParsingParams:
    var params: CssParsingParams = ---
    css_parsing_params_construct_realm_css_parsing_mode(&params, realm)
    return params

## Append `text` to `out`, indented by `indent` levels of two spaces, and a line feed (the oracle's `line`).
func test_css_sheets_line(out: ak.StringBuilder*, indent: i32, text: ak.StringView):
    for _ in 0..<indent:
        ak.string_builder_append(out, "  ")
    ak.string_builder_append_string_view(out, text)
    ak.string_builder_append_u8(out, '\n')

## The rules of a list, recursively: class, type for bindings, internal type, cssText (the oracle's `print_rules`).
func test_css_sheets_print_rules(out: ak.StringBuilder*, rules: CssRuleList*, indent: i32):
    for rule in ak.vector_span(&rules.m_rules):
        var text = ak.string_builder_new()
        let css_text = css_rule_css_text(rule)
        dump_appendff(&text, "{} type={} internal={} text={}", [ak.arg_string_view(dump_class_name(rule.cell())), ak.arg_u64((u64)css_rule_type_for_bindings(rule)),
                                                                ak.arg_u64((u64)css_rule_type(rule)), css_arg_string(&css_text)])
        test_css_sheets_line(out, indent, ak.string_builder_string_view(&text))
        if let grouping = as_if_css_grouping_rule(rule):
            test_css_sheets_print_rules(out, css_grouping_rule_css_rules(grouping), indent + 1)
        if let keyframes = as_if_css_keyframes_rule(rule):
            test_css_sheets_print_rules(out, css_keyframes_rule_css_rules(keyframes), indent + 1)

## The oracle's `print_sheet`.
func test_css_sheets_print_sheet(out: ak.StringBuilder*, sheet: CssCssStyleSheet*):
    let rules = css_css_style_sheet_rules(sheet)
    var text = ak.string_builder_new()
    dump_appendff(&text, "rules {}", [ak.arg_u64((u64)css_rule_list_length(rules))])
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&text))
    test_css_sheets_print_rules(out, rules, 2)

## The oracle's `print_exception`: the pending exception a failed CSSOM call left.
func test_css_sheets_print_exception(out: ak.StringBuilder*):
    var text = ak.string_builder_new()
    match idl_take_pending_exception():
        .idl_dom_exception(exception):
            let name = idl_dom_exception_name(exception)
            let message = idl_dom_exception_message(exception)
            dump_appendff(&text, "exception {}: ", [css_arg_fly_string(&name)])
            ak.string_builder_append_utf16_view(&text, ak.utf16_fly_string_to_utf16_view(&message))
        .idl_simple_exception(simple):
            let message = idl_simple_exception_message(&simple)
            dump_appendff(&text, "simple exception: {}", [css_arg_string(&message)])
        _:
            ak.string_builder_append(&text, "completion")
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&text))

## A line `<label> <value>` (the oracle's formatted lines of results).
func test_css_sheets_labeled(out: ak.StringBuilder*, label: str, value: ak.StringView):
    var text = ak.string_builder_new()
    ak.string_builder_append(&text, label)
    ak.string_builder_append_string_view(&text, value)
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&text))

## A line `<label> <number>`.
func test_css_sheets_labeled_number(out: ak.StringBuilder*, label: str, value: i64):
    let text = ak.string_number_i64(value)
    test_css_sheets_labeled(out, label, ak.string_bytes_as_string_view(&text))

## The oracle's `print_layer_names`.
func test_css_sheets_print_layer_names(context: void*?, rule: CssRule*):
    let out = (ak.StringBuilder*)(context else trap("no builder"))
    var text = ak.string_builder_new()
    if let block = as_if_css_layer_block_rule(rule):
        let name = css_layer_block_rule_name(block)
        let qualified = css_layer_block_rule_internal_qualified_name(block)
        dump_appendff(&text, "block name='{}' qualified='{}'", [css_arg_fly_string(&name), css_arg_fly_string(&qualified)])
    elif let statement = as_if_css_layer_statement_rule(rule):
        let names = css_layer_statement_rule_internal_qualified_name_list(statement)
        var joined = ak.string_builder_new()
        ak.string_builder_join_fly_string(&joined, ak.sv(","), ak.vector_span_const(&names))
        dump_appendff(&text, "statement '{}'", [ak.arg_string_view(ak.string_builder_string_view(&joined))])
    elif let style = as_if_css_style_rule(rule):
        let selector = css_style_rule_selector_text(style)
        let layer = css_style_rule_qualified_layer_name(style)
        dump_appendff(&text, "style '{}' layer='{}'", [css_arg_string(&selector), css_arg_fly_string(&layer)])
    else:
        return
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&text))

## A decimal argument of a case.
func test_css_sheets_u32(text: str) -> u32:
    let view = ak.sv(text)
    return ak.string_view_to_number_u32(&view) else trap("a number")

## Run one oracle case (the oracle's `run`) and answer its output.
func test_css_sheets_run(vm: Vm*, realm: Realm*, test_case: const TestCssSheetsCase*) -> ak.String:
    var out = ak.string_builder_new()
    let mode = test_case.mode
    let sheet = parse_css_stylesheet(test_css_sheets_params(realm), ak.sv(test_case.arguments[0]))
    if mode == "sheet":
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "dump":
        var builder = ak.string_builder_new()
        for rule in ak.vector_span(&css_css_style_sheet_rules(sheet).m_rules):
            dump_rule_string_builder(&builder, rule, 1)
        let dumped = ak.string_builder_string_view(&builder)
        let lines = ak.string_view_split_view_u8(&dumped, '\n')
        for dump_line in ak.vector_span_const(&lines):
            test_css_sheets_labeled(&out, "dump: ", dump_line)
    elif mode == "insert":
        let inserted = css_css_style_sheet_insert_rule(sheet, ak.sv(test_case.arguments[1]), test_css_sheets_u32(test_case.arguments[2])) catch _:
            test_css_sheets_print_exception(&out)
            recover ak.u32_max
        if inserted != ak.u32_max:
            test_css_sheets_labeled_number(&out, "inserted at ", (i64)inserted)
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "delete":
        var deleted = true
        css_css_style_sheet_delete_rule(sheet, test_css_sheets_u32(test_case.arguments[1])) catch _:
            test_css_sheets_print_exception(&out)
            deleted = false
            recover ()
        if deleted:
            test_css_sheets_line(&out, 1, ak.sv("deleted"))
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "addrule":
        var selector: ak.String? = none
        if test_case.arguments[1] != "-":
            selector = ak.string_from_str(test_case.arguments[1])
        var style: ak.String? = none
        if test_case.arguments[2] != "-":
            style = ak.string_from_str(test_case.arguments[2])
        var index: u32? = none
        if test_case.arguments[3] != "-":
            index = test_css_sheets_u32(test_case.arguments[3])
        let returned = css_css_style_sheet_add_rule(sheet, selector, style, index) catch _:
            test_css_sheets_print_exception(&out)
            recover 0
        if returned != 0:
            test_css_sheets_labeled_number(&out, "returned ", (i64)returned)
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "ginsert":
        let grouping = as_css_grouping_rule(css_rule_list_item(css_css_style_sheet_rules(sheet), 0) else trap("no rule"))
        let inserted = css_grouping_rule_insert_rule(grouping, ak.sv(test_case.arguments[1]), test_css_sheets_u32(test_case.arguments[2])) catch _:
            test_css_sheets_print_exception(&out)
            recover ak.u32_max
        if inserted != ak.u32_max:
            test_css_sheets_labeled_number(&out, "inserted at ", (i64)inserted)
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "gdelete":
        let grouping = as_css_grouping_rule(css_rule_list_item(css_css_style_sheet_rules(sheet), 0) else trap("no rule"))
        var deleted = true
        css_grouping_rule_delete_rule(grouping, test_css_sheets_u32(test_case.arguments[1])) catch _:
            test_css_sheets_print_exception(&out)
            deleted = false
            recover ()
        if deleted:
            test_css_sheets_line(&out, 1, ak.sv("deleted"))
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "selector":
        let rule = as_css_style_rule(css_rule_list_item(css_css_style_sheet_rules(sheet), 0) else trap("no rule"))
        css_style_rule_set_selector_text(rule, ak.sv(test_case.arguments[1]))
        let selector_text = css_style_rule_selector_text(rule)
        test_css_sheets_labeled(&out, "selectorText ", ak.string_bytes_as_string_view(&selector_text))
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "listinsert":
        let rules = css_css_style_sheet_rules(sheet)
        let inserted = css_rule_list_insert_a_css_rule(rules, .string_view(ak.sv(test_case.arguments[1])), test_css_sheets_u32(test_case.arguments[2]), CssRuleListNested.no, css_css_style_sheet_declared_namespaces(sheet)) catch _:
            test_css_sheets_print_exception(&out)
            recover ak.u32_max
        if inserted != ak.u32_max:
            test_css_sheets_labeled_number(&out, "inserted at ", (i64)inserted)
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "listremove":
        var deleted = true
        css_rule_list_remove_a_css_rule(css_css_style_sheet_rules(sheet), test_css_sheets_u32(test_case.arguments[1])) catch _:
            test_css_sheets_print_exception(&out)
            deleted = false
            recover ()
        if deleted:
            test_css_sheets_line(&out, 1, ak.sv("deleted"))
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "selectorfree":
        let rule = as_css_style_rule(css_rule_list_item(css_css_style_sheet_rules(sheet), 0) else trap("no rule"))
        css_rule_set_parent_style_sheet(rule.css_rule(), none)
        css_style_rule_set_selector_text(rule, ak.sv(test_case.arguments[1]))
        let selector_text = css_style_rule_selector_text(rule)
        test_css_sheets_labeled(&out, "selectorText ", ak.string_bytes_as_string_view(&selector_text))
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "pageselector":
        let rule = as_css_page_rule(css_rule_list_item(css_css_style_sheet_rules(sheet), 0) else trap("no rule"))
        css_page_rule_set_selector_text(rule, ak.sv(test_case.arguments[1]))
        let selector_text = css_page_rule_selector_text(rule)
        test_css_sheets_labeled(&out, "selectorText ", ak.string_bytes_as_string_view(&selector_text))
        test_css_sheets_print_sheet(&out, sheet)
    elif mode == "namespace":
        test_css_sheets_print_namespaces(&out, sheet, ak.sv(test_case.arguments[1]))
    elif mode == "layers":
        css_rule_list_for_each_effective_rule(css_css_style_sheet_rules(sheet), TraversalOrder.preorder, ak.Function1[CssRule*, unit](call = test_css_sheets_print_layer_names, context = &out))
    elif not test_css_sheets_run_focused(&out, vm, realm, mode, sheet):
        trap("unknown mode")
    return ak.string_builder_to_string_without_validation(&out)

## Whether `a` sorts after `b` (by bytes).
func test_css_sheets_name_greater(a: const ak.FlyString*, b: const ak.FlyString*) -> bool:
    let a_view = ak.fly_string_bytes_as_string_view(a)
    return ak.string_view_compare(&a_view, ak.fly_string_bytes_as_string_view(b)) > 0

## The oracle's `namespace` mode: the namespace caches of a sheet.
func test_css_sheets_print_namespaces(out: ak.StringBuilder*, sheet: CssCssStyleSheet*, prefix: ak.StringView):
    var text = ak.string_builder_new()
    if let uri = css_css_style_sheet_namespace_uri(sheet, prefix):
        dump_appendff(&text, "namespace_uri '{}'", [css_arg_fly_string(&uri)])
    else:
        ak.string_builder_append(&text, "namespace_uri none")
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&text))

    var default_text = ak.string_builder_new()
    if let default_namespace = css_css_style_sheet_default_namespace(sheet):
        dump_appendff(&default_text, "default '{}'", [css_arg_fly_string(&default_namespace)])
    else:
        ak.string_builder_append(&default_text, "default none")
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&default_text))

    # The declared namespaces, sorted (a HashTable's order is the hash's).
    let declared = css_css_style_sheet_declared_namespaces(sheet)
    var names = ak.hash_table_values(&declared)
    for i in 1..<ak.vector_size(&names):
        var j = i
        while j > 0 and test_css_sheets_name_greater(ak.vector_at(&names, j - 1), ak.vector_at(&names, j)):
            let swap = *ak.vector_at(&names, j)
            *ak.vector_at(&names, j) = *ak.vector_at(&names, j - 1)
            *ak.vector_at(&names, j - 1) = swap
            j -= 1
    var declared_text = ak.string_builder_new()
    ak.string_builder_append(&declared_text, "declared ")
    for name in ak.vector_span(&names):
        dump_appendff(&declared_text, "'{}' ", [css_arg_fly_string(&name)])
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&declared_text))

    var imports_text = ak.string_builder_new()
    let imports = css_css_style_sheet_import_rules(sheet)
    dump_appendff(&imports_text, "imports {}", [ak.arg_u64((u64)ak.vector_size(&imports))])
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&imports_text))

test "style sheets, rule lists and rules match the reference build on the oracle cases":
    let (vm, realm, _) = test_html_setup()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        # The oracle runs the cases in one process from a fresh anonymous-layer counter.
        css_layer_block_rule_anonymous_layer_id = 0
        var failures = 0
        for test_case in &test_css_sheets_cases:
            let actual = test_css_sheets_run(vm, realm, test_case)
            if not ak.string_eq_string_view(&actual, ak.sv(test_case.expected)):
                let actual_view = ak.string_bytes_as_string_view(&actual)
                print(f"case {test_case.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(&actual_view)}")
                failures += 1
        assert(failures == 0, "style sheet oracle cases differ")