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)