first running version

.gitignore

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

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "files.associations": {
+        "stdio.h": "c",
+        "stdlib.h": "c"
+    }
+}

bintree.c

@@ -26,7 +26,7 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
             free(newNode); //Free unused Memory
             return NULL;; //Memory allocation failed
         }
-        newNode->data = data; //Copy Data
+        memcpy(newNode->data, data, dataSize); //Copy Data
 
         newNode->left = NULL;
         newNode->right = NULL;
@@ -68,17 +68,52 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
 // push the top node and push all its left nodes.
 void *nextTreeData(TreeNode *root)
 {
+    static StackNode *stack = NULL;
+    static TreeNode *current = NULL;
+
+    if(root != NULL){
+        clearStack(stack);
+        stack = NULL;
+        current = root;
+    }
+
+    while (current != NULL){
+        stack = push(stack, current);
+        current = current->left;
+    }
+
+    if(stack == NULL){
+        return 0;
+    }
+    TreeNode *node = (TreeNode *)top(stack);
+    stack = pop(stack);
+
+    current = node->right;
+
+    return node->data;
     
 } 
 
 // Releases all memory resources (including data copies).
 void clearTree(TreeNode *root)
 {
+    if(root == NULL){
+        return;
+    }
+    
+    clearTree(root->left);
+    clearTree(root->right);
+
+    free(root->data);
+    free(root);
     
 }
 
 // Returns the number of entries in the tree given by root.
 unsigned int treeSize(const TreeNode *root)
 {
-
+    if(root == NULL){
+        return 0;
+    }
+    return 1 + treeSize(root->left) + treeSize(root->right);
 }

bintreeTest.c

@@ -0,0 +1,330 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "unity.h"
+#include "bintree.h"
+
+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;
+    return 0;
+}
+
+int compareStrings(const void *arg1, const void *arg2){
+    return -strcmp((const char *)arg1, (const char *)arg2);
+}
+
+
+void setUp(void){
+    //Use if needed    
+}
+void tearDown(void){
+    //Use if needed
+}
+
+//addToTree()
+void test_addToTree_singleElement(void){
+    int value = 42;
+    TreeNode *tree = NULL;
+
+    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
+
+    TEST_ASSERT_NOT_NULL(tree);
+    TEST_ASSERT_EQUAL_INT(value, *(int *)tree->data);
+    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)

makefile

@@ -37,6 +37,10 @@ doble_initial:
 # --------------------------
 # Unit Tests
 # --------------------------
+stackTests: stack.o test_stack.c $(unityfolder)/unity.c
+	$(CC) $(CFLAGS) -I$(unityfolder) -o stackTests test_stack.c stack.o $(unityfolder)/unity.c ${LDFLAGS}
+bintreeTests: bintree.o stack.o bintreeTest.c $(unityfolder)/unity.c
+	$(CC) $(CFLAGS) -I$(unityfolder) -o bintreeTests bintreeTest.c bintree.o stack.o $(unityfolder)/unity.c ${LDFLAGS}
 unitTests:
 	echo "needs to be implemented"
 
@@ -45,7 +49,7 @@ unitTests:
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble
+	del /f *.o doble doble_initial bintreeTests stackTests
 else
-	rm -f *.o doble
+	rm -f *.o doble doble_initial bintreeTests stackTests
 endif

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;
 }

stack.c

@@ -10,24 +10,51 @@
 // Pushes data as pointer onto the stack.
 StackNode* push(StackNode* stack, void* data)
 {
-
+    //pointer onto new struct
+   StackNode* newNode = malloc(sizeof(StackNode));
+   newNode->data = data;
+    //*stack := first node of the stack; is now the second to first node
+   newNode->nextNode = stack;
+    return newNode;
 }
 
 // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
 // freed by caller.)
 StackNode* pop(StackNode* stack)
 {
+    //getting the second to first node
+    StackNode* tmp = stack->nextNode;
 
+    // data should be freed by the caller
+    // free(stack->data);
+    // stack->data = NULL;
+    free(stack);
+    stack = NULL;
+
+    return tmp;
 }
 
 // Returns the data of the top element.
 void* top(StackNode* stack)
 {
+    //No stack --> No data-pointer
+    if (stack == NULL) return NULL;
 
+    return stack->data;
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode* stack)
 {
+    if (stack == NULL) return;
 
+    if (stack->nextNode != NULL) clearStack(stack->nextNode);
+
+    // date should be freed by the caller.
+    // free(stack->data);
+    // stack->data = NULL;
+
+    free(stack);
+    // technically not needed (dangling pointer)
+    stack = NULL;
 }

stack.h

@@ -7,7 +7,10 @@ The latest element is taken from the stack. */
 
 #include <stdlib.h>
 
-//TODO: passenden Datentyp als struct anlegen
+typedef struct StackNode {
+    void* data;
+    struct StackNode* nextNode;
+} StackNode;
 
 // Pushes data as pointer onto the stack.
 StackNode* push(StackNode *stack, void *data);

test_stack.c

@@ -0,0 +1,90 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "unity.h"
+#include "stack.h"
+
+
+void test_topReturnsCorrectValue(void) {
+    // 1. Arrange
+    int* value1;
+    int* value2;
+    int* outVal1;
+    int* outVal2;
+    value1 = malloc(sizeof(int));
+    value2 = malloc(sizeof(int));
+    StackNode* startNode = NULL;
+
+    // 2. Act
+    *value1 = 1234;
+    *value2 = 5678;
+    startNode = push(startNode, value1);
+    // new top node is node 2
+    startNode = push(startNode, value2);
+    outVal2 = top(startNode);
+    // node 1 should now be the top node
+    startNode = pop(startNode);
+    outVal1 = top(startNode);
+
+    // 3. Assert
+    //Also tests for the functionality of 'push'
+    TEST_ASSERT_EQUAL_INT32(*value1, *outVal1);
+    TEST_ASSERT_EQUAL_INT32(*value2, *outVal2);
+
+    free(value1);
+    value1 = NULL;
+    free(value2);
+    value2 = NULL;
+    clearStack(startNode);
+}
+
+void test_topReturnsNullOnNotExistingStack(void) {
+    // 1. Arrange
+    StackNode* startNode = NULL;
+    int* data;
+
+    // 2. Act
+    data = top(startNode);
+
+    //3. Assert
+    TEST_ASSERT_NULL(data);
+}
+
+void test_popRemovesElements(void) {
+   // 1. Arrange
+   StackNode* startNode = NULL;
+   
+   // 2. Act
+   // Entering some Elements into Stack (could be added manually for testing)
+   startNode = push(startNode, NULL);
+   startNode = push(startNode, NULL);
+   startNode = push(startNode, NULL);
+   startNode = push(startNode, NULL);
+   // Now removing created Elements
+   startNode = pop(startNode);
+   startNode = pop(startNode);
+   startNode = pop(startNode);
+   startNode = pop(startNode);
+
+    // 3. Assert
+    TEST_ASSERT_NULL(startNode);
+}
+
+void setUp(void){
+
+}
+
+void tearDown(void){
+
+}
+
+int main(void) {
+    UNITY_BEGIN();
+
+    printf("\n============================\nStack tests\n============================\n");
+
+    RUN_TEST(test_topReturnsNullOnNotExistingStack);
+    RUN_TEST(test_topReturnsCorrectValue);
+    RUN_TEST(test_popRemovesElements);
+
+    return UNITY_END();
+}