use super::make_layout_tree;
use super::*;
#[test]
fn tree_style_tabs_single_pane() {
let tree = make_layout_tree(LayoutMode::TreeStyleTabs);
let rect = Rect::new(0.0, 0.0, 800.0, 600.0);
let result = tree.compute_layout(rect);
assert_eq!(result.pane_rects.len(), 1);
let pane = result.pane_rects.get(&1).expect("active member rect");
assert_eq!(pane.w, 800.0);
assert_eq!(pane.h, 600.0);
assert!(!result.tree_rows.is_empty());
}
#[test]
fn flat_tabs_single_pane() {
let tree = make_layout_tree(LayoutMode::FlatTabs);
let rect = Rect::new(0.0, 0.0, 800.0, 600.0);
let result = tree.compute_layout(rect);
assert_eq!(result.pane_rects.len(), 1);
assert!(result.pane_rects.contains_key(&1));
assert_eq!(result.tab_order.len(), 3);
}
#[test]
fn flat_tabs_no_active_empty_rects() {
let mut tree = GraphTree::new(LayoutMode::FlatTabs, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 1u64,
provenance: Provenance::Anchor,
});
let result = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
assert!(result.pane_rects.is_empty());
}
#[test]
fn split_panes_divides_space() {
let tree = make_layout_tree(LayoutMode::SplitPanes);
let rect = Rect::new(0.0, 0.0, 900.0, 600.0);
let result = tree.compute_layout(rect);
assert_eq!(result.pane_rects.len(), 3);
for (_, r) in &result.pane_rects {
assert!(r.x >= 0.0);
assert!(r.y >= 0.0);
assert!(r.x + r.w <= 900.1); assert!(r.y + r.h <= 600.1);
assert!(r.w > 0.0);
assert!(r.h > 0.0);
}
let total_height: f32 = result.pane_rects.values().map(|r| r.h).sum();
assert!(
(total_height - 600.0).abs() < 1.0,
"expected total height ~600, got {}",
total_height
);
for (_, r) in &result.pane_rects {
assert!(
(r.w - 900.0).abs() < 1.0,
"expected full width ~900, got {}",
r.w
);
}
}
#[test]
fn split_panes_non_overlapping() {
let tree = make_layout_tree(LayoutMode::SplitPanes);
let result = tree.compute_layout(Rect::new(0.0, 0.0, 900.0, 600.0));
let rects: Vec<&Rect> = result.pane_rects.values().collect();
for i in 0..rects.len() {
for j in (i + 1)..rects.len() {
let a = rects[i];
let b = rects[j];
let no_overlap = a.x + a.w <= b.x + 0.1
|| b.x + b.w <= a.x + 0.1
|| a.y + a.h <= b.y + 0.1
|| b.y + b.h <= a.y + 0.1;
assert!(no_overlap, "panes overlap: {:?} and {:?}", a, b);
}
}
}
#[test]
fn split_panes_respects_min_width() {
let mut tree = GraphTree::new(LayoutMode::SplitPanes, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 1u64,
provenance: Provenance::Anchor,
});
tree.apply(NavAction::Attach {
member: 2,
provenance: Provenance::Traversal {
source: 1,
edge_kind: None,
},
});
tree.apply(NavAction::SetLifecycle(1, Lifecycle::Active));
tree.apply(NavAction::SetLifecycle(2, Lifecycle::Active));
tree.get_mut(&1).unwrap().layout_override = Some(crate::forme::member::LayoutOverride {
min_width: Some(400.0),
min_height: None,
flex_grow: Some(1.0),
flex_shrink: Some(0.0), preferred_split: None,
split_ratio: None,
});
let result = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
let r1 = result.pane_rects.get(&1).expect("member 1 rect");
assert!(r1.w >= 399.0, "min_width not respected: {}", r1.w);
}
#[test]
fn split_panes_vertical_direction() {
let mut tree = GraphTree::new(LayoutMode::SplitPanes, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 1u64,
provenance: Provenance::Anchor,
});
tree.apply(NavAction::Attach {
member: 2,
provenance: Provenance::Traversal {
source: 1,
edge_kind: None,
},
});
tree.apply(NavAction::SetLifecycle(1, Lifecycle::Active));
tree.apply(NavAction::SetLifecycle(2, Lifecycle::Active));
tree.get_mut(&1).unwrap().layout_override = Some(crate::forme::member::LayoutOverride {
min_width: None,
min_height: None,
flex_grow: None,
flex_shrink: None,
preferred_split: Some(crate::forme::member::SplitDirection::Vertical),
split_ratio: None,
});
let result = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
let r1 = result.pane_rects.get(&1).expect("member 1 rect");
let r2 = result.pane_rects.get(&2).expect("member 2 rect");
assert!(
(r1.w - 800.0).abs() < 1.0,
"expected full width, got {}",
r1.w
);
assert!(
(r2.w - 800.0).abs() < 1.0,
"expected full width, got {}",
r2.w
);
assert!((r1.h + r2.h - 600.0).abs() < 1.0);
}
#[test]
fn layout_tab_order_stable() {
let tree = make_layout_tree(LayoutMode::FlatTabs);
let result1 = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
let result2 = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
let ids1: Vec<u64> = result1.tab_order.iter().map(|t| t.member).collect();
let ids2: Vec<u64> = result2.tab_order.iter().map(|t| t.member).collect();
assert_eq!(ids1, ids2, "tab order should be stable across calls");
}
#[test]
fn tree_rows_respect_expansion() {
let mut tree = make_layout_tree(LayoutMode::TreeStyleTabs);
let result = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
assert_eq!(result.tree_rows.len(), 3);
tree.apply(NavAction::ToggleExpand(1));
let result = tree.compute_layout(Rect::new(0.0, 0.0, 800.0, 600.0));
assert_eq!(result.tree_rows.len(), 1); }
#[test]
fn traversal_attach_with_missing_source_falls_back_to_root() {
let mut tree = GraphTree::new(LayoutMode::TreeStyleTabs, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 2u64,
provenance: Provenance::Traversal {
source: 99,
edge_kind: None,
},
});
assert!(tree.contains(&2));
assert!(tree.topology().roots().contains(&2));
assert!(tree.topology().parent_of(&2).is_none());
tree.topology().assert_invariants();
}
#[test]
fn manual_attach_with_missing_source_falls_back_to_root() {
let mut tree = GraphTree::new(LayoutMode::TreeStyleTabs, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 1u64,
provenance: Provenance::Manual {
source: Some(99), context: None,
},
});
assert!(tree.contains(&1));
assert!(tree.topology().roots().contains(&1));
tree.topology().assert_invariants();
}
#[test]
fn derived_attach_with_missing_connection_falls_back_to_root() {
let mut tree = GraphTree::new(LayoutMode::TreeStyleTabs, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 5u64,
provenance: Provenance::Derived {
connection: Some(42), derivation: "test".to_string(),
},
});
assert!(tree.contains(&5));
assert!(tree.topology().roots().contains(&5));
tree.topology().assert_invariants();
}
#[test]
fn all_members_reachable_after_mixed_attaches() {
let mut tree = GraphTree::new(LayoutMode::TreeStyleTabs, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 1u64,
provenance: Provenance::Anchor,
});
tree.apply(NavAction::Attach {
member: 2,
provenance: Provenance::Traversal {
source: 1,
edge_kind: None,
},
});
tree.apply(NavAction::Attach {
member: 3,
provenance: Provenance::Traversal {
source: 99,
edge_kind: None,
},
});
tree.apply(NavAction::ToggleExpand(1));
tree.apply(NavAction::ToggleExpand(2));
tree.apply(NavAction::ToggleExpand(3));
let rows = tree.visible_rows();
let row_ids: Vec<u64> = rows.iter().map(|r| r.member).collect();
assert!(row_ids.contains(&1));
assert!(row_ids.contains(&2));
assert!(row_ids.contains(&3));
tree.topology().assert_invariants();
}