testing

bintree.c

@@ -1,36 +1,199 @@
+#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),
-    * `clearTree`: gibt den gesamten Baum frei (rekursiv),
-    * `treeSize`: zählt die Knoten im Baum (rekursiv),
-    * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */
+/*  * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv),           Done
+    * `clearTree`: gibt den gesamten Baum frei (rekursiv),                      Done
+    * `treeSize`: zählt die Knoten im Baum (rekursiv),                          Done
+    * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. Done */  
+
+
+    static StackNode    *stackRoot  = NULL;
+
+
+    TreeNode        *addToTree          (TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate);
+    void            *nextTreeData       (TreeNode *root);
+    void            clearTree           (TreeNode *root);
+    unsigned int    treeSize            (const TreeNode *root);
+
+    // self declared functions
+    TreeNode        *addToTreeRec       (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root);
+    void            clearTreeRec        (TreeNode *currentNode);
+    void            clearNode           (TreeNode *node);
+    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
 // if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
+
+//      returned Value is new root
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
+    // create a node
+    TreeNode *newNode;
 
+
+    newNode         = calloc(1, sizeof(TreeNode));
+    newNode->data   = calloc(1, dataSize);
+    newNode->left   = NULL;
+    newNode->right  = NULL;
+    memcpy(newNode->data, data, dataSize);
+
+
+    return addToTreeRec(root, newNode, compareFct, isDuplicate, 1);
 }
 
+
+TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root)
+{
+    if ((currentNode == NULL))
+    {
+        if ((isDuplicate == NULL) || root)
+        {
+            if (isDuplicate != NULL)
+            {
+                *isDuplicate = 0;
+            }
+            
+            return newNode;
+        }
+        else
+        {
+            *isDuplicate = 0;
+            return currentNode;
+        }
+    }
+    else if ((compareFct(currentNode->data, newNode->data) < 0))
+    {
+        currentNode->left   = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0);
+    }
+    else if ((compareFct(currentNode->data, newNode->data) > 0))
+    {
+        currentNode->right  = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate, 0);
+    }
+    else if ((compareFct(currentNode->data, newNode->data) == 0))
+    {
+        if (isDuplicate == NULL)
+        {
+            currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0);
+        }
+        else
+        {
+            *isDuplicate = 1;
+        }
+    }
+
+    if (isDuplicate != NULL)
+    {
+        *isDuplicate = 0;
+    }
+    return currentNode;
+}
+ 
+
 // Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction.
 // Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element,
 // 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 = stackRoot;
+    }
+    else
+    {
+        // return current top entry and then pop that top entry
+        pointerToReturn = top(stackRoot);
+        stackRoot       = pop(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;
+}
+
+
 // Releases all memory resources (including data copies).
 void clearTree(TreeNode *root)
 {
-
+    clearTreeRec(root);
 }
 
+
+void clearTreeRec(TreeNode *currentNode)
+{
+    if (currentNode != NULL)
+    {
+        clearTree(currentNode->left);
+        clearTree(currentNode->right);
+        clearNode(currentNode);
+    }
+}
+
+
+void clearNode(TreeNode *node)
+{
+    free(node->data);
+    node->data  = NULL;
+
+    node->left  = NULL;
+    node->right = NULL;
+
+    free(node);
+    node        = NULL;
+}
+
+
 // Returns the number of entries in the tree given by root.
 unsigned int treeSize(const TreeNode *root)
+{   
+    unsigned int amountOfNodes = 0;
+
+    
+    amountOfNodes = treeSizeRec(root);
+
+
+    return amountOfNodes;
+}
+
+
+int treeSizeRec(const TreeNode *currentNode)
 {
+    int nodeCount = 0;
+
+
+    if (currentNode != NULL)
+    {
+        nodeCount += treeSizeRec(currentNode->left);
+        nodeCount += treeSizeRec(currentNode->right);
+        return nodeCount + 1;
+    }
+
+    return nodeCount;
+}
 
-}

bintreeTests.c

@@ -0,0 +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
+
+
+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)
+{
+    const int *entry1 = (const void *)arg1;
+    const int *entry2 = (const void *)arg2;
+
+    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_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 *)nextTreeData(NULL));
+    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 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()
+{
+    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();
+}
+

highscores.txt

@@ -1,2 +1 @@
-player_name;9943
 player1;3999

makefile

@@ -35,8 +35,14 @@ $(program_obj_filesobj_files): %.o: %.c
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
-	echo "needs to be implemented"
+# unitTests:
+#	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