Makefile angepasst an unit tests. Unit tests geändert

bintree.h

@@ -5,11 +5,11 @@
 
 typedef int (*CompareFctType)(const void *arg1, const void *arg2);
 
-typedef struct node
+typedef struct treenode
 {
     void *data;
-    struct node *left;
-    struct node *right;
+    struct treenode *left;
+    struct treenode *right;
 } TreeNode;
 
 // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates 

makefile

@@ -29,21 +29,32 @@ 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
+$(program_obj_files): %.o: %.c
 	$(CC) -c $(FLAGS) $^ -o $@
 
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
-	echo "needs to be implemented"
+# Test Stack (JETZT MIT UNITY)
+# Wir müssen unity/unity.c mitkompilieren und -Iunity nutzen
+test_stack: test_stack.c stack.o $(unityfolder)/unity.c
+	$(CC) $(FLAGS) -Iunity test_stack.c stack.o $(unityfolder)/unity.c -o test_stack$(EXT)
 
-# --------------------------
+unitTests_stack: test_stack
+	./test_stack$(EXT)
+test_numbers: test_numbers.c numbers.c bintree.c stack.c unity/unity.c
+	gcc -Wall -Wextra -std=c99 -Iunity \
+	    -o test_numbers \
+	    test_numbers.c numbers.c bintree.c stack.c unity/unity.c
+unitTests_number: test_numbers
+	./test_numbers
+
+#-------------------------
 # Clean
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble
+	del /f *.o doble.exe test_stack.exe test_numbers.exe
 else
 	rm -f *.o doble
 endif

numbers.c

@@ -11,16 +11,93 @@
   * Duplizieren eines zufälligen Eintrags im Array.
   * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */
 
-// 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.
+//Vergleichsfunktion von qsort
+static int compareUnsignedInt(const void *a, const void *b)
+{
+const unsigned int *x = (const unsigned int *)a;
+   const unsigned int *y = (const unsigned int *)b;
+
+   if (*x < *y) return -1;
+   if (*x > *y) return 1;
+   return 0;
+}
+
+//Mischen des Arrays
+static void shuffleArray(unsigned int *array, unsigned int n)
+{
+   if (n > 1)
+   {
+       for (unsigned int i = n - 1; i > 0; i--)
+       {
+           unsigned int j = rand() % (i + 1);
+           unsigned int temp = array[i];
+           array[i] = array[j];
+           array[j] = temp;
+       }
+   }
+}
+//Wenn weniger als zwei Zahlen
 unsigned int *createNumbers(unsigned int len)
 {
+   if (len < 2) return NULL;
 
+//Dynamisches Array
+   unsigned int *numbers = malloc(len * sizeof(unsigned int));
+   if (numbers == NULL) return NULL;
+//Variabelen für den Binärbaum
+   TreeNode *root = NULL;
+   int isDuplicate = 0;
+   unsigned int count = 0;
+
+
+   while (count < len - 1)
+   {   //Zufallszahlen generieren
+       unsigned int value = (rand() % (2 * len)) + 1;
+
+
+       root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);
+
+       if (isDuplicate == 0)
+       {   //in array schreiben falls kein Duplikat
+           numbers[count] = value;
+           count++;
        }
 
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
+   }
+   //Duplikat erzeugen
+   unsigned int randomIndex = rand() % (len - 1);
+   unsigned int duplicateValue = numbers[randomIndex];
+   numbers[len - 1] = duplicateValue;
+   root = addToTree(root, &duplicateValue, sizeof(unsigned int), compareUnsignedInt, NULL);
+   //Array mischen damit duplikat nicht am Ende immer ist
+   shuffleArray(numbers, len);
+
+   clearTree(root);
+   return numbers;
+}
+//get Duplicate
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
-
+ if (numbers == NULL || len < 2) {
+   return 0;
+ }
+//Kopie vom Array anlegen
+ unsigned int *copy = malloc(len * sizeof(unsigned int));
+
+ if (copy == NULL) {
+   return 0;
+ }
+ memcpy(copy, numbers, len * sizeof(unsigned int));
+ qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
+ unsigned int duplicate = 0;
+//Duplikat finden
+ for (unsigned int i = 0; i + 1 < len; ++i) {
+   if (copy[i] == copy[i + 1]) {
+     duplicate = copy[i];
+     break;
+   }
+ }
+//Speicher freigeben
+ free(copy);
+ return duplicate;
 }

test_numbers.c

@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <time.h>
+
+#include "unity/unity.h"
+#include "numbers.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+static unsigned int countOccurrences(const unsigned int *numbers, unsigned int len, unsigned int value)
+{
+    unsigned int count = 0;
+    for (unsigned int i = 0; i < len; ++i) {
+        if (numbers[i] == value) {
+            count++;
+        }
+    }
+    return count;
+}
+
+void test_createNumbers_returns_non_null(void)
+{
+    unsigned int len = 20;
+    unsigned int *numbers = createNumbers(len);
+
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    free(numbers);
+}
+
+void test_createNumbers_value_range(void)
+{
+    unsigned int len = 30;
+    unsigned int *numbers = createNumbers(len);
+
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    for (unsigned int i = 0; i < len; ++i) {
+        TEST_ASSERT_TRUE(numbers[i] >= 1);
+        TEST_ASSERT_TRUE(numbers[i] <= 2 * len);
+    }
+
+    free(numbers);
+}
+
+void test_getDuplicate_finds_exactly_one_duplicate(void)
+{
+    unsigned int len = 25;
+    unsigned int *numbers = createNumbers(len);
+
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    unsigned int duplicate = getDuplicate(numbers, len);
+    TEST_ASSERT_NOT_EQUAL_UINT(0, duplicate);
+
+    unsigned int occurrences =
+        countOccurrences(numbers, len, duplicate);
+
+    TEST_ASSERT_EQUAL_UINT(2, occurrences);
+
+    free(numbers);
+}
+
+void test_error_cases(void)
+{
+    TEST_ASSERT_NULL(createNumbers(0));
+    TEST_ASSERT_NULL(createNumbers(1));
+
+    TEST_ASSERT_EQUAL_UINT(0, getDuplicate(NULL, 10));
+
+    unsigned int oneElement[1] = { 42 };
+    TEST_ASSERT_EQUAL_UINT(0, getDuplicate(oneElement, 1));
+}
+
+int main(void)
+{
+    srand((unsigned int) time(NULL));
+
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_returns_non_null);
+    RUN_TEST(test_createNumbers_value_range);
+    RUN_TEST(test_getDuplicate_finds_exactly_one_duplicate);
+    RUN_TEST(test_error_cases);
+
+    return UNITY_END();
+}

test_stack.c

@@ -0,0 +1,72 @@
+#include <stdlib.h>
+#include "unity.h"
+#include "stack.h"
+
+// Globale Variablen für den Test (optional, aber praktisch hier)
+StackNode *stack = NULL;
+int *a;
+int *b;
+
+void setUp(void) {
+    stack = NULL;
+    // Wir reservieren Speicher für jedes Test-Szenario frisch
+    a = malloc(sizeof(int));
+    b = malloc(sizeof(int));
+    *a = 10;
+    *b = 20;
+}
+
+void tearDown(void) {
+    // Aufräumen nach jedem Test
+    if (stack != NULL) {
+        clearStack(stack);
+        stack = NULL;
+    }
+    // Falls der Stack die Daten NICHT freest, müssen wir es tun:
+    // Hinweis: Wenn clearStack die Daten freest, darfst du hier a und b nicht free-en!
+    // Ich gehe davon aus, der Stack freest die Daten NICHT.
+    free(a);
+    free(b);
+}
+
+void test_push_and_top(void) {
+    stack = push(stack, a);
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_INT(10, *(int*)top(stack));
+
+    stack = push(stack, b);
+    TEST_ASSERT_EQUAL_INT(20, *(int*)top(stack));
+}
+
+void test_pop_logic(void) {
+    // Vorbereitung
+    stack = push(stack, a);
+    stack = push(stack, b);
+
+    // Test Pop 1
+    stack = pop(stack);
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_INT(10, *(int*)top(stack));
+
+    // Test Pop 2 (Stack sollte leer werden)
+    stack = pop(stack);
+    TEST_ASSERT_NULL(stack);
+}
+
+void test_clearStack(void) {
+    stack = push(stack, a);
+    stack = push(stack, b);
+
+    clearStack(stack);
+    stack = NULL; // Muss im Code manuell gemacht werden, wenn clearStack void ist
+
+    TEST_ASSERT_NULL(stack);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_push_and_top);
+    RUN_TEST(test_pop_logic);
+    RUN_TEST(test_clearStack);
+    return UNITY_END();
+}