void testRemoveNode() {
struct BSTree *tree = buildBSTTree();
struct Node *cur;
struct data myData1, myData2, myData3, myData4;
myData1.number = 50;
myData1.name = "rooty";
myData2.number = 13;
myData2.name = "lefty";
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
_removeNode(tree->root, &myData4);
printTestResult(compare(tree->root->val, &myData1) == 0 && tree->root->left->left == NULL, "_removeNode", "remove left of left of root 1st try");
_removeNode(tree->root, &myData3);
printTestResult(compare(tree->root->val, &myData1) == 0 && tree->root->right == NULL, "_removeNode", "remove right of root 2st try");
_removeNode(tree->root, &myData2);
printTestResult(compare(tree->root->val, &myData1) == 0 && tree->root->left == 0, "_removeNode", "remove right of root 3st try");
cur = _removeNode(tree->root, &myData1);
printTestResult(cur == NULL, "_removeNode", "remove right of root 4st try");
}
/*
fucntion to test that the BST contains the elements that we added to it
*/
void testContainsBSTree() {
struct BSTree *tree = buildBSTTree();
struct data myData1, myData2, myData3, myData4, myData5;
myData1.number = 50;
myData1.name = "rooty";
myData2.number = 13;
myData2.name = "lefty";
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
myData5.number = 111;
myData5.name = "not in tree";
printTestResult(containsBSTree(tree, &myData1), "containsBSTree", "when test containing 50 as root");
printTestResult(containsBSTree(tree, &myData2), "containsBSTree", "when test containing 13 as left of root");
printTestResult(containsBSTree(tree, &myData3), "containsBSTree", "when test containing 110 as right of root");
printTestResult(containsBSTree(tree, &myData4), "containsBSTree", "when test containing 10 as left of left of root");
//check containsBSTree fucntion when the tree does not contain a node
printTestResult(!containsBSTree(tree, &myData5), "containsBSTree", "when test containing 111, which is not in the tree");
}
void testRemoveNode() {
struct BSTree *tree = buildBSTTree();
struct data *myData;
/*Grabs the expected value from the tree, then deletes a node and checks if the new value in that place matches the expected value.*/
myData = tree->root->right->val;
_removeNode(tree->root, tree->root->val);
printTestResult( (compare(tree->root->val, myData) == 0), "_removeNode", "Testing remove Root\n");
myData = tree->root->right->left->val;
_removeNode(tree->root, tree->root->right->val);
printTestResult( (compare(tree->root->right->val, myData) == 0), "_removeNode", "Testing remove Root->Right\n"); /*Keep in mind that the tree has changed.*/
myData = tree->root->left->right->left->val;
_removeNode(tree->root, tree->root->left->val);
printTestResult( (compare(tree->root->left->val, myData) == 0), "_removeNode", "Testing remove Root->Left\n");
myData = tree->root->right->val;
_removeNode(tree->root, tree->root->val);
printTestResult( (compare(tree->root->val, myData) == 0), "_removeNode", "Testing remove Root again\n");
struct data not_in_tree;
not_in_tree.number = 9000;
printf("Testing invalid remove. The two lines below should match exactly\n");
printTree(tree);
_removeNode(tree->root, ¬_in_tree); /*Should print error message and leave tree unchanged.*/
printTree(tree);
printf("Deleting the BSTree...\n");
deleteBSTree(tree);
printf("Returning from testRemoveNode().\n");
}
void testRemoveNode() {
// printf("\n%s\n","calling from in here");
struct BSTree *tree = buildBSTTree();
// printf("\n%s\n","tree built");
struct Node *cur;
// printf("\n%s\n","ptr made");
struct data myData1, myData2, myData3, myData4;
// printf("\n%s\n","structs defined");
myData1.number = 50;
myData1.name = "rooty";
myData2.number = 13;
myData2.name = "lefty";
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
//printf("\n%s\n","calling remove node");
_removeNode(tree->root, &myData4);
printTestResult(compare(tree->root->val, &myData1) == 0 && tree->root->left->left == NULL, "_removeNode", "remove left of left of root 1st try");
_removeNode(tree->root, &myData3);
printTestResult(compare(tree->root->val, &myData1) == 0 && tree->root->right == NULL, "_removeNode", "remove right of root 2st try");
_removeNode(tree->root, &myData2);
printTestResult(compare(tree->root->val, &myData1) == 0 && tree->root->left == 0, "_removeNode", "remove right of root 3st try");
cur = _removeNode(tree->root, &myData1);
printTestResult(cur == NULL, "_removeNode", "remove right of root 4st try");
}
void testRemoveLeftMost() {
struct BSTree *tree = buildBSTTree();
struct data *myData;
struct data *delete_val; /*In this case we need another struct to delete value 105
Since _removeLeftMost is not supposed to delete the value (it may be pointed to by another element in the tree)
we will need to manually delete it ourselves once the node has been deleted.*/
myData = tree->root->left->left->val;
_removeLeftMost(tree->root);
printTestResult( (tree->root->left->left == NULL), "_removeLeftMost", "Removing leftmost from Root");
free(myData);
delete_val = tree->root->left->val;
myData = tree->root->left->right->val;
_removeLeftMost(tree->root);
printTestResult( (compare(tree->root->left->val, myData) == 0), "_removeLeftMost", "Removing leftmost from Root again");
free(delete_val);
delete_val = tree->root->right->right->left->val;
myData = tree->root->right->right->left->right->val;
_removeLeftMost(tree->root->right->right);
free(delete_val);
printTestResult( (compare(tree->root->right->right->left->val, myData) == 0), "_removeLeftMost", "removing leftmost from Root->Right->Right");
printf("Deleting the BSTree...\n");
deleteBSTree(tree);
printf("Returning from testRemoveLeftMost().\n");
}
/*
Function to test that the BST contains the elements that we added to it
*/
void testContainsBSTree() {
/* printf("test the test \n");*/
struct BSTree *tree = buildBSTTree();
struct data myData;
myData.number = 90;
myData.name = "Root";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 90 as Root");
myData.number = 10;
myData.name = "Root->L";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 10 as Root->Left");
myData.number = 5;
myData.name = "Root->L->L";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 5 as Root->Left->Left");
myData.number = 50;
myData.name = "Root->L->R";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 50 as Root->Left->Right");
myData.number = 40;
myData.name = "Root->L->R->L";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 40 as Root->Left->Right->Left");
myData.number = 55;
myData.name = "Root->L->R->R";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 55 as Root->Left->Right->Right");
myData.number = 100;
myData.name = "Root->R";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 100 as Root->Right");
myData.number = 110;
myData.name = "Root->R->R";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 110 as Root->Right->Right");
myData.number = 105;
myData.name = "Root->R->R->L";
printTestResult(containsBSTree(tree->root, &myData), "containsBSTree", "When test containing 105 as Root->Right->Right->Left");
/*Check if containsBSTree will properly recognize if a number is not in the tree. */
myData.number = 1337;
myData.name = "Root->N->A->N";
printTestResult(!containsBSTree(tree->root, &myData), "containsBSTree", "When testing if 1337 is not in the tree.");
printf("Deleting the BSTree...\n");
deleteBSTree(tree);
printf("Returning from testContainsBSTree().\n");
}
void testRemoveLeftMost() {
struct BSTree *tree = buildBSTTree();
struct Node *cur;
cur = _removeLeftMost(tree->root);
printTestResult(cur == tree->root, "_removeLeftMost", "removing leftmost of root 1st try");
cur = _removeLeftMost(tree->root->right);
printTestResult(cur == NULL, "_removeLeftMost", "removing leftmost of right of root 1st try");
cur = _removeLeftMost(tree->root);
printTestResult(cur == tree->root, "_removeLeftMost", "removing leftmost of root 2st try");
}
void testContainsBSTree() {
struct BSTree *tree = buildBSTTree();
struct data myData1;
struct data myData2;
struct data myData3;
struct data myData4;
struct data myData5;
myData1.number = 50;
myData1.name = "rooty";
myData2.number = 13;
myData2.name = "lefty";
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
myData5.number = 111;
myData5.name = "not in tree";
if (containsBSTree(tree, &myData1))
printf("containsBSTree(): PASS when test containing 50 as root\n");
else
printf("containsBSTree(): FAIL when test containing 50 as root\n");
if (containsBSTree(tree, &myData2))
printf("containsBSTree(): PASS when test containing 13 as left of root\n");
else
printf("containsBSTree(): FAIL when test containing 13 as left of root\n");
if (containsBSTree(tree, &myData3))
printf("containsBSTree(): PASS when test containing 110 as right of root\n");
else
printf("containsBSTree(): FAIL when test containing 110 as right of root\n");
if (containsBSTree(tree, &myData4))
printf("containsBSTree(): PASS when test containing 10 as left of left of root\n");
else
printf("containsBSTree(): FAIL when test containing 10 as left of left of root\n");
if (!containsBSTree(tree, &myData5))
printf("containsBSTree(): PASS when test containing 111, which is not in the tree\n");
else
printf("containsBSTree(): FAIL when test containing 111, which shouldn't be in the tree.\n");
}
/*
fucntion to test the left_Most_element
*/
void testLeftMost() {
struct BSTree *tree = buildBSTTree();
struct data myData3;
struct data myData4;
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
printTestResult(compare(_leftMost(tree->root), &myData4) == 0, "_leftMost", "left most of root");
printTestResult(compare(_leftMost(tree->root->left), &myData4) == 0, "_leftMost", "left most of left of root");
printTestResult(compare(_leftMost(tree->root->left->left), &myData4) == 0, "_leftMost", "left most of left of left of root");
}
/*
Function to test the left_Most_element
*/
void testLeftMost() {
struct BSTree *tree = buildBSTTree();
struct data *myData;
myData = (struct data*)tree->root->left->left->val;
printTestResult( (compare(_leftMost(tree->root)->val, myData) == 0), "_leftMost", "Left most of Root");
printTestResult( (compare(_leftMost(tree->root->left)->val, myData) == 0), "_leftMost", "Left most of Left of Root");
myData = (struct data*)tree->root->left->right->left->val;
printTestResult( (compare(_leftMost(tree->root->left->right)->val, myData) == 0), "_leftMost", "Left most of Left of Right of Root");
myData = (struct data*)tree->root->right->right->left->val;
printTestResult( (compare(_leftMost(tree->root->right->right)->val, myData) == 0), "_leftMost", "Left most of Right of Right of Root");
printf("Deleting the BSTree...\n");
deleteBSTree(tree);
printf("Returning from testLeftMost().\n");
}
void testRemoveNode() {
struct BSTree *tree = buildBSTTree();
struct Node *cur;
struct data myData1;
struct data myData2;
struct data myData3;
struct data myData4;
myData1.number = 50;
myData1.name = "rooty";
myData2.number = 13;
myData2.name = "lefty";
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
_removeNode(tree->root, &myData4);
if (compare(tree->root->val, &myData1) == 0 && tree->root->left->left == NULL)
printf("_removeNode(): PASS remove left of left of root 1st try\n");
else
printf("_removeNode(): FAIL remove left of left of root 1st try\n");
_removeNode(tree->root, &myData3);
if (compare(tree->root->val, &myData1) == 0 && tree->root->right == NULL)
printf("_removeNode(): PASS remove right of root 2st try\n");
else
printf("_removeNode(): FAIL remove right of root 2st try\n");
_removeNode(tree->root, &myData2);
if (compare(tree->root->val, &myData1) == 0 && tree->root->left == 0)
printf("_removeNode(): PASS remove left of root 3st try\n");
else
printf("_removeNode(): FAIL remove left of root 3st try\n");
cur = _removeNode(tree->root, &myData1);
if (cur == NULL)
printf("_removeNode(): PASS remove root 4st try\n");
else
printf("_removeNode(): FAIL remove root 4st try\n");
}
/*
fucntion to test the left_Most_element
*/
void testLeftMost() {
struct BSTree *tree = buildBSTTree();
struct data myData3, myData4;
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
printTestResult(compare(_leftMost(tree->root), &myData4) == 0, "_leftMost", "left most of root");
printTestResult(compare(_leftMost(tree->root->left), &myData4) == 0, "_leftMost", "left most of left of root");
printTestResult(compare(_leftMost(tree->root->left->left), &myData4) == 0, "_leftMost", "left most of left of left of root");
printTestResult(compare(_leftMost(tree->root->right), &myData3) == 0, "_leftMost", "left most of right of root");
printf("Deleting the BSTree...\n");
deleteBSTree(tree);
printf("Returning from testLeftMost().\n");
}
void testLeftMost() {
struct BSTree *tree = buildBSTTree();
struct data myData1;
struct data myData2;
struct data myData3;
struct data myData4;
myData1.number = 50;
myData1.name = "rooty";
myData2.number = 13;
myData2.name = "lefty";
myData3.number = 110;
myData3.name = "righty";
myData4.number = 10;
myData4.name = "lefty of lefty";
if (compare(_leftMost(tree->root), &myData4) == 0)
printf("_leftMost(): PASS left most of root\n");
else
printf("_leftMost(): FAIL left most of root\n");
if (compare(_leftMost(tree->root->left), &myData4) == 0)
printf("_leftMost(): PASS left most of left of root\n");
else
printf("_leftMost(): FAIL left most of left of root\n");
if (compare(_leftMost(tree->root->left->left), &myData4) == 0)
printf("_leftMost(): PASS left most of left of left of root\n");
else
printf("_leftMost(): FAIL left most of left of left of root\n");
if (compare(_leftMost(tree->root->right), &myData3) == 0)
printf("_leftMost(): PASS left most of right of root\n");
else
printf("_leftMost(): FAIL left most of right of root\n");
}
void testRemoveLeftMost() {
struct BSTree *tree = buildBSTTree();
struct Node *cur;
cur = _removeLeftMost(tree->root);
if (cur == tree->root)
printf("_removeLeftMost: PASS removing leftmost of root 1st try\n");
else
printf("_removeLeftMost: FAIL removing leftmost of root 1st try\n");
cur = _removeLeftMost(tree->root->right);
if (cur == NULL)
printf("_removeLeftMost: PASS removing leftmost of right of root 1st try\n");
else
printf("_removeLeftMost: FAIL removing leftmost of right of root 1st try\n");
cur = _removeLeftMost(tree->root);
if (cur == tree->root)
printf("_removeLeftMost: PASS removing leftmost of root 2st try\n");
else
printf("_removeLeftMost: FAIL removing leftmost of root 2st try\n");
}
