Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-21 23:59:00 +01:00
Code Issues Projects Releases Packages Wiki Activity

Fix the unit test

Browse source 
These were broken for various issues.
This commit is contained in:
Martin Robinson 2023-05-31 10:32:09 +02:00 • committed by Oriol Brufau
parent 25f6cc04a2
commit 5c5cc4b795
2 changed files with 63 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

26
components/layout_2020/flow/float.rs
View file

@ -40,17 +40,17 @@ pub(crate) struct FloatBox {
/// elements relative to their containing blocks. This data structure is used to
/// help map between these two coordinate systems.
#[derive(Clone, Copy, Debug)]
pub(crate) struct ContainingBlockPositionInfo {
pub struct ContainingBlockPositionInfo {
/// The distance from the block start of the independent block formatting
/// context that contains the floats and the block start of the current
/// containing block, excluding uncollapsed block start margins. Note that
/// this does not include uncollapsed block start margins because we don't
/// know the value of collapsed margins until we lay out children.
pub block_start: Length,
pub(crate) block_start: Length,
/// Any uncollapsed block start margins that we have collected between the
/// block start of the float containing independent block formatting context
/// and this containing block, including for this containing block.
pub block_start_margins_not_collapsed: CollapsedMargin,
pub(crate) block_start_margins_not_collapsed: CollapsedMargin,
/// The distance from the inline start position of the float containing
/// independent formatting context and the inline start of this containing
/// block.
@ -61,9 +61,9 @@ pub(crate) struct ContainingBlockPositionInfo {
pub inline_end: Length,
}
impl ContainingBlockPositionInfo {
fn new() -> ContainingBlockPositionInfo {
ContainingBlockPositionInfo {
impl Default for ContainingBlockPositionInfo {
fn default() -> Self {
Self {
block_start: Length::zero(),
block_start_margins_not_collapsed: CollapsedMargin::zero(),
inline_start: Length::zero(),
@ -72,12 +72,22 @@ impl ContainingBlockPositionInfo {
}
}
impl ContainingBlockPositionInfo {
pub fn new_with_inline_offsets(inline_start: Length, inline_end: Length) -> Self {
Self {
inline_start,
inline_end,
..Default::default()
}
}
}
/// Data kept during layout about the floats in a given block formatting context.
///
/// This is a persistent data structure. Each float has its own private copy of the float context,
/// although such copies may share portions of the `bands` tree.
#[derive(Clone, Debug)]
pub(crate) struct FloatContext {
pub struct FloatContext {
/// A persistent AA tree of float bands.
///
/// This tree is immutable; modification operations return the new tree, which may share nodes
@ -114,7 +124,7 @@ impl FloatContext {
FloatContext {
bands,
ceiling: Length::zero(),
containing_block_info: ContainingBlockPositionInfo::new(),
containing_block_info: Default::default(),
clear_left_position: Length::zero(),
clear_right_position: Length::zero(),
}

84
components/layout_2020/tests/floats.rs
View file

@ -9,7 +9,7 @@ extern crate lazy_static;
use euclid::num::Zero;
use layout::flow::float::{ClearSide, FloatBand, FloatBandNode, FloatBandTree, FloatContext};
use layout::flow::float::{ContainingBlockOffsets, FloatSide, PlacementInfo};
use layout::flow::float::{ContainingBlockPositionInfo, FloatSide, PlacementInfo};
use layout::geom::flow_relative::{Rect, Vec2};
use quickcheck::{Arbitrary, Gen};
use std::f32;
@ -57,8 +57,7 @@ impl<'a> Drop for PanicMsgSuppressor<'a> {
struct FloatBandWrapper(FloatBand);
impl Arbitrary for FloatBandWrapper {
fn arbitrary(generator: &mut Gen) -> FloatBandWrapper
{
fn arbitrary(generator: &mut Gen) -> FloatBandWrapper {
let top: u32 = Arbitrary::arbitrary(generator);
let left: Option<u32> = Arbitrary::arbitrary(generator);
let right: Option<u32> = Arbitrary::arbitrary(generator);
@ -73,21 +72,17 @@ impl Arbitrary for FloatBandWrapper {
#[derive(Clone, Debug)]
struct FloatRangeInput {
start_index: u32,
band_count: u32,
side: FloatSide,
length: u32,
}
impl Arbitrary for FloatRangeInput {
fn arbitrary(generator: &mut Gen) -> FloatRangeInput
{
fn arbitrary(generator: &mut Gen) -> FloatRangeInput {
let start_index: u32 = Arbitrary::arbitrary(generator);
let band_count: u32 = Arbitrary::arbitrary(generator);
let is_left: bool = Arbitrary::arbitrary(generator);
let length: u32 = Arbitrary::arbitrary(generator);
FloatRangeInput {
start_index,
band_count,
side: if is_left {
FloatSide::Left
} else {
@ -337,21 +332,25 @@ struct FloatInput {
// The float may be placed no higher than this line. This simulates the effect of line boxes
// per CSS 2.1 § 9.5.1 rule 6.
ceiling: u32,
/// Distances from the logical left side of the block formatting context to the logical sides
/// of the current containing block.
cb_offset: ContainingBlockOffsets,
/// Containing block positioning information, which is used to track the current offsets
/// from the float containing block formatting context to the current containing block.
containing_block_info: ContainingBlockPositionInfo,
}
impl Arbitrary for FloatInput {
fn arbitrary(generator: &mut Gen) -> FloatInput
{
let width: u32 = Arbitrary::arbitrary(generator);
let height: u32 = Arbitrary::arbitrary(generator);
let is_left: bool = Arbitrary::arbitrary(generator);
let ceiling: u32 = Arbitrary::arbitrary(generator);
let left: u32 = Arbitrary::arbitrary(generator);
let right: u32 = Arbitrary::arbitrary(generator);
let clear: u8 = Arbitrary::arbitrary(generator);
fn arbitrary(generator: &mut Gen) -> FloatInput {
// See #29819: Limit the maximum size of all f32 values here because
// massive float values will start to introduce very bad floating point
// errors.
// TODO: This should be be addressed in a better way. Perhaps we should
// reintroduce the use of app_units in Layout 2020.
let width = u32::arbitrary(generator) % 12345;
let height = u32::arbitrary(generator) % 12345;
let is_left = bool::arbitrary(generator);
let ceiling = u32::arbitrary(generator) % 12345;
let left = u32::arbitrary(generator) % 12345;
let containing_block_width = u32::arbitrary(generator) % 12345;
let clear = u8::arbitrary(generator);
FloatInput {
info: PlacementInfo {
size: Vec2 {
@ -366,11 +365,10 @@ impl Arbitrary for FloatInput {
clear: new_clear_side(clear),
},
ceiling,
cb_offset: ContainingBlockOffsets {
top: Length::zero(),
left: Length::new(left as f32),
right: Length::new(right as f32),
},
containing_block_info: ContainingBlockPositionInfo::new_with_inline_offsets(
Length::new(left as f32),
Length::new(left as f32 + containing_block_width as f32),
),
}
}
@ -389,12 +387,12 @@ impl Arbitrary for FloatInput {
this.info.clear = new_clear_side(clear_side);
shrunk = true;
}
if let Some(left) = self.cb_offset.left.px().shrink().next() {
this.cb_offset.left = Length::new(left);
if let Some(left) = self.containing_block_info.inline_start.px().shrink().next() {
this.containing_block_info.inline_start = Length::new(left);
shrunk = true;
}
if let Some(right) = self.cb_offset.right.px().shrink().next() {
this.cb_offset.right = Length::new(right);
if let Some(right) = self.containing_block_info.inline_end.px().shrink().next() {
this.containing_block_info.inline_end = Length::new(right);
shrunk = true;
}
if let Some(ceiling) = self.ceiling.shrink().next() {
@ -430,7 +428,7 @@ struct PlacedFloat {
origin: Vec2<Length>,
info: PlacementInfo,
ceiling: Length,
walls: ContainingBlockOffsets,
containing_block_info: ContainingBlockPositionInfo,
}
impl Drop for FloatPlacement {
@ -447,8 +445,8 @@ impl Drop for FloatPlacement {
placed_float.info,
placed_float.origin,
placed_float.ceiling,
placed_float.walls.left,
placed_float.walls.right,
placed_float.containing_block_info.inline_start,
placed_float.containing_block_info.inline_end,
);
}
eprintln!("Bands:\n{:?}\n", self.float_context.bands);
@ -471,12 +469,12 @@ impl FloatPlacement {
for float in floats {
let ceiling = Length::new(float.ceiling as f32);
float_context.lower_ceiling(ceiling);
float_context.cb_bfc_distance = float.cb_offset;
float_context.containing_block_info = float.containing_block_info;
placed_floats.push(PlacedFloat {
origin: float_context.add_float(&float.info),
info: float.info,
ceiling,
walls: float.cb_offset,
containing_block_info: float.containing_block_info,
})
}
FloatPlacement {
@ -495,9 +493,14 @@ impl FloatPlacement {
fn check_floats_rule_1(placement: &FloatPlacement) {
for placed_float in &placement.placed_floats {
match placed_float.info.side {
FloatSide::Left => assert!(placed_float.origin.inline >= placed_float.walls.left),
FloatSide::Left => assert!(
placed_float.origin.inline >= placed_float.containing_block_info.inline_start
),
FloatSide::Right => {
assert!(placed_float.rect().max_inline_position() <= placed_float.walls.right)
assert!(
placed_float.rect().max_inline_position() <=
placed_float.containing_block_info.inline_end
)
},
}
}
@ -603,12 +606,14 @@ fn check_floats_rule_7(placement: &FloatPlacement) {
// Only consider floats that stick out.
match placed_float.info.side {
FloatSide::Left => {
if placed_float.rect().max_inline_position() <= placed_float.walls.right {
if placed_float.rect().max_inline_position() <=
placed_float.containing_block_info.inline_end
{
continue;
}
},
FloatSide::Right => {
if placed_float.origin.inline >= placed_float.walls.left {
if placed_float.origin.inline >= placed_float.containing_block_info.inline_start {
continue;
}
},
@ -668,7 +673,7 @@ fn check_floats_rule_9(floats_and_perturbations: Vec<(FloatInput, u32)>) {
let mut placement = placement.clone();
{
let mut placed_float = &mut placement.placed_floats[float_index];
let placed_float = &mut placement.placed_floats[float_index];
let perturbation = Length::new(perturbation as f32);
match placed_float.info.side {
FloatSide::Left => {
@ -754,6 +759,7 @@ fn check_basic_float_rules(placement: &FloatPlacement) {
fn test_floats_rule_1() {
let f: fn(Vec<FloatInput>) = check;
quickcheck::quickcheck(f);
fn check(floats: Vec<FloatInput>) {
check_floats_rule_1(&FloatPlacement::place(floats));
}