extern crate vec_tree;
use vec_tree::VecTree;
#[test]
fn try_insert_root() {
let mut tree = VecTree::with_capacity(1);
let root = tree.try_insert_root(42).unwrap();
assert_eq!(tree[root], 42);
}
#[test]
fn insert_root() {
let mut tree = VecTree::with_capacity(1);
let root = tree.insert_root(42);
assert_eq!(tree[root], 42);
}
#[test]
fn try_insert() {
let mut tree = VecTree::with_capacity(3);
let root = tree.try_insert_root(0).unwrap();
let child_1 = tree.try_insert(1, root).unwrap();
let child_2 = tree.try_insert(2, root).unwrap();
assert_eq!(tree[root], 0);
assert_eq!(tree[child_1], 1);
assert_eq!(tree[child_2], 2);
}
#[test]
#[should_panic]
fn try_insert_root_twice() {
let mut tree = VecTree::with_capacity(2);
let _root = tree.try_insert_root(42).unwrap();
let _root2 = tree.try_insert_root(43).unwrap();
}
#[test]
#[should_panic]
fn insert_root_twice() {
let mut tree = VecTree::with_capacity(2);
let _root = tree.insert_root(42);
let _root2 = tree.insert_root(43);
}
#[test]
fn remove_a_root_node() {
let mut tree = VecTree::with_capacity(1);
let root_node1 = tree.try_insert_root(42).unwrap();
tree.remove(root_node1);
let root_node2 = tree.try_insert_root(43).unwrap();
assert_eq!(tree[root_node2], 43);
}
#[test]
fn cannot_get_free_value() {
let mut tree = VecTree::with_capacity(1);
let i = tree.try_insert_root(42).unwrap();
assert_eq!(tree.remove(i).unwrap(), 42);
assert!(!tree.contains(i));
}
#[test]
fn cannot_get_other_generation_value() {
let mut tree = VecTree::with_capacity(2);
let root_node = tree.try_insert_root(42).unwrap();
let i = tree.try_insert(42, root_node).unwrap();
assert_eq!(tree.remove(i).unwrap(), 42);
assert!(!tree.contains(i));
let j = tree.try_insert(42, root_node).unwrap();
assert!(!tree.contains(i));
assert_eq!(tree[j], 42);
assert!(i != j);
}
#[test]
fn try_insert_when_full() {
let mut tree = VecTree::with_capacity(2);
let root_node = tree.try_insert_root(42).unwrap();
let _child = tree.try_insert(42, root_node).unwrap();
assert_eq!(tree.try_insert(42, root_node).unwrap_err(), 42);
}
#[test]
fn insert_many_and_cause_doubling() {
let mut tree = VecTree::new();
let root = tree.try_insert_root(0).unwrap();
let indices: Vec<_> = (0..1000).map(|i| tree.insert(i * i, root)).collect();
for (i, idx) in indices.iter().cloned().enumerate() {
assert_eq!(tree.remove(idx).unwrap(), i * i);
assert!(!tree.contains(idx));
}
}
#[test]
fn capacity_and_reserve() {
let mut tree: VecTree<usize> = VecTree::with_capacity(42);
assert_eq!(tree.capacity(), 42);
tree.reserve(10);
assert_eq!(tree.capacity(), 52);
}
#[test]
fn get_mut() {
let mut tree = VecTree::new();
let idx = tree.insert_root(5);
tree[idx] += 1;
assert_eq!(tree[idx], 6);
}
#[test]
#[should_panic]
fn index_deleted_item() {
let mut tree = VecTree::new();
let idx = tree.insert_root(42);
tree.remove(idx);
tree[idx];
}
#[test]
fn check_the_validity_of_the_tree_after_remove() {
let mut tree: VecTree<usize> = VecTree::with_capacity(4);
let root = tree.try_insert_root(0).unwrap();
let child1 = tree.try_insert(1, root).unwrap();
let child2 = tree.try_insert(2, root).unwrap();
let child3 = tree.try_insert(3, root).unwrap();
tree.remove(child3);
tree.try_insert(4, root).unwrap();
assert_eq!(
tree.children(root)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[1, 2, 4]
);
tree.remove(child2);
tree.try_insert(5, root).unwrap();
assert_eq!(
tree.children(root)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[1, 4, 5]
);
tree.remove(child1);
tree.try_insert(6, root).unwrap();
assert_eq!(
tree.children(root)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[4, 5, 6]
);
}
#[test]
fn check_remove_with_one_child() {
let mut tree: VecTree<usize> = VecTree::with_capacity(2);
let root = tree.try_insert_root(0).unwrap();
let child1 = tree.try_insert(1, root).unwrap();
tree.remove(child1);
assert_eq!(
tree.children(root)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[]
);
let child2 = tree.try_insert(2, root).unwrap();
assert_eq!(
tree.children(root)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[2]
);
tree.remove(child2);
assert_eq!(
tree.children(root)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[]
);
}
#[test]
fn out_of_bounds_get_with_index_from_other_tree() {
let mut tree1 = VecTree::with_capacity(1);
let mut tree2 = VecTree::with_capacity(1);
let root_tree1 = tree1.insert_root(1);
let _root_tree2 = tree2.insert_root(2);
let child_tree1 = tree1.insert(2, root_tree1);
assert!(tree2.get(child_tree1).is_none());
}
#[test]
fn out_of_bounds_remove_with_index_from_other_tree() {
let mut tree1 = VecTree::with_capacity(1);
let mut tree2 = VecTree::with_capacity(1);
let root_tree1 = tree1.insert_root(1);
let _root_tree2 = tree2.insert_root(2);
let child_tree1 = tree1.insert(2, root_tree1);
assert!(tree2.remove(child_tree1).is_none());
}
#[test]
fn get_parent() {
let mut tree = VecTree::new();
let grand_child = {
let root_node = tree.insert_root(1);
let child = tree.insert(2, root_node);
tree.insert(3, child)
};
let child = tree.parent(grand_child).unwrap();
assert_eq!(tree[child], 2);
let root_node = tree.parent(child).unwrap();
assert_eq!(tree[root_node], 1);
assert_eq!(tree.parent(root_node), None);
}
#[test]
fn add_children_and_iterate_over_it() {
let mut tree = VecTree::new();
let root_node = tree.insert_root(1);
let child_node_1 = tree.insert(2, root_node);
let child_node_2 = tree.insert(3, root_node);
let child_node_3 = tree.insert(4, root_node);
let _grandchild = tree.insert(5, child_node_3);
assert_eq!(
tree.children(root_node)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[2, 3, 4]
);
assert_eq!(
tree.children(child_node_1)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[]
);
assert_eq!(
tree.children(child_node_2)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[]
);
assert_eq!(
tree.children(child_node_3)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[5]
);
}
#[test]
fn iterate_over_preceding_siblings() {
let mut tree = VecTree::new();
let root_node = tree.insert_root(1);
let child_node_1 = tree.insert(2, root_node);
let child_node_2 = tree.insert(3, root_node);
let child_node_3 = tree.insert(4, root_node);
assert_eq!(
tree.preceding_siblings(root_node)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[1]
);
assert_eq!(
tree.preceding_siblings(child_node_1)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[2]
);
assert_eq!(
tree.preceding_siblings(child_node_2)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[3, 2]
);
assert_eq!(
tree.preceding_siblings(child_node_3)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[4, 3, 2]
);
}
#[test]
fn iterate_over_following_siblings() {
let mut tree = VecTree::new();
let root_node = tree.insert_root(1);
let child_node_1 = tree.insert(2, root_node);
let child_node_2 = tree.insert(3, root_node);
let child_node_3 = tree.insert(4, root_node);
assert_eq!(
tree.following_siblings(root_node)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[1]
);
assert_eq!(
tree.following_siblings(child_node_1)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[2, 3, 4]
);
assert_eq!(
tree.following_siblings(child_node_2)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[3, 4]
);
assert_eq!(
tree.following_siblings(child_node_3)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[4]
);
}
#[test]
fn iterate_over_ancestors() {
let mut tree = VecTree::new();
let root_node = tree.insert_root(1);
let child_node_1 = tree.insert(2, root_node);
let child_node_2 = tree.insert(3, root_node);
let grandchild = tree.insert(5, child_node_2);
assert_eq!(
tree.ancestors(root_node)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[1]
);
assert_eq!(
tree.ancestors(child_node_1)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[2, 1]
);
assert_eq!(
tree.ancestors(child_node_2)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[3, 1]
);
assert_eq!(
tree.ancestors(grandchild)
.map(|node_id| tree[node_id])
.collect::<Vec<_>>(),
[5, 3, 1]
);
}
#[test]
fn iterate_over_descendants() {
let mut tree = VecTree::new();
let root_node = tree.insert_root(0);
let node_1 = tree.insert(1, root_node);
let node_2 = tree.insert(2, root_node);
let _node_3 = tree.insert(3, root_node);
let node_4 = tree.insert(4, node_1);
let _node_5 = tree.insert(5, node_1);
let _node_6 = tree.insert(6, node_4);
let _node_7 = tree.insert(7, node_2);
let descendants = tree
.descendants(root_node)
.map(|node| tree[node])
.collect::<Vec<i32>>();
let expected_result = [0, 1, 4, 6, 5, 2, 7, 3];
assert_eq!(descendants, expected_result);
}
#[test]
fn iterate_over_descendants_with_depth() {
let mut tree = VecTree::new();
let root_node = tree.insert_root(0);
let node_1 = tree.insert(1, root_node);
let node_2 = tree.insert(2, root_node);
let _node_3 = tree.insert(3, root_node);
let node_4 = tree.insert(4, node_1);
let _node_5 = tree.insert(5, node_1);
let _node_6 = tree.insert(6, node_4);
let _node_7 = tree.insert(7, node_2);
let descendants = tree
.descendants_with_depth(root_node)
.map(|(node, depth)| (tree[node], depth))
.collect::<Vec<(i32, u32)>>();
let expected_result = [
(0, 0),
(1, 1),
(4, 2),
(6, 3),
(5, 2),
(2, 1),
(7, 2),
(3, 1),
];
assert_eq!(descendants, expected_result);
}
#[test]
fn check_descendants_are_removed() {
let mut tree = VecTree::with_capacity(5);
let root_node = tree.try_insert_root(0).unwrap();
let node_1 = tree.try_insert(1, root_node).unwrap();
let _node_2 = tree.try_insert(2, node_1).unwrap();
let node_3 = tree.try_insert(3, node_1).unwrap();
let _node_4 = tree.try_insert(4, node_3).unwrap();
let descendants = tree
.descendants(root_node)
.map(|node| tree[node])
.collect::<Vec<i32>>();
assert_eq!(descendants, [0, 1, 2, 3, 4]);
tree.remove(node_1);
let node_5 = tree.try_insert(5, root_node).unwrap();
let _node_6 = tree.try_insert(6, node_5).unwrap();
let node_7 = tree.try_insert(7, node_5).unwrap();
let _node_8 = tree.try_insert(8, node_7).unwrap();
let descendants = tree
.descendants(root_node)
.map(|node| tree[node])
.collect::<Vec<i32>>();
assert_eq!(descendants, [0, 5, 6, 7, 8]);
}
#[test]
fn move_a_node() {
let mut tree = VecTree::with_capacity(3);
let root_node = tree.try_insert_root(0).unwrap();
let node_1 = tree.try_insert(1, root_node).unwrap();
let _node_2 = tree.try_insert(2, root_node).unwrap();
let descendants = tree
.descendants(root_node)
.map(|node| tree[node])
.collect::<Vec<i32>>();
assert_eq!(descendants, [0, 1, 2]);
tree.append_child(root_node, node_1);
let descendants = tree
.descendants(root_node)
.map(|node| tree[node])
.collect::<Vec<i32>>();
assert_eq!(descendants, [0, 2, 1]);
}