Files
craft-libs/crates/ui/src/docking/model_tests.rs
Dylan M. Taylor 4029f023a6 ui: check floating destinations and integrity-matched font bytes (#567)
- docking: apply_with_permissions refuses a move or open into a floating
  window for a panel that is not floatable (Move, OpenAt, MovePanel and
  group/column/window moves), and a Group placement at a floating anchor,
  which becomes a split of its frame, needs accepts_splits.
- fonts: the served-font loader keys fetched files, in-flight requests,
  failures and pending UI faces by (url, integrity), and installs bytes
  only into faces requiring the integrity they were fetched under
  (Stack::provide_fetched); the public Stack::provide is unchanged.
2026-11-03 23:05:04 -05:00

829 lines
44 KiB
Rust

use super::dock_model::{Place, node_at};
use super::*;
use crate::layout::{SplitAxis, SplitSize};
pub(super) fn g(panels: &[u32], active: usize) -> Group<u32> {
Group::new(panels.to_vec(), active)
}
fn tabs(panels: &[u32], active: usize) -> Node<u32> {
Node::Tabs { panels: panels.to_vec(), active }
}
fn hsplit(size: SplitSize, first: Node<u32>, second: Node<u32>) -> Node<u32> {
Node::Split { axis: SplitAxis::Horizontal, size, first: Box::new(first), second: Box::new(second) }
}
/// Canvas 1 above frame tabs [11, 12]; an end dock with column A ([2, 3], [4]) and column B
/// ([5]); a floating window with groups [6, 7] and [8].
pub(super) fn docked() -> Layout<u32> {
let middle =
Node::Split { axis: SplitAxis::Vertical, size: SplitSize::Ratio(0.7), first: Box::new(tabs(&[1], 0)), second: Box::new(tabs(&[11, 12], 1)) };
let dock =
Node::Dock { side: Side::End, columns: vec![Column::new(vec![g(&[2, 3], 1), g(&[4], 0)], 180.0), Column::new(vec![g(&[5], 0)], 120.0)] };
Layout {
root: Some(hsplit(SplitSize::FixedSecond(300.0), middle, dock)),
floating: vec![Floating::stack(vec![g(&[6, 7], 1), g(&[8], 0)], [100.0, 100.0, 300.0, 400.0]).unwrap()],
}
}
pub(super) const ALL: [u32; 10] = [1, 2, 3, 4, 5, 6, 7, 8, 11, 12];
fn sorted(layout: &Layout<u32>) -> Vec<u32> {
let mut panels: Vec<u32> = layout.panels().into_iter().copied().collect();
panels.sort_unstable();
panels
}
/// Members, active panel and minimized state of the group holding `panel`.
fn group_state(layout: &Layout<u32>, panel: u32) -> (Vec<u32>, u32, bool) {
match layout.place(&panel).unwrap() {
place @ (Place::Node(_) | Place::Floating { .. }) => match layout.node_of(&place).unwrap() {
Node::Tabs { panels, active } => (panels.clone(), panels[*active], false),
other => panic!("{other:?}"),
},
place => {
let group = layout.group(&place).unwrap();
(group.panels.clone(), group.panels[group.active], group.minimized)
}
}
}
fn dock(layout: &Layout<u32>, side: Side) -> &Vec<Column<u32>> {
let path = layout.dock_path(side).unwrap();
let Some(Node::Dock { columns, .. }) = node_at(layout.root.as_ref().unwrap(), &path) else { panic!() };
columns
}
fn panels_of(groups: &[Group<u32>]) -> Vec<Vec<u32>> {
groups.iter().map(|g| g.panels.clone()).collect()
}
#[test]
fn group_moves_keep_order_active_tab_and_minimized_state() {
let targets = [
Target::At { anchor: 5, placement: Placement::Group { below: true, height: None } },
Target::At { anchor: 5, placement: Placement::Column { after: true } },
Target::At { anchor: 8, placement: Placement::Group { below: false, height: None } },
Target::NewDock { side: Side::Start },
Target::Float { rect: Some([20.0, 20.0, 200.0, 300.0]) },
Target::Float { rect: None },
];
// A frame Tabs node, a column group and a floating group.
for source in [11, 2, 6] {
for to in &targets {
let mut layout = docked();
if source != 11 {
layout.apply(Action::SetMinimized { panel: source, minimized: true }).unwrap();
}
let before = group_state(&layout, source);
layout.apply(Action::MoveGroup { panel: source, to: to.clone() }).unwrap_or_else(|e| panic!("{source} {to:?}: {e}"));
let after = group_state(&layout, source);
assert_eq!((&after.0, after.1), (&before.0, before.1), "{source} {to:?}");
// A group keeps its minimized state from dock to dock; a floating window's tree
// has no minimized groups.
if matches!((source, layout.place(&source)), (2, Some(Place::Dock { .. }))) {
assert_eq!(after.2, before.2, "{source} {to:?}");
}
assert_eq!(sorted(&layout), ALL);
}
}
// Into a frame split the group becomes a Tabs node with the same order and selection.
let mut layout = docked();
layout.apply(Action::MoveGroup { panel: 6, to: Target::At { anchor: 1, placement: Placement::Split(Zone::Left) } }).unwrap();
assert_eq!(group_state(&layout, 6), (vec![6, 7], 7, false));
assert_eq!(layout.floating[0].groups().len(), 1);
}
#[test]
fn group_merge_into_tabs_inserts_every_member_before_the_anchor_tab() {
let mut layout = docked();
layout.apply(Action::MoveGroup { panel: 6, to: Target::At { anchor: 2, placement: Placement::Tab { before: Some(3) } } }).unwrap();
assert_eq!(group_state(&layout, 2), (vec![2, 6, 7, 3], 7, false));
assert_eq!(panels_of(&layout.floating[0].groups()), [vec![8]]);
let mut layout = docked();
layout.apply(Action::MoveGroup { panel: 2, to: Target::At { anchor: 11, placement: Placement::Tab { before: Some(12) } } }).unwrap();
assert_eq!(group_state(&layout, 11), (vec![11, 2, 3, 12], 3, false));
assert_eq!(panels_of(&dock(&layout, Side::End)[0].groups), [vec![4]]);
// A target inside the moving group is a no-op; a protected anchor refuses tabs.
let before = docked();
let mut layout = before.clone();
layout.apply(Action::MoveGroup { panel: 2, to: Target::At { anchor: 3, placement: Placement::Tab { before: None } } }).unwrap();
assert_eq!(layout, before);
let protect = |p: &u32| if *p == 1 { Permissions::PROTECTED } else { Permissions::default() };
let to = Target::At { anchor: 1, placement: Placement::Tab { before: None } };
assert_eq!(layout.apply_with_permissions(Action::MoveGroup { panel: 2, to }, protect), Err(DockError::NotAllowed));
assert_eq!(layout, before);
}
#[test]
fn a_floating_destination_takes_only_floatable_panels_and_a_group_there_needs_splits() {
let before = docked();
// Panel 4 may move but not float; panel 6 (floating) takes no splits.
let policy = |p: &u32| match p {
4 => Permissions { floatable: false, ..Permissions::default() },
6 => Permissions { accepts_splits: false, ..Permissions::default() },
_ => Permissions::default(),
};
let tab = Placement::Tab { before: None };
let group = Placement::Group { below: true, height: None };
for action in [
Action::Move { panel: 4, anchor: 8, placement: tab.clone() },
Action::MovePanel { panel: 4, to: Target::At { anchor: 8, placement: tab.clone() } },
Action::MoveGroup { panel: 4, to: Target::At { anchor: 8, placement: tab.clone() } },
Action::MoveGroup { panel: 11, to: Target::At { anchor: 6, placement: group.clone() } },
] {
let mut layout = before.clone();
assert_eq!(layout.apply_with_permissions(action.clone(), policy), Err(DockError::NotAllowed), "{action:?}");
assert_eq!(layout, before);
}
// Floatable panels still join the window, and a group still goes below a docked anchor.
let mut layout = before.clone();
layout.apply_with_permissions(Action::Move { panel: 5, anchor: 8, placement: tab }, policy).unwrap();
let mut layout = before.clone();
layout.apply_with_permissions(Action::MoveGroup { panel: 11, to: Target::At { anchor: 2, placement: group } }, policy).unwrap();
}
#[test]
fn column_moves_and_floats_keep_every_group() {
let mut layout = docked();
layout.apply(Action::SetIconic { panel: 4, iconic: true }).unwrap();
layout.apply(Action::MoveColumn { panel: 2, to: Target::NewDock { side: Side::Start } }).unwrap();
let Some(Node::Split { size, first, .. }) = &layout.root else { panic!() };
assert_eq!(*size, SplitSize::FixedFirst(180.0));
assert!(matches!(**first, Node::Dock { side: Side::Start, .. }));
let start = dock(&layout, Side::Start);
assert_eq!(start.len(), 1);
assert_eq!(panels_of(&start[0].groups), [vec![2, 3], vec![4]]);
assert_eq!((start[0].width, start[0].iconic, start[0].groups[0].active), (180.0, true, 1));
assert_eq!(panels_of(&dock(&layout, Side::End)[0].groups), [vec![5]]);
// The last column leaves the end dock, which collapses.
layout.apply(Action::MoveColumn { panel: 5, to: Target::At { anchor: 2, placement: Placement::Column { after: false } } }).unwrap();
assert!(layout.dock_path(Side::End).is_none());
let start = dock(&layout, Side::Start);
assert_eq!(start.iter().map(|c| c.width).collect::<Vec<_>>(), [120.0, 180.0]);
layout.apply(Action::MoveColumn { panel: 3, to: Target::Float { rect: None } }).unwrap();
let window = layout.floating.last().unwrap();
assert_eq!(panels_of(&window.groups()), [vec![2, 3], vec![4]]);
assert_eq!(window.rect[2], 180.0);
assert_eq!(sorted(&layout), ALL);
assert_eq!(layout.apply(Action::MoveColumn { panel: 11, to: Target::Float { rect: None } }), Err(DockError::InvalidPlacement));
}
#[test]
fn window_docks_as_stacked_groups_or_merges_as_tabs() {
let mut layout = docked();
layout.apply(Action::MoveWindow { panel: 8, to: Target::At { anchor: 4, placement: Placement::Group { below: true, height: None } } }).unwrap();
assert_eq!(panels_of(&dock(&layout, Side::End)[0].groups), [vec![2, 3], vec![4], vec![6, 7], vec![8]]);
assert!(layout.floating.is_empty());
let mut layout = docked();
layout.apply(Action::MoveWindow { panel: 8, to: Target::At { anchor: 11, placement: Placement::Tab { before: None } } }).unwrap();
assert_eq!(group_state(&layout, 11), (vec![11, 12, 6, 7, 8], 7, false));
let mut layout = docked();
layout.apply(Action::MoveWindow { panel: 6, to: Target::NewDock { side: Side::Start } }).unwrap();
let start = dock(&layout, Side::Start);
assert_eq!((panels_of(&start[0].groups), start[0].width), (vec![vec![6, 7], vec![8]], 300.0));
let before = docked();
let mut layout = before.clone();
layout.apply(Action::MoveWindow { panel: 7, to: Target::At { anchor: 8, placement: Placement::Tab { before: None } } }).unwrap();
assert_eq!(layout, before);
assert_eq!(layout.apply(Action::MoveWindow { panel: 2, to: Target::Float { rect: None } }), Err(DockError::InvalidPlacement));
}
#[test]
fn close_group_and_close_window_record_a_restorable_location_per_member() {
let mut workspace = Workspace::new(docked());
let allow = |_: &u32| Permissions::default();
assert_eq!(workspace.apply(Action::CloseGroup { panel: 3 }, allow).unwrap(), [2, 3]);
assert_eq!(workspace.hidden.iter().map(|(p, _)| *p).collect::<Vec<_>>(), [2, 3]);
assert_eq!(panels_of(&dock(&workspace.layout, Side::End)[0].groups), [vec![4]]);
workspace.set_visible(2, true, None, |_| Permissions::default()).unwrap();
workspace.set_visible(3, true, None, |_| Permissions::default()).unwrap();
assert_eq!(panels_of(&dock(&workspace.layout, Side::End)[0].groups), [vec![2, 3], vec![4]]);
assert_eq!(workspace.layout.closed_by(&Action::CloseWindow { panel: 7 }).unwrap(), [6, 7, 8]);
assert_eq!(workspace.apply(Action::CloseWindow { panel: 7 }, allow).unwrap(), [6, 7, 8]);
assert!(workspace.layout.floating.is_empty());
assert_eq!(workspace.hidden.len(), 3);
for panel in [6, 7, 8] {
workspace.set_visible(panel, true, None, |_| Permissions::default()).unwrap();
}
assert_eq!(workspace.layout.floating.len(), 1);
assert_eq!(panels_of(&workspace.layout.floating[0].groups()), [vec![6, 7], vec![8]]);
assert_eq!(workspace.layout.floating[0].rect, [100.0, 100.0, 300.0, 400.0]);
workspace.apply(Action::CloseOthers { panel: 12 }, allow).unwrap();
assert_eq!(group_state(&workspace.layout, 12).0, [12]);
workspace.set_visible(11, true, None, |_| Permissions::default()).unwrap();
assert_eq!(group_state(&workspace.layout, 12).0, [11, 12]);
assert!(workspace.hidden.is_empty());
assert_eq!(sorted(&workspace.layout), ALL);
// A member that may not close keeps the whole group open.
let keep = |p: &u32| if *p == 4 { Permissions { closable: false, ..Permissions::default() } } else { Permissions::default() };
let before = workspace.clone();
assert_eq!(workspace.apply(Action::CloseGroup { panel: 4 }, keep), Err(DockError::NotAllowed));
assert_eq!(workspace, before);
}
#[test]
fn panels_closed_one_by_one_reopen_into_one_group() {
let allow = |_: &u32| Permissions::default();
let rect = [100.0, 100.0, 300.0, 400.0];
let cycle = |workspace: &mut Workspace<u32>, close: &[u32], reopen: &[u32]| {
for &panel in close {
workspace.set_visible(panel, false, None, allow).unwrap();
}
for &panel in reopen {
workspace.set_visible(panel, true, None, allow).unwrap_or_else(|e| panic!("{close:?} {reopen:?} {panel}: {e}"));
}
assert!(workspace.hidden.is_empty());
};
let orders2 = [[2, 3], [3, 2]];
for close in orders2 {
for reopen in orders2 {
let mut workspace = Workspace::new(docked());
cycle(&mut workspace, &close, &reopen);
let columns = dock(&workspace.layout, Side::End);
assert_eq!(
columns.iter().map(|c| panels_of(&c.groups)).collect::<Vec<_>>(),
[vec![vec![2, 3], vec![4]], vec![vec![5]]],
"{close:?} {reopen:?}"
);
}
}
let orders2 = [[10, 20], [20, 10]];
for close in orders2 {
for reopen in orders2 {
let mut workspace = Workspace::new(Layout { root: Some(tabs(&[1], 0)), floating: vec![Floating::single(vec![10, 20], 0, rect)] });
cycle(&mut workspace, &close, &reopen);
let [window] = &workspace.layout.floating[..] else { panic!("{close:?} {reopen:?}: {:?}", workspace.layout.floating) };
assert_eq!((window.panels().copied().collect::<Vec<_>>(), window.rect), (vec![10, 20], rect), "{close:?} {reopen:?}");
}
}
// Three tabs: the locations do not always record the order, only the window.
let orders3 = [[10, 20, 30], [10, 30, 20], [20, 10, 30], [20, 30, 10], [30, 10, 20], [30, 20, 10]];
for close in orders3 {
for reopen in orders3 {
let mut workspace = Workspace::new(Layout { root: Some(tabs(&[1], 0)), floating: vec![Floating::single(vec![10, 20, 30], 0, rect)] });
cycle(&mut workspace, &close, &reopen);
let [window] = &workspace.layout.floating[..] else { panic!("{close:?} {reopen:?}: {:?}", workspace.layout.floating) };
let mut panels: Vec<u32> = window.panels().copied().collect();
panels.sort_unstable();
assert_eq!(panels, [10, 20, 30], "{close:?} {reopen:?}");
}
}
}
#[test]
fn a_panel_reopened_through_a_hidden_neighbour_keeps_its_own_group_state() {
let allow = |_: &u32| Permissions::default();
let dock_of = |columns: Vec<Column<u32>>| Layout {
root: Some(hsplit(SplitSize::FixedSecond(480.0), tabs(&[1], 0), Node::Dock { side: Side::End, columns })),
floating: Vec::new(),
};
// Groups [2] and [3] stacked with their own heights: 2 comes back at its height, not 3's.
let stacked = dock_of(vec![
Column::new(vec![Group { height: Some(120.0), ..g(&[2], 0) }, Group { height: Some(300.0), ..g(&[3], 0) }], 240.0),
Column::new(vec![g(&[5], 0)], 240.0),
]);
let mut workspace = Workspace::new(stacked);
workspace.set_visible(2, false, None, allow).unwrap();
workspace.set_visible(3, false, None, allow).unwrap();
workspace.set_visible(2, true, None, allow).unwrap();
let group = |w: &Workspace<u32>, panel: u32| {
dock(&w.layout, Side::End).iter().flat_map(|c| c.groups.iter()).find(|g| g.panels.contains(&panel)).cloned().unwrap()
};
assert_eq!(group(&workspace, 2).height, Some(120.0), "{:?}", workspace.layout);
workspace.set_visible(3, true, None, allow).unwrap();
assert_eq!(group(&workspace, 3).height, Some(300.0), "{:?}", workspace.layout);
// [2] beside an icon-only column holding [3]: 2 comes back in a column of its own width,
// not as an icon.
let iconic = Column { iconic: true, ..Column::new(vec![g(&[3], 0)], 200.0) };
let mut workspace = Workspace::new(dock_of(vec![Column::new(vec![g(&[2], 0)], 260.0), iconic]));
workspace.set_visible(2, false, None, allow).unwrap();
workspace.set_visible(3, false, None, allow).unwrap();
workspace.set_visible(2, true, None, allow).unwrap();
let column = dock(&workspace.layout, Side::End).iter().find(|c| c.groups.iter().any(|g| g.panels.contains(&2))).cloned().unwrap();
assert!(!column.iconic, "{:?}", workspace.layout);
assert_eq!(column.width, 260.0);
}
#[test]
fn panels_closed_one_by_one_reopen_on_their_own_sides() {
let allow = |_: &u32| Permissions::default();
let orders = [[2, 3], [3, 2]];
let frames = Layout {
root: Some(hsplit(SplitSize::Ratio(0.3), tabs(&[1], 0), hsplit(SplitSize::Ratio(0.5), tabs(&[2], 0), tabs(&[3], 0)))),
floating: Vec::new(),
};
let columns = Layout {
root: Some(hsplit(
SplitSize::FixedSecond(480.0),
tabs(&[1], 0),
Node::Dock { side: Side::End, columns: vec![Column::new(vec![g(&[2], 0)], 240.0), Column::new(vec![g(&[3], 0)], 240.0)] },
)),
floating: Vec::new(),
};
for close in orders {
for reopen in orders {
let mut workspace = Workspace::new(frames.clone());
for (panel, visible) in close.iter().map(|p| (*p, false)).chain(reopen.iter().map(|p| (*p, true))) {
workspace.set_visible(panel, visible, None, allow).unwrap();
}
let order: Vec<u32> = workspace.layout.panels().into_iter().copied().collect();
assert_eq!(order, [1, 2, 3], "{close:?} {reopen:?}: {:?}", workspace.layout);
assert!(order.iter().all(|p| matches!(workspace.layout.place(p), Some(Place::Node(_)))));
assert_ne!(workspace.layout.place(&2), workspace.layout.place(&3), "{close:?} {reopen:?}");
let mut workspace = Workspace::new(columns.clone());
for (panel, visible) in close.iter().map(|p| (*p, false)).chain(reopen.iter().map(|p| (*p, true))) {
workspace.set_visible(panel, visible, None, allow).unwrap();
}
let groups: Vec<_> = dock(&workspace.layout, Side::End).iter().map(|c| panels_of(&c.groups)).collect();
assert_eq!(groups, [vec![vec![2]], vec![vec![3]]], "{close:?} {reopen:?}");
}
}
// A panel that sat at the edge beside a hidden one keeps that one's own location: 3 opens
// right of 1, not as a tab beside 2.
let mut workspace = Workspace::new(Layout { root: Some(tabs(&[1], 0)), floating: Vec::new() });
let at = |anchor: u32, placement: Placement<u32>| Location {
floating: None,
anchor: Some(anchor),
placement,
size: None,
stack: None,
sibling: Vec::new(),
group: None,
};
workspace.hidden = vec![(2, at(3, Placement::Edge(Zone::Right))), (3, at(1, Placement::Split(Zone::Right)))];
workspace.set_visible(2, true, None, allow).unwrap();
workspace.set_visible(3, true, None, allow).unwrap();
assert!(matches!(workspace.layout.place(&3), Some(Place::Node(_))));
assert_ne!(workspace.layout.place(&2), workspace.layout.place(&3), "{:?}", workspace.layout);
// Past the edge frame the chain keeps its forward anchors: 4 does not anchor on 3 while 3
// anchors on 4, and both still reopen.
let mut workspace = Workspace::new(Layout { root: Some(tabs(&[1], 0)), floating: Vec::new() });
workspace.hidden =
vec![(2, at(3, Placement::Edge(Zone::Right))), (3, at(4, Placement::Split(Zone::Right))), (4, at(1, Placement::Split(Zone::Right)))];
workspace.set_visible(2, true, None, allow).unwrap();
assert_eq!(workspace.hidden.iter().find(|(p, _)| *p == 4).and_then(|(_, l)| l.anchor), Some(1), "{:?}", workspace.hidden);
workspace.set_visible(3, true, None, allow).unwrap();
workspace.set_visible(4, true, None, allow).unwrap();
assert!(workspace.hidden.is_empty() && [1, 2, 3, 4].iter().all(|p| workspace.layout.contains(p)), "{:?}", workspace.layout);
}
#[test]
fn restore_into_a_column_group_seam_and_new_column_round_trips() {
let column_a = Column::new(vec![g(&[2, 3], 1), Group { minimized: true, height: Some(150.0), ..g(&[4], 0) }, g(&[9], 0)], 180.0);
let column_b = Column { iconic: true, iconic_width: Some(48.0), ..Column::new(vec![g(&[5], 0)], 120.0) };
let end = Node::Dock { side: Side::End, columns: vec![column_a, column_b] };
let start = Node::Dock { side: Side::Start, columns: vec![Column::new(vec![g(&[10], 0)], 200.0)] };
let original = Layout {
root: Some(hsplit(SplitSize::FixedFirst(200.0), start, hsplit(SplitSize::FixedSecond(300.0), tabs(&[1], 0), end))),
floating: vec![Floating::stack(vec![g(&[6], 0), Group { height: Some(90.0), ..g(&[7], 0) }], [10.0, 10.0, 200.0, 300.0]).unwrap()],
};
original.validate().unwrap();
// 4: the seam between [2, 3] and [9]; 9: below [4]; 5: a new column after A; 10: alone in
// its dock; 3: a tab; 7: below a floating group.
for panel in [4, 9, 5, 10, 3, 7] {
let mut layout = original.clone();
let location = layout.location(&panel).unwrap();
#[cfg(feature = "serde")]
let location: Location<u32> = serde_json::from_str(&serde_json::to_string(&location).unwrap()).unwrap();
layout.apply(Action::Close { panel }).unwrap();
layout.restore(panel, &location).unwrap_or_else(|e| panic!("{panel}: {e} {location:?}"));
assert_eq!(layout, original, "{panel}: {location:?}");
}
}
#[test]
fn dock_validation_rejects_two_docks_per_side_nested_docks_empty_columns_and_bad_widths() {
docked().validate().unwrap();
let empty_dock = |side| Node::Dock { side, columns: Vec::new() };
Layout { root: Some(hsplit(SplitSize::FixedFirst(10.0), empty_dock(Side::Start), tabs(&[1], 0))), floating: Vec::new() }.validate().unwrap();
let two = hsplit(SplitSize::Ratio(0.5), empty_dock(Side::Start), empty_dock(Side::Start));
let nested = Node::Split {
axis: SplitAxis::Vertical,
size: SplitSize::Ratio(0.5),
first: Box::new(empty_dock(Side::Start)),
second: Box::new(tabs(&[1], 0)),
};
let wrong_side = hsplit(SplitSize::Ratio(0.5), empty_dock(Side::End), tabs(&[1], 0));
for root in [two, nested, wrong_side] {
assert_eq!(Layout { root: Some(root), floating: Vec::new() }.validate(), Err(DockError::InvalidPlacement));
}
let with_column = |column: Column<u32>| Layout { root: Some(Node::Dock { side: Side::End, columns: vec![column] }), floating: Vec::new() };
let bad = [
Column::new(Vec::new(), 100.0),
Column::new(vec![g(&[], 0)], 100.0),
Column::new(vec![g(&[2], 1)], 100.0),
Column::new(vec![Group { height: Some(f32::NAN), ..g(&[2], 0) }], 100.0),
Column::new(vec![g(&[2], 0)], 0.0),
Column::new(vec![g(&[2], 0)], -5.0),
Column::new(vec![g(&[2], 0)], f32::INFINITY),
Column::new(vec![g(&[2], 0)], 2.0e6),
Column { iconic_width: Some(f32::NAN), ..Column::new(vec![g(&[2], 0)], 100.0) },
];
for column in bad {
assert!(with_column(column.clone()).validate().is_err(), "{column:?}");
}
let mut duplicate = docked();
duplicate.floating[0].root = Node::Tabs { panels: vec![6, 7, 2], active: 0 };
assert_eq!(duplicate.validate(), Err(DockError::DuplicatePanel));
let mut empty_window = docked();
empty_window.floating[0].root = Node::Tabs { panels: Vec::new(), active: 0 };
assert_eq!(empty_window.validate(), Err(DockError::InvalidGeometry));
let mut docked_window = docked();
docked_window.floating[0].root = Node::Dock { side: Side::End, columns: vec![Column::new(vec![g(&[6, 7], 0)], 100.0)] };
assert_eq!(docked_window.validate(), Err(DockError::InvalidPlacement));
let mut native = docked();
native.floating[0].native = Some([0.0, 0.0, -1.0, 10.0]);
assert_eq!(native.validate(), Err(DockError::InvalidGeometry));
let mut monitor = docked();
monitor.floating[0].monitor = Some(super::Monitor { name: None, rect: [0.0, 0.0, 1920.0, 1080.0], scale: f32::NAN });
assert_eq!(monitor.validate(), Err(DockError::InvalidGeometry));
let mut monitor_size = docked();
monitor_size.floating[0].monitor_size = Some([f32::NAN, 1080.0]);
assert_eq!(monitor_size.validate(), Err(DockError::InvalidGeometry));
let mut layout = docked();
assert_eq!(layout.apply(Action::ResizeColumn { panel: 2, width: f32::NAN }), Err(DockError::InvalidGeometry));
assert_eq!(layout.apply(Action::ResizeColumn { panel: 11, width: 50.0 }), Err(DockError::InvalidPlacement));
assert_eq!(layout, docked());
}
#[test]
fn a_locked_workspace_records_its_native_windows() {
let mut workspace = Workspace::new(docked());
workspace.locked = true;
for rect in [[0.0, 0.0, 300.0, 400.0], [40.0, 30.0, 300.0, 400.0]] {
workspace.apply(Action::SetNative { panel: 6, rect: Some(rect) }, |_| Permissions::default()).unwrap();
assert_eq!(workspace.layout.floating[0].native, Some(rect));
}
}
#[test]
fn locked_workspace_rejects_structure_but_allows_activate_open_minimize_and_resize() {
let mut workspace = Workspace::new(docked());
let allow = |_: &u32| Permissions::default();
workspace.apply(Action::Close { panel: 12 }, allow).unwrap();
workspace.locked = true;
let before = workspace.clone();
let refused = [
Action::Move { panel: 2, anchor: 5, placement: Placement::Tab { before: None } },
Action::MoveGroup { panel: 2, to: Target::Float { rect: None } },
Action::MoveColumn { panel: 5, to: Target::NewDock { side: Side::Start } },
Action::MoveWindow { panel: 6, to: Target::At { anchor: 4, placement: Placement::Group { below: true, height: None } } },
Action::Float { panel: 4, rect: [0.0, 0.0, 100.0, 100.0] },
Action::MoveFloating { panel: 6, rect: [0.0, 0.0, 100.0, 100.0] },
Action::Close { panel: 4 },
Action::CloseGroup { panel: 4 },
Action::CloseWindow { panel: 6 },
];
for action in refused {
assert_eq!(workspace.apply(action.clone(), allow), Err(DockError::NotAllowed), "{action:?}");
assert_eq!(workspace, before);
}
assert_eq!(workspace.set_visible(4, false, None, |_| Permissions::default()), Err(DockError::NotAllowed));
let allowed = [
Action::Activate { panel: 2 },
Action::Open { panel: 12, anchor: Some(11) },
Action::SetMinimized { panel: 4, minimized: true },
Action::SetIconic { panel: 5, iconic: true },
Action::ResizeColumn { panel: 5, width: 160.0 },
Action::ResizeGroup { panel: 4, height: Some(120.0) },
Action::ResizeIconic { panel: 5, width: Some(60.0) },
Action::ResizeSplit { path: Vec::new(), size: SplitSize::FixedSecond(320.0) },
];
workspace.apply_all(allowed, allow).unwrap();
assert!(workspace.hidden.is_empty());
assert_eq!(workspace.layout.panel_state(&12), PanelState::Front);
assert_eq!(workspace.layout.panel_state(&4), PanelState::Open);
assert_eq!(workspace.layout.panel_state(&5), PanelState::Open);
assert_eq!(workspace.layout.panel_state(&2), PanelState::Front);
assert_eq!(workspace.layout.panel_state(&3), PanelState::Open);
// Opening at a chosen place works too; moving a shown panel there does not.
workspace.apply(Action::OpenAt { panel: 13, anchor: 11, placement: Placement::Split(Zone::Bottom) }, allow).unwrap();
assert!(workspace.layout.contains(&13));
assert_eq!(
workspace.apply(Action::OpenAt { panel: 2, anchor: 11, placement: Placement::Split(Zone::Bottom) }, allow),
Err(DockError::NotAllowed)
);
}
#[test]
fn hiding_a_panel_that_may_not_close_is_refused() {
let mut workspace = Workspace::new(docked());
let canvas = |p: &u32| if *p == 1 { Permissions { accepts_splits: true, ..Permissions::PROTECTED } } else { Permissions::default() };
assert_eq!(workspace.set_visible(1, false, None, canvas), Err(DockError::NotAllowed));
assert!(workspace.layout.contains(&1) && workspace.hidden.is_empty());
workspace.set_visible(2, false, None, canvas).unwrap();
assert!(!workspace.layout.contains(&2));
}
#[test]
fn reconcile_drops_unknown_panels_and_places_missing_registered_ones() {
let default = Workspace::new(docked());
let mut workspace = default.clone();
workspace.layout.apply(Action::Close { panel: 5 }).unwrap();
workspace.layout.apply(Action::Close { panel: 12 }).unwrap();
workspace.layout.apply(Action::OpenAt { panel: 99, anchor: 2, placement: Placement::Tab { before: None } }).unwrap();
let stray = workspace.layout.location(&99).unwrap();
workspace.hidden.push((98, stray));
let registered = |p: &u32| *p < 90;
workspace.reconcile(registered, |_| Permissions::default(), &default);
workspace.validate().unwrap();
// Unregistered panels wait in `hidden` and come back once registered.
assert_eq!(workspace.hidden.iter().map(|(p, _)| *p).collect::<Vec<_>>(), [98, 99]);
assert_eq!(sorted(&workspace.layout), ALL);
workspace.set_visible(99, true, None, |_| Permissions::default()).unwrap();
assert_eq!(group_state(&workspace.layout, 2).0, [2, 3, 99]);
assert_eq!(dock(&workspace.layout, Side::End).len(), 2);
assert_eq!(group_state(&workspace.layout, 11).0, [11, 12]);
let mut broken = default.clone();
broken.layout.floating[0].rect[2] = -1.0;
broken.reconcile(registered, |_| Permissions::default(), &default);
assert_eq!(broken.layout, default.layout);
}
#[test]
fn reset_returns_to_saved_or_default() {
let default = docked();
let mut workspace = Workspace::new(default.clone());
workspace.apply(Action::MoveGroup { panel: 6, to: Target::NewDock { side: Side::Start } }, |_| Permissions::default()).unwrap();
workspace.reset(&default);
assert_eq!(workspace.layout, default);
let mut saved = default.clone();
saved.apply(Action::Close { panel: 8 }).unwrap();
saved.apply(Action::MoveGroup { panel: 11, to: Target::Float { rect: None } }).unwrap();
workspace.saved = Some(saved.clone());
workspace.reset(&default);
assert_eq!(workspace.layout, saved);
assert_eq!(workspace.hidden.iter().map(|(p, _)| *p).collect::<Vec<_>>(), [8]);
workspace.validate().unwrap();
}
#[cfg(feature = "serde")]
mod serde_tests {
use super::*;
use serde_json::{Value, json};
#[test]
fn a_saved_stack_of_groups_loads_as_a_vertical_split_by_their_heights() {
let saved = json!({
"groups": [{"panels": [4], "active": 0, "height": 100.0}, {"panels": [5, 6], "active": 1, "height": 300.0}],
"rect": [1.0, 2.0, 300.0, 400.0],
});
let window: Floating<u32> = serde_json::from_value(saved).unwrap();
let expected = Node::Split {
axis: SplitAxis::Vertical,
size: SplitSize::Ratio(0.25),
first: Box::new(Node::Tabs { panels: vec![4], active: 0 }),
second: Box::new(Node::Tabs { panels: vec![5, 6], active: 1 }),
};
assert_eq!((window.root, window.minimized), (expected, false));
let all_minimized = json!({"groups": [{"panels": [4], "active": 0, "minimized": true}], "rect": [1.0, 2.0, 300.0, 400.0]});
let window: Floating<u32> = serde_json::from_value(all_minimized).unwrap();
assert_eq!((window.root, window.minimized), (Node::Tabs { panels: vec![4], active: 0 }, true));
}
#[test]
fn single_plain_floating_window_writes_the_v1_shape() {
let rect = [1.0, 2.0, 300.0, 200.0];
let plain = Floating::single(vec![4u32, 5], 1, rect);
assert_eq!(serde_json::to_value(&plain).unwrap(), json!({"id": plain.id, "panels": [4, 5], "active": 1, "rect": rect}));
let minimized = Floating { minimized: true, ..Floating::single(vec![4u32], 0, rect) };
let stacked = Floating::stack(vec![g(&[4], 0), g(&[5], 0)], rect).unwrap();
let native = Floating { native: Some(rect), ..Floating::single(vec![4u32], 0, rect) };
for window in [minimized, stacked, native] {
let value = serde_json::to_value(&window).unwrap();
assert!(value.get("root").is_some() && value.get("panels").is_none(), "{value}");
assert_eq!(value["id"], json!(window.id), "{value}");
assert_eq!(serde_json::from_value::<Floating<u32>>(value).unwrap(), window);
}
assert!(serde_json::from_value::<Floating<u32>>(json!({"rect": rect})).is_err());
}
#[test]
fn in_window_windows_keep_their_ids_through_a_save() {
let rect = [1.0, 2.0, 300.0, 200.0];
let layout = Layout {
root: None,
floating: vec![Floating::single(vec![4u32], 0, rect).with_id(7), Floating::stack(vec![g(&[5], 0), g(&[6], 0)], rect).unwrap().with_id(8)],
};
let saved = serde_json::to_string(&layout).unwrap();
let loaded: Layout<u32> = serde_json::from_str(&saved).unwrap();
assert_eq!(loaded, layout);
assert_eq!(loaded.floating.iter().map(|w| w.id).collect::<Vec<_>>(), [7, 8]);
}
#[test]
fn v2_round_trips() {
let mut workspace = Workspace::new(docked());
workspace.apply(Action::CloseGroup { panel: 4 }, |_| Permissions::default()).unwrap();
workspace.apply(Action::SetNative { panel: 8, rect: Some([5.0, 5.0, 400.0, 300.0]) }, |_| Permissions::default()).unwrap();
workspace.saved = Some(docked());
workspace.locked = true;
let text = serde_json::to_string(&workspace).unwrap();
let parsed: Workspace<u32> = serde_json::from_str(&text).unwrap();
assert_eq!(parsed, workspace);
assert_eq!(serde_json::from_str::<Value>(&text).unwrap()["version"], json!(2));
let mut old = parsed.clone();
old.version = 1;
let mut value = serde_json::to_value(&old).unwrap();
value.as_object_mut().unwrap().remove("version");
assert_eq!(serde_json::from_value::<Workspace<u32>>(value).unwrap().version, 1);
old.version = 3;
assert_eq!(old.validate(), Err(DockError::UnsupportedVersion));
}
#[derive(Clone, Copy, Debug)]
enum Kind {
Layout,
Workspace,
Hidden,
}
/// App, file contents, and the JSON pointers to its docking values.
type Fixture = (&'static str, &'static str, &'static [(&'static str, Kind)]);
#[test]
fn v1_layout_json_parses_unchanged() {
use Kind::*;
let fixtures: [Fixture; 7] = [
(
"designcraft",
include_str!("../../tests/fixtures/v1/designcraft.json"),
&[
("/docking", Layout),
("/dockingHidden", Hidden),
("/customWorkspaces/0/docking", Layout),
("/customWorkspaces/0/dockingHidden", Hidden),
],
),
("vectorcraft", include_str!("../../tests/fixtures/v1/vectorcraft.json"), &[("/docking", Layout), ("/docking_hidden", Hidden)]),
("lightcraft", include_str!("../../tests/fixtures/v1/lightcraft.json"), &[("/docking", Workspace)]),
("pdfcraft", include_str!("../../tests/fixtures/v1/pdfcraft.json"), &[("/docking", Workspace)]),
("cadcraft", include_str!("../../tests/fixtures/v1/cadcraft.json"), &[("/workspace/docking", Workspace)]),
("soundcraft", include_str!("../../tests/fixtures/v1/soundcraft.json"), &[("/docking", Workspace), ("/mix_docking", Workspace)]),
(
"photocraft",
include_str!("../../tests/fixtures/v1/photocraft.json"),
&[("/docking", Layout), ("/docking_hidden", Hidden), ("/panel_layout/docking", Layout), ("/panel_layout/dockingHidden", Hidden)],
),
];
for (app, text, fields) in fixtures {
let file: Value = serde_json::from_str(text).unwrap();
for (pointer, kind) in fields {
let value = file.pointer(pointer).unwrap_or_else(|| panic!("{app}{pointer}")).clone();
let layout_value = match kind {
Layout => value.clone(),
Workspace => value["layout"].clone(),
Hidden => {
let hidden: std::collections::BTreeMap<String, Location<String>> = serde_json::from_value(value).unwrap();
assert!(!hidden.is_empty(), "{app}{pointer}");
continue;
}
};
if let Workspace = kind {
let workspace: super::Workspace<String> = serde_json::from_value(value).unwrap_or_else(|e| panic!("{app}{pointer}: {e}"));
workspace.validate().unwrap_or_else(|e| panic!("{app}{pointer}: {e}"));
assert_eq!(workspace.version, 1);
for (panel, location) in &workspace.hidden {
let mut layout = workspace.layout.clone();
layout.restore(panel.clone(), location).unwrap_or_else(|e| panic!("{app}{pointer} {panel}: {e}"));
}
}
let layout: super::Layout<String> = serde_json::from_value(layout_value.clone()).unwrap_or_else(|e| panic!("{app}{pointer}: {e}"));
layout.validate().unwrap_or_else(|e| panic!("{app}{pointer}: {e}"));
// Nothing new is in use, so the layout writes back exactly as read, plus the
// fresh id of each floating window.
let mut written = serde_json::to_value(&layout).unwrap();
for (window, value) in layout.floating.iter().zip(written["floating"].as_array_mut().unwrap()) {
assert_eq!(value.as_object_mut().unwrap().remove("id"), Some(json!(window.id)), "{app}{pointer}");
}
assert_eq!(written, layout_value, "{app}{pointer}");
}
}
}
#[test]
fn every_app_fixture_reconciles_with_its_canvas_shown() {
let s = |p: &str| p.to_owned();
let permissions = |p: &String| if p == "canvas" { Permissions::PROTECTED } else { Permissions::default() };
// The canvas between a start dock and the properties, which no fixture matches exactly.
let beside = super::Layout {
root: Some(Node::Split {
axis: SplitAxis::Horizontal,
size: SplitSize::FixedFirst(240.0),
first: Box::new(Node::Dock {
side: Side::Start,
columns: vec![Column::new(vec![Group::new(vec![s("layers"), s("pages")], 0)], 240.0)],
}),
second: Box::new(Node::Split {
axis: SplitAxis::Horizontal,
size: SplitSize::Ratio(0.75),
first: Box::new(Node::Tabs { panels: vec![s("canvas")], active: 0 }),
second: Box::new(Node::Tabs { panels: vec![s("properties"), s("stroke")], active: 0 }),
}),
}),
floating: Vec::new(),
};
// The canvas with no anchor to go back beside.
let alone = super::Layout { root: Some(Node::Tabs { panels: vec![s("canvas")], active: 0 }), floating: Vec::new() };
let fixtures = [
("designcraft", include_str!("../../tests/fixtures/v1/designcraft.json"), "/docking"),
("designcraft", include_str!("../../tests/fixtures/v1/designcraft.json"), "/customWorkspaces/0/docking"),
("vectorcraft", include_str!("../../tests/fixtures/v1/vectorcraft.json"), "/docking"),
("lightcraft", include_str!("../../tests/fixtures/v1/lightcraft.json"), "/docking/layout"),
("pdfcraft", include_str!("../../tests/fixtures/v1/pdfcraft.json"), "/docking/layout"),
("cadcraft", include_str!("../../tests/fixtures/v1/cadcraft.json"), "/workspace/docking/layout"),
("soundcraft", include_str!("../../tests/fixtures/v1/soundcraft.json"), "/docking/layout"),
("soundcraft", include_str!("../../tests/fixtures/v1/soundcraft.json"), "/mix_docking/layout"),
("photocraft", include_str!("../../tests/fixtures/v1/photocraft.json"), "/docking"),
("photocraft", include_str!("../../tests/fixtures/v1/photocraft.json"), "/panel_layout/docking"),
];
for (app, text, pointer) in fixtures {
let file: Value = serde_json::from_str(text).unwrap();
let mut saved: super::Layout<String> = serde_json::from_value(file.pointer(pointer).unwrap().clone()).unwrap();
let own = saved.contains(&s("canvas")).then(|| saved.clone());
saved.take(&s("canvas"));
for default in own.iter().chain([&beside, &alone]) {
let mut workspace = super::Workspace::new(saved.clone());
// A file written while the canvas could still be lost.
if let Ok(location) = default.location(&s("canvas")) {
workspace.hidden.push((s("canvas"), location));
}
for mut workspace in [super::Workspace::new(saved.clone()), workspace] {
workspace.reconcile(|_| true, permissions, &super::Workspace::new(default.clone()));
workspace.validate().unwrap_or_else(|e| panic!("{app}{pointer}: {e}"));
assert!(workspace.layout.contains(&s("canvas")), "{app}{pointer}: {:?}", workspace.layout);
assert!(workspace.hidden.iter().all(|(p, _)| p != "canvas"), "{app}{pointer}");
}
}
}
}
}
#[test]
fn edge_placement_splits_the_part_between_the_docks_or_the_root() {
// Dock layout: a floating window lands under the frames, beside the end dock.
let mut layout = docked();
layout.apply(Action::MoveWindow { panel: 6, to: Target::At { anchor: 1, placement: Placement::Edge(Zone::Bottom) } }).unwrap();
let Some(Node::Split { first, second, .. }) = &layout.root else { panic!("{layout:?}") };
assert!(matches!(&**second, Node::Dock { .. }));
let Node::Split { axis: SplitAxis::Vertical, size: SplitSize::Ratio(size), second: bottom, .. } = &**first else { panic!("{first:?}") };
assert_eq!(*size, 0.75);
assert_eq!(**bottom, tabs(&[6, 7, 8], 1));
assert!(layout.floating.is_empty());
// Frame layout: one panel takes the whole left edge.
let mut frames = Layout { root: Some(hsplit(SplitSize::Ratio(0.5), tabs(&[1], 0), tabs(&[2, 3], 0))), floating: Vec::new() };
frames.apply(Action::Move { panel: 3, anchor: 1, placement: Placement::Edge(Zone::Left) }).unwrap();
let Some(Node::Split { axis: SplitAxis::Horizontal, size: SplitSize::Ratio(size), first, .. }) = &frames.root else { panic!() };
assert_eq!((*size, &**first), (0.25, &tabs(&[3], 0)));
let before = frames.clone();
assert_eq!(frames.apply(Action::Move { panel: 2, anchor: 1, placement: Placement::Edge(Zone::Center) }), Err(DockError::InvalidPlacement));
assert_eq!(frames, before);
}
#[test]
fn a_sized_split_sets_the_new_split_and_the_enclosing_one_beside_the_anchor() {
// 1 | (2 | 3): 4 goes left of 3, and the split between 2 and 3 gives the room.
let layout = Layout {
root: Some(hsplit(SplitSize::Ratio(0.5), tabs(&[1], 0), hsplit(SplitSize::FixedSecond(60.0), tabs(&[2], 0), tabs(&[3], 0)))),
floating: vec![Floating::single(vec![4], 0, [0.0, 0.0, 100.0, 100.0])],
};
let sized = |zone| Placement::SplitSized { zone, size: SplitSize::FixedFirst(100.0), outer: SplitSize::FixedSecond(164.0) };
let mut moved = layout.clone();
moved.apply(Action::Move { panel: 4, anchor: 3, placement: sized(Zone::Left) }).unwrap();
let inner = hsplit(SplitSize::FixedSecond(164.0), tabs(&[2], 0), hsplit(SplitSize::FixedFirst(100.0), tabs(&[4], 0), tabs(&[3], 0)));
assert_eq!(moved.root, Some(hsplit(SplitSize::Ratio(0.5), tabs(&[1], 0), inner)));
// 1 has no divider on its left: the split on its right gives the room.
let mut moved = layout.clone();
moved.apply(Action::Move { panel: 4, anchor: 1, placement: sized(Zone::Left) }).unwrap();
let rest = hsplit(SplitSize::FixedSecond(60.0), tabs(&[2], 0), tabs(&[3], 0));
assert_eq!(moved.root, Some(hsplit(SplitSize::FixedSecond(164.0), hsplit(SplitSize::FixedFirst(100.0), tabs(&[4], 0), tabs(&[1], 0)), rest)));
// 1 has no divider above or below it, and a center is no side.
for (anchor, zone) in [(1, Zone::Top), (3, Zone::Center)] {
let mut moved = layout.clone();
assert_eq!(moved.apply(Action::Move { panel: 4, anchor, placement: sized(zone) }), Err(DockError::InvalidPlacement), "{anchor} {zone:?}");
assert_eq!(moved, layout);
}
}