dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / layout / tests_layout_state.lucb
#==============================================================================================
#
# tests_layout_state - AvailableSize, AvailableSpace, PagedStore, StaticPositionRect and
# LayoutState::UsedValues on their own
#
# DESCRIPTION:
# The donor has no unit tests for these files; these pin the behavior of their C++
# (AvailableSpace.cpp/.h, LayoutState.cpp/.h, FormattingContext.h's css_clamp): the debug
# strings and comparisons of available sizes, the page table of used values,
# aligned static positions, box edges with collapsed borders, content size setters,
# the available inner space, and UsedValues' copy assignment (a deep copy of the rare
# data and the line boxes).
#
#==============================================================================================
# mark: Helpers =================================================================================
## `CSSPixels(value)` of an integer.
func test_layout_state_px(value: i64) -> gfx.CssPixels:
return gfx.CssPixels.from_int(value)
## Whether `string` is `expected`.
func test_layout_state_string_is(string: ak.String, expected: str) -> bool:
let view = ak.string_bytes_as_string_view(&string)
return ak.string_view_equals(&view, expected)
# mark: AvailableSize and AvailableSpace ========================================================
test "AvailableSize: the four kinds, their pixel values and debug strings":
let definite = layout_available_size_make_definite(gfx.CssPixels.from_f64(12.5))
let indefinite = layout_available_size_make_indefinite()
let min_content = layout_available_size_make_min_content()
let max_content = layout_available_size_make_max_content()
assert(layout_available_size_is_definite(&definite) and not layout_available_size_is_intrinsic_sizing_constraint(&definite))
assert(layout_available_size_is_indefinite(&indefinite) and not layout_available_size_is_intrinsic_sizing_constraint(&indefinite))
assert(layout_available_size_is_min_content(&min_content) and layout_available_size_is_intrinsic_sizing_constraint(&min_content))
assert(layout_available_size_is_max_content(&max_content) and layout_available_size_is_intrinsic_sizing_constraint(&max_content))
assert(layout_available_size_to_px_or_zero(&definite) == gfx.CssPixels.from_f64(12.5))
assert(layout_available_size_to_px_or_zero(&indefinite) == test_layout_state_px(0))
assert(layout_available_size_to_px_or_zero(&max_content) == test_layout_state_px(0))
# The stored values: CSSPixels::max() for the unbounded kinds, 0 for min-content.
assert(indefinite.m_value == gfx.css_pixels_max() and max_content.m_value == gfx.css_pixels_max() and min_content.m_value == test_layout_state_px(0))
assert(test_layout_state_string_is(layout_available_size_to_string(&definite), "definite(12.5)"))
assert(test_layout_state_string_is(layout_available_size_to_string(&indefinite), "indefinite"))
assert(test_layout_state_string_is(layout_available_size_to_string(&min_content), "min-content"))
assert(test_layout_state_string_is(layout_available_size_to_string(&max_content), "max-content"))
let space = LayoutAvailableSpace(width = layout_available_size_make_definite(test_layout_state_px(800)), height = indefinite)
assert(test_layout_state_string_is(layout_available_space_to_string(&space), "definite(800) x indefinite"))
var constructed: LayoutAvailableSpace = ---
layout_available_space_construct(&constructed, min_content, max_content)
assert(constructed.width == min_content and constructed.height == max_content)
test "AvailableSize: comparisons with CSSPixels and with each other":
let ten = layout_available_size_make_definite(test_layout_state_px(10))
let indefinite = layout_available_size_make_indefinite()
let min_content = layout_available_size_make_min_content()
let max_content = layout_available_size_make_max_content()
# CSSPixels > AvailableSize
assert(layout_gt(test_layout_state_px(11), ten) and not layout_gt(test_layout_state_px(10), ten))
assert(not layout_gt(test_layout_state_px(1000000), indefinite) and not layout_gt(test_layout_state_px(1000000), max_content))
assert(layout_gt(test_layout_state_px(-5), min_content))
# CSSPixels < AvailableSize
assert(layout_lt_css_pixels(test_layout_state_px(9), ten) and not layout_lt_css_pixels(test_layout_state_px(10), ten))
assert(layout_lt_css_pixels(test_layout_state_px(1000000), indefinite) and layout_lt_css_pixels(test_layout_state_px(1000000), max_content))
assert(not layout_lt_css_pixels(test_layout_state_px(-5), min_content))
# AvailableSize < CSSPixels
assert(layout_lt_layout_available_size(ten, test_layout_state_px(11)) and not layout_lt_layout_available_size(ten, test_layout_state_px(10)))
assert(layout_lt_layout_available_size(min_content, test_layout_state_px(-1000)))
assert(not layout_lt_layout_available_size(indefinite, test_layout_state_px(5)) and not layout_lt_layout_available_size(max_content, test_layout_state_px(5)))
# AvailableSize < AvailableSize compares the stored values only.
assert(layout_available_size_lt(&min_content, ten) and layout_available_size_lt(&ten, indefinite) and not layout_available_size_lt(&indefinite, max_content))
test "css_clamp lets min exceed max; clamp_to_max_dimension_value clamps saturated values":
assert(layout_css_clamp(5i64, 10i64, 3i64) == 10)
assert(layout_css_clamp(5i64, 1i64, 3i64) == 3)
assert(layout_css_clamp(test_layout_state_px(2), test_layout_state_px(1), test_layout_state_px(3)) == test_layout_state_px(2))
assert(layout_clamp_to_max_dimension_value(gfx.css_pixels_max()) == gfx.CssPixels.from_f32(17895700.0))
assert(layout_clamp_to_max_dimension_value(gfx.css_pixels_min()) == gfx.CssPixels.from_f32(17895700.0))
assert(layout_clamp_to_max_dimension_value(test_layout_state_px(123)) == test_layout_state_px(123))
# mark: StaticPositionRect and PagedStore =======================================================
test "StaticPositionRect aligns a box of a size at the start, center or end of its rectangle":
var rect = LayoutStaticPositionRect(rect = gfx.CssPixelRect(gfx.CssPixelPoint(test_layout_state_px(10), test_layout_state_px(20)), gfx.CssPixelSize(test_layout_state_px(100), test_layout_state_px(51))))
let size = gfx.CssPixelSize(test_layout_state_px(20), test_layout_state_px(10))
var position = layout_static_position_rect_aligned_position_for_box_with_size(&rect, size)
assert(position.m_x == test_layout_state_px(10) and position.m_y == test_layout_state_px(20))
rect.horizontal_alignment = LayoutStaticPositionRectAlignment.center
rect.vertical_alignment = LayoutStaticPositionRectAlignment.center
position = layout_static_position_rect_aligned_position_for_box_with_size(&rect, size)
# (51 - 10) / 2 is a CSSPixelFraction read as CSSPixels: 20.5.
assert(position.m_x == test_layout_state_px(50) and position.m_y == gfx.CssPixels.from_f64(40.5))
rect.horizontal_alignment = LayoutStaticPositionRectAlignment.end
rect.vertical_alignment = LayoutStaticPositionRectAlignment.end
position = layout_static_position_rect_aligned_position_for_box_with_size(&rect, size)
assert(position.m_x == test_layout_state_px(90) and position.m_y == test_layout_state_px(61))
test "PagedStore maps layout indices to used values page by page":
var store: LayoutPagedStore[LayoutStateUsedValues]
layout_paged_store_ensure_capacity(&store, 5)
assert(ak.vector_size(&store.m_pages) == 1)
assert(layout_paged_store_get(&store, 3) == none)
assert(layout_paged_store_get(&store, 100) == none)
let three = layout_paged_store_allocate(&store, 3)
three.margin_left = test_layout_state_px(7)
let forty = layout_paged_store_allocate(&store, 40)
forty.margin_left = test_layout_state_px(9)
assert(ak.vector_size(&store.m_pages) == 3)
assert(layout_paged_store_get(&store, 3) == three and layout_paged_store_get(&store, 40) == forty)
assert(layout_paged_store_get(&store, 17) == none and layout_paged_store_get(&store, 4) == none)
var seen: ak.Vector[gfx.CssPixels]
for used_values in layout_paged_store_for_each(&store):
ak.vector_append_t(&seen, used_values.margin_left)
assert(ak.vector_size(&seen) == 2 and *ak.vector_at(&seen, 0) == test_layout_state_px(7) and *ak.vector_at(&seen, 1) == test_layout_state_px(9))
# allocate() resets an existing entry to T {}, at the same address.
let again = layout_paged_store_allocate(&store, 3)
assert(again == three and again.margin_left == test_layout_state_px(0))
# mark: UsedValues ==============================================================================
test "UsedValues: box edges, collapsed borders and the content size setters":
var used_values = LayoutStateUsedValues()
used_values.margin_left = test_layout_state_px(1)
used_values.border_left = test_layout_state_px(5)
used_values.padding_left = test_layout_state_px(2)
used_values.margin_right = test_layout_state_px(3)
used_values.border_right = test_layout_state_px(3)
used_values.padding_right = test_layout_state_px(4)
used_values.border_top = test_layout_state_px(3)
layout_state_used_values_set_content_width(&used_values, test_layout_state_px(100))
assert(layout_state_used_values_has_definite_width(&used_values))
assert(layout_state_used_values_margin_box_width(&used_values) == test_layout_state_px(118))
assert(layout_state_used_values_border_box_width(&used_values) == test_layout_state_px(114))
assert(layout_state_used_values_padding_box_width(&used_values) == test_layout_state_px(106))
assert(not layout_state_used_values_use_collapsing_borders_model(&used_values))
# The collapsing border model halves the borders, rounded: 5 / 2 = 2.5 -> 3, 3 / 2 = 1.5 -> 2.
layout_state_used_values_set_override_borders_data(&used_values, PaintPaintableBoxBordersDataWithElementKind())
assert(layout_state_used_values_use_collapsing_borders_model(&used_values))
assert(layout_state_used_values_border_left_collapsed(&used_values) == test_layout_state_px(3))
assert(layout_state_used_values_border_top_collapsed(&used_values) == test_layout_state_px(2))
assert(layout_state_used_values_margin_box_width(&used_values) == test_layout_state_px(1 + 3 + 2 + 100 + 4 + 2 + 3))
# Negative sizes are clamped to 0; a width becomes definite, a height does not.
layout_state_used_values_set_content_width(&used_values, test_layout_state_px(-10))
assert(layout_state_used_values_content_width(&used_values) == test_layout_state_px(0))
layout_state_used_values_set_content_height(&used_values, test_layout_state_px(-10))
assert(layout_state_used_values_content_height(&used_values) == test_layout_state_px(0) and not layout_state_used_values_has_definite_height(&used_values))
layout_state_used_values_set_indefinite_content_width(&used_values)
assert(not layout_state_used_values_has_definite_width(&used_values))
test "UsedValues: the available inner space and its intrinsic sizing constraints":
var used_values = LayoutStateUsedValues()
layout_state_used_values_set_content_width(&used_values, test_layout_state_px(300))
let outer = LayoutAvailableSpace(width = layout_available_size_make_definite(test_layout_state_px(800)), height = layout_available_size_make_max_content())
var inner = layout_state_used_values_available_inner_space_or_constraints_from(&used_values, outer)
assert(inner.width == layout_available_size_make_definite(test_layout_state_px(300)))
# An indefinite inner height takes the outer intrinsic sizing constraint.
assert(inner.height == layout_available_size_make_max_content())
let definite_outer = LayoutAvailableSpace(width = outer.width, height = layout_available_size_make_definite(test_layout_state_px(50)))
inner = layout_state_used_values_available_inner_space_or_constraints_from(&used_values, definite_outer)
assert(layout_available_size_is_indefinite(&inner.height))
# A width constraint wins over a definite width (which it makes indefinite).
used_values.width_constraint = LayoutSizeConstraint.min_content
assert(not layout_state_used_values_has_definite_width(&used_values))
inner = layout_state_used_values_available_inner_space_or_constraints_from(&used_values, outer)
assert(layout_available_size_is_min_content(&inner.width))
test "UsedValues: copy assignment copies the rare data and the line boxes":
var markers: u8[2]
let first_box = (LayoutBox*)&markers[0]
let second_box = (LayoutBox*)&markers[1]
var original = LayoutStateUsedValues()
original.margin_top = test_layout_state_px(4)
layout_state_used_values_add_floating_descendant(&original, first_box)
layout_state_used_values_set_static_position_rect(&original, LayoutStaticPositionRect(rect = gfx.CssPixelRect(gfx.CssPixelPoint(test_layout_state_px(3), test_layout_state_px(4)), gfx.CssPixelSize())))
ak.vector_append_t(&original.line_boxes, LayoutLineBox())
var copy = LayoutStateUsedValues()
layout_state_used_values_assign(©, &original)
assert(copy.margin_top == test_layout_state_px(4))
assert(copy.m_rare != none and copy.m_rare != original.m_rare)
layout_state_used_values_add_floating_descendant(©, second_box)
assert(ak.hash_table_size(layout_state_used_values_floating_descendants(&original)) == 1)
assert(ak.hash_table_size(layout_state_used_values_floating_descendants(©)) == 2)
let static_position = layout_state_used_values_static_position(©)
assert(static_position.m_x == test_layout_state_px(3) and static_position.m_y == test_layout_state_px(4))
ak.vector_append_t(©.line_boxes, LayoutLineBox())
assert(ak.vector_size(&original.line_boxes) == 1 and ak.vector_size(©.line_boxes) == 2)
# Without rare data, the copy has none either; with none, floating_descendants() is the shared empty table.
var plain = LayoutStateUsedValues()
layout_state_used_values_assign(©, &plain)
assert(copy.m_rare == none and ak.hash_table_size(layout_state_used_values_floating_descendants(©)) == 0)