}
static void test_setup(void) { }
+
//-----------------------------------------------------------------------------
// Begin Unit Tests
//-----------------------------------------------------------------------------
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_checks_root_is_always_black_property){
void* box88 = mem_box(88);
rbt_t* tree = rbt_new(test_compare);
CHECK(BAD_ROOT_COLOR == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_nodes_not_sorted_two_nodes){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
CHECK(OUT_OF_ORDER == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_nodes_not_sorted_four_nodes){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
CHECK(OUT_OF_ORDER == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_black_nodes_are_unbalanced_two_nodes){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_black_nodes_are_unbalanced_three_nodes){
void* box42 = mem_box(42);
void* box22 = mem_box(22);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_black_nodes_are_unbalanced_four_nodes){
void* box42 = mem_box(42);
void* box22 = mem_box(22);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_node_is_unvalid_color){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_root_parent_pointer_is_not_null){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_node_parent_poitners_are_wrong_two_nodes){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
mem_release(tree);
mem_release(node3);
}
+
TEST(Verify_tree_is_valid_fails_when_node_parent_poitners_are_wrong_four_nodes){
void* box42 = mem_box(42);
void* box22 = mem_box(22);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_tree_is_valid_fails_when_node_points_to_itself){
void* box42 = mem_box(42);
void* box22 = mem_box(22);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_node_to_root_left_works){
void* box42 = mem_box(42);
void* box31 = mem_box(31);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_node_to_root_right_works){
void* box42 = mem_box(42);
void* box64 = mem_box(64);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_first_level_works){
void* box42 = mem_box(42);
void* box31 = mem_box(31);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_below_full_first_level_works){
void* box42 = mem_box(42);
void* box31 = mem_box(31);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_parent_uncle_mismatch_outside_left){
void* box42 = mem_box(42);
void* box32 = mem_box(32);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_parent_uncle_mismatch_outside_right){
void* box42 = mem_box(42);
void* box53 = mem_box(53);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_parent_uncle_mismatch_inside_left){
void* box42 = mem_box(42);
void* box20 = mem_box(20);
CHECK(OK == rbt_check_status(tree));
mem_release(tree);
}
+
TEST(Verify_rbt_insert_parent_uncle_mismatch_inside_right){
void* box42 = mem_box(42);
void* box99 = mem_box(99);
mem_release(tree);
mem_release(box78);
}
+
TEST(Verify_rbt_lookup_returns_correct_node){
void* box42 = mem_box(42);
void* box33 = mem_box(33);
mem_release(node4);
mem_release(tree);
}
+
//case 2: black node, one red child
TEST(Verify_rbt_delete_left_black_node_with_single_red_left_child){
void* box42 = mem_box(42);
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_left_black_node_with_single_red_right_child){
void* box42 = mem_box(42);
void* box33 = mem_box(33);
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_right_black_node_with_single_red_right_child){
void* box42 = mem_box(42);
void* box33 = mem_box(33);
mem_release(node3);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_right_black_node_with_single_red_left_child){
void* box42 = mem_box(42);
void* box33 = mem_box(33);
mem_release(node3);
mem_release(tree);
}
+
//case 3: black node, no non-null children, red parent
//red parent implies non-null black sibbling
//four subcases for sibbling's children
mem_release(node5);
mem_release(tree);
}
+
//3.1.2: test when node being deleted is parent->left and parent is grandparent->left
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_no_children_left){
void* target = mem_box(15);
mem_release(node5);
mem_release(tree);
}
+
//3.2: sibbling has outside child
//3.2.1: test when node being deleted is parent->right and parent is grandparent->right
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_has_outside_child_right){
mem_release(node5);
mem_release(tree);
}
+
//3.2.2: test when node being deleted is parent->left and parent is grandparent->left
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_has_outside_child_left){
void* target = mem_box(12);
mem_release(node5);
mem_release(tree);
}
+
//3.3: sibbling has inside child
//3.3.1: test when node being deleted is parent->right and parent is grandparent->right
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_has_inside_child_right){
mem_release(node5);
mem_release(tree);
}
+
//3.3.2: test when node being deleted is parent->left and parent is grandparent->left
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_has_inside_child_left){
void* target = mem_box(15);
mem_release(node5);
mem_release(tree);
}
+
//3.4: sibbling has no children
//3.4.1: test when node being deleted is parent->right and parent is grandparent->right
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_has_two_children_right){
mem_release(node5);
mem_release(tree);
}
+
//3.4.2: test when node being deleted is parent->left and parent is grandparent->left
TEST(Verify_rbt_delete_black_node_from_red_parent_sib_has_two_children_left){
void* target = mem_box(15);
mem_release(node5);
mem_release(tree);
}
+
//case 4: black node, no non-null children, black parent
//properties of RBT imply node has a sibbling
//five subcases
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_no_children_left){
void* target = mem_box(22);
//create tree w/ several nodes
mem_release(node2);
mem_release(tree);
}
+
//test tree rebalancing after remove. case 4.1 is the only rm case that requires a structural rebalancing:
//trivial case: parent is tree->root (tested above) ; no action required
//A: rebalance node w/ red sibbling (rotation moves to have black sibbling to fall in one of the following cases)
mem_release(node11);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_rebalance_red_sibbling_right){
void* target = mem_box(88);
void* box42 = mem_box(42);
mem_release(node06);
mem_release(tree);
}
+
//B: rebalance w/ black parent, black sibbling w/ black children
TEST(Verify_rbt_delete_rebalance_black_parent_black_sib_with_black_children_left){
void* target = mem_box(15);
mem_release(node7);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_rebalance_black_parent_black_sib_with_black_children_right){
void* target = mem_box(75);
void* box42 = mem_box(42);
mem_release(node5);
mem_release(tree);
}
+
//C: rebalance w/ red parent, red sibbling w/ black children
TEST(Verify_rbt_delete_rebalance_red_parent_black_sib_with_black_children_left){
void* target = mem_box(11);
mem_release(node11);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_rebalance_red_parent_black_sib_with_black_children_right){
void* target = mem_box(99);
void* box42 = mem_box(42);
mem_release(node06);
mem_release(tree);
}
+
//D: rebalance for sibbling w/ outside red child
TEST(Verify_rbt_delete_rebalance_sib_with_red_child_outside_left){
void* target = mem_box(11);
mem_release(node06);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_rebalance_sib_with_red_child_outside_right){
void* target = mem_box(88);
void* box42 = mem_box(42);
mem_release(node06);
mem_release(tree);
}
+
//E: rebalance for sibbling w/ inside red child
TEST(Verify_rbt_delete_rebalance_sib_with_red_child_inside_left){
void* target = mem_box(11);
mem_release(node06);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_rebalance_sib_with_red_child_inside_right){
void* target = mem_box(88);
void* box42 = mem_box(42);
mem_release(node06);
mem_release(tree);
}
+
//F: rebalance for sibbling with two red children
TEST(Verify_rbt_delete_rebalance_sib_with_two_red_children_left){
void* target = mem_box(11);
mem_release(node06);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_rebalance_sib_with_two_red_children_right){
void* target = mem_box(88);
void* box42 = mem_box(42);
mem_release(node06);
mem_release(tree);
}
+
//4.2: sibbling is black, outside red child
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_outside_red_child_right){
void* target = mem_box(99);
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_outside_red_child_left){
void* target = mem_box(8);
//create tree w/ several nodes
mem_release(node2);
mem_release(tree);
}
+
//4.3: sibbling is black, inside red child
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_inside_red_child_right){
void* target = mem_box(99);
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_inside_red_child_left){
void* target = mem_box(8);
//create tree w/ several nodes
mem_release(node2);
mem_release(tree);
}
+
//4.4: sibbling is black, two red children
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_two_children_right){
void* target = mem_box(99);
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_black_node_from_black_parent_sib_has_two_children_left){
void* target = mem_box(8);
//create tree w/ several nodes
mem_release(node2);
mem_release(tree);
}
+
//4.5: sibbling is red, two black children
TEST(Verify_rbt_delete_black_node_from_black_parent_red_sib_right){
void* target = mem_box(99);
mem_release(node2);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_black_node_from_black_parent_red_sib_left){
void* target = mem_box(8);
//create tree w/ several nodes
mem_release(node2);
mem_release(tree);
}
+
//second class: deleting nodes that have two children
TEST(Verify_rbt_delete_node_with_two_children_successor_is_left){
void* target = mem_box(22);
mem_release(doomed);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_node_with_two_children){
void* target = mem_box(42);
void* box88 = mem_box(88);
mem_release(doomed);
mem_release(tree);
}
+
//third class: special cases: deleting root
TEST(Verify_rbt_delete_root_node_with_single_red_left_child){
void* box88 = mem_box(88);
mem_release(node1);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_root_node_with_single_red_right_child){
void* box42 = mem_box(42);
void* box88 = mem_box(88);
mem_release(node1);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_root_node_with_no_children){
void* box88 = mem_box(88);
rbt_t* tree = rbt_new(test_compare);
mem_release(node1);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_root_node_with_two_children){
void* target = mem_box(22);
void* box42 = mem_box(42);
mem_release(doomed);
mem_release(tree);
}
+
TEST(Verify_rbt_delete_node_with_four_nodes){
void* target = mem_box(42);
void* box88 = mem_box(88);
mem_release(doomed);
mem_release(tree);
}
+
//deleting node that is not present
TEST(Verify_rbt_delete_node_not_present_does_nothing){
void* target = mem_box(42);
projects / projs / libcds.git / commitdiff