Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b

app/src/pane_group/tree_tests.rs

@@ -0,0 +1,701 @@
+use super::*;
+
+#[test]
+fn test_split_pane_layout() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+    let mut root_pane = PaneData::new(panes[0]);
+
+    // Add a pane to the right.
+    root_pane.split(panes[0], panes[1], Direction::Right);
+    assert_eq!(root_pane.pane_ids(), vec![panes[0], panes[1]]);
+
+    // Insert a vertical (below) pane after the first pane.
+    root_pane.split(panes[0], panes[2], Direction::Down);
+    assert_eq!(root_pane.pane_ids(), vec![panes[0], panes[2], panes[1]]);
+
+    // Remove the last pane.
+    root_pane.remove(panes[1]);
+    assert_eq!(root_pane.pane_ids(), vec![panes[0], panes[2]]);
+
+    let panes = [PaneId::dummy_pane_id(); 3];
+    let mut root_pane = PaneData::new(panes[0]);
+
+    // Add a pane to the left.
+    root_pane.split(panes[0], panes[1], Direction::Left);
+    assert_eq!(root_pane.pane_ids(), vec![panes[1], panes[0]]);
+
+    // Add a pane above the first pane.
+    root_pane.split(panes[0], panes[2], Direction::Up);
+    assert_eq!(root_pane.pane_ids(), vec![panes[2], panes[0], panes[1]]);
+}
+
+#[test]
+fn test_left_pane_split() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+    let mut root_pane = PaneData::new(panes[0]);
+
+    root_pane.split(panes[0], panes[1], Direction::Left);
+    assert_eq!(root_pane.pane_ids(), vec![panes[1], panes[0]]);
+
+    root_pane.split(panes[0], panes[2], Direction::Left);
+    assert_eq!(root_pane.pane_ids(), vec![panes[1], panes[2], panes[0]]);
+
+    root_pane.split(panes[0], panes[3], Direction::Left);
+    assert_eq!(
+        root_pane.pane_ids(),
+        vec![panes[1], panes[2], panes[3], panes[0]]
+    );
+}
+
+#[test]
+fn test_root_split_leaf() {
+    let panes = [PaneId::dummy_pane_id(), PaneId::dummy_pane_id()];
+
+    let mut tree = PaneData::new(panes[0]);
+    tree.split_root(panes[1], Direction::Down);
+    assert_eq!(tree.pane_ids(), vec![panes[0], panes[1]]);
+    assert_eq!(
+        tree.root.as_branch().expect("Should be a branch").axis(),
+        SplitDirection::Vertical
+    );
+}
+
+#[test]
+fn test_root_split_same_axis() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    // Start with a horizontal split.
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    // Add a pane at the start of the split.
+    tree.split_root(panes[2], Direction::Left);
+
+    // Add a pane at the end of the split.
+    tree.split_root(panes[3], Direction::Right);
+
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Horizontal);
+    assert_eq!(
+        root.direct_children(),
+        vec![panes[2], panes[0], panes[1], panes[3]]
+    );
+}
+
+#[test]
+fn test_root_split_different_axis() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    // Start with a horizontal split:
+    // -------------
+    // |  0  |  1  |
+    // -------------
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    // Add a pane above, converting the root to a vertical split:
+    // -------------
+    // |     2     |
+    // -------------
+    // |  0  |  1  |
+    // -------------
+    tree.split_root(panes[2], Direction::Up);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Vertical);
+    assert_eq!(root.node(0).as_leaf(), Some(panes[2]));
+    assert_eq!(
+        root.node(1)
+            .as_branch()
+            .expect("Should be a branch")
+            .direct_children(),
+        vec![panes[0], panes[1]]
+    );
+
+    // Add a pane to the right, converting the root to a horizontal split.
+    // -------------------
+    // |     2     |     |
+    // ------------+  3  |
+    // |  0  |  1  |     |
+    // -------------------
+    tree.split_root(panes[3], Direction::Right);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(
+        root.node(0)
+            .as_branch()
+            .expect("Should be a branch")
+            .get_children(),
+        vec![panes[2], panes[0], panes[1]]
+    );
+    assert_eq!(root.node(1).as_leaf(), Some(panes[3]));
+}
+
+#[test]
+fn test_move_pane_basic() {
+    let panes = [PaneId::dummy_pane_id(), PaneId::dummy_pane_id()];
+
+    // Start with a horizontal split:
+    // -------------
+    // |  0  |  1  |
+    // -------------
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    // Move pane 0 to the right of pane 1, which should result in
+    // -------------
+    // |  1  |  0  |
+    // -------------
+    tree.move_pane(panes[0], panes[1], Direction::Right);
+
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Horizontal);
+    assert_eq!(root.direct_children(), vec![panes[1], panes[0]]);
+
+    // Move pane 0 on top of pane 1, which should result in
+    // --------------
+    // |     0      |
+    // -------------
+    // |     1      |
+    // -------------
+    tree.move_pane(panes[0], panes[1], Direction::Up);
+
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Vertical);
+    assert_eq!(root.direct_children(), vec![panes[0], panes[1]]);
+}
+
+#[test]
+fn test_move_pane_multiple_splits() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    // Start with a horizontal split:
+    // -------------
+    // |  0  |  1  |
+    // -------------
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    // Add a pane above, converting the root to a vertical split:
+    // -------------
+    // |     2     |
+    // -------------
+    // |  0  |  1  |
+    // -------------
+    tree.split_root(panes[2], Direction::Up);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Vertical);
+    assert_eq!(root.node(0).as_leaf(), Some(panes[2]));
+    assert_eq!(
+        root.node(1)
+            .as_branch()
+            .expect("Should be a branch")
+            .direct_children(),
+        vec![panes[0], panes[1]]
+    );
+
+    // Add a pane to the right, converting the root to a horizontal split.
+    // -------------------
+    // |     2     |     |
+    // ------------+  3  |
+    // |  0  |  1  |     |
+    // -------------------
+    tree.split_root(panes[3], Direction::Right);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(
+        root.node(0)
+            .as_branch()
+            .expect("Should be a branch")
+            .get_children(),
+        vec![panes[2], panes[0], panes[1]]
+    );
+    assert_eq!(root.node(1).as_leaf(), Some(panes[3]));
+
+    // Move Pane 2 to the left of pane 3, which would result in
+    // -------------------------
+    // |     |     |     |      |
+    // | 0   |  1  |  2  |   3  |
+    // |     |     |     |      |
+    // -------------------------
+    tree.move_pane(panes[2], panes[3], Direction::Left);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Horizontal);
+    assert_eq!(
+        root.node(0).as_branch().expect("should be branch").axis(),
+        SplitDirection::Horizontal
+    );
+    assert_eq!(
+        root.node(0)
+            .as_branch()
+            .expect("Should be a branch")
+            .get_children(),
+        vec![panes[0], panes[1]]
+    );
+    assert_eq!(root.node(1).as_leaf(), Some(panes[2]));
+    assert_eq!(root.node(2).as_leaf(), Some(panes[3]));
+}
+
+#[test]
+fn test_move_pane_no_short_circuit() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    // Setup
+    // -------------
+    // |     0     |
+    // -------------
+    // |  1  |  2  |
+    // -------------
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Down);
+    tree.split(panes[1], panes[2], Direction::Right);
+
+    // Move Pane 1 to the bottom of pane 0.  This should result in a single vertical split
+    // with 3 panes, but currently is short circuiting because 1 is already below 0.
+
+    tree.move_pane(panes[1], panes[0], Direction::Down);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Vertical);
+    assert_eq!(root.direct_children(), panes.to_vec());
+}
+
+#[test]
+fn test_move_pane_no_short_circuit_2() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    // Setup
+    // -------------
+    // |     0     |
+    // -------------
+    // |     1     |
+    // -------------
+    // |     2     |
+    // -------------
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Down);
+    tree.split(panes[1], panes[2], Direction::Down);
+
+    // Move Pane 1 to the left of pane 2.  This should result in a horizontal split
+    // with 2 panes, below pane 0.
+
+    tree.move_pane(panes[1], panes[2], Direction::Left);
+    let root = tree.root.as_branch().expect("Should be a branch");
+    assert_eq!(root.axis(), SplitDirection::Vertical);
+    assert_eq!(root.node(0).as_leaf().expect("Should be a leaf"), panes[0]);
+    assert_eq!(
+        root.node(1)
+            .as_branch()
+            .expect("Should be a branch")
+            .direct_children(),
+        vec![panes[1], panes[2]]
+    );
+}
+
+#[test]
+fn test_sibling_by_direction() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    // Setup
+    // -----------------------
+    // |         0           |
+    // -----------------------
+    // |     |     |   3     |
+    // |  1  |  2  |---------|
+    // |     |     |   4     |
+    // -----------------------
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Down);
+    tree.split(panes[1], panes[2], Direction::Right);
+    tree.split(panes[2], panes[3], Direction::Right);
+    tree.split(panes[3], panes[4], Direction::Down);
+
+    assert_eq!(
+        tree.sibling_by_direction(panes[1], Direction::Right),
+        Some(panes[2])
+    );
+    assert_eq!(
+        tree.sibling_by_direction(panes[2], Direction::Left),
+        Some(panes[1])
+    );
+    assert_eq!(tree.sibling_by_direction(panes[0], Direction::Right), None);
+    assert_eq!(tree.sibling_by_direction(panes[0], Direction::Left), None);
+    assert_eq!(tree.sibling_by_direction(panes[2], Direction::Right), None);
+    assert_eq!(tree.sibling_by_direction(panes[1], Direction::Left), None);
+    assert_eq!(tree.sibling_by_direction(panes[1], Direction::Up), None);
+    assert_eq!(tree.sibling_by_direction(panes[1], Direction::Down), None);
+    assert_eq!(tree.sibling_by_direction(panes[0], Direction::Up), None);
+    assert_eq!(tree.sibling_by_direction(panes[0], Direction::Down), None);
+
+    assert_eq!(tree.sibling_by_direction(panes[3], Direction::Up), None);
+    assert_eq!(
+        tree.sibling_by_direction(panes[3], Direction::Down),
+        Some(panes[4])
+    );
+    assert_eq!(
+        tree.sibling_by_direction(panes[4], Direction::Up),
+        Some(panes[3])
+    );
+    assert_eq!(tree.sibling_by_direction(panes[4], Direction::Down), None);
+}
+
+#[test]
+fn test_pane_by_direction_simple() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Right),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[1]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Left),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Right),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Left),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[0]]))
+    );
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Up),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Down),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Up),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Down),
+        FindPaneByDirectionResult::Located
+    );
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Right),
+        FindPaneByDirectionResult::NotFound
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Left),
+        FindPaneByDirectionResult::NotFound
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Up),
+        FindPaneByDirectionResult::NotFound
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Down),
+        FindPaneByDirectionResult::NotFound
+    );
+}
+
+#[test]
+fn test_pane_by_direction_multi_split() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+    tree.split(panes[0], panes[2], Direction::Down);
+    tree.split(panes[1], panes[3], Direction::Down);
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Right),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[1], panes[3]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Left),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Up),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Down),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[2]]))
+    );
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Right),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Left),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[0], panes[2]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Up),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Down),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[3]]))
+    );
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Right),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[1], panes[3]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Left),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Up),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[0]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[2], Direction::Down),
+        FindPaneByDirectionResult::Located
+    );
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[3], Direction::Right),
+        FindPaneByDirectionResult::Located
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[3], Direction::Left),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[0], panes[2]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[3], Direction::Up),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[1]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[3], Direction::Down),
+        FindPaneByDirectionResult::Located
+    );
+}
+
+#[test]
+fn test_pane_by_direction_multi_level_split() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[3], Direction::Right);
+    tree.split(panes[0], panes[2], Direction::Down);
+    tree.split(panes[0], panes[1], Direction::Right);
+    tree.split(panes[3], panes[6], Direction::Down);
+    tree.split(panes[3], panes[5], Direction::Right);
+    tree.split(panes[3], panes[4], Direction::Down);
+
+    assert_eq!(
+        tree.root.panes_by_direction(panes[0], Direction::Right),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[1]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[1], Direction::Right),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[3], panes[4], panes[6]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[5], Direction::Left),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[3], panes[4]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[6], Direction::Up),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[4], panes[5]]))
+    );
+    assert_eq!(
+        tree.root.panes_by_direction(panes[4], Direction::Down),
+        FindPaneByDirectionResult::Found(HashSet::from([panes[6]]))
+    );
+}
+
+#[test]
+fn test_are_rects_overlapping_on_axis() {
+    let rect1 = RectF::from_points(Vector2F::new(0.0, 0.0), Vector2F::new(10.0, 10.0));
+    let rect2 = RectF::from_points(Vector2F::new(10.0, -5.0), Vector2F::new(20.0, 5.0));
+    let rect3 = RectF::from_points(Vector2F::new(10.0, 10.0), Vector2F::new(20.0, 20.0));
+    let rect4 = RectF::from_points(Vector2F::new(-5.0, 10.0), Vector2F::new(5.0, 20.0));
+    let rect5 = RectF::from_points(Vector2F::new(30.0, 30.0), Vector2F::new(40.0, 40.0));
+    let rect6 = RectF::from_points(Vector2F::new(-20.0, -20.0), Vector2F::new(-10.0, -10.0));
+
+    assert!(PaneData::are_rects_overlapping(
+        &rect1,
+        &rect2,
+        SplitDirection::Horizontal
+    ));
+    assert!(!PaneData::are_rects_overlapping(
+        &rect1,
+        &rect5,
+        SplitDirection::Horizontal
+    ));
+    assert!(!PaneData::are_rects_overlapping(
+        &rect1,
+        &rect3,
+        SplitDirection::Horizontal
+    ));
+    assert!(!PaneData::are_rects_overlapping(
+        &rect1,
+        &rect6,
+        SplitDirection::Horizontal
+    ));
+
+    assert!(PaneData::are_rects_overlapping(
+        &rect1,
+        &rect4,
+        SplitDirection::Vertical
+    ));
+    assert!(!PaneData::are_rects_overlapping(
+        &rect1,
+        &rect5,
+        SplitDirection::Vertical
+    ),);
+    assert!(!PaneData::are_rects_overlapping(
+        &rect1,
+        &rect3,
+        SplitDirection::Vertical
+    ));
+}
+
+#[test]
+fn test_hide_and_show_child_agent_pane() {
+    let panes = [PaneId::dummy_pane_id(), PaneId::dummy_pane_id()];
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    // Both panes visible initially.
+    assert_eq!(tree.visible_pane_ids(), vec![panes[0], panes[1]]);
+    assert!(!tree.is_pane_hidden(&panes[1]));
+
+    // Hide the child agent pane.
+    tree.hide_pane_for_child_agent(panes[1]);
+    assert!(tree.is_pane_hidden(&panes[1]));
+    assert_eq!(tree.visible_pane_ids(), vec![panes[0]]);
+    // pane_ids still includes hidden panes (they remain in the tree).
+    assert_eq!(tree.pane_ids(), vec![panes[0], panes[1]]);
+
+    // Show the child agent pane.
+    tree.show_pane_for_child_agent(panes[1]);
+    assert!(!tree.is_pane_hidden(&panes[1]));
+    assert_eq!(tree.visible_pane_ids(), vec![panes[0], panes[1]]);
+}
+
+#[test]
+fn test_hide_child_agent_pane_is_idempotent() {
+    let panes = [PaneId::dummy_pane_id(), PaneId::dummy_pane_id()];
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+
+    // Hiding the same pane twice should not create duplicate entries.
+    tree.hide_pane_for_child_agent(panes[1]);
+    tree.hide_pane_for_child_agent(panes[1]);
+    assert_eq!(tree.num_hidden_panes(), 1);
+
+    // A single show call should fully unhide it.
+    tree.show_pane_for_child_agent(panes[1]);
+    assert!(!tree.is_pane_hidden(&panes[1]));
+    assert_eq!(tree.num_hidden_panes(), 0);
+}
+
+#[test]
+fn test_original_pane_for_replacement() {
+    let original = PaneId::dummy_pane_id();
+    let replacement = PaneId::dummy_pane_id();
+    let unrelated = PaneId::dummy_pane_id();
+    let mut tree = PaneData::new(original);
+    tree.split(original, unrelated, Direction::Right);
+
+    // No replacement yet.
+    assert_eq!(tree.original_pane_for_replacement(original), None);
+    assert_eq!(tree.original_pane_for_replacement(replacement), None);
+
+    // Perform a temporary replacement.
+    assert!(tree.replace_pane(original, replacement, true));
+    assert_eq!(
+        tree.original_pane_for_replacement(replacement),
+        Some(original)
+    );
+    // The original itself is not a replacement.
+    assert_eq!(tree.original_pane_for_replacement(original), None);
+    // Unrelated pane is unaffected.
+    assert_eq!(tree.original_pane_for_replacement(unrelated), None);
+
+    // Revert — lookup should return None again.
+    assert_eq!(
+        tree.revert_temporary_replacement(replacement),
+        Some(original)
+    );
+    assert_eq!(tree.original_pane_for_replacement(replacement), None);
+}
+
+#[test]
+fn test_hide_multiple_child_agent_panes() {
+    let panes = [
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+        PaneId::dummy_pane_id(),
+    ];
+    let mut tree = PaneData::new(panes[0]);
+    tree.split(panes[0], panes[1], Direction::Right);
+    tree.split(panes[1], panes[2], Direction::Right);
+
+    tree.hide_pane_for_child_agent(panes[1]);
+    tree.hide_pane_for_child_agent(panes[2]);
+    assert_eq!(tree.visible_pane_ids(), vec![panes[0]]);
+
+    // Reveal only one child.
+    tree.show_pane_for_child_agent(panes[1]);
+    assert_eq!(tree.visible_pane_ids(), vec![panes[0], panes[1]]);
+    assert!(tree.is_pane_hidden(&panes[2]));
+}