Additional unitTests

bintreeTest.c

@@ -8,8 +8,8 @@ int compareInts(const void *arg1, const void *arg2){
     int val1 = *(int *)arg1;
     int val2 = *(int *)arg2;
 
-    if(val1 < val2) return 1;
-    if(val1 > val2) return -1;
+    if(val1 < val2) return -1;
+    if(val1 > val2) return 1;
     return 0;
 }
 
@@ -36,12 +36,159 @@ void test_addToTree_singleElement(void){
     TEST_ASSERT_NULL(tree->left);
     TEST_ASSERT_NULL(tree->right);
 }
+
+void test_addToTree_multipleElements(void){
+    TreeNode *tree = NULL;
+    int values[] = {20, 30, 40, 50, 60, 70, 80};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    TEST_ASSERT_NOT_NULL(tree);
+    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->data);
+    TEST_ASSERT_EQUAL_INT(30, *(int *)tree->right->data);
+    TEST_ASSERT_EQUAL_INT(40, *(int *)tree->right->right->data);
+    TEST_ASSERT_EQUAL_INT(50, *(int *)tree->right->right->right->data);
+    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->right->right->right->data);
+}
+
+void test_addToTree_multipleElementsOptimised(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 40, 60, 80};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    TEST_ASSERT_NOT_NULL(tree);
+    TEST_ASSERT_EQUAL_INT(50, *(int *)tree->data);
+    TEST_ASSERT_EQUAL_INT(30, *(int *)tree->left->data);
+    TEST_ASSERT_EQUAL_INT(70, *(int *)tree->right->data);
+    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
+    TEST_ASSERT_EQUAL_INT(40, *(int *)tree->left->right->data);
+}
+
+void test_addToTree_withDuplicatesAccept(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 20, 60, 60};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    TEST_ASSERT_NOT_NULL(tree);
+
+    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
+    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->right->data);
+    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->data);
+    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->right->data);
+}
+
+void test_addToTree_withoutDuplicatesAccept(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 20, 60, 60};
+    int isDuplicate = 0;
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, &isDuplicate);
+        if(i == 4 || i == 6){
+            TEST_ASSERT_EQUAL_INT(1, isDuplicate);
+        } else{
+            TEST_ASSERT_EQUAL_INT(0, isDuplicate);
+        }
+    }
+
+    TEST_ASSERT_NOT_NULL(tree);
+    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
+    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->data);
+    TEST_ASSERT_EQUAL_INT(5, treeSize(tree));
+}
+void test_treeSize_emptyTree(void){
+    
+    TEST_ASSERT_EQUAL_UINT(0, treeSize(NULL));
+}
+
+void test_treeSize_singleNode(void){
+    TreeNode *tree = NULL;
+    int value = 42;
+    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
+
+    TEST_ASSERT_NOT_NULL(tree);
+    TEST_ASSERT_EQUAL_UINT(1, treeSize(tree));
+}
+
+void test_treeSize_multipleNodes(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 40, 60, 80};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+
+    TEST_ASSERT_NOT_NULL(tree);
+    TEST_ASSERT_EQUAL_UINT(7, treeSize(tree));
+
+}
+
+void test_nextTreeData_emptyTree(void){
+    TEST_ASSERT_NULL(nextTreeData(NULL));
+}
+
+void test_clearTree_emptyTree(void){
+    clearTree(NULL);
+    TEST_ASSERT_TRUE(1);
+}
+
+void test_clearTree_singleElement(void){
+    int value = 42;
+    TreeNode *tree = NULL;
+
+    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
+
+    clearTree(tree);
+
+    TEST_ASSERT_TRUE(1);
+}
+
+void test_clearTree_multipleElements(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 40, 60, 80};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    clearTree(tree);
+
+    TEST_ASSERT_TRUE(1);
+}
 int main(){
     UNITY_BEGIN();
 
     printf("\n============================\nBintree tests\n============================\n");
     
+    //addToTree()
     RUN_TEST(test_addToTree_singleElement);
+    RUN_TEST(test_addToTree_multipleElements);
+    RUN_TEST(test_addToTree_multipleElementsOptimised);
+    RUN_TEST(test_addToTree_withDuplicatesAccept);
+    RUN_TEST(test_addToTree_withoutDuplicatesAccept);
+
+    //treeSize()
+    RUN_TEST(test_treeSize_emptyTree);
+    RUN_TEST(test_treeSize_singleNode);
+    RUN_TEST(test_treeSize_multipleNodes);
+
+    //nextTreeData()
+
+    RUN_TEST(test_nextTreeData_emptyTree);
+
+    //clearTree()
+    RUN_TEST(test_clearTree_emptyTree);
+    RUN_TEST(test_clearTree_singleElement);
+    RUN_TEST(test_clearTree_multipleElements);
 
     return UNITY_END();