turtschinba100320/info2Praktikum-DobleSpielBastiBjoern
2
0
Fork 0
forked from freudenreichan/info2Praktikum-DobleSpiel
Code Pull Requests Activity

BinTree fertig gemacht inclusive unity tests

Browse Source
This commit is contained in:
Basti 2025-12-16 02:29:34 +01:00
parent 4d27f910ff
commit 099a5c5cc5
4 changed files with 313 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
bintree.c
View File

@ -12,7 +12,36 @@
// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
{
if(root == NULL)
{
TreeNode *newNode = malloc(sizeof(TreeNode));
newNode->data = malloc(dataSize);
memcpy(newNode->data, data, dataSize);
newNode->left = NULL;
newNode->right = NULL;
if(isDuplicate != NULL)
*isDuplicate = 0;
return newNode;
}
else
{
int cmpResult = compareFct(data, root->data);
if(cmpResult < 0)
root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
else if(cmpResult > 0)
root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
else
{
// Duplicate found
if(isDuplicate != NULL)
*isDuplicate = 1;
}
return root;
}
}
// 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.
@ -20,17 +49,56 @@ 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;
if (root != NULL)
{
clearStack(stack);
stack = NULL;
TreeNode *current = root;
while (current != NULL)
{
stack = push(stack, current);
current = current->left;
}
}
if (stack == NULL)
return NULL;
TreeNode *node = (TreeNode *)top(stack);
stack = pop(stack);
void *data = node->data;
TreeNode *current = node->right;
while (current != NULL)
{
stack = push(stack, current);
current = current->left;
}
return data;
}
// Releases all memory resources (including data copies).
void clearTree(TreeNode *root)
{
if(root != NULL)
{
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);
}

122
bintreeTests.c Normal file
View File

@ -0,0 +1,122 @@
#include <stdio.h>
#include <stdlib.h>
#include "unity.h"
#include "bintree.h"
/* ---------- Helper ---------- */
int compareInt(const void *a, const void *b)
{
int ia = *(const int *)a;
int ib = *(const int *)b;
return ia - ib;
}
void setUp(void){}
void tearDown(void){}
/* ---------- addToTree ---------- */
void test_addToTree_adds_first_element(void)
{
TreeNode *root = NULL;
int value = 5;
int isDup = -1;
root = addToTree(root, &value, sizeof(int), compareInt, &isDup);
TEST_ASSERT_NOT_NULL(root);
TEST_ASSERT_EQUAL_INT(0, isDup);
TEST_ASSERT_EQUAL_INT(1, treeSize(root));
clearTree(root);
}
void test_addToTree_detects_duplicate(void)
{
TreeNode *root = NULL;
int value = 5;
int isDup = -1;
root = addToTree(root, &value, sizeof(int), compareInt, &isDup);
root = addToTree(root, &value, sizeof(int), compareInt, &isDup);
TEST_ASSERT_EQUAL_INT(1, isDup);
TEST_ASSERT_EQUAL_INT(1, treeSize(root));
clearTree(root);
}
/* ---------- treeSize ---------- */
void test_treeSize_counts_multiple_elements(void)
{
TreeNode *root = NULL;
int values[] = {5, 2, 8, 1, 3};
for (int i = 0; i < 5; i++)
root = addToTree(root, &values[i], sizeof(int), compareInt, NULL);
TEST_ASSERT_EQUAL_UINT(5, treeSize(root));
clearTree(root);
}
/* ---------- nextTreeData ---------- */
void test_nextTreeData_returns_sorted_order(void)
{
TreeNode *root = NULL;
int values[] = {5, 2, 8, 1, 3};
for (int i = 0; i < 5; i++)
root = addToTree(root, &values[i], sizeof(int), compareInt, NULL);
int expected[] = {1, 2, 3, 5, 8};
int *val;
/* erster Aufruf initialisiert den Iterator */
val = (int *)nextTreeData(root);
TEST_ASSERT_NOT_NULL(val);
TEST_ASSERT_EQUAL_INT(expected[0], *val);
/* weitere Aufrufe liefern die nächsten Elemente */
for (int i = 1; i < 5; i++)
{
val = (int *)nextTreeData(NULL);
TEST_ASSERT_NOT_NULL(val);
TEST_ASSERT_EQUAL_INT(expected[i], *val);
}
/* danach muss NULL kommen */
TEST_ASSERT_NULL(nextTreeData(NULL));
clearTree(root);
}
/* ---------- clearTree ---------- */
void test_clearTree_on_empty_tree_does_not_crash(void)
{
clearTree(NULL);
TEST_PASS();
}
/* ---------- MAIN ---------- */
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_addToTree_adds_first_element);
RUN_TEST(test_addToTree_detects_duplicate);
RUN_TEST(test_treeSize_counts_multiple_elements);
RUN_TEST(test_nextTreeData_returns_sorted_order);
RUN_TEST(test_clearTree_on_empty_tree_does_not_crash);
return UNITY_END();
}

25
makefile
View File

@ -29,21 +29,30 @@ program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o
doble : main.o $(program_obj_files)
$(CC) $(FLAGS) $^ -o doble
$(program_obj_filesobj_files): %.o: %.c
$(CC) -c $(FLAGS) $^ -o $@
numbers.o: numbers.c
$(CC) -c $(CFLAGS) numbers.c
# --------------------------
# Objektdateien kompilieren
# --------------------------
%.o: %.c
$(CC) -c $(FLAGS) $< -o $@
# --------------------------
# Unit Tests
# --------------------------
numbersTests: numbers.o numbersTests.c $(unityfolder)/unity.c
$(CC) $(CFLAGS) -I$(unityfolder) -o runNumbersTests numbersTests.c numbers.o $(unityfolder)/unity.c
$(CC) $(FLAGS) -I$(unityfolder) \
-o runNumbersTests \
numbersTests.c numbers.o $(unityfolder)/unity.c
stackTests: stack.o stackTests.c $(unityfolder)/unity.c
$(CC) $(CFLAGS) -I$(unityfolder) -o runStackTests stackTests.c stack.o $(unityfolder)/unity.c
$(CC) $(FLAGS) -I$(unityfolder) \
-o runStackTests \
stackTests.c stack.o $(unityfolder)/unity.c
bintreeTests: bintree.o stack.o bintreeTests.c $(unityfolder)/unity.c
$(CC) $(FLAGS) -I$(unityfolder) \
-o runBintreeTests \
bintreeTests.c bintree.o stack.o $(unityfolder)/unity.c
# --------------------------
# Clean
@ -52,5 +61,5 @@ clean:
ifeq ($(OS),!Windows_NT)
del /f *.o doble *.exe
else
rm -f *.o doble *runNumbersTests
rm -f *.o doble run*Tests*
endif

104
stackTests.c
View File

@ -1,4 +1,4 @@
#include <stdio.h>
/*#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
#include "unity.h"
@ -24,5 +24,107 @@ int main(void)
UNITY_BEGIN();
RUN_TEST(test_push_created_new_stacknode);
return UNITY_END();
}*/
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
#include "unity.h"
void setUp(void){}
void tearDown(void){}
/* ---------------- PUSH ---------------- */
void test_push_created_new_stacknode(void)
{
int testdata1 = 111;
StackNode test = {&testdata1,NULL};
int testdata2 = 222;
StackNode *test1 = push(&test,&testdata2);
TEST_ASSERT_NOT_NULL(test1);
TEST_ASSERT_EQUAL_PTR(&testdata2,test1->data);
TEST_ASSERT_EQUAL_PTR(&test,test1->next);
}
/* ---------------- TOP ---------------- */
void test_top_on_empty_stack_returns_null(void)
{
TEST_ASSERT_NULL(top(NULL));
}
void test_top_returns_top_element(void)
{
int data = 42;
StackNode node = {&data, NULL};
TEST_ASSERT_EQUAL_PTR(&data, top(&node));
}
/* ---------------- POP ---------------- */
void test_pop_on_empty_stack_returns_null(void)
{
TEST_ASSERT_NULL(pop(NULL));
}
void test_pop_removes_top_element(void)
{
int d1 = 1;
int d2 = 2;
StackNode *s = NULL;
s = push(s, &d1);
s = push(s, &d2);
StackNode *newTop = pop(s);
TEST_ASSERT_NOT_NULL(newTop);
TEST_ASSERT_EQUAL_PTR(&d1, newTop->data);
clearStack(newTop); // Speicher aufräumen
}
/* ---------------- CLEAR ---------------- */
void test_clearStack_on_empty_stack_does_not_crash(void)
{
clearStack(NULL);
TEST_PASS(); // Test besteht, wenn kein Crash
}
void test_clearStack_clears_multiple_elements(void)
{
int d1 = 1, d2 = 2, d3 = 3;
StackNode *s = NULL;
s = push(s, &d1);
s = push(s, &d2);
s = push(s, &d3);
clearStack(s);
TEST_PASS(); // kein Crash = bestanden
}
/* ---------------- MAIN ---------------- */
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_push_created_new_stacknode);
RUN_TEST(test_top_on_empty_stack_returns_null);
RUN_TEST(test_top_returns_top_element);
RUN_TEST(test_pop_on_empty_stack_returns_null);
RUN_TEST(test_pop_removes_top_element);
RUN_TEST(test_clearStack_on_empty_stack_does_not_crash);
RUN_TEST(test_clearStack_clears_multiple_elements);
return UNITY_END();
}