Makefile angepasst an unit tests. Unit tests geändert

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

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();
+}