dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / tests_selector.lucb
#==============================================================================================
#
# tests_selector - tests of CSS::Selector, PageSelector and PseudoClassBitmap (region r38)
#
# DESCRIPTION:
# Ladybird has no unit tests for Selector.cpp, PageSelector.cpp or PseudoClassBitmap.h.
# The oracle cases (tests_selector_cases) run the reference build's selector parser and
# Selector members on 105 inputs: per parsed selector its serialization, specificity, the
# fast-match and ancestor-filter flags with the ancestor hashes, the sibling invalidation
# distance, the nesting / unknown -webkit- / ::slotted / ::part flags, the target
# pseudo-element, the contained pseudo-classes and Dump.cpp's dump_selector; nested
# selectors (adapt_nested_relative_selector_list) and their absolutized forms against
# `:is(.p, #q)` and `:has(.y)` (invalid inside :has()); An+B patterns (serialize, matches 1-12); @page selector lists; and the
# ErrorReporter's errors. The focused tests below pin the rest to the C++ (values read
# from the donor's code).
#
#==============================================================================================
# mark: The oracle cases ========================================================================
## A parser context whose declared namespaces are the oracle's: `svg`.
func test_selector_params() -> CssParsingParams:
var params: CssParsingParams = ---
css_parsing_params_construct_css_parsing_mode(¶ms)
_ = ak.hash_table_set(¶ms.declared_namespaces, ak.fly_string_from_str("svg"))
return params
## Appends `text` and a newline.
func test_selector_line(out: ak.StringBuilder*, text: ak.String):
ak.string_builder_append_string_view(out, ak.string_bytes_as_string_view(&text))
ak.string_builder_append_u8(out, '\n')
## "true" or "false", as AK formats a bool.
func test_selector_bool(value: bool) -> str:
return "true" if value else "false"
## The oracle's `describe`: a selector's members, then its dump_selector.
func test_selector_describe(out: ak.StringBuilder*, selector: const CssSelector*):
let serialized = css_selector_serialize(selector)
test_selector_line(out, css_string_formatted("serialize: {}", [css_arg_string(&serialized)]))
test_selector_line(out, css_string_formatted("specificity: {}", [ak.arg_u64((u64)css_selector_specificity(selector))]))
test_selector_line(out, css_string_formatted("fast: {} ancestor_filter: {}", [ak.arg_str(test_selector_bool(css_selector_can_use_fast_matches(selector))),
ak.arg_str(test_selector_bool(css_selector_can_use_ancestor_filter(selector)))]))
ak.string_builder_append(out, "hashes:")
for hash_value in css_selector_ancestor_hashes(selector):
ak.string_builder_append_u8(out, ' ')
let number = ak.string_number_u64((u64)hash_value)
ak.string_builder_append_string_view(out, ak.string_bytes_as_string_view(&number))
ak.string_builder_append_u8(out, '\n')
test_selector_line(out, css_string_formatted("sibling_distance: {}", [ak.arg_u64((u64)css_selector_sibling_invalidation_distance(selector))]))
test_selector_line(out, css_string_formatted("nesting: {} webkit: {} slotted: {} part: {}", [
ak.arg_str(test_selector_bool(css_selector_contains_the_nesting_selector(selector))),
ak.arg_str(test_selector_bool(css_selector_contains_unknown_webkit_pseudo_element(selector))),
ak.arg_str(test_selector_bool(css_selector_is_slotted(selector))),
ak.arg_str(test_selector_bool(css_selector_has_part_pseudo_element(selector))),
]))
if let target = css_selector_target_pseudo_element(selector):
let target_serialized = css_selector_pseudo_element_selector_serialize(&target)
test_selector_line(out, css_string_formatted("target: {}", [css_arg_string(&target_serialized)]))
ak.string_builder_append(out, "pseudo_classes:")
for i in 0..<(i32)css_data.PseudoClass.count:
let pseudo_class = (css_data.PseudoClass)i
if css_selector_contains_pseudo_class(selector, pseudo_class):
ak.string_builder_append_u8(out, ' ')
ak.string_builder_append_string_view(out, css_data.pseudo_class_name(pseudo_class))
ak.string_builder_append_u8(out, '\n')
dump_selector_string_builder(out, selector)
## The ErrorReporter's errors, "error: <message> (<occurrences>)", in its table's order; then clears them.
func test_selector_dump_errors(out: ak.StringBuilder*):
for entry in ak.hash_map_begin(&css_error_reporter_the().m_errors):
let message = css_serialize_parsing_error(&entry.key)
test_selector_line(out, css_string_formatted("error: {} ({})", [css_arg_string(&message), ak.arg_u64((u64)entry.value.occurrences)]))
ak.hash_map_clear(&css_error_reporter_the().m_errors)
## Runs one oracle case and returns its output.
func test_selector_run_case(mode: str, input: str) -> ak.String:
var out = ak.string_builder_new()
let params = test_selector_params()
if mode == "selector":
if let list = parse_selector(params, ak.sv(input)):
for selector in ak.vector_span_const(&list):
ak.string_builder_append(&out, "--\n")
test_selector_describe(&out, selector)
else:
ak.string_builder_append(&out, "failure\n")
return ak.string_builder_to_string_without_validation(&out)
elif mode == "nested":
if let list = parse_selector_for_nested_style_rule(params, ak.sv(input)):
let parent_list = parse_selector(params, ak.sv(":is(.p, #q)")) else trap("the parent selector parses")
let parent_compounds = css_selector_compound_selectors(*ak.vector_first_const(&parent_list))
let parent = *ak.vector_first_const(&ak.vector_first_const(&parent_compounds).simple_selectors)
let has_parent_list = parse_selector(params, ak.sv(":has(.y)")) else trap("the :has() parent selector parses")
let has_parent_compounds = css_selector_compound_selectors(*ak.vector_first_const(&has_parent_list))
let has_parent = *ak.vector_first_const(&ak.vector_first_const(&has_parent_compounds).simple_selectors)
for selector in ak.vector_span_const(&list):
let nested = css_selector_serialize(selector)
test_selector_line(&out, css_string_formatted("nested: {}", [css_arg_string(&nested)]))
if let absolutized = css_selector_absolutized(selector, parent):
let serialized = css_selector_serialize(absolutized)
test_selector_line(&out, css_string_formatted("absolutized: {} specificity: {}", [css_arg_string(&serialized), ak.arg_u64((u64)css_selector_specificity(absolutized))]))
else:
test_selector_line(&out, ak.string_from_str("absolutized: null"))
if let absolutized_has = css_selector_absolutized(selector, has_parent):
let serialized_has = css_selector_serialize(absolutized_has)
test_selector_line(&out, css_string_formatted("absolutized_has: {}", [css_arg_string(&serialized_has)]))
else:
test_selector_line(&out, ak.string_from_str("absolutized_has: null"))
else:
ak.string_builder_append(&out, "failure\n")
return ak.string_builder_to_string_without_validation(&out)
elif mode == "anb":
let input_view = ak.sv(input)
let parts = ak.string_view_split_view_u8(&input_view, ' ')
let a = ak.string_view_to_number_i32(ak.vector_at_const(&parts, 0)) else trap("A")
let b = ak.string_view_to_number_i32(ak.vector_at_const(&parts, 1)) else trap("B")
let pattern = CssSelectorSimpleSelectorAnPlusBPattern(step_size = a, offset = b)
var matches = ak.string_builder_new()
for i: i32 in 1..=12:
ak.string_builder_append_u8(&matches, '1' if css_selector_simple_selector_an_plus_b_pattern_matches(&pattern, i) else '0')
let serialized = css_selector_simple_selector_an_plus_b_pattern_serialize(&pattern)
test_selector_line(&out, css_string_formatted("serialize: {} matches: {}", [css_arg_string(&serialized), ak.arg_string_view(ak.string_builder_string_view(&matches))]))
elif mode == "page":
if let list = parse_page_selector_list(params, ak.sv(input)):
for selector in &ak.vector_span_const(&list):
let serialized = css_page_selector_serialize(selector)
test_selector_line(&out, css_string_formatted("page: '{}'", [css_arg_string(&serialized)]))
else:
ak.string_builder_append(&out, "failure\n")
return ak.string_builder_to_string_without_validation(&out)
test_selector_dump_errors(&out)
return ak.string_builder_to_string_without_validation(&out)
test "selectors match the reference build on the oracle cases":
web_initialize_strings()
ak.hash_map_clear(&css_error_reporter_the().m_errors)
var failures = 0
# The cases outgrow the test's fixed buffer; selectors hold no cells, so the C heap will do.
with memory.heap:
for test_case in &test_selector_cases:
let actual = test_selector_run_case(test_case.mode, test_case.input)
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.input}\nexpected:\n{test_case.expected}actual:\n{(str)ak.string_view_bytes(&actual_view)}")
failures += 1
assert(failures == 0, "selector oracle cases differ")
# mark: Focused tests ===========================================================================
test "PseudoClassBitmap sets, clears, reads and merges bits across its two words (PseudoClassBitmap.h)":
assert(css_pseudo_class_bitmap_word_count == 2)
var bitmap: CssPseudoClassBitmap
css_pseudo_class_bitmap_set(&bitmap, css_data.PseudoClass.active, true)
css_pseudo_class_bitmap_set(&bitmap, css_data.PseudoClass.where, true) # 64: the second word
css_pseudo_class_bitmap_set(&bitmap, css_data.PseudoClass.volume_locked, true) # 63
assert(bitmap.m_bits[0] == (1u64 | (1u64 << 63)) and bitmap.m_bits[1] == 1)
assert(css_pseudo_class_bitmap_get(&bitmap, css_data.PseudoClass.where) and not css_pseudo_class_bitmap_get(&bitmap, css_data.PseudoClass.hover))
css_pseudo_class_bitmap_set(&bitmap, css_data.PseudoClass.active, false)
assert(not css_pseudo_class_bitmap_get(&bitmap, css_data.PseudoClass.active) and bitmap.m_bits[0] == 1u64 << 63)
var other: CssPseudoClassBitmap
css_pseudo_class_bitmap_set(&other, css_data.PseudoClass.hover, true)
css_pseudo_class_bitmap_or_assign(&bitmap, other)
assert(css_pseudo_class_bitmap_get(&bitmap, css_data.PseudoClass.hover) and css_pseudo_class_bitmap_get(&bitmap, css_data.PseudoClass.where))
assert(css_pseudo_class_bitmap_get(&bitmap, css_data.PseudoClass.volume_locked))
test "PageSelector: the page pseudo-classes by name, any case, and serialization (PageSelector.cpp)":
assert(css_page_pseudo_class_from_string(ak.sv("first")) == CssPagePseudoClass.first)
assert(css_page_pseudo_class_from_string(ak.sv("BLANK")) == CssPagePseudoClass.blank)
assert(css_page_pseudo_class_from_string(ak.sv("Left")) == CssPagePseudoClass.left)
assert(css_page_pseudo_class_from_string(ak.sv("right")) == CssPagePseudoClass.right)
assert(css_page_pseudo_class_from_string(ak.sv("nth")) == none)
let blank_name = css_to_string_css_page_pseudo_class(CssPagePseudoClass.blank)
assert(ak.string_view_equals(&blank_name, "blank"))
var pseudo_classes: ak.Vector[CssPagePseudoClass]
ak.vector_append_t(&pseudo_classes, CssPagePseudoClass.right)
ak.vector_append_t(&pseudo_classes, CssPagePseudoClass.first)
var selector: CssPageSelector = ---
css_page_selector_construct(&selector, ak.fly_string_from_str("toc"), pseudo_classes)
let serialized = css_page_selector_serialize(&selector)
assert(ak.string_eq_string_view(&serialized, ak.sv("toc:right:first")))
let selector_pseudo_classes = css_page_selector_pseudo_classes(&selector)
assert(ak.vector_size(&selector_pseudo_classes) == 2)
var unnamed: CssPageSelector = ---
css_page_selector_construct(&unnamed, none, ak.Vector[CssPagePseudoClass]())
assert(css_page_selector_name(&unnamed) == none)
let unnamed_serialized = css_page_selector_serialize(&unnamed)
assert(ak.string_is_empty(&unnamed_serialized))
test "PseudoElementSelector: known types, legacy single-colon pseudo-elements, accessors (Selector.h, Selector.cpp:659)":
assert(css_selector_pseudo_element_selector_is_known_pseudo_element_type(css_data.PseudoElement.after))
assert(css_selector_pseudo_element_selector_is_known_pseudo_element_type(css_data.PseudoElement.view_transition_old))
assert(not css_selector_pseudo_element_selector_is_known_pseudo_element_type(css_data.PseudoElement.known_pseudo_element_count))
assert(not css_selector_pseudo_element_selector_is_known_pseudo_element_type(css_data.PseudoElement.unknown_web_kit))
assert(css_is_legacy_single_colon_pseudo_element(css_data.PseudoElement.before) and css_is_legacy_single_colon_pseudo_element(css_data.PseudoElement.first_line))
assert(not css_is_legacy_single_colon_pseudo_element(css_data.PseudoElement.marker))
# The unknown -webkit- pseudo-element keeps its name, which serialize prints.
var webkit: CssSelectorPseudoElementSelector = ---
css_selector_pseudo_element_selector_construct_string(&webkit, css_data.PseudoElement.unknown_web_kit, ak.string_from_str("-webkit-thing"))
let webkit_serialized = css_selector_pseudo_element_selector_serialize(&webkit)
assert(ak.string_eq_string_view(&webkit_serialized, ak.sv("::-webkit-thing")))
var idents: ak.Vector[ak.FlyString]
ak.vector_append_t(&idents, ak.fly_string_from_str("a"))
ak.vector_append_t(&idents, ak.fly_string_from_str("1x"))
var part: CssSelectorPseudoElementSelector = ---
css_selector_pseudo_element_selector_construct_css_selector_pseudo_element_se(&part, css_data.PseudoElement.part, CssSelectorPseudoElementSelectorValue.vector_fly_string(idents))
assert(css_selector_pseudo_element_selector_type(&part) == css_data.PseudoElement.part)
let part_idents = css_selector_pseudo_element_selector_ident_list(&part)
assert(ak.vector_size(&part_idents) == 2)
let part_serialized = css_selector_pseudo_element_selector_serialize(&part)
assert(ak.string_eq_string_view(&part_serialized, ak.sv("::part(a \\31 x)")))
test "Selector::relative_to, contains_pseudo_class and the caches (Selector.cpp:681, 222, 841)":
var params: CssParsingParams = ---
css_parsing_params_construct_css_parsing_mode(¶ms)
let list = parse_selector(params, ak.sv(".a:hover + :not(:focus)")) else trap("parses")
assert(ak.vector_size(&list) == 1)
let selector = *ak.vector_first_const(&list)
assert(css_selector_contains_pseudo_class(selector, css_data.PseudoClass.hover))
assert(css_selector_contains_pseudo_class(selector, css_data.PseudoClass.not_))
assert(css_selector_contains_pseudo_class(selector, css_data.PseudoClass.focus)) # from the argument
assert(not css_selector_contains_pseudo_class(selector, css_data.PseudoClass.active))
let parent = CssSelectorSimpleSelector(type_ = CssSelectorSimpleSelectorType.id,
value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_name(css_selector_simple_selector_name_create(ak.fly_string_from_str("P"))))
let relative = css_selector_relative_to(selector, parent)
let relative_serialized = css_selector_serialize(relative)
assert(ak.string_eq_string_view(&relative_serialized, ak.sv("#P .a:hover + :not(:focus)")))
assert(ak.vector_size(&relative.m_compound_selectors) == 3)
# The original keeps its compound selectors and combinators (relative_to copies them).
assert(ak.vector_size(&selector.m_compound_selectors) == 2)
assert(ak.vector_first_const(&selector.m_compound_selectors).combinator == CssSelectorCombinator.none_)
# Specificity and the sibling invalidation distance are computed once and cached.
assert(selector.m_specificity == none)
assert(css_selector_specificity(selector) == 0x300)
assert(selector.m_specificity == 0x300)
assert(css_selector_sibling_invalidation_distance(selector) == 1)
assert(selector.m_sibling_invalidation_distance == 1)
# A selector without the nesting selector absolutizes to itself.
assert(css_selector_absolutized(selector, parent) == selector)