Luce packages
LuceLuce BaseLuciaOS

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(&copy, &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(&copy, 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(&copy)) == 2)
    let static_position = layout_state_used_values_static_position(&copy)
    assert(static_position.m_x == test_layout_state_px(3) and static_position.m_y == test_layout_state_px(4))
    ak.vector_append_t(&copy.line_boxes, LayoutLineBox())
    assert(ak.vector_size(&original.line_boxes) == 1 and ak.vector_size(&copy.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(&copy, &plain)
    assert(copy.m_rare == none and ak.hash_table_size(layout_state_used_values_floating_descendants(&copy)) == 0)