#[allow(unused_imports)]
mod knot_test {
use crate::knot::TreeKnot;
use crate::node::Node;
#[test]
fn knot_default_test() {
let test_tree: TreeKnot<i32> = TreeKnot::default();
assert_eq!(test_tree, TreeKnot::Empty);
}
#[test]
fn knot_new_test() {
let test_tree: TreeKnot<i32> = TreeKnot::new();
assert_eq!(test_tree, TreeKnot::Empty)
}
#[test]
fn knot_get_key_test() {
let test_tree: TreeKnot<i32> = TreeKnot::NonEmpty(Box::new(Node {
key: 32,
left: TreeKnot::Empty,
right: TreeKnot::Empty,
}));
assert_eq!(32, *test_tree.get_key());
}
#[test]
fn knot_insert_test() {
let mut test_tree = TreeKnot::new();
test_tree.insert(&3);
assert_eq!(3, *test_tree.get_key());
}
#[test]
fn knot_insert_full_test() {
let mut test_knot = TreeKnot::new();
test_knot.insert(&3);
assert_eq!(test_knot, TreeKnot::NonEmpty(Box::new(
Node {
key: 3,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})));
assert_eq!(*test_knot.get_key(), 3);
test_knot.insert(&3);
assert_eq!(test_knot, TreeKnot::NonEmpty(Box::new(
Node {
key: 3,
left: TreeKnot::Empty,
right: TreeKnot::NonEmpty(Box::new(Node {
key: 3,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
})));
assert_eq!(*test_knot.ignore().right.get_key(), 3);
test_knot.insert(&2);
assert_eq!(test_knot, TreeKnot::NonEmpty(Box::new(
Node {
key: 3,
right: TreeKnot::NonEmpty(Box::new(Node {
key: 3,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
left: TreeKnot::NonEmpty(Box::new(Node {
key: 2,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
})));
assert_eq!(*test_knot.ignore().left.get_key(), 2);
}
#[test]
fn knot_find_test() {
let mut knot_test = TreeKnot::new();
assert_eq!(*knot_test.find(&3), TreeKnot::Empty);
knot_test.insert(&3);
knot_test.insert(&4);
assert_eq!(*knot_test.find(&3), TreeKnot::NonEmpty(Box::new(Node {
key: 3,
left: TreeKnot::Empty,
right: TreeKnot::NonEmpty(Box::new(Node {
key: 4,
left: TreeKnot::Empty,
right: TreeKnot::Empty,
})),
})));
assert_eq!(*knot_test.find(&4), TreeKnot::NonEmpty(Box::new(Node {
key: 4,
left: TreeKnot::Empty,
right: TreeKnot::Empty,
})));
assert_eq!(*knot_test.find(&2), TreeKnot::Empty);
}
#[test]
fn knot_min_max_test() {
let mut knot_test = TreeKnot::new();
knot_test.insert(&3);
knot_test.insert(&3);
knot_test.insert(&4);
knot_test.insert(&2);
knot_test.insert(&2);
assert_eq!(*knot_test.max(), TreeKnot::NonEmpty(Box::new(Node {
key: 4,
left: TreeKnot::Empty,
right: TreeKnot::Empty,
})));
assert_eq!(*knot_test.min(), TreeKnot::NonEmpty(Box::new(Node {
key: 2,
left: TreeKnot::Empty,
right: TreeKnot::NonEmpty(Box::new(Node {
key: 2,
left: TreeKnot::Empty,
right: TreeKnot::Empty,
})),
})));
}
#[test]
fn knot_walk_test() {
let mut knot_test = TreeKnot::new();
knot_test.insert(&5);
knot_test.insert(&6);
knot_test.insert(&4);
knot_test.insert(&7);
knot_test.insert(&3);
knot_test.insert(&8);
knot_test.insert(&2);
knot_test.insert(&9);
knot_test.insert(&1);
assert_eq!(knot_test.walk(), vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
}
}
#[allow(unused_imports)]
mod tree_test {
use crate::tree::BinaryTree;
use crate::knot::TreeKnot;
use crate::node::Node;
use crate::iter::TreeIter;
use std::collections::VecDeque;
#[test]
fn tree_default_test() {
let test_tree:BinaryTree<i32> = BinaryTree::default();
assert_eq!(
test_tree,
BinaryTree {
top: TreeKnot::Empty,
size: 0,
}
)
}
#[test]
fn tree_new_test() {
let test_tree:BinaryTree<i32> = BinaryTree::new();
assert_eq!(
test_tree,
BinaryTree {
top: TreeKnot::Empty,
size: 0,
}
);
}
#[test]
fn tree_insert_test() {
let mut test_tree = BinaryTree::new();
test_tree.insert(&3);
assert_eq!(test_tree, BinaryTree {
top: TreeKnot::NonEmpty(Box::new(Node {
key: 3,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
size: 1,
});
}
#[test]
fn tree_insert_full_test() {
let mut tree_test = BinaryTree::new();
tree_test.insert(&3);
tree_test.insert(&2);
tree_test.insert(&3);
assert_eq!(tree_test, BinaryTree {
top: TreeKnot::NonEmpty(Box::new(Node {
key: 3,
right: TreeKnot::NonEmpty(Box::new(Node {
key: 3,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
left: TreeKnot::NonEmpty(Box::new(Node {
key: 2,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
})),
size: 3,
});
}
#[test]
fn tree_len_test() {
let mut tree_test = BinaryTree::new();
tree_test.insert(&1);
tree_test.insert(&1);
tree_test.insert(&1);
assert_eq!(tree_test.len(), 3);
}
#[test]
fn tree_empty_test() {
let mut nonempty = BinaryTree::new();
let empty = BinaryTree::<i32>::new();
nonempty.insert(&1);
assert_eq!(nonempty.is_empty(), false);
assert_eq!(empty.is_empty(), true);
}
#[test]
fn tree_find_test() {
let mut tree_test = BinaryTree::new();
tree_test.insert(&3);
tree_test.insert(&2);
tree_test.insert(&4);
tree_test.insert(&5);
tree_test.insert(&6);
tree_test.insert(&7);
assert_eq!(tree_test.contains(&3), true);
assert_eq!(tree_test.contains(&2), true);
assert_eq!(tree_test.contains(&8), false);
assert_eq!(tree_test.contains(&4), true);
assert_eq!(tree_test.contains(&5), true);
assert_eq!(tree_test.contains(&9), false);
assert_eq!(tree_test.contains(&6), true);
assert_eq!(tree_test.contains(&1), false);
assert_eq!(tree_test.contains(&7), true);
}
#[test]
fn tree_first_last_test() {
let mut tree_test = BinaryTree::new();
tree_test.insert(&3);
tree_test.insert(&2);
tree_test.insert(&3);
tree_test.insert(&4);
tree_test.insert(&3);
tree_test.insert(&4);
tree_test.insert(&1);
assert_eq!(*tree_test.first(), 1);
assert_eq!(*tree_test.last(), 4);
}
#[test]
fn tree_walk_test() {
let mut tree_test = BinaryTree::new();
tree_test.insert(&5);
tree_test.insert(&6);
tree_test.insert(&4);
tree_test.insert(&7);
tree_test.insert(&3);
tree_test.insert(&8);
tree_test.insert(&2);
tree_test.insert(&9);
tree_test.insert(&1);
assert_eq!(tree_test.into_iter(), TreeIter { iter: VecDeque::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9])});
}
#[test]
fn tree_append_test() {
let mut first = BinaryTree::new();
let mut second = BinaryTree::new();
first.insert(&1);
second.insert(&2);
first.append(&second);
assert_eq!(first, BinaryTree{
top: TreeKnot::NonEmpty(Box::new(Node {
key: 1,
right: TreeKnot::NonEmpty(Box::new(Node {
key: 2,
right: TreeKnot::Empty,
left: TreeKnot::Empty,
})),
left: TreeKnot::Empty,
})),
size: 2,
});
}
}