Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / 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(&params)
    _ = ak.hash_table_set(&params.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(&params)
    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)