first running version

.gitignore

@@ -1,5 +1,6 @@
 doble_initial
 stackTests
 bintreeTests
+doble
 *.o
 *.exe

bintree.c

@@ -77,12 +77,14 @@ void *nextTreeData(TreeNode *root)
         current = root;
     }
 
-    while (current != NULL)
-    {
+    while (current != NULL){
         stack = push(stack, current);
         current = current->left;
     }
 
+    if(stack == NULL){
+        return 0;
+    }
     TreeNode *node = (TreeNode *)top(stack);
     stack = pop(stack);
 

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;
 }
 
@@ -25,6 +25,7 @@ void tearDown(void){
     //Use if needed
 }
 
+//addToTree()
 void test_addToTree_singleElement(void){
     int value = 42;
     TreeNode *tree = NULL;
@@ -36,12 +37,293 @@ 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_multipleElements_optimized(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));
+}
+
+//treeSize()
+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));
+
+}
+
+//nextTreeData()
+void test_nextTreeData_emptyTree(void){
+    TEST_ASSERT_NULL(nextTreeData(NULL));
+}
+
+void test_nextTreeData_singleElement(void){
+    TreeNode *tree = NULL;
+    int value = 42;
+    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
+
+    int *result = (int *)nextTreeData(tree);
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_INT(value, *result);
+
+    TEST_ASSERT_NULL(nextTreeData(NULL));
+
+    clearTree(tree);
+}
+
+void test_nextTreeData_multipleElements(void){
+
+    TreeNode *tree = NULL;
+    int values[] = {20, 30, 40, 50, 60, 70, 80};
+    int expected[] = {20, 30, 40, 50, 60, 70, 80}; 
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    int *result = (int *)nextTreeData(tree);
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_INT(expected[0], *result);
+
+    for(int i = 1; i < 7; i++){
+        result = (int *)nextTreeData(NULL);
+
+        TEST_ASSERT_NOT_NULL(result);
+        TEST_ASSERT_EQUAL_INT(expected[i], *result);
+    }
+
+    TEST_ASSERT_NULL(nextTreeData(NULL));
+
+    clearTree(tree);
+}
+
+void test_nextTreeData_multipleElements_optimized(void){
+
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 40, 60, 80};
+    int expected[] = {20, 30, 40, 50, 60, 70, 80};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    int *result = (int *)nextTreeData(tree);
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_INT(expected[0], *result);
+
+    for(int i = 1; i < 7; i++){
+        result = (int *)nextTreeData(NULL);
+
+        TEST_ASSERT_NOT_NULL(result);
+        TEST_ASSERT_EQUAL_INT(expected[i], *result);
+    }
+
+    TEST_ASSERT_NULL(nextTreeData(NULL));
+
+    clearTree(tree);
+}
+
+
+void test_nextTreeData_withDuplicates(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 20, 60, 60};
+    int expected[] = {20, 20, 30, 50, 60, 60, 70};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    int *result = (int *)nextTreeData(tree);
+
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_INT(expected[0], *result);
+
+    for(int i = 1; i < 7; i++){
+        result = (int *)nextTreeData(NULL);
+
+        TEST_ASSERT_NOT_NULL(result);
+        TEST_ASSERT_EQUAL_INT(expected[i], *result);
+    }
+
+    TEST_ASSERT_NULL(nextTreeData(NULL));
+}
+
+void test_nextTreeData_restart(void){
+    TreeNode *tree = NULL;
+    int values[] = {50, 30, 70, 20, 40, 60, 80};
+    int expected[] = {20, 30, 40, 50, 60, 70, 80};
+
+    for(int i = 0; i < 7; i++){
+        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
+    }
+
+    int *result = (int *)nextTreeData(tree);
+
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_INT(expected[0], *result);
+
+    for(int i = 1; i < 4; i++){
+        result = (int *)nextTreeData(NULL);
+
+        TEST_ASSERT_NOT_NULL(result);
+        TEST_ASSERT_EQUAL_INT(expected[i], *result);
+    }
+
+    result = (int *)nextTreeData(tree);
+
+    TEST_ASSERT_NOT_NULL(result);
+    TEST_ASSERT_EQUAL_INT(expected[0], *result);
+
+    for(int i = 1; i < 7; i++){
+        result = (int *)nextTreeData(NULL);
+
+        TEST_ASSERT_NOT_NULL(result);
+        TEST_ASSERT_EQUAL_INT(expected[i], *result);
+    }
+}
+
+//clearTree()
+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_multipleElements_optimized);
+    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);
+    RUN_TEST(test_nextTreeData_singleElement);
+    RUN_TEST(test_nextTreeData_multipleElements);
+    RUN_TEST(test_nextTreeData_multipleElements_optimized);
+    RUN_TEST(test_nextTreeData_withDuplicates);
+    RUN_TEST(test_nextTreeData_restart);
+
+    //clearTree()
+    RUN_TEST(test_clearTree_emptyTree);
+    RUN_TEST(test_clearTree_singleElement);
+    RUN_TEST(test_clearTree_multipleElements);
 
     return UNITY_END();
     

highscores.txt

@@ -1,2 +1,3 @@
+test;24999
 test;9999
 player1;3999

main.c

@@ -1,5 +1,6 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <time.h>
 #include "numbers.h"
 #include "timer.h"
 #include "highscore.h"
@@ -37,6 +38,8 @@ void showNumbers(const unsigned int *numbers, unsigned int len)
 // Main game loop: generate numbers, ask user for duplicate, measure time, update highscores.
 int main(int argc, char *argv[])
 {
+    srand(time(NULL));
+
     int exitCode = EXIT_FAILURE;
 
     if(argc != 2)

numbers.c

@@ -14,13 +14,86 @@
 // Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.
+
+
+int compareUInts(const void *arg1, const void *arg2){
+    unsigned int val1 = *(unsigned int *)arg1;
+    unsigned int val2 = *(unsigned int *)arg2;
+
+    if(val1 < val2) return -1;
+    if(val1 > val2) return 1;
+    return 0;
+}
+
 unsigned int* createNumbers(unsigned int len)
 {
+    if(len == 0){
+        return NULL;
+    }
 
+    unsigned int* numbers = (unsigned int*)malloc(len * sizeof(unsigned int));
+    if(numbers == NULL){
+        return NULL;
+    }
+
+    TreeNode *tree = NULL;
+    
+    unsigned int i = 0;
+    while(i < len){
+        unsigned int tmp = (rand() % (2*len)) + 1;
+
+        int isDuplicate = 0;
+        tree = addToTree(tree, &tmp, sizeof(unsigned int), compareUInts, &isDuplicate);
+
+        if(!isDuplicate){
+            numbers[i] = tmp;
+            i++;
+        }
+    }
+
+    clearTree(tree);
+
+    unsigned int rIdx = rand() % len;
+    unsigned int duplicate = numbers[rIdx];
+
+    unsigned int tIdx = rand() % len;
+    while(tIdx == rIdx){
+        tIdx = rand() % len;
+    }
+    numbers[tIdx] = duplicate;
+
+    return numbers;
 }
 
 // Returns only the only number in numbers which is present twice. Returns zero on errors.
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
+    if(numbers == NULL || len < 2){
+        return 0;
+    }
 
+    unsigned int* sorted = (unsigned int*)malloc(len * sizeof(unsigned int));
+    if(sorted == NULL){
+        return 0;
+    }
+
+    TreeNode *tree = NULL;
+    for(unsigned int i = 0; i < len; i++){
+        tree = addToTree(tree, &numbers[i], sizeof(unsigned int), compareUInts, NULL);
+    }
+
+    sorted[0] = *(unsigned int *)nextTreeData(tree);
+
+    for(unsigned int j = 1; j < len; j++){
+        sorted[j] = *(unsigned int*)nextTreeData(NULL);
+    }
+    unsigned int duplicate = 0;
+    for(unsigned int k = 0; k < len - 1; k++){
+        if(sorted[k] == sorted[k+1]){
+            duplicate = sorted[k];
+            break;
+        }
+    }
+    free(sorted);
+    return duplicate;
 }