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(¶ms, 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")