monolith

use super::*;

use proptest::prelude::*;

const AREA: Rect = Rect::new(0.0, 0.0, 1000.0, 600.0);

#[derive(Clone, Debug)]

enum Op {

    Add(u8, bool),

    Remove(u8),

    Focus(u8),

    Move(Dir),

    Block(Dir),

    Merge(Dir),

    View(u8),

    ToggleView(u8),

    Retag(u8, u8),

    Float(u8),

    Expand(u8),

    Flip,

    Resize(bool, i8),

    Scratch(u8),

    Summon,

    Unplug,

    Replug,

}

fn dir() -> impl Strategy<Value = Dir> {

    prop_oneof![

        Just(Dir::Left),

        Just(Dir::Right),

        Just(Dir::Up),

        Just(Dir::Down)

    ]

}

fn op() -> impl Strategy<Value = Op> {

    prop_oneof![

        4 => (0u8..4, prop::bool::weighted(0.15)).prop_map(|(t, f)| Op::Add(t, f)),

        1 => any::<u8>().prop_map(Op::Remove),

        3 => any::<u8>().prop_map(Op::Focus),

        4 => dir().prop_map(Op::Move),

        2 => dir().prop_map(Op::Block),

        3 => dir().prop_map(Op::Merge),

        1 => (0u8..4).prop_map(Op::View),

        2 => (0u8..4).prop_map(Op::ToggleView),

        1 => (any::<u8>(), 0u8..4).prop_map(|(w, t)| Op::Retag(w, t)),

        1 => any::<u8>().prop_map(Op::Float),

        1 => (0u8..3).prop_map(Op::Expand),

        1 => Just(Op::Flip),

        1 => (any::<bool>(), any::<i8>()).prop_map(|(a, d)| Op::Resize(a, d)),

        1 => any::<u8>().prop_map(Op::Scratch),

        1 => Just(Op::Summon),

        1 => Just(Op::Unplug),

        1 => Just(Op::Replug),

    ]

}

fn nth(l: &Layout, i: u8) -> Option<WindowId> {

    let ids: Vec<WindowId> = l.windows().map(|(id, _)| id).collect();

    (!ids.is_empty()).then(|| ids[i as usize % ids.len()])

}

fn apply(l: &mut Layout, tags: &[TagId], op: &Op) {

    let active = l.active_output();

    match *op {

        Op::Add(t, f) => {

            let w = l.add_window(

                None,

                Some(tags[t as usize]),

                f.then(|| Rect::new(10.0, 10.0, 200.0, 100.0)),

            );

            if l.visible(w) {

                l.focus(w);

            }

        }

        Op::Remove(i) => nth(l, i).into_iter().for_each(|w| l.remove_window(w)),

        Op::Focus(i) => {

            if let Some(w) = nth(l, i).filter(|&w| l.visible(w)) {

                l.focus(w);

            }

        }

        Op::Move(d) => {

            l.move_window(d);

        }

        Op::Block(d) => {

            l.move_container(d);

        }

        Op::Merge(d) => {

            l.merge_window(d);

        }

        Op::View(t) => active.into_iter().for_each(|o| l.view(o, tags[t as usize])),

        Op::ToggleView(t) => active

            .into_iter()

            .for_each(|o| l.toggle_view(o, tags[t as usize])),

        Op::Retag(i, t) => nth(l, i)

            .into_iter()

            .for_each(|w| l.set_tag(w, tags[t as usize])),

        Op::Float(i) => nth(l, i).into_iter().for_each(|w| l.toggle_floating(w)),

        Op::Expand(s) => {

            l.expand(

                [

                    ExpandScope::Window,

                    ExpandScope::Container,

                    ExpandScope::All,

                ][s as usize],

            );

        }

        Op::Flip => active.into_iter().for_each(|o| l.flip(o)),

        Op::Resize(h, d) => {

            let axis = if h { Axis::Horizontal } else { Axis::Vertical };

            l.resize(axis, f64::from(d) / 200.0);

        }

        Op::Scratch(i) => nth(l, i).into_iter().for_each(|w| l.scratchpad_add(w, "s")),

        Op::Summon => {

            l.summon("s");

        }

        Op::Unplug => {

            let b = l.outputs().find(|(_, out)| out.name == "b").map(|(o, _)| o);

            if let Some(o) = b {

                l.remove_output(o);

            }

        }

        Op::Replug => {

            if !l.outputs().any(|(_, out)| out.name == "b") {

                l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

            }

        }

    }

}

/// The area a tiled window gets, zero for floating or unplaced ones.

fn tiled_area(l: &Layout, w: WindowId) -> f64 {

    let Some(o) = l.window(w).and_then(|x| x.output) else {

        return 0.0;

    };

    l.arrange(o)

        .tiled

        .iter()

        .find(|p| p.window == w && p.visible)

        .map_or(0.0, |p| p.rect.w * p.rect.h)

}

fn check_geometry(l: &Layout) {

    for (o, out) in l.outputs() {

        let arr = l.arrange(o);

        let mut drawn: Vec<WindowId> = arr

            .tiled

            .iter()

            .filter(|p| p.visible)

            .map(|p| p.window)

            .chain(arr.floating.iter().map(|&(w, _)| w))

            .chain(arr.fullscreen)

            .collect();

        drawn.sort();

        drawn.dedup();

        let mut visible: Vec<WindowId> = l

            .windows()

            .filter(|&(w, win)| win.output == Some(o) && l.visible(w))

            .map(|(w, _)| w)

            .collect();

        visible.sort();

        assert_eq!(drawn, visible, "arrangement disagrees with visible()");

        let shown: Vec<Rect> = arr

            .tiled

            .iter()

            .filter(|p| p.visible)

            .map(|p| p.rect)

            .collect();

        for p in arr.tiled.iter().filter(|p| !p.visible) {

            assert!(p.rect.w * p.rect.h <= 1e-6, "hidden {:?} has area", p.rect);

        }

        for r in &shown {

            assert!(r.w >= 0.0 && r.h >= 0.0);

            assert!(r.x >= out.area.x - 1e-6 && r.right() <= out.area.right() + 1e-6);

            assert!(r.y >= out.area.y - 1e-6 && r.bottom() <= out.area.bottom() + 1e-6);

        }

        for (i, a) in shown.iter().enumerate() {

            for b in &shown[i + 1..] {

                let ox = a.right().min(b.right()) - a.x.max(b.x);

                let oy = a.bottom().min(b.bottom()) - a.y.max(b.y);

                assert!(ox <= 1e-6 || oy <= 1e-6, "{a:?} overlaps {b:?}");

            }

        }

    }

}

proptest! {

    #![proptest_config(ProptestConfig::with_cases(2000))]

    #[test]

    fn random_commands_keep_the_model_sound(

        ops in prop::collection::vec(op(), 1..80),

        autotile in any::<bool>(),

    ) {

        let mut l = Layout {

            autotile,

            ..Layout::default()

        };

        l.add_output("a", AREA);

        l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

        let tags = [l.homeless(), l.tag("1"), l.tag("2"), l.tag("3")];

        for op in &ops {

            let moving = matches!(op, Op::Move(_) | Op::Merge(_) | Op::Block(_));

            let shown_before = l.focused().filter(|&w| tiled_area(&l, w) > 1.0);

            apply(&mut l, &tags, op);

            l.check();

            check_geometry(&l);

            if moving && let Some(w) = shown_before {

                prop_assert!(tiled_area(&l, w) > 1.0, "{w:?} vanished after {op:?}");

            }

        }

    }

    #[test]

    fn replugging_restores_what_unplugging_moved(ops in prop::collection::vec(op(), 1..60)) {

        let mut l = Layout::default();

        l.add_output("a", AREA);

        l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

        let tags = [l.homeless(), l.tag("1"), l.tag("2"), l.tag("3")];

        for op in &ops {

            apply(&mut l, &tags, op);

        }

        let Some(b) = l.outputs().find(|(_, out)| out.name == "b").map(|(o, _)| o) else {

            return Ok(());

        };

        let before = |l: &Layout, o| {

            let out = l.output(o).unwrap();

            (out.tree.windows().collect::<Vec<_>>(), out.floating.clone(), out.viewed.clone())

        };

        let was = before(&l, b);

        l.remove_output(b);

        let b = l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

        l.check();

        prop_assert_eq!(before(&l, b), was);

    }

}

/// The hidden-slot rules from planner.html, demo 11.

#[test]

fn hidden_windows_keep_their_slots() {

    let (a, b, c, d, e) = (1, 2, 3, 4, 5);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(d, a);

    t.insert_after(b, d);

    t.insert_row(c);

    t.insert_after(e, c);

    t.check();

    let hidden = |w: u32| w != d && w != e;

    let all = |_| true;

    let rect = |t: &Tree<u32>, w| {

        t.arrange(AREA, 0.0, all)

            .into_iter()

            .find(|p| p.0 == w)

            .unwrap()

            .1

    };

    assert!(t.move_window(a, Dir::Right, hidden));

    assert!(rect(&t, b).x < rect(&t, d).x && rect(&t, d).x < rect(&t, a).x);

    assert!(t.move_window(c, Dir::Up, hidden));

    t.check();

    assert_eq!(rect(&t, e).w, AREA.w, "E is demoted to a row of its own");

}

/// Moving out of a row toward a lane of hidden windows joins that lane, so

/// they share it when shown again instead of a new lane opening between.

#[test]

fn moving_toward_a_hidden_lane_joins_it() {

    let (a, b, c, d, e) = (1, 2, 3, 4, 5);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(b, a);

    t.insert_after(c, b);

    t.insert_row(d);

    t.insert_after(e, c);

    let tag_two = |w: u32| w != a && w != d;

    assert!(t.move_window(e, Dir::Down, tag_two));

    t.check();

    let all = t.arrange(AREA, 0.0, |_| true);

    let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;

    assert_eq!(rect(e).y, rect(d).y);

    assert!(rect(d).x < rect(e).x);

    assert!(rect(a).y < rect(d).y);

}

#[test]

fn merging_steps_out_of_a_stack_before_joining_another() {

    let (a, b, c) = (1, 2, 3);

    let stacked = || {

        let mut t: Tree<u32> = Tree::default();

        t.insert_row(a);

        t.insert_after(b, a);

        t.insert_after(c, b);

        assert!(t.merge_window(b, Dir::Left, |_| true));

        t

    };

    let rects = |t: &Tree<u32>| {

        t.check();

        let all = t.arrange(AREA, 0.0, |_| true);

        move |w| all.iter().find(|p: &&(u32, Rect)| p.0 == w).unwrap().1

    };

    let mut t = stacked();

    assert!(t.merge_window(a, Dir::Right, |_| true));

    let rect = rects(&t);

    assert!(rect(b).x < rect(a).x && rect(a).x < rect(c).x);

    assert_eq!(rect(a).h, AREA.h);

    assert!(t.merge_window(a, Dir::Right, |_| true));

    let rect = rects(&t);

    assert_eq!(rect(a).x, rect(c).x);

    let mut t = stacked();

    assert!(t.merge_window(a, Dir::Up, |_| true));

    let rect = rects(&t);

    assert_eq!(rect(a).w, AREA.w);

    assert!(rect(a).bottom() <= rect(b).y && rect(b).y == rect(c).y);

}

/// A window alone on screen in a container of hidden ones expands among the

/// windows it is shown beside, not inside the container nobody can see.

#[test]

fn expand_skips_containers_of_hidden_windows() {

    let (a, b, c) = (1, 2, 3);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(b, a);

    t.insert_after(c, b);

    assert!(t.merge_window(a, Dir::Right, |_| true));

    let shown = |w: u32| w != a;

    assert!(t.toggle_expand(b, 0, 1, shown));

    assert!(t.maximized(b, shown));

    let all = t.arrange(AREA, 0.0, shown);

    let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;

    assert_eq!(rect(b).w, AREA.w);

}

/// Going in and out of a stack repeatedly leaves every window the size it was.

#[test]

fn stacking_in_and_out_does_not_drift() {

    for out in [Dir::Up, Dir::Down, Dir::Right] {

        let (a, b, c) = (1, 2, 3);

        let mut t: Tree<u32> = Tree::default();

        t.insert_row(a);

        t.insert_after(b, a);

        t.insert_after(c, b);

        assert!(t.merge_window(c, Dir::Left, |_| true));

        assert!(t.merge_window(c, out, |_| true));

        let once = t.arrange(AREA, 0.0, |_| true);

        for _ in 0..8 {

            t.merge_window(c, Dir::Left, |_| true);

            t.merge_window(c, out, |_| true);

        }

        t.check();

        assert_eq!(t.arrange(AREA, 0.0, |_| true), once, "stepping out {out:?}");

    }

}

/// Windows of other tags in the rows around a window must not change what

/// the user sees as it moves through them, nor drift over round trips.

#[test]

fn moving_past_hidden_windows_does_not_drift() {

    let (a, b, h, h2) = (1, 2, 3, 4);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(h);

    t.insert_row(a);

    t.insert_after(h2, a);

    t.insert_after(b, h2);

    let vis = |w: u32| w != h && w != h2;

    let mut once = None;

    for _ in 0..4 {

        for d in [Dir::Up, Dir::Up, Dir::Down] {

            t.move_window(b, d, vis);

            let shown = t.arrange(AREA, 0.0, vis);

            let r = shown.iter().find(|p| p.0 == b).unwrap().1;

            assert!(

                (r.w * r.h - AREA.w * AREA.h / 2.0).abs() < 1e-6,

                "{d:?} left {r:?}"

            );

        }

        t.check();

        let all = t.arrange(AREA, 0.0, |_| true);

        assert_eq!(*once.get_or_insert_with(|| all.clone()), all);

    }

}

/// Monitors sleeping together unplug one after another, so windows already

/// moved off the first must still go home to it, not to the second.

#[test]

fn windows_return_to_where_they_were_first_evicted_from() {

    let mut l = Layout::default();

    let a = l.add_output("a", AREA);

    l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

    let c = l.add_output("c", Rect::new(1800.0, 0.0, 800.0, 600.0));

    let w = l.add_window(Some(a), None, None);

    l.remove_output(a);

    let b = l.outputs().find(|(_, out)| out.name == "b").unwrap().0;

    l.remove_output(b);

    assert_eq!(l.window(w).unwrap().output, Some(c));

    l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

    let a = l.add_output("a", AREA);

    l.check();

    assert_eq!(l.window(w).unwrap().output, Some(a));

    assert!(l.output(a).unwrap().tree.contains(w));

}

/// A stack showing one window looks like a lone window, so moving toward it

/// swaps places instead of joining a stack the user cannot see.

#[test]

fn moving_toward_a_stack_showing_one_window_swaps() {

    let (a, b, h) = (1, 2, 3);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(b, a);

    t.insert_after(h, b);

    assert!(t.merge_window(h, Dir::Left, |_| true));

    let vis = |w: u32| w != h;

    assert!(t.move_window(a, Dir::Right, vis));

    t.check();

    let shown = t.arrange(AREA, 0.0, vis);

    let rect = |w| shown.iter().find(|p| p.0 == w).unwrap().1;

    assert!(rect(b).x < rect(a).x);

    assert_eq!(rect(a).h, AREA.h);

}

/// A move either changes what is on screen or changes nothing at all, and a

/// window move never rearranges hidden windows among themselves. Steps around

/// hidden windows used to succeed invisibly and eat the keypress.

#[test]

fn moves_are_seen_or_undone() {

    let dirs = [Dir::Left, Dir::Right, Dir::Up, Dir::Down];

    let mut runner = proptest::test_runner::TestRunner::deterministic();

    let ops = prop::collection::vec((0u8..4, 0u8..4, 0u8..4, 0u8..32), 1..14);

    for _ in 0..2000 {

        let seq = proptest::strategy::ValueTree::current(&ops.new_tree(&mut runner).unwrap());

        let mut t: Tree<u32> = Tree::default();

        t.insert_row(0);

        let mut n = 1;

        for &(w, d, kind, hide) in &seq {

            let vis = |x: u32| hide & (1 << x) == 0;

            if kind == 0 && n < 5 {

                t.insert_after(n, u32::from(w) % n);

                n += 1;

                continue;

            }

            let w = u32::from(w) % n;

            let shown = |t: &Tree<u32>| {

                let mut v: Vec<_> = t

                    .arrange(AREA, 0.0, vis)

                    .into_iter()

                    .filter(|p| vis(p.0))

                    .collect();

                v.sort_by_key(|p| p.0);

                v

            };

            let before = shown(&t);

            let hidden = |t: &Tree<u32>| {

                let mut t = t.clone();

                t.retain(|x| !vis(x));

                t.shape()

            };

            let rest = hidden(&t);

            let d = dirs[usize::from(d)];

            let moved = match kind {

                1 => t.merge_window(w, d, vis),

                2 => t.move_window(w, d, vis),

                3 => t.move_container(w, d, vis),

                _ => continue,

            };

            t.check();

            assert_eq!(moved, shown(&t) != before, "{seq:?}");

            if kind != 3 {

                assert_eq!(hidden(&t), rest, "{seq:?}");

            }

        }

    }

}

/// A fullscreen window hides everything but its own transients, which stay

/// reachable by focus and are not hidden when they map.

#[test]

fn fullscreen_leaves_its_transients_reachable() {

    let mut l = Layout::default();

    let o = l.add_output("a", AREA);

    let beside = l.add_window(None, None, None);

    l.focus(beside);

    let game = l.add_window(None, None, None);

    l.focus(game);

    l.toggle_fullscreen(game);

    let stranger = l.add_window(None, None, None);

    assert!(l.covered(stranger));

    let dialog = l.add_window(None, None, Some(Rect::new(300.0, 200.0, 200.0, 100.0)));

    l.set_parent(dialog, Some(game));

    assert!(!l.covered(dialog));

    l.focus(dialog);

    let arr = l.arrange(o);

    assert_eq!(arr.fullscreen, Some(game));

    assert_eq!(arr.over, vec![dialog]);

    for dir in [Dir::Left, Dir::Right, Dir::Up, Dir::Down] {

        if let Some(w) = l.focus_dir(dir) {

            assert!(w == game || w == dialog, "focus walked to a covered window");

        }

    }

    l.remove_window(game);

    assert!(!l.covered(stranger));

    assert_eq!(l.window(dialog).and_then(|w| w.parent), None);

}

fn rect_of(t: &Tree<u32>, w: u32, vis: impl Fn(u32) -> bool) -> Rect {

    t.arrange(AREA, 0.0, vis)

        .into_iter()

        .find(|p| p.0 == w)

        .unwrap()

        .1

}

#[test]

fn splitting_a_lone_window_shares_its_space() {

    let (a, b, c) = (1, 2, 3);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_split(b, a, Axis::Horizontal);

    t.check();

    let (ra, rb) = (rect_of(&t, a, |_| true), rect_of(&t, b, |_| true));

    assert_eq!((ra.w, rb.w, ra.h), (AREA.w / 2.0, AREA.w / 2.0, AREA.h));

    assert!(ra.x < rb.x);

    t.insert_split(c, b, Axis::Vertical);

    t.check();

    let (rb, rc) = (rect_of(&t, b, |_| true), rect_of(&t, c, |_| true));

    assert_eq!(

        (rb.h, rc.h, rb.w),

        (AREA.h / 2.0, AREA.h / 2.0, AREA.w / 2.0)

    );

    assert!(rb.y < rc.y);

    assert_eq!(rect_of(&t, a, |_| true), ra, "the sibling is undisturbed");

}

#[test]

fn splitting_along_the_parents_axis_appends_a_sibling() {

    let (a, b, c, d) = (1, 2, 3, 4);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_split(b, a, Axis::Horizontal);

    t.insert_split(c, b, Axis::Vertical);

    let before = rect_of(&t, a, |_| true);

    t.insert_split(d, a, Axis::Horizontal);

    t.check();

    let all = |_| true;

    let (ra, rd, rb) = (

        rect_of(&t, a, all),

        rect_of(&t, d, all),

        rect_of(&t, b, all),

    );

    assert_eq!((ra.w, rd.w), (before.w / 2.0, before.w / 2.0));

    assert!(ra.x < rd.x && rd.x < rb.x);

    assert_eq!(rb.w, AREA.w / 2.0, "the neighbour keeps its share");

}

#[test]

fn splitting_beside_hidden_windows_leaves_their_slots_alone() {

    let (a, b, c, d) = (1, 2, 3, 4);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(b, a);

    t.insert_after(c, a);

    let tag_one = |w: u32| w == a || w == d;

    assert_eq!(rect_of(&t, a, tag_one).h, AREA.h);

    t.insert_split(d, a, Axis::Vertical);

    t.check();

    let (ra, rd) = (rect_of(&t, a, tag_one), rect_of(&t, d, tag_one));

    assert_eq!((ra.h, rd.h, ra.w), (AREA.h / 2.0, AREA.h / 2.0, AREA.w));

    assert!(ra.y < rd.y);

    t.insert_split(d + 1, a, Axis::Horizontal);

    t.check();

    let shown = |w: u32| w == a || w == d + 1;

    let (ra, re) = (rect_of(&t, a, shown), rect_of(&t, d + 1, shown));

    assert_eq!((ra.w, re.w), (AREA.w / 2.0, AREA.w / 2.0));

    assert!(ra.x < re.x);

    assert_eq!(t.windows().count(), 5, "hidden windows stay in the tree");

}

#[test]

fn autotile_dwindles_by_the_anchors_shape() {

    let mut l = Layout {

        autotile: true,

        ..Layout::default()

    };

    let o = l.add_output("a", AREA);

    let tag = l.tag("1");

    l.view(o, tag);

    let mut ids = Vec::new();

    for _ in 0..4 {

        let w = l.add_window(Some(o), Some(tag), None);

        l.focus(w);

        ids.push(w);

        l.check();

    }

    let arr = l.arrange(o);

    let r = |w| arr.tiled.iter().find(|p| p.window == w).unwrap().rect;

    let [a, b, c, d] = [ids[0], ids[1], ids[2], ids[3]];

    assert!(

        r(a).x < r(b).x && r(a).h > r(b).h * 1.5,

        "{a:?} left, {b:?} right"

    );

    assert!(r(b).y < r(c).y && r(b).x == r(c).x);

    assert!(r(c).x < r(d).x && r(c).y == r(d).y);

}

#[test]

fn urgency_skips_the_focused_window_and_ends_with_focus() {

    let mut l = Layout::default();

    let o = l.add_output("a", AREA);

    let tag = l.tag("1");

    l.view(o, tag);

    let a = l.add_window(Some(o), Some(tag), None);

    let b = l.add_window(Some(o), Some(tag), None);

    l.focus(a);

    l.mark_urgent(a);

    l.mark_urgent(b);

    assert!(!l.window(a).unwrap().urgent);

    assert!(l.window(b).unwrap().urgent);

    assert!(!l.tags().any(|(_, t)| t.urgent));

    l.focus(b);

    assert!(!l.window(b).unwrap().urgent);

}

#[test]

fn oversized_floats_keep_their_top_edge_and_a_strip() {

    let bounds = Rect::new(0.0, 0.0, 1000.0, 600.0);

    let huge = Rect::new(-5000.0, -300.0, 3000.0, 2000.0);

    let r = clamp_float(huge, bounds);

    assert_eq!((r.x, r.y), (-2936.0, 0.0));

    let r = clamp_float(Rect::new(5000.0, 5000.0, 3000.0, 2000.0), bounds);

    assert_eq!((r.x, r.y), (936.0, 536.0));

    let fits = clamp_float(Rect::new(900.0, 500.0, 300.0, 200.0), bounds);

    assert_eq!((fits.x, fits.y), (700.0, 400.0));

}

#[test]

fn floats_follow_their_output_area_and_panels() {

    let mut l = Layout::default();

    let o = l.add_output("a", AREA);

    let w = l.add_window(Some(o), None, Some(Rect::new(500.0, 300.0, 400.0, 300.0)));

    l.set_output_area(o, Rect::new(100.0, 50.0, 500.0, 300.0));

    let r = l.window(w).unwrap().float_rect.unwrap();

    assert_eq!((r.x, r.y, r.w, r.h), (350.0, 200.0, 200.0, 150.0));

    l.set_reserved(

        o,

        Insets {

            top: 100.0,

            ..Insets::default()

        },

    );

    let r = l.window(w).unwrap().float_rect.unwrap();

    let usable = l.output(o).unwrap().usable();

    assert!(r.y >= usable.y && r.bottom() <= usable.bottom());

}

#[test]

fn floats_shrink_into_a_smaller_output_they_are_evicted_to() {

    let mut l = Layout::default();

    let a = l.add_output("a", AREA);

    let b = l.add_output("b", Rect::new(1000.0, 0.0, 500.0, 300.0));

    let w = l.add_window(Some(a), None, Some(Rect::new(800.0, 400.0, 200.0, 200.0)));

    l.remove_output(a);

    assert_eq!(l.window(w).unwrap().output, Some(b));

    let r = l.window(w).unwrap().float_rect.unwrap();

    let usable = l.output(b).unwrap().usable();

    assert_eq!((r.w, r.h), (100.0, 100.0));

    assert!(r.x >= usable.x && r.right() <= usable.right());

    assert!(r.y >= usable.y && r.bottom() <= usable.bottom());

}

/// Dragging a split moves only the two tiles that meet at it, whichever of

/// them the drag started from, and stops where one would vanish.