presented code

.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "macos-clang-arm64",
+      "includePath": [
+        "${workspaceFolder}/**"
+      ],
+      "compilerPath": "/usr/bin/clang",
+      "cStandard": "${default}",
+      "cppStandard": "${default}",
+      "intelliSenseMode": "macos-clang-arm64",
+      "compilerArgs": [
+        ""
+      ]
+    }
+  ],
+  "version": 4
+}

.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "C/C++ Runner: Debug Session",
+      "type": "lldb",
+      "request": "launch",
+      "args": [],
+      "cwd": "/Users/florianwetzel/I2_Praktikum/DobleSpiel",
+      "program": "/Users/florianwetzel/I2_Praktikum/DobleSpiel/build/Debug/outDebug"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,59 @@
+{
+  "C_Cpp_Runner.cCompilerPath": "clang",
+  "C_Cpp_Runner.cppCompilerPath": "clang++",
+  "C_Cpp_Runner.debuggerPath": "lldb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wcast-align",
+    "-Wconversion",
+    "-Wsign-conversion",
+    "-Wnull-dereference"
+  ],
+  "C_Cpp_Runner.msvcWarnings": [
+    "/W4",
+    "/permissive-",
+    "/w14242",
+    "/w14287",
+    "/w14296",
+    "/w14311",
+    "/w14826",
+    "/w44062",
+    "/w44242",
+    "/w14905",
+    "/w14906",
+    "/w14263",
+    "/w44265",
+    "/w14928"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false,
+  "C_Cpp_Runner.useUndefinedSanitizer": false,
+  "C_Cpp_Runner.useLeakSanitizer": false,
+  "C_Cpp_Runner.showCompilationTime": false,
+  "C_Cpp_Runner.useLinkTimeOptimization": false,
+  "C_Cpp_Runner.msvcSecureNoWarnings": false
+}

bintree.c

@@ -1,28 +1,31 @@
+#include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include "stack.h"
 #include "bintree.h"
 
 
 //TODO: binären Suchbaum implementieren
-/*  * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv),       Done
+/*  * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv),           Done
-    * `clearTree`: gibt den gesamten Baum frei (rekursiv),                  Done
+    * `clearTree`: gibt den gesamten Baum frei (rekursiv),                      Done
-    * `treeSize`: zählt die Knoten im Baum (rekursiv),
+    * `treeSize`: zählt die Knoten im Baum (rekursiv),                          Done
-    * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */
+    * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. Done */  
 
 
-    static TreeNode *root = NULL;
+    static StackNode    *stackRoot  = NULL;
 
 
-    TreeNode        *addToTree      (TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate);
+    TreeNode        *addToTree          (TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate);
-    void            *nextTreeData   (TreeNode *root);
+    void            *nextTreeData       (TreeNode *root);
-    void            clearTree       (TreeNode *root);
+    void            clearTree           (TreeNode *root);
-    unsigned int    treeSize        (const TreeNode *root);
+    unsigned int    treeSize            (const TreeNode *root);
 
     // self declared functions
-    TreeNode        *addToTreeRec   (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate);
+    TreeNode        *addToTreeRec       (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root);
-    void            clearTreeRec    (TreeNode *currentNode);
+    void            clearTreeRec        (TreeNode *currentNode);
-    void            clearNode       (TreeNode *node);
+    void            clearNode           (TreeNode *node);
-    void            treeSizeRec     (const TreeNode *currentNode, unsigned int *nodeCount);
+    int             treeSizeRec         (const TreeNode *currentNode);
+    void            *nextTreeDataRec    (TreeNode *node, StackNode *stack);
 
 
 // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates
@@ -42,31 +45,42 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
     memcpy(newNode->data, data, dataSize);
 
 
-    return addToTreeRec(root, newNode, compareFct, isDuplicate);
+    return addToTreeRec(root, newNode, compareFct, isDuplicate, 1);
 }
 
 
-TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate)
+TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root)
 {
     if (currentNode == NULL)
     {
-        isDuplicate = 0;
+        if ((isDuplicate == NULL) || root)
-        return newNode;
+        {
+            if (isDuplicate != NULL)
+            {
+                *isDuplicate = 0;
+            }
+            
+            return newNode;
+        }
+        else
+        {
+            *isDuplicate = 0;
+            return currentNode;
+        }
     }
-    else if (compareFct(newNode->data, currentNode->data) < 0)
+    else if (compareFct(currentNode->data, newNode->data) < 0)
     {
-        currentNode->left   = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate);
+        currentNode->left   = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0);
     }
-    else if (compareFct(newNode->data, currentNode->data) > 0)
+    else if (compareFct(currentNode->data, newNode->data) > 0)
     {
-        currentNode->right  = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate);
+        currentNode->right  = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate, 0);
     }
-    else
+    else if (compareFct(currentNode->data, newNode->data) == 0)
     {
-        //duplicate
         if (isDuplicate == NULL)
         {
-            currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate);
+            currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0);
         }
         else
         {
@@ -84,9 +98,40 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType
 // push the top node and push all its left nodes.
 
 // Needs stack!!
+//      Stack functions: push(), pop(), top(), clearStack()
 void *nextTreeData(TreeNode *root)
 {
+    void *pointerToReturn = NULL;
 
+    if (root != NULL)
+    {
+        // Add tree to stack so that bigest entry is ontop
+        stackRoot       = nextTreeDataRec(root, stackRoot);
+        pointerToReturn = top(stackRoot);
+    }
+    else
+    {
+        // return current top entry and then pop that top entry
+        stackRoot       = pop(stackRoot);
+        pointerToReturn = top(stackRoot);
+    }
+
+    
+    return pointerToReturn;
+}
+
+
+void *nextTreeDataRec(TreeNode *tree, StackNode *stack)
+{
+    if (tree != NULL)
+    {
+        stack = nextTreeDataRec (tree->left, stack);
+        stack = push            (stack, tree->data);
+        stack = nextTreeDataRec (tree->right, stack);
+    }
+
+
+    return stack;
 }
 
 
@@ -102,8 +147,8 @@ void clearTreeRec(TreeNode *currentNode)
     if (currentNode != NULL)
     {
         clearTree(currentNode->left);
-        clearNode(currentNode);
         clearTree(currentNode->right);
+        clearNode(currentNode);
     }
 }
 
@@ -127,19 +172,25 @@ unsigned int treeSize(const TreeNode *root)
     unsigned int amountOfNodes = 0;
 
     
-    treeSizeRec(root, &amountOfNodes);
+    amountOfNodes = treeSizeRec(root);
 
 
     return amountOfNodes;
 }
 
-void treeSizeRec(const TreeNode *currentNode, unsigned int *nodeCount)
+
+int treeSizeRec(const TreeNode *currentNode)
 {
+    int nodeCount = 0;
+
+
     if (currentNode != NULL)
     {
-        treeSizeRec(currentNode->left, nodeCount);
+        nodeCount += treeSizeRec(currentNode->left);
-        *nodeCount++;
+        nodeCount += treeSizeRec(currentNode->right);
-        treeSizeRec(currentNode->right, nodeCount);
+        return nodeCount + 1;
     }
+
+    return nodeCount;
 }
 

bintreeTests.c

@@ -1,43 +1,223 @@
 #include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
 #include "unity.h"
 #include "bintree.h"
+#include "stack.h"
 
 #define MAX_TEST_NAME_LEN 10
 
 
-typedef struct
+void setUp(void) {
+    // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
+}
+
+
+void tearDown(void) {
+    // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
+}
+
+
+static int compareIntEntries(const void *arg1, const void *arg2)
 {
-    char name[MAX_TEST_NAME_LEN];
+    const int *entry1 = (const void *)arg1;
-    int score;
+    const int *entry2 = (const void *)arg2;
-} HighscoreEntry;
+
+    int result = *entry2 - *entry1;
+
+
+    return result;
+}
 
 
 // test if addToTree expands tree correctly
 //      by going down the path where the given pice of data is expected
 //      and checking if the pice of data is found there
-void test_addToTreeExpandsTreeCorrectlyNoDoubles(void)
+void test_addToTreeExpandsTreeCorrectly(void)
 {
+    TreeNode    *testRoot       = NULL;
+    int         testIsDouble    = 0;
+    int         score1          = 12;
+    int         score2          = 6;
+    int         score3          = 18;
+    int         score4          = 3;
+    int         score5          = 9;
+    int         score6          = 15;
+    int         score7          = 21;
 
+
+    testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL);
+
+    // Checking the Tree without Doubles
+    TEST_ASSERT_NOT_NULL(testRoot);
+    TEST_ASSERT_EQUAL(score1, *(int *)testRoot->data);
+    
+    TEST_ASSERT_NOT_NULL(testRoot->left);
+    TEST_ASSERT_EQUAL(score2, *(int *)testRoot->left->data);
+    TEST_ASSERT_NOT_NULL(testRoot->right);
+    TEST_ASSERT_EQUAL(score3, *(int *)testRoot->right->data);
+    TEST_ASSERT_NOT_NULL(testRoot->left->left);
+    TEST_ASSERT_EQUAL(score4, *(int *)testRoot->left->left->data);
+    TEST_ASSERT_NOT_NULL(testRoot->left->right);
+    TEST_ASSERT_EQUAL(score5, *(int *)testRoot->left->right->data);
+    TEST_ASSERT_NOT_NULL(testRoot->right->left);
+    TEST_ASSERT_EQUAL(score6, *(int *)testRoot->right->left->data);
+    TEST_ASSERT_NOT_NULL(testRoot->right->right);
+    TEST_ASSERT_EQUAL(score7, *(int *)testRoot->right->right->data);
+    
+    // Adding Double
+    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
+    TEST_ASSERT_NOT_NULL(testRoot->left->left->left);
+    TEST_ASSERT_EQUAL_UINT16(score4, *(int *)testRoot->left->left->left->data);
+
+    // Trying to add Double while Doubles not Permitted
+    testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, &testIsDouble);
+    TEST_ASSERT_NULL(testRoot->right->right->left);
+    TEST_ASSERT_EQUAL_UINT16(1, testIsDouble);
+    
+
+    clearTree(testRoot);
 }
 
 
 // test if nextTreeData returns the next pice of data correctly
 //      needs Stack!!!
+void test_nextTreeDataReturnsNextDataCorrectly(void)
+{
+    TreeNode    *testRoot       = NULL;
+    int         score1          = 12;
+    int         score2          = 6;
+    int         score3          = 18;
+    int         score4          = 3;
+    int         score5          = 9;
+    int         score6          = 15;
+    int         score7          = 21;
+
+
+    // Prepare a Tree
+    testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL);
+
+    // Create Stack
+    StackNode   *entry  = nextTreeData(testRoot);
+
+    // check if nextTreeData returns Data correctly
+    TEST_ASSERT_NOT_NULL(entry);
+
+    TEST_ASSERT_EQUAL(score7, *(int *)entry);
+    TEST_ASSERT_EQUAL(score3, *(int *)nextTreeData(NULL));
+    TEST_ASSERT_EQUAL(score6, *(int *)nextTreeData(NULL));
+    TEST_ASSERT_EQUAL(score1, *(int *)nextTreeData(NULL));
+    TEST_ASSERT_EQUAL(score5, *(int *)nextTreeData(NULL));
+    TEST_ASSERT_EQUAL(score2, *(int *)nextTreeData(NULL));
+    TEST_ASSERT_EQUAL(score4, *(int *)nextTreeData(NULL));
+
+
+    clearTree(testRoot);
+}
 
 
 // test if clear Tree frees all node.name and node memory AND sets them to zero
 //      aditionally tests if the memoryspaces have been cleared
+void test_clearTreeworksLikeExpected(void)
+{
+    TreeNode    *testRoot       = NULL;
+    int         score1          = 12;
+    int         score2          = 6;
+    int         score3          = 18;
+    int         score4          = 3;
+    int         score5          = 9;
+    int         score6          = 15;
+    int         score7          = 21;
+
+
+    testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL);
+
+    // Save all Adresses
+    TreeNode *node1 = testRoot;
+    TreeNode *node2 = testRoot->left;
+    TreeNode *node3 = testRoot->left->left;
+    TreeNode *node4 = testRoot->left->right;
+    TreeNode *node5 = testRoot->right;
+    TreeNode *node6 = testRoot->right->left;
+    TreeNode *node7 = testRoot->right->right;
+
+    clearTree(testRoot);
+    
+    // Check if everything has been set to NULL
+    TEST_ASSERT_NULL(node1->data);
+    TEST_ASSERT_NULL(node1->data);
+    TEST_ASSERT_NULL(node2->data);
+    TEST_ASSERT_NULL(node3->data);
+    TEST_ASSERT_NULL(node4->data);
+    TEST_ASSERT_NULL(node5->data);
+    TEST_ASSERT_NULL(node6->data);
+    TEST_ASSERT_NULL(node7->data);
+}
 
 
 // tests if treeSize returns correct amount of nodes in Tree
-//      by using addNode a given number of times and testing to see if 
+//      by using addToTree a given number of times and testing to see if 
 //      the treeSize matches the number of nodes added
+void test_treeSizeWorkingLikeExpected(void)
+{
+    TreeNode        *testRoot       = NULL;
+    int             nodeCount       = 7;
+    unsigned int    testTreeSize    = 0;
+    int             score1          = 12;
+    int             score2          = 6;
+    int             score3          = 18;
+    int             score4          = 3;
+    int             score5          = 9;
+    int             score6          = 15;
+    int             score7          = 21;
+
+
+    // Fill Tree
+    testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL);
+    testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL);
+
+    testTreeSize = treeSize(testRoot);
+
+    TEST_ASSERT_EQUAL(nodeCount, testTreeSize);
+
+    clearTree(testRoot);
+}
 
 
 // main, strings together all tests
 int main()
 {
-    printf("\n============================\nBinary Tree tests\n============================\n");
+    UNITY_BEGIN();
 
+    printf("\n============================\nBinary Tree tests\n============================\n");
+    RUN_TEST(test_addToTreeExpandsTreeCorrectly);
+    RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly);
+    RUN_TEST(test_clearTreeworksLikeExpected);
+    RUN_TEST(test_treeSizeWorkingLikeExpected);
+
+    return UNITY_END();
 }
 

makefile

@@ -35,8 +35,24 @@ $(program_obj_filesobj_files): %.o: %.c
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
+# unitTests:
-	echo "needs to be implemented"
+#	echo "needs to be implemented"
+
+bintree: bintree.c
+	$(CC) $(FLAGS) -c bintree bintree.c
+
+bintreeTests: stack.o bintree.o bintreeTests.c $(unityfolder)/unity.c
+	$(CC) $(FLAGS) -o runbintreeTests bintreeTests.c bintree.o stack.o $(unityfolder)/unity.c
+
+stack: stack.c
+	$(CC) $(FLAGS) -c stack stack.c
+
+test_stack: stack.o test_stack.c $(unityfolder)/unity.c
+	$(CC) $(FLAGS) -o runstackTests test_stack.c stack.o $(unityfolder)/unity.c
+
+test_numbers: numbers.o bintree.o stack.o test_numbers.c $(unityfolder)/unity.c
+	$(CC) $(FLAGS) -o run_numbersTests test_numbers.c numbers.o bintree.o stack.o $(unityfolder)/unity.c
+
 
 # --------------------------
 # Clean

numbers.c

@@ -14,13 +14,109 @@
 // 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.
+
+static int compareUInt(const void *a, const void *b)
+{
+    unsigned int A = *(unsigned int*)a;
+    unsigned int B = *(unsigned int*)b;
+    if (A < B) return -1;
+    if (A > B) return 1;
+    return 0;
+}
+
+static int existsInTree(TreeNode *root, unsigned int value)
+{
+    if (!root) return 0;
+
+    unsigned int *data;
+
+    // Traversierung initialisieren
+    data = nextTreeData(root);
+
+    do    
+    {
+        if (*data == value)
+            return 1;
+    } while ((data = nextTreeData(NULL)) != NULL);
+
+    return 0;
+}
+
 unsigned int *createNumbers(unsigned int len)
 {
+    if (len < 2) return NULL;
 
+    srand((unsigned int)time(NULL));
+
+    unsigned int *numbers = malloc(sizeof(unsigned int) * len);
+    if (!numbers) return NULL;
+
+    TreeNode *root = NULL;
+    unsigned int value;
+
+    // Array mit eindeutigen Zufallszahlen füllen
+    for (unsigned int i = 0; i < len; i++)
+    {
+        do
+        {
+            value = (rand() % (2 * len)) + 1;
+        }
+        while (existsInTree(root, value));
+
+        // Baum wie highscore benutzen (immer NULL)
+        root = addToTree(
+            root,
+            &value,
+            sizeof(unsigned int),
+            compareUInt,
+            NULL
+        );
+
+        numbers[i] = value;
+    }
+
+    // genau eine Zufallszahl duplizieren
+    unsigned int idx1 = rand() % len;
+    unsigned int idx2;
+
+    do
+    {
+        idx2 = rand() % len;
+    }
+    while (idx2 == idx1);
+
+    numbers[idx2] = numbers[idx1];
+
+    clearTree(root);
+    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 || len < 2) return 0;
 
+    unsigned int *copy = malloc(len * sizeof(unsigned int));
+    if (!copy) return 0;
+
+    // Array kopieren
+    memcpy(copy, numbers, len * sizeof(unsigned int));
+
+    // Sortieren
+    qsort(copy, len, sizeof(unsigned int), compareUInt);
+
+    // Doppelte Zahl finden
+    unsigned int duplicate = 0;
+    for (unsigned int i = 0; i < len - 1; i++)
+    {
+        if (copy[i] == copy[i + 1])
+        {
+            duplicate = copy[i];
+            break;
+        }
+    }
+
+    free(copy);
+    return duplicate;
 }

stack.c

@@ -10,24 +10,64 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
+    StackNode *newNode = malloc(sizeof(StackNode));
+    if(newNode == NULL)
+    {
+        //printf("Fehler Bei Speicherallozierung!");
+        return NULL;
+    }
 
+    newNode->data = data;
+    newNode->next = 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)
 {
+    if(stack == NULL)
+    {
+        //printf("Fehlerhafte Adresse uebergeben");
+        return NULL;
+    }
 
+    StackNode *next = stack->next;
+
+    free(stack);
+
+    return next;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
+    if(stack == NULL)
+    {
+        //printf("Fehlerhafte Adresse uebergeben");
+        return NULL;
+    }
 
+    return stack->data;
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
+    if(stack == NULL)
+    {
+        //printf("Fehlerhafte Adresse uebergeben");
+        return;
+    }
 
+    StackNode *currentNode = stack;
+    StackNode *nextNode;
+
+    while(currentNode != NULL)
+    {
+        nextNode = currentNode->next;
+        free(currentNode);
+        currentNode = nextNode;
+    }
 }

stack.h

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

test_numbers.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "numbers.h"
+#include "unity/unity.h"
+
+
+void setUp(void) {
+    // gehört zu unit-Grundaufbau
+}
+
+void tearDown(void) {
+    // gehört zu unit-Grundaufbau
+}
+
+// Testet, ob createNumbers ein gültiges Array erzeugt
+// und genau ein Duplikat enthalten ist
+void test_createNumbers_basic(void)
+{
+    unsigned int len = 10;
+    unsigned int *numbers = createNumbers(len);
+
+    // Array muss existieren
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    // Es muss genau EIN Duplikat geben
+    unsigned int duplicate = getDuplicate(numbers, len);
+    TEST_ASSERT_NOT_EQUAL(0, duplicate);
+
+    free(numbers);
+}
+
+/// Testet, ob getDuplicate die korrekte doppelte Zahl erkennt
+
+void test_getDuplicate_correctValue(void)
+{
+    unsigned int numbers[] = {1, 3, 5, 7, 3};
+    unsigned int len = 5;
+
+    unsigned int dup = getDuplicate(numbers, len);
+
+    TEST_ASSERT_EQUAL(3, dup);
+}
+
+// Testet Fehlerfälle von getDuplicate
+static void test_getDuplicate_errors(void)
+{
+    TEST_ASSERT_EQUAL_UINT(0, getDuplicate(NULL, 10));
+    TEST_ASSERT_EQUAL_UINT(0, getDuplicate((unsigned int*)1, 1)); // len < 2
+}
+
+// Testbereich
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_basic);
+    RUN_TEST(test_getDuplicate_correctValue);
+    RUN_TEST(test_getDuplicate_errors);
+
+    return UNITY_END();
+}

test_stack.c

@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "unity.h"
+#include "stack.h"
+
+void setUp(void) {
+    // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
+}
+
+void tearDown(void) {
+    // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
+}
+
+
+
+void testeStackBeschreiben()
+{
+    //printf("=== Test: push() ===\n");
+
+    StackNode *stack = NULL;
+    int wert1 = 42;
+    stack = push(stack, &wert1);
+
+    int *topValue = (int *)(stack->data);
+
+    TEST_ASSERT_NOT_NULL(topValue);
+    TEST_ASSERT_EQUAL_INT(42, *topValue);
+
+
+    int wert2 = 12;
+    stack = push(stack, &wert2);
+
+    topValue = (int *)(stack->data);
+    int *secondValue = (int *)((stack->next)->data);
+
+    TEST_ASSERT_NOT_NULL(topValue);
+    TEST_ASSERT_EQUAL_INT(12, *topValue);
+    TEST_ASSERT_NOT_NULL(secondValue);
+    TEST_ASSERT_EQUAL_INT(42, *secondValue);
+
+
+    //printf("=== Ende Test: push() ===\n\n");
+    return;
+}
+
+void testepop()
+{
+    //printf("=== Test: pop() ===\n");
+
+    StackNode *stack = NULL;
+    int wert1 = 20;
+    int wert2 = 74;
+
+    stack = push(stack, &wert1);
+    stack = push(stack, &wert2);
+
+    stack = pop(stack);
+
+    int *topValue = (int *)(stack->data);
+
+    TEST_ASSERT_NOT_NULL(topValue);
+    TEST_ASSERT_EQUAL_INT(20, *topValue);
+
+    //printf("=== Ende Test: pop() ===\n\n");
+}
+
+void testetop()
+{
+    //printf("=== Test: top() ===\n");
+    
+    StackNode *stack = NULL;
+    int wert1 = 20;
+    int wert2 = 74;
+
+    stack = push(stack, &wert1);
+    stack = push(stack, &wert2);
+
+    int *topValue = top(stack);
+
+    TEST_ASSERT_NOT_NULL(topValue);
+    TEST_ASSERT_EQUAL_INT(74, *topValue);
+
+    //printf("=== Ende Test: top() ===\n\n");
+}
+
+void testeclearStack()
+{
+    //printf("=== Test: clearStack() ===\n");
+
+    StackNode *stack = NULL;
+    int wert1 = 20;
+    int wert2 = 74;
+
+    stack = push(stack, &wert1);
+    stack = push(stack, &wert2);
+
+    clearStack(stack);
+
+    //printf("Test: clearStack() aufgerufen. Speicher freigegeben.\n");
+    //printf("=== Ende Test: clearStack() ===\n\n");
+}
+
+int main()
+{
+    UNITY_BEGIN();
+
+    //printf("...");
+
+    RUN_TEST(testeStackBeschreiben);
+    RUN_TEST(testepop);
+    RUN_TEST(testetop);
+    RUN_TEST(testeclearStack);
+
+    /*testeStackBeschreiben();
+    testepop();
+    testetop();
+    testeclearStack();*/
+
+    return UNITY_END();
+}