DobleSpiel/bintreeTests.c

#include <stdio.h>
#include <string.h>
#include "unity.h"
#include "bintree.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)
{
    // printf("in comp\n");
    const int *entry1 = (const void *)arg1;
    const int *entry2 = (const void *)arg2;

    // printf("const set\n");
    int result = *entry2 - *entry1;

    // int result = entry2 - entry1;

    // printf("exit comp\n");
    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);
    printf("add1passed\n");
    
    testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL);
    printf("add2passed\n");
    
    testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL);
    printf("add3passed\n");
    
    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
    printf("add4passed\n");
    
    testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL);
    printf("add5passed\n");
    
    testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL);
    printf("add6passed\n");
    /*
    testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL);
    printf("add7passed\n");
    */

    // Checking the Tree without Doubles
    TEST_ASSERT_NOT_NULL(testRoot);
    TEST_ASSERT_EQUAL_UINT16(score1, testRoot->data);
    printf("node1passed\n");
    
    TEST_ASSERT_NOT_NULL(testRoot->left);
    TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left->data);
    printf("node2passed\n");
    
    TEST_ASSERT_NOT_NULL(testRoot->right);
    TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right->data);
    printf("node3passed\n");
    
    TEST_ASSERT_NOT_NULL(testRoot->left->left);
    TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->data);
    printf("node4passed\n");
    
    TEST_ASSERT_NOT_NULL(testRoot->left->right);
    TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right->data);
    printf("node5passed\n");
    
    TEST_ASSERT_NOT_NULL(testRoot->right->left);
    TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data);
    printf("node6passed\n");
    /*
    TEST_ASSERT_NOT_NULL(testRoot->right->right);
    TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right->data);
    printf("node7passed\n");
    /*
    // Adding Double
    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);
    TEST_ASSERT_NOT_NULL(testRoot->left->left->left);
    TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left);

    // 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)
{

}


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


    // 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);
    testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL);

   // Save all Adresses
   TreeNode *node1  = testRoot->left;
   TreeNode *node2  = testRoot->left->left;
   TreeNode *node3  = testRoot->left->right;
   TreeNode *node4  = testRoot->right;
   TreeNode *node5  = testRoot->right->left;
   TreeNode *node6  = testRoot->right->right;
   TreeNode *node7  = testRoot->left->left->left;

   clearTree(testRoot);

    // Check if everything has been set to NULL
    TEST_ASSERT_NULL(testRoot);
    TEST_ASSERT_NULL(node1);
    TEST_ASSERT_NULL(node2);
    TEST_ASSERT_NULL(node3);
    TEST_ASSERT_NULL(node4);
    TEST_ASSERT_NULL(node5);
    TEST_ASSERT_NULL(node6);
    TEST_ASSERT_NULL(node7);
}


// 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);
    testRoot = addToTree(testRoot, &score4, 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();
}