Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / painting / tests_paintables.lucb

#==============================================================================================
#
#   tests_paintables - queries and hit tests of committed paint trees, pinned to the reference
#                      build
#
#   DESCRIPTION:
#       The donor has no unit tests for Painting/. These run the cases of tests_paintables_cases
#       (a local oracle over the reference build's LibWeb, luce-browser-tools,
#       oracles/luce-browser-engine/layout_geometry, modes "paint" and "paintables") through the
#       port: a document is laid out and committed with the harness of tests_layout_geometry,
#       then every paintable of the paint tree is queried in pre-order (its flags, containing
#       block, enclosing stacking context, ::selection background, every absolute rect of a
#       paintable box, border radii, z-index and the overflow, scrolling and resize predicates,
#       outline offset and CSS clip; each fragment's rect, orientation, range rects for each
#       selection state and the code unit under points across it), and in "paint" mode the
#       viewport is hit tested (exact and text cursor) at a grid of points. Mode "selection S SO E
#       EO" selects a range between two text nodes and compares the selection states and the
#       fragments' range rects.
#
#==============================================================================================

# mark: The queries ================================================================================

## "1" or "0" (the oracle's `yn`).
func test_paintables_yn(value: bool) -> str:
    return "1" if value else "0"

## A paintable's debug description, or "-" (the oracle's `desc`).
func test_paintables_desc(builder: ak.StringBuilder*, paintable: PaintPaintable*?):
    if let found = paintable:
        let description = paint_paintable_debug_description(found)
        ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&description))
    else:
        ak.string_builder_append(builder, "-")

## A paintable box's debug description, or "-".
func test_paintables_desc_box(builder: ak.StringBuilder*, paintable_box: PaintPaintableBox*?):
    if let found = paintable_box:
        test_paintables_desc(builder, found.paint_paintable())
    else:
        test_paintables_desc(builder, none)

## A CSSPixels value as AK formats it.
func test_paintables_px(builder: ak.StringBuilder*, value: gfx.CssPixels):
    dump_appendff(builder, "{}", [dump_arg_css_pixels(value)])

## The oracle's `put_radii`.
func test_paintables_put_radii(builder: ak.StringBuilder*, name: str, radii: display_list.BorderRadiiData):
    ak.string_builder_append(builder, "  ")
    ak.string_builder_append(builder, name)
    let values: gfx.CssPixels[8] = [radii.top_left.horizontal_radius, radii.top_left.vertical_radius, radii.top_right.horizontal_radius, radii.top_right.vertical_radius,
                                    radii.bottom_right.horizontal_radius, radii.bottom_right.vertical_radius, radii.bottom_left.horizontal_radius, radii.bottom_left.vertical_radius]
    for value in values:
        ak.string_builder_append(builder, " ")
        test_paintables_px(builder, value)
    ak.string_builder_append(builder, "\n")

## The queries of one paintable box.
func test_paintables_put_box(b: ak.StringBuilder*, p: PaintPaintable*, box: PaintPaintableBox*):
    if not paint_paintable_is_viewport_paintable(p):
        ak.string_builder_append(b, "  enclosing_sc ")
        let enclosing = paint_paintable_enclosing_stacking_context(p) else trap("no enclosing stacking context")
        test_paintables_desc_box(b, paint_stacking_context_paintable_box(enclosing))
        ak.string_builder_append(b, "\n")
    ak.string_builder_append(b, "  rect ")
    dump_append_css_pixel_rect(b, paint_paintable_box_absolute_rect(box))
    ak.string_builder_append(b, " padding ")
    dump_append_css_pixel_rect(b, paint_paintable_box_absolute_padding_box_rect(box))
    ak.string_builder_append(b, " border ")
    dump_append_css_pixel_rect(b, paint_paintable_box_absolute_border_box_rect(box))
    ak.string_builder_append(b, "\n  united border ")
    dump_append_css_pixel_rect(b, paint_paintable_box_absolute_united_border_box_rect(box))
    ak.string_builder_append(b, " content ")
    dump_append_css_pixel_rect(b, paint_paintable_box_absolute_united_content_rect(box))
    ak.string_builder_append(b, " padding ")
    dump_append_css_pixel_rect(b, paint_paintable_box_absolute_united_padding_box_rect(box))
    ak.string_builder_append(b, "\n  clip_edge ")
    dump_append_css_pixel_rect(b, paint_paintable_box_overflow_clip_edge_rect(box))
    ak.string_builder_append(b, " reference ")
    dump_append_css_pixel_rect(b, paint_paintable_box_transform_reference_box(box))
    ak.string_builder_append(b, "\n")
    test_paintables_put_radii(b, "radii", paint_paintable_box_border_radii_data(box))
    test_paintables_put_radii(b, "shrunk", paint_paintable_box_normalized_border_radii_data(box, PaintPaintableBoxShrinkRadiiForBorders.yes))
    if let z = paint_paintable_box_effective_z_index(box):
        dump_appendff(b, "  z {}", [ak.arg_i64((i64)z)])
    else:
        ak.string_builder_append(b, "  z auto")
    let axes = paint_paintable_box_physical_resize_axes(box)
    dump_appendff(b, " scrollable {} wheel {} {} overflow_applies {} mirrored {} resizer {} axes {} {} transform {}\n", [
        ak.arg_str(test_paintables_yn(paint_paintable_box_has_scrollable_overflow(box))),
        ak.arg_str(test_paintables_yn(paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(box, PaintPaintableBoxScrollDirection.horizontal))),
        ak.arg_str(test_paintables_yn(paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(box, PaintPaintableBoxScrollDirection.vertical))),
        ak.arg_str(test_paintables_yn(paint_paintable_box_overflow_property_applies(box))),
        ak.arg_str(test_paintables_yn(paint_paintable_box_is_chrome_mirrored(box))),
        ak.arg_str(test_paintables_yn(paint_paintable_box_has_resizer(box))),
        ak.arg_str(test_paintables_yn(axes.horizontal)),
        ak.arg_str(test_paintables_yn(axes.vertical)),
        ak.arg_str(test_paintables_yn(paint_paintable_box_has_css_transform(box))),
    ])
    ak.string_builder_append(b, "  outline_offset ")
    test_paintables_px(b, paint_paintable_box_outline_offset(box))
    ak.string_builder_append(b, " scrollable_ancestor ")
    test_paintables_desc_box(b, paint_paintable_box_nearest_scrollable_ancestor(box))
    if let clip = paint_paintable_box_get_clip_rect(box):
        ak.string_builder_append(b, " clip ")
        dump_append_css_pixel_rect(b, clip)
    ak.string_builder_append(b, "\n")

## The queries of one fragment.
func test_paintables_put_fragment(b: ak.StringBuilder*, index: usize, f: const PaintPaintableFragment*):
    let rect = paint_paintable_fragment_absolute_rect(f)
    let start = paint_paintable_fragment_start_offset(f)
    let length = paint_paintable_fragment_length_in_code_units(f)
    dump_appendff(b, "  frag {} ", [ak.arg_u64((u64)index)])
    test_paintables_desc(b, paint_paintable_fragment_paintable(f))
    dump_appendff(b, " {} ", [ak.arg_u64((u64)start)])
    dump_append_css_pixel_rect(b, rect)
    dump_appendff(b, " orientation {} trailing {}\n", [ak.arg_i64((i64)paint_paintable_fragment_orientation(f)), ak.arg_str(test_paintables_yn(paint_paintable_fragment_has_trailing_whitespace(f)))])
    ak.string_builder_append(b, "    range ")
    dump_append_css_pixel_rect(b, paint_paintable_fragment_range_rect(f, PaintPaintableSelectionState.start_and_end, start + 1, start + (length - 1 if length > 1 else 0)))
    ak.string_builder_append(b, " full ")
    dump_append_css_pixel_rect(b, paint_paintable_fragment_range_rect(f, PaintPaintableSelectionState.full, 0, 0))
    ak.string_builder_append(b, " start ")
    dump_append_css_pixel_rect(b, paint_paintable_fragment_range_rect(f, PaintPaintableSelectionState.start, start + 1, 0))
    ak.string_builder_append(b, " end ")
    dump_append_css_pixel_rect(b, paint_paintable_fragment_range_rect(f, PaintPaintableSelectionState.end, 0, start + 2))
    ak.string_builder_append(b, " cursor ")
    dump_append_css_pixel_rect(b, paint_paintable_fragment_range_rect(f, PaintPaintableSelectionState.start_and_end, start + 1, start + 1))
    ak.string_builder_append(b, "\n    index")
    for k in -1..=5:
        # CSSPixelPoint { rect.x() + rect.width() * k / 4, rect.y() + rect.height() / 2 }
        let x = gfx.css_pixel_rect_x(&rect).add(layout_div_int(gfx.mul_css_pixels_int(gfx.css_pixel_rect_width(&rect), k), 4))
        let y = gfx.css_pixel_rect_y(&rect).add(layout_div_int(gfx.css_pixel_rect_height(&rect), 2))
        dump_appendff(b, " {}", [ak.arg_u64((u64)paint_paintable_fragment_index_in_node_for_point(f, gfx.CssPixelPoint(x, y)))])
    ak.string_builder_append(b, "\n")

## The queries of one paintable (the oracle's run_paint traversal).
func test_paintables_put_paintable(b: ak.StringBuilder*, index: usize, p: PaintPaintable*):
    dump_appendff(b, "#{} ", [ak.arg_u64((u64)index)])
    test_paintables_desc(b, p)
    dump_appendff(b, " positioned {} fixed {} sticky {} abspos {} floating {} inline {} visible {} hittable {} sc {}\n", [
        ak.arg_str(test_paintables_yn(paint_paintable_is_positioned(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_is_fixed_position(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_is_sticky_position(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_is_absolutely_positioned(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_is_floating(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_is_inline(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_is_visible(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_visible_for_hit_testing(p))),
        ak.arg_str(test_paintables_yn(paint_paintable_has_stacking_context(p))),
    ])
    ak.string_builder_append(b, "  containing_block ")
    test_paintables_desc_box(b, paint_paintable_containing_block(p))
    ak.string_builder_append(b, "\n")
    if paint_paintable_is_paintable_box(p) or paint_paintable_is_inline(p):
        ak.string_builder_append(b, "  agnostic ")
        dump_append_css_pixel_point(b, paint_paintable_box_type_agnostic_position(p))
        ak.string_builder_append(b, "\n")
    let selection_style = paint_paintable_selection_style(p)
    dump_appendff(b, "  selection {} {}\n", [ak.arg_u64((u64)selection_style.background_color.m_value), ak.arg_str(test_paintables_yn(paint_paintable_selection_style_has_styling(&selection_style)))])
    if let box = as_if_paint_paintable_box(p):
        test_paintables_put_box(b, p, box)
    if let lines = as_if_paint_paintable_with_lines(p):
        let fragments = paint_paintable_with_lines_fragments(lines)
        for i in 0..<ak.vector_size(fragments):
            test_paintables_put_fragment(b, i, ak.vector_at(fragments, i))

# mark: Hit tests ==================================================================================

## The oracle's `put_hit`.
func test_paintables_put_hit(b: ak.StringBuilder*, result: PaintHitTestResult?):
    if result == none:
        ak.string_builder_append(b, "-")
        return
    let hit = result else trap("unreachable")
    test_paintables_desc(b, hit.paintable)
    dump_appendff(b, " {}", [ak.arg_u64((u64)hit.index_in_node)])
    if let vertical = hit.vertical_distance:
        ak.string_builder_append(b, " v ")
        test_paintables_px(b, vertical)
    if let horizontal = hit.horizontal_distance:
        ak.string_builder_append(b, " h ")
        test_paintables_px(b, horizontal)

# mark: Selections =================================================================================

## The numbers of a "selection S SO E EO" mode (its four decimal fields after the word).
func test_paintables_selection_numbers(mode: str) -> u32[4]:
    var numbers: u32[4] = [0, 0, 0, 0]
    var field: i64 = -1
    var in_number = false
    for character in mode:
        if character >= '0' and character <= '9':
            if not in_number:
                field += 1
                in_number = true
            numbers[(usize)field] = numbers[(usize)field] * 10 + ((u32)character - 48)
        else:
            in_number = false
    return numbers

## The oracle's run_selection: a range between offsets of two text nodes (the document's text nodes in pre-order),
## ViewportPaintable::recompute_selection_states, each paintable's state and each fragment's range rect for it.
func test_paintables_put_selection(b: ak.StringBuilder*, document: DomDocument*, viewport: PaintViewportPaintable*, mode: str):
    let numbers = test_paintables_selection_numbers(mode)
    var texts: ak.Vector[DomNode*]
    for node in dom_node_inclusive_subtree(document.dom_node()):
        if is_dom_text(node):
            ak.vector_append_t(&texts, node)
    let range = dom_range_create_dom_document(document)
    dom_range_set_start(range, *ak.vector_at(&texts, (usize)numbers[0]), numbers[1]) else trap("MUST: Range::set_start")
    dom_range_set_end(range, *ak.vector_at(&texts, (usize)numbers[2]), numbers[3]) else trap("MUST: Range::set_end")
    paint_viewport_paintable_recompute_selection_states(viewport, range)
    let start_offset = (usize)dom_abstract_range_start_offset(range.dom_abstract_range())
    let end_offset = (usize)dom_abstract_range_end_offset(range.dom_abstract_range())
    var index: usize = 0
    for p in paint_paintable_inclusive_subtree(viewport.paint_paintable()):
        dump_appendff(b, "#{} ", [ak.arg_u64((u64)index)])
        index += 1
        test_paintables_desc(b, p)
        dump_appendff(b, " state {}\n", [ak.arg_u64((u64)paint_paintable_selection_state(p))])
        let lines = as_if_paint_paintable_with_lines(p) else continue
        let fragments = paint_paintable_with_lines_fragments(lines)
        for i in 0..<ak.vector_size(fragments):
            let fragment = ak.vector_at(fragments, i)
            dump_appendff(b, "  frag {} ", [ak.arg_u64((u64)i)])
            dump_append_css_pixel_rect(b, paint_paintable_fragment_range_rect(fragment, paint_paintable_selection_state(paint_paintable_fragment_paintable(fragment)), start_offset, end_offset))
            ak.string_builder_append(b, "\n")

# mark: Running the cases ==========================================================================

## Runs one case ("paint" or "paintables") and answers its output.
func test_paintables_run_case(heap: gc.Heap*, realm: Realm*, test_case: const TestLayoutGeometryCase*) -> ak.String:
    var out = ak.string_builder_new()
    var (document, navigable) = test_layout_tree_parse_and_style(heap, realm, test_case.html, test_case.css)
    defer gc.root_release(&navigable)
    test_layout_geometry_update_layout(document)
    gc.heap_collect_garbage(heap)

    let viewport = dom_document_unsafe_paintable(document) else trap("no paint tree")
    paint_viewport_paintable_build_stacking_context_tree_if_needed(viewport)
    var b = ak.string_builder_new()
    if test_case.mode.bytes.length > 10 and (str)test_case.mode.bytes[0..<10] == "selection ":
        test_paintables_put_selection(&b, document, viewport, test_case.mode)
        test_layout_tree_put_lines(&out, ak.string_builder_string_view(&b))
        return ak.string_builder_to_string_without_validation(&out)
    var index: usize = 0
    for p in paint_paintable_inclusive_subtree(viewport.paint_paintable()):
        test_paintables_put_paintable(&b, index, p)
        index += 1
    if test_case.mode == "paint":
        var y: i64 = 2
        while y < 300:
            var x: i64 = 3
            while x < 420:
                dump_appendff(&b, "hit {},{} exact ", [ak.arg_i64(x), ak.arg_i64(y)])
                let point = gfx.CssPixelPoint(gfx.CssPixels.from_int(x), gfx.CssPixels.from_int(y))
                test_paintables_put_hit(&b, paint_paintable_box_hit_test(viewport.paint_paintable_box(), point, PaintHitTestType.exact))
                ak.string_builder_append(&b, " cursor ")
                test_paintables_put_hit(&b, paint_paintable_box_hit_test(viewport.paint_paintable_box(), point, PaintHitTestType.text_cursor))
                ak.string_builder_append(&b, "\n")
                x += 21
            y += 14
    test_layout_tree_put_lines(&out, ak.string_builder_string_view(&b))
    return ak.string_builder_to_string_without_validation(&out)

# mark: Tests ======================================================================================

test "paint tree queries (flags, rects, radii, fragments, range rects), hit tests and selection states match the reference build":
    web_initialize_strings()
    test_fonts_setup()
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var (realm, realm_root) = test_layout_tree_window_realm(vm)
    defer gc.root_release(&realm_root)
    let heap = vm_heap(vm)
    var passed: usize = 0
    var failed: usize = 0
    let allocator: memory.Allocator = heap
    with allocator:
        test_page_client_color_scheme = CssPreferredColorScheme.light
        defer test_page_client_color_scheme = CssPreferredColorScheme.auto
        test_media_invalidation_install_user_agent_sheets(realm)
        defer test_style_computer_release_user_agent_sheets()
        for test_case in &test_paintables_cases:
            let actual = test_paintables_run_case(heap, realm, test_case)
            let actual_view = ak.string_bytes_as_string_view(&actual)
            if ak.string_view_equals(&actual_view, test_case.expected):
                passed += 1
            else:
                failed += 1
                print(f"paintables case mismatch: {test_case.html} / {test_case.css}")
                print(f"expected:\n{test_case.expected}actual:\n{ak.string_view_text(actual_view)}")
    print(f"paintables: {passed} passed, {failed} failed")
    assert(failed == 0)
    assert(passed > 0)