path: root/components/layout_2020/tests/floats.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

//! Property-based randomized testing for the core float layout algorithm.

use std::f32::INFINITY;
use std::ops::Range;
use std::panic::{self, PanicHookInfo};
use std::sync::{Mutex, MutexGuard};
use std::{thread, u32};

use app_units::Au;
use euclid::num::Zero;
use layout_2020::flow::float::{
    Clear, ContainingBlockPositionInfo, FloatBand, FloatBandNode, FloatBandTree, FloatContext,
    FloatSide, PlacementInfo,
};
use layout_2020::geom::{LogicalRect, LogicalVec2};
use quickcheck::{Arbitrary, Gen};

static PANIC_HOOK_MUTEX: Mutex<()> = Mutex::new(());

// Suppresses panic messages. Some tests need to fail and we don't want them to spam the console.
// Note that, because the panic hook is process-wide, tests that are expected to fail might
// suppress panic messages from other failing tests. To work around this, run failing tests one at
// a time or use only a single test thread.
struct PanicMsgSuppressor<'a> {
    #[allow(dead_code)]
    mutex_guard: MutexGuard<'a, ()>,
    prev_hook: Option<Box<dyn Fn(&PanicHookInfo<'_>) + 'static + Sync + Send>>,
}

impl<'a> PanicMsgSuppressor<'a> {
    fn new(mutex_guard: MutexGuard<'a, ()>) -> PanicMsgSuppressor<'a> {
        let prev_hook = panic::take_hook();
        panic::set_hook(Box::new(|_| ()));
        PanicMsgSuppressor {
            mutex_guard,
            prev_hook: Some(prev_hook),
        }
    }
}

impl<'a> Drop for PanicMsgSuppressor<'a> {
    fn drop(&mut self) {
        panic::set_hook(self.prev_hook.take().unwrap())
    }
}

// AA tree helpers

#[derive(Clone, Debug)]
struct FloatBandWrapper(FloatBand);

impl Arbitrary for FloatBandWrapper {
    fn arbitrary(generator: &mut Gen) -> FloatBandWrapper {
        let top: u32 = u32::arbitrary(generator);
        let inline_start: Option<u32> = Some(u32::arbitrary(generator));
        let inline_end: Option<u32> = Some(u32::arbitrary(generator));

        FloatBandWrapper(FloatBand {
            top: Au::from_f32_px(top as f32),
            inline_start: inline_start.map(|value| Au::from_f32_px(value as f32)),
            inline_end: inline_end.map(|value| Au::from_f32_px(value as f32)),
        })
    }
}

#[derive(Clone, Debug)]
struct FloatRangeInput {
    start_index: u32,
    side: FloatSide,
    length: u32,
}

impl Arbitrary for FloatRangeInput {
    fn arbitrary(generator: &mut Gen) -> FloatRangeInput {
        let start_index: u32 = Arbitrary::arbitrary(generator);
        let is_left: bool = Arbitrary::arbitrary(generator);
        let length: u32 = Arbitrary::arbitrary(generator);
        FloatRangeInput {
            start_index,
            side: if is_left {
                FloatSide::InlineStart
            } else {
                FloatSide::InlineEnd
            },
            length,
        }
    }
}

// AA tree predicates

fn check_node_ordering(node: &FloatBandNode) {
    let mid = node.band.top;
    if let Some(ref left) = node.left.0 {
        assert!(left.band.top < mid);
    }
    if let Some(ref right) = node.right.0 {
        assert!(right.band.top > mid);
    }
    if let Some(ref left) = node.left.0 {
        check_node_ordering(left);
    }
    if let Some(ref right) = node.right.0 {
        check_node_ordering(right);
    }
}

// https://en.wikipedia.org/wiki/AA_tree#Balancing_rotations
fn check_node_balance(node: &FloatBandNode) {
    // 1. The level of every leaf node is one.
    if node.left.0.is_none() && node.right.0.is_none() {
        assert_eq!(node.level, 1);
    }
    // 2. The level of every left child is exactly one less than that of its parent.
    if let Some(ref left) = node.left.0 {
        assert_eq!(left.level, node.level - 1);
    }
    // 3. The level of every right child is equal to or one less than that of its parent.
    if let Some(ref right) = node.right.0 {
        assert!(right.level == node.level || right.level == node.level - 1);
    }
    // 4. The level of every right grandchild is strictly less than that of its grandparent.
    if let Some(ref right) = node.right.0 {
        if let Some(ref right_right) = right.right.0 {
            assert!(right_right.level < node.level);
        }
    }
    // 5. Every node of level greater than one has two children.
    if node.level > 1 {
        assert!(node.left.0.is_some() && node.right.0.is_some());
    }
}

fn check_tree_ordering(tree: FloatBandTree) {
    if let Some(ref root) = tree.root.0 {
        check_node_ordering(root);
    }
}

fn check_tree_balance(tree: FloatBandTree) {
    if let Some(ref root) = tree.root.0 {
        check_node_balance(root);
    }
}

fn check_tree_find(tree: &FloatBandTree, block_position: Au, sorted_bands: &[FloatBand]) {
    let found_band = tree
        .find(block_position)
        .expect("Couldn't find the band in the tree!");
    let reference_band_index = sorted_bands
        .iter()
        .position(|band| band.top > block_position)
        .expect("Couldn't find the reference band!") -
        1;
    let reference_band = &sorted_bands[reference_band_index];
    assert_eq!(found_band.top, reference_band.top);
    assert_eq!(found_band.inline_start, reference_band.inline_start);
    assert_eq!(found_band.inline_end, reference_band.inline_end);
}

fn check_tree_find_next(tree: &FloatBandTree, block_position: Au, sorted_bands: &[FloatBand]) {
    let found_band = tree
        .find_next(block_position)
        .expect("Couldn't find the band in the tree!");
    let reference_band_index = sorted_bands
        .iter()
        .position(|band| band.top > block_position)
        .expect("Couldn't find the reference band!");
    let reference_band = &sorted_bands[reference_band_index];
    assert_eq!(found_band.top, reference_band.top);
    assert_eq!(found_band.inline_start, reference_band.inline_start);
    assert_eq!(found_band.inline_end, reference_band.inline_end);
}

fn check_node_range_setting(
    node: &FloatBandNode,
    block_range: &Range<Au>,
    side: FloatSide,
    value: Au,
) {
    if node.band.top >= block_range.start && node.band.top < block_range.end {
        match side {
            FloatSide::InlineStart => assert!(node.band.inline_start.unwrap() >= value),
            FloatSide::InlineEnd => assert!(node.band.inline_end.unwrap() <= value),
        }
    }

    if let Some(ref left) = node.left.0 {
        check_node_range_setting(left, block_range, side, value)
    }
    if let Some(ref right) = node.right.0 {
        check_node_range_setting(right, block_range, side, value)
    }
}

fn check_tree_range_setting(
    tree: &FloatBandTree,
    block_range: &Range<Au>,
    side: FloatSide,
    value: Au,
) {
    if let Some(ref root) = tree.root.0 {
        check_node_range_setting(root, block_range, side, value)
    }
}

// AA tree unit tests

// Tests that the tree is a properly-ordered binary tree.
#[test]
fn test_tree_ordering() {
    let f: fn(Vec<FloatBandWrapper>) = check;
    quickcheck::quickcheck(f);
    fn check(bands: Vec<FloatBandWrapper>) {
        let mut tree = FloatBandTree::new();
        for FloatBandWrapper(band) in bands {
            tree = tree.insert(band);
        }
        check_tree_ordering(tree);
    }
}

// Tests that the tree is balanced (i.e. AA tree invariants are maintained).
#[test]
fn test_tree_balance() {
    let f: fn(Vec<FloatBandWrapper>) = check;
    quickcheck::quickcheck(f);
    fn check(bands: Vec<FloatBandWrapper>) {
        let mut tree = FloatBandTree::new();
        for FloatBandWrapper(band) in bands {
            tree = tree.insert(band);
        }
        check_tree_balance(tree);
    }
}

// Tests that the `find()` method works.
#[test]
fn test_tree_find() {
    let f: fn(Vec<FloatBandWrapper>, Vec<u16>) = check;
    quickcheck::quickcheck(f);
    fn check(bands: Vec<FloatBandWrapper>, lookups: Vec<u16>) {
        let mut bands: Vec<FloatBand> = bands.into_iter().map(|band| band.0).collect();
        bands.push(FloatBand {
            top: Au::zero(),
            inline_start: None,
            inline_end: None,
        });
        bands.push(FloatBand {
            top: Au::from_f32_px(INFINITY),
            inline_start: None,
            inline_end: None,
        });
        let mut tree = FloatBandTree::new();
        for band in &bands {
            tree = tree.insert(*band);
        }
        bands.sort_by(|a, b| a.top.partial_cmp(&b.top).unwrap());
        for lookup in lookups {
            check_tree_find(&tree, Au::from_f32_px(lookup as f32), &bands);
        }
    }
}

// Tests that the `find_next()` method works.
#[test]
fn test_tree_find_next() {
    let f: fn(Vec<FloatBandWrapper>, Vec<u16>) = check;
    quickcheck::quickcheck(f);
    fn check(bands: Vec<FloatBandWrapper>, lookups: Vec<u16>) {
        let mut bands: Vec<FloatBand> = bands.into_iter().map(|band| band.0).collect();
        bands.push(FloatBand {
            top: Au::zero(),
            inline_start: None,
            inline_end: None,
        });
        bands.push(FloatBand {
            top: Au::from_f32_px(INFINITY),
            inline_start: None,
            inline_end: None,
        });
        bands.sort_by(|a, b| a.top.partial_cmp(&b.top).unwrap());
        bands.dedup_by(|a, b| a.top == b.top);
        let mut tree = FloatBandTree::new();
        for band in &bands {
            tree = tree.insert(*band);
        }
        for lookup in lookups {
            check_tree_find_next(&tree, Au::from_f32_px(lookup as f32), &bands);
        }
    }
}

// Tests that `set_range()` works.
#[test]
fn test_tree_range_setting() {
    let f: fn(Vec<FloatBandWrapper>, Vec<FloatRangeInput>) = check;
    quickcheck::quickcheck(f);
    fn check(bands: Vec<FloatBandWrapper>, ranges: Vec<FloatRangeInput>) {
        let mut tree = FloatBandTree::new();
        for FloatBandWrapper(ref band) in &bands {
            tree = tree.insert(*band);
        }

        let mut tops: Vec<Au> = bands.iter().map(|band| band.0.top).collect();
        tops.push(Au::from_f32_px(INFINITY));
        tops.sort_by(|a, b| a.to_px().partial_cmp(&b.to_px()).unwrap());

        for range in ranges {
            let start = range.start_index.min(tops.len() as u32 - 1);
            let end = (range.start_index as u64 + range.length as u64).min(tops.len() as u64 - 1);
            let block_range = tops[start as usize]..tops[end as usize];
            let length = Au::from_px(range.length as i32);
            let new_tree = tree.set_range(&block_range, range.side, length);
            check_tree_range_setting(&new_tree, &block_range, range.side, length);
        }
    }
}

// Float predicates

#[derive(Clone, Debug)]
struct FloatInput {
    // Information needed to place the float.
    info: PlacementInfo,
    // 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: Au,
    /// 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 {
        // 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: LogicalVec2 {
                    inline: Au::from_f32_px(width as f32),
                    block: Au::from_f32_px(height as f32),
                },
                side: if is_left {
                    FloatSide::InlineStart
                } else {
                    FloatSide::InlineEnd
                },
                clear: new_clear(clear),
            },
            ceiling: Au::from_f32_px(ceiling as f32),
            containing_block_info: ContainingBlockPositionInfo::new_with_inline_offsets(
                Au::from_f32_px(left as f32),
                Au::from_f32_px(left as f32 + containing_block_width as f32),
            ),
        }
    }

    fn shrink(&self) -> Box<dyn Iterator<Item = FloatInput>> {
        let mut this = (*self).clone();
        let mut shrunk = false;
        if let Some(inline_size) = self.info.size.inline.to_px().shrink().next() {
            this.info.size.inline = Au::from_px(inline_size);
            shrunk = true;
        }
        if let Some(block_size) = self.info.size.block.to_px().shrink().next() {
            this.info.size.block = Au::from_px(block_size);
            shrunk = true;
        }
        if let Some(clear) = (self.info.clear as u8).shrink().next() {
            this.info.clear = new_clear(clear);
            shrunk = true;
        }
        if let Some(left) = self
            .containing_block_info
            .inline_start
            .to_px()
            .shrink()
            .next()
        {
            this.containing_block_info.inline_start = Au::from_px(left);
            shrunk = true;
        }
        if let Some(right) = self
            .containing_block_info
            .inline_end
            .to_px()
            .shrink()
            .next()
        {
            this.containing_block_info.inline_end = Au::from_px(right);
            shrunk = true;
        }
        if let Some(ceiling) = self.ceiling.to_px().shrink().next() {
            this.ceiling = Au::from_px(ceiling);
            shrunk = true;
        }
        if shrunk {
            quickcheck::single_shrinker(this)
        } else {
            quickcheck::empty_shrinker()
        }
    }
}

fn new_clear(value: u8) -> Clear {
    match value & 3 {
        0 => Clear::None,
        1 => Clear::InlineStart,
        2 => Clear::InlineEnd,
        _ => Clear::Both,
    }
}

#[derive(Clone)]
struct FloatPlacement {
    float_context: FloatContext,
    placed_floats: Vec<PlacedFloat>,
}

// Information about the placement of a float.
#[derive(Clone)]
struct PlacedFloat {
    origin: LogicalVec2<Au>,
    info: PlacementInfo,
    ceiling: Au,
    containing_block_info: ContainingBlockPositionInfo,
}

impl Drop for FloatPlacement {
    fn drop(&mut self) {
        if !thread::panicking() {
            return;
        }

        // Dump the float context for debugging.
        eprintln!("Failing float placement:");
        for placed_float in &self.placed_floats {
            eprintln!(
                "   * {:?} @ {:?}, T {:?} L {:?} R {:?}",
                placed_float.info,
                placed_float.origin,
                placed_float.ceiling,
                placed_float.containing_block_info.inline_start,
                placed_float.containing_block_info.inline_end,
            );
        }
        eprintln!("Bands:\n{:?}\n", self.float_context.bands);
    }
}

impl PlacedFloat {
    fn rect(&self) -> LogicalRect<Au> {
        LogicalRect {
            start_corner: self.origin,
            size: self.info.size,
        }
    }
}

impl FloatPlacement {
    fn place(floats: Vec<FloatInput>) -> FloatPlacement {
        let mut float_context = FloatContext::new(Au::from_f32_px(INFINITY));
        let mut placed_floats = vec![];
        for float in floats {
            let ceiling = float.ceiling;
            float_context.set_ceiling_from_non_floats(ceiling);
            float_context.containing_block_info = float.containing_block_info;
            placed_floats.push(PlacedFloat {
                origin: float_context.add_float(&float.info),
                info: float.info,
                ceiling,
                containing_block_info: float.containing_block_info,
            })
        }
        FloatPlacement {
            float_context,
            placed_floats,
        }
    }
}

// From CSS 2.1 § 9.5.1 [1].
//
// [1]: https://www.w3.org/TR/CSS2/visuren.html#float-position

// 1. The left outer edge of a left-floating box may not be to the left of the left edge of its
//    containing block. An analogous rule holds for right-floating elements.
fn check_floats_rule_1(placement: &FloatPlacement) {
    for placed_float in &placement.placed_floats {
        match placed_float.info.side {
            FloatSide::InlineStart => assert!(
                placed_float.origin.inline >= placed_float.containing_block_info.inline_start
            ),
            FloatSide::InlineEnd => {
                assert!(
                    placed_float.rect().max_inline_position() <=
                        placed_float.containing_block_info.inline_end
                )
            },
        }
    }
}

// 2. If the current box is left-floating, and there are any left-floating boxes generated by
//    elements earlier in the source document, then for each such earlier box, either the left
//    outer edge of the current box must be to the right of the right outer edge of the earlier
//    box, or its top must be lower than the bottom of the earlier box. Analogous rules hold for
//    right-floating boxes.
fn check_floats_rule_2(placement: &FloatPlacement) {
    for (this_float_index, this_float) in placement.placed_floats.iter().enumerate() {
        for prev_float in &placement.placed_floats[0..this_float_index] {
            match (this_float.info.side, prev_float.info.side) {
                (FloatSide::InlineStart, FloatSide::InlineStart) => {
                    assert!(
                        this_float.origin.inline >= prev_float.rect().max_inline_position() ||
                            this_float.origin.block >= prev_float.rect().max_block_position()
                    );
                },
                (FloatSide::InlineEnd, FloatSide::InlineEnd) => {
                    assert!(
                        this_float.rect().max_inline_position() <= prev_float.origin.inline ||
                            this_float.origin.block >= prev_float.rect().max_block_position()
                    );
                },
                (FloatSide::InlineStart, FloatSide::InlineEnd) |
                (FloatSide::InlineEnd, FloatSide::InlineStart) => {},
            }
        }
    }
}

// 3. The right outer edge of a left-floating box may not be to the right of the left outer edge of
//    any right-floating box that is next to it. Analogous rules hold for right-floating elements.
fn check_floats_rule_3(placement: &FloatPlacement) {
    for (this_float_index, this_float) in placement.placed_floats.iter().enumerate() {
        for other_float in &placement.placed_floats[0..this_float_index] {
            // This logic to check intersection is complicated by the fact that we need to treat
            // zero-height floats later in the document as "next to" floats earlier in the
            // document. Otherwise we might end up with a situation like:
            //
            //    <div id="a" style="float: left; width: 32px; height: 32px"></div>
            //    <div id="b" style="float: right; width: 0px; height: 0px"></div>
            //
            // Where the top of `b` should probably be 32px per Rule 3, but unless this distinction
            // is made the top of `b` could legally be 0px.
            if this_float.origin.block >= other_float.rect().max_block_position() ||
                (this_float.info.size.block == Au::zero() &&
                    this_float.rect().max_block_position() < other_float.origin.block) ||
                (this_float.info.size.block > Au::zero() &&
                    this_float.rect().max_block_position() <= other_float.origin.block)
            {
                continue;
            }

            match (this_float.info.side, other_float.info.side) {
                (FloatSide::InlineStart, FloatSide::InlineEnd) => {
                    assert!(this_float.rect().max_inline_position() <= other_float.origin.inline);
                },
                (FloatSide::InlineEnd, FloatSide::InlineStart) => {
                    assert!(this_float.origin.inline >= other_float.rect().max_inline_position());
                },
                (FloatSide::InlineStart, FloatSide::InlineStart) |
                (FloatSide::InlineEnd, FloatSide::InlineEnd) => {},
            }
        }
    }
}

// 4. A floating box's outer top may not be higher than the top of its containing block. When the
//    float occurs between two collapsing margins, the float is positioned as if it had an
//    otherwise empty anonymous block parent taking part in the flow. The position of such a parent
//    is defined by the rules in the section on margin collapsing.
fn check_floats_rule_4(placement: &FloatPlacement) {
    for placed_float in &placement.placed_floats {
        assert!(placed_float.origin.block >= Au::zero());
    }
}

// 5. The outer top of a floating box may not be higher than the outer top of any block or floated
//    box generated by an element earlier in the source document.
fn check_floats_rule_5(placement: &FloatPlacement) {
    let mut block_position = Au::zero();
    for placed_float in &placement.placed_floats {
        assert!(placed_float.origin.block >= block_position);
        block_position = placed_float.origin.block;
    }
}

// 6. The outer top of an element's floating box may not be higher than the top of any line-box
//    containing a box generated by an element earlier in the source document.
fn check_floats_rule_6(placement: &FloatPlacement) {
    for placed_float in &placement.placed_floats {
        assert!(placed_float.origin.block >= placed_float.ceiling);
    }
}

// 7. A left-floating box that has another left-floating box to its left may not have its right
//    outer edge to the right of its containing block's right edge. (Loosely: a left float may not
//    stick out at the right edge, unless it is already as far to the left as possible.) An
//    analogous rule holds for right-floating elements.
fn check_floats_rule_7(placement: &FloatPlacement) {
    for (placed_float_index, placed_float) in placement.placed_floats.iter().enumerate() {
        // Only consider floats that stick out.
        match placed_float.info.side {
            FloatSide::InlineStart => {
                if placed_float.rect().max_inline_position() <=
                    placed_float.containing_block_info.inline_end
                {
                    continue;
                }
            },
            FloatSide::InlineEnd => {
                if placed_float.origin.inline >= placed_float.containing_block_info.inline_start {
                    continue;
                }
            },
        }

        // Make sure there are no previous floats to the left or right.
        for prev_float in &placement.placed_floats[0..placed_float_index] {
            assert!(
                prev_float.info.side != placed_float.info.side ||
                    prev_float.rect().max_block_position() <= placed_float.origin.block ||
                    prev_float.origin.block >= placed_float.rect().max_block_position()
            );
        }
    }
}

// 8. A floating box must be placed as high as possible.
fn check_floats_rule_8(floats_and_perturbations: Vec<(FloatInput, u32)>) {
    let floats = floats_and_perturbations
        .iter()
        .map(|(float, _)| (*float).clone())
        .collect();
    let placement = FloatPlacement::place(floats);

    for (float_index, &(_, perturbation)) in floats_and_perturbations.iter().enumerate() {
        if perturbation == 0 {
            continue;
        }

        let mut placement = placement.clone();
        placement.placed_floats[float_index].origin.block -= Au::from_f32_px(perturbation as f32);

        let result = {
            let mutex_guard = PANIC_HOOK_MUTEX.lock().unwrap();
            let _suppressor = PanicMsgSuppressor::new(mutex_guard);
            panic::catch_unwind(|| check_basic_float_rules(&placement))
        };
        assert!(result.is_err());
    }
}

// 9. A left-floating box must be put as far to the left as possible, a right-floating box as far
//    to the right as possible. A higher position is preferred over one that is further to the
//    left/right.
fn check_floats_rule_9(floats_and_perturbations: Vec<(FloatInput, u32)>) {
    let floats = floats_and_perturbations
        .iter()
        .map(|(float, _)| (*float).clone())
        .collect();
    let placement = FloatPlacement::place(floats);

    for (float_index, &(_, perturbation)) in floats_and_perturbations.iter().enumerate() {
        if perturbation == 0 {
            continue;
        }

        let mut placement = placement.clone();
        {
            let placed_float = &mut placement.placed_floats[float_index];
            let perturbation = Au::from_f32_px(perturbation as f32);
            match placed_float.info.side {
                FloatSide::InlineStart => placed_float.origin.inline -= perturbation,
                FloatSide::InlineEnd => placed_float.origin.inline += perturbation,
            }
        }

        let result = {
            let mutex_guard = PANIC_HOOK_MUTEX.lock().unwrap();
            let _suppressor = PanicMsgSuppressor::new(mutex_guard);
            panic::catch_unwind(|| check_basic_float_rules(&placement))
        };
        assert!(result.is_err());
    }
}

// From CSS 2.1 § 9.5.2 (https://www.w3.org/TR/CSS2/visuren.html#propdef-clear):
//
// 10. The top outer edge of the float must be below the bottom outer edge of all earlier
//     left-floating boxes (in the case of 'clear: left'), or all earlier right-floating boxes (in
//     the case of 'clear: right'), or both ('clear: both').
fn check_floats_rule_10(placement: &FloatPlacement) {
    let mut block_position = Au::zero();
    for placed_float in &placement.placed_floats {
        assert!(placed_float.origin.block >= block_position);
        block_position = placed_float.origin.block;
    }

    for (this_float_index, this_float) in placement.placed_floats.iter().enumerate() {
        if this_float.info.clear == Clear::None {
            continue;
        }

        for other_float in &placement.placed_floats[0..this_float_index] {
            // This logic to check intersection is complicated by the fact that we need to treat
            // zero-height floats later in the document as "next to" floats earlier in the
            // document. Otherwise we might end up with a situation like:
            //
            //    <div id="a" style="float: left; width: 32px; height: 32px"></div>
            //    <div id="b" style="float: right; width: 0px; height: 0px"></div>
            //
            // Where the top of `b` should probably be 32px per Rule 3, but unless this distinction
            // is made the top of `b` could legally be 0px.
            if this_float.origin.block >= other_float.rect().max_block_position() ||
                (this_float.info.size.block == Au::zero() &&
                    this_float.rect().max_block_position() < other_float.origin.block) ||
                (this_float.info.size.block > Au::zero() &&
                    this_float.rect().max_block_position() <= other_float.origin.block)
            {
                continue;
            }

            match this_float.info.clear {
                Clear::InlineStart => assert_ne!(other_float.info.side, FloatSide::InlineStart),
                Clear::InlineEnd => assert_ne!(other_float.info.side, FloatSide::InlineEnd),
                Clear::Both => assert!(false),
                Clear::None => unreachable!(),
            }
        }
    }
}

// Checks that rule 1-7 and rule 10 hold (i.e. all rules that don't specify that floats are placed
// "as far as possible" in some direction).
fn check_basic_float_rules(placement: &FloatPlacement) {
    check_floats_rule_1(placement);
    check_floats_rule_2(placement);
    check_floats_rule_3(placement);
    check_floats_rule_4(placement);
    check_floats_rule_5(placement);
    check_floats_rule_6(placement);
    check_floats_rule_7(placement);
    check_floats_rule_10(placement);
}

// Float unit tests

#[test]
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));
    }
}

#[test]
fn test_floats_rule_2() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_2(&FloatPlacement::place(floats));
    }
}

#[test]
fn test_floats_rule_3() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_3(&FloatPlacement::place(floats));
    }
}

#[test]
fn test_floats_rule_4() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_4(&FloatPlacement::place(floats));
    }
}

#[test]
fn test_floats_rule_5() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_5(&FloatPlacement::place(floats));
    }
}

#[test]
fn test_floats_rule_6() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_6(&FloatPlacement::place(floats));
    }
}

#[test]
fn test_floats_rule_7() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_7(&FloatPlacement::place(floats));
    }
}

#[test]
fn test_floats_rule_8() {
    let f: fn(Vec<(FloatInput, u32)>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<(FloatInput, u32)>) {
        check_floats_rule_8(floats);
    }
}

#[test]
fn test_floats_rule_9() {
    let f: fn(Vec<(FloatInput, u32)>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<(FloatInput, u32)>) {
        check_floats_rule_9(floats);
    }
}

#[test]
fn test_floats_rule_10() {
    let f: fn(Vec<FloatInput>) = check;
    quickcheck::quickcheck(f);
    fn check(floats: Vec<FloatInput>) {
        check_floats_rule_10(&FloatPlacement::place(floats));
    }
}