stackTests hinzugefügt

.gitignore

@@ -1,62 +0,0 @@
-# ---> C
-# Prerequisites
-*.d
-
-# Object files
-*.o
-*.ko
-*.obj
-*.elf
-
-# Linker output
-*.ilk
-*.map
-*.exp
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Libraries
-*.lib
-*.la
-*.lo
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Executables
-*.exe
-*.out
-*.app
-*.i*86
-*.x86_64
-*.hex
-Startcode/doble_initial
-Startcode/doble
-Startcode/unitTests
-
-# Debug files
-*.dSYM/
-*.su
-*.idb
-*.pdb
-
-# Kernel Module Compile Results
-*.mod*
-*.cmd
-.tmp_versions/
-modules.order
-Module.symvers
-Mkfile.old
-dkms.conf
-
-# IDE folders
-.vscode/
-.idea/
-
-# macOS
-.DS_Store

Startcode/numbers.c

@@ -1,26 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-#include <string.h>
-#include "numbers.h"
-#include "bintree.h"
-
-//TODO: getDuplicate und createNumbers implementieren
-/*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
-  * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
-  * 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.
-unsigned int *createNumbers(unsigned int len)
-{
-
-}
-
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
-unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
-{
-
-}

makefile

@@ -29,21 +29,28 @@ 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_files): %.o: %.c
+$(program_obj_filesobj_files): %.o: %.c
 	$(CC) -c $(FLAGS) $^ -o $@
 
+numbers.o: numbers.c
+	$(CC) -c $(CFLAGS) numbers.c
+
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
-	echo "needs to be implemented"
+
+numbersTests: numbers.o numbersTests.c $(unityfolder)/unity.c
+	$(CC) $(CFLAGS) -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
 
 # --------------------------
 # Clean
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble
+	del /f *.o doble *.exe
 else
-	rm -f *.o doble
+	rm -f *.o doble *runNumbersTests
 endif

numbers.c

@@ -0,0 +1,98 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <stdbool.h>
+#include "numbers.h"
+
+//TODO: getDuplicate und createNumbers implementieren
+/*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
+  * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
+  * 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.
+unsigned int *createNumbers(unsigned int len)
+{
+    if (len < 2) {
+        // Mindestens zwei Elemente nötig, damit ein Duplikat existiert
+        return NULL;
+    }
+
+    unsigned int *numbers = malloc(len * sizeof(unsigned int));
+    if (!numbers) return NULL;
+
+    bool *used = calloc(2 * len + 1, sizeof(bool));
+    if (!used) {
+        free(numbers);
+        return NULL;
+    }
+
+    static int initialized = 0;
+    if (!initialized) {
+        srand((unsigned int)time(NULL));
+        initialized = 1;
+    }
+
+    // Einzigartige Zufallszahlen generieren
+    for (unsigned int i = 0; i < len - 1; ) {
+        unsigned int num = (rand() % (2 * len)) + 1;
+        if (!used[num]) {
+            used[num] = true;
+            numbers[i++] = num;
+        }
+    }
+
+    // Eine der Zahlen duplizieren
+    unsigned int duplicateIndex = rand() % (len - 1);
+    numbers[len - 1] = numbers[duplicateIndex];
+
+    // Fisher–Yates shuffle
+    for (unsigned int i = len - 1; i > 0; i--) {
+        unsigned int j = rand() % (i + 1);
+        unsigned int tmp = numbers[i];
+        numbers[i] = numbers[j];
+        numbers[j] = tmp;
+    }
+
+    free(used);
+    return numbers;
+}
+
+// Returns only the only number in numbers which is present twice. Returns zero on errors.
+unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
+{
+    if (numbers == NULL || len < 2) {
+        return 0;
+    }
+
+    unsigned int *sortedNumbers = malloc(len * sizeof(unsigned int));
+    if (sortedNumbers == NULL) {
+        return 0;
+    }
+    memcpy(sortedNumbers, numbers, len * sizeof(unsigned int));
+
+    // Einfacher bubble sort
+    for (unsigned int i = 0; i < len - 1; i++) {
+        for (unsigned int j = 0; j < len - i - 1; j++) {
+            if (sortedNumbers[j] > sortedNumbers[j + 1]) {
+                unsigned int temp = sortedNumbers[j];
+                sortedNumbers[j] = sortedNumbers[j + 1];
+                sortedNumbers[j + 1] = temp;
+            }
+        }
+    }
+
+    unsigned int duplicate = 0;
+    for (unsigned int i = 0; i < len - 1; i++) {
+        if (sortedNumbers[i] == sortedNumbers[i + 1]) {
+            duplicate = sortedNumbers[i];
+            break;
+        }
+    }
+
+    free(sortedNumbers);
+    return duplicate;
+}

numbersTests.c

@@ -0,0 +1,179 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "numbers.h"
+#include "unity.h"
+#include <stdbool.h>
+
+//Initialisierung
+void setUp(void){}
+void tearDown(void){}
+
+// Hilfsfunktion: zählt Vorkommen eines Werts
+static unsigned int countOccurrences(unsigned int* arr, unsigned int n, unsigned int value)
+{
+    unsigned int count = 0;
+    for (unsigned int i = 0; i < n; i++)
+        if (arr[i] == value)
+            count++;
+    return count;
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: createNumbers erzeugt ein Array der richtigen Größe
+// ---------------------------------------------------------------------------
+void test_createNumbers_returns_valid_array(void)
+{
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // Ein paar Werte prüfen (dürfen alles sein, nur kein Segfault)
+    for (unsigned int i = 0; i < n; i++)
+        TEST_ASSERT_TRUE(arr[i] >= 0);
+
+    free(arr);
+}
+
+// ---------------------------------------------------------------------------
+// Test 2: createNumbers erzeugt GENAU EIN Duplikat
+// ---------------------------------------------------------------------------
+void test_createNumbers_contains_exactly_one_duplicate(void)
+{
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // zähle wie viele Werte doppelt vorkommen
+    unsigned int duplicateValue = 0;
+    unsigned int totalDuplicateAppearances = 0;
+
+    for (unsigned int i = 0; i < n; i++)
+    {
+        unsigned int c = countOccurrences(arr, n, arr[i]);
+        if (c == 2)   // genau zweimal → Bestandteil des Duplikats
+        {
+            duplicateValue = arr[i];
+            totalDuplicateAppearances++;
+        }
+    }
+
+    // Wenn genau eine Zahl doppelt vorkommt,
+    // finden wir sie zweimal → totalDuplicateAppearances == 2
+    TEST_ASSERT_EQUAL_UINT(2, totalDuplicateAppearances);
+
+    free(arr);
+}
+// ---------------------------------------------------------------------------
+// Test 3: getDuplicated findet genau die richtige doppelte Zahl
+// ---------------------------------------------------------------------------
+void test_getDuplicated_finds_correct_duplicate(void)
+{
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // Ermittle das Duplikat manuell
+    unsigned int expected = 0;
+
+    for (unsigned int i = 0; i < n; i++)
+    {
+        if (countOccurrences(arr, n, arr[i]) == 2)
+        {
+            expected = arr[i];
+            break;
+        }
+    }
+
+    unsigned int result = getDuplicate(arr, n);
+
+    TEST_ASSERT_EQUAL_UINT(expected, result);
+
+    free(arr);
+}
+
+// ---------------------------------------------------------------------------
+// Hilfsfunktion: prüft ob createNumbers einen Fehlerzustand signalisiert
+// Du kannst diese später anpassen (z.B. wenn Fehler-Flags eingebaut werden)
+// ---------------------------------------------------------------------------
+static bool did_createNumbers_fail(unsigned int* ptr)
+{
+    return (ptr == NULL);   // aktuell: NULL bedeutet Fehler
+}
+
+
+// ---------------------------------------------------------------------------
+// Test: createNumbers soll bei count < 2 fehlschlagen
+// ---------------------------------------------------------------------------
+void test_createNumbers_rejects_too_small_counts(void)
+{
+    unsigned int* r1 = createNumbers(0);
+    unsigned int* r2 = createNumbers(1);
+
+    TEST_ASSERT_TRUE(did_createNumbers_fail(r1));
+    TEST_ASSERT_TRUE(did_createNumbers_fail(r2));
+}
+
+
+// ---------------------------------------------------------------------------
+// Test: createNumbers(2) soll funktionieren (Minimum gültiger Input)
+// ---------------------------------------------------------------------------
+void test_createNumbers_with_two_elements_is_valid(void)
+{
+    unsigned int* arr = createNumbers(2);
+
+    TEST_ASSERT_FALSE(did_createNumbers_fail(arr));
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // should contain exactly one duplicate
+    unsigned int c0 = countOccurrences(arr, 2, arr[0]);
+    unsigned int c1 = countOccurrences(arr, 2, arr[1]);
+
+    TEST_ASSERT_TRUE((c0 == 2) || (c1 == 2));
+
+    free(arr);
+}
+
+
+// ---------------------------------------------------------------------------
+// Test: getDuplicate() soll Fehler erkennen, wenn arr == NULL
+// ---------------------------------------------------------------------------
+void test_getDuplicate_handles_null_pointer(void)
+{
+    unsigned int result = getDuplicate(NULL, 10);
+// Erwartung: Fehlerzustand → aktuell vermutlich 0 oder UINT_MAX
+    // Wir prüfen nur, DASS es ein Fehler ist:
+    TEST_ASSERT_TRUE(result == 0 || result == UINT_MAX);
+}
+
+
+// ---------------------------------------------------------------------------
+// Test: getDuplicated) soll Fehler erkennen, wenn count < 2
+// ---------------------------------------------------------------------------
+void test_getDuplicate_handles_invalid_count(void)
+{
+    unsigned int dummy[1] = { 5 };
+
+    unsigned int result = getDuplicate(dummy, 1);
+
+    TEST_ASSERT_TRUE(result == 0 || result == UINT_MAX);
+}
+
+// ---------------------------------------------------------------------------
+// main() für Unity
+// ---------------------------------------------------------------------------
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_returns_valid_array);
+    RUN_TEST(test_createNumbers_contains_exactly_one_duplicate);
+    RUN_TEST(test_getDuplicated_finds_correct_duplicate);
+    RUN_TEST(test_createNumbers_rejects_too_small_counts);
+    RUN_TEST(test_createNumbers_with_two_elements_is_valid);
+    RUN_TEST(test_getDuplicate_handles_null_pointer);
+    RUN_TEST(test_getDuplicate_handles_invalid_count);
+
+    return UNITY_END();
+}

stack.c

@@ -10,7 +10,10 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
-
+    StackNode *top = malloc(sizeof(StackNode));
+    top->next= stack;
+    top->data= data;
+    return top;
 }
 
 // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be

stack.h

@@ -8,6 +8,11 @@ The latest element is taken from the stack. */
 #include <stdlib.h>
 
 //TODO: passenden Datentyp als struct anlegen
+typedef struct StackNode
+{
+    void *data;
+    struct StackNode *next;
+}StackNode;
 
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data);

stackTests.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "stack.h"
+#include "unity.h"
+
+//Initialisierung
+void setUp(void){}
+void tearDown(void){}
+
+void test_push_created_new_stacknode(void)
+{
+    StackNode test = {111,NULL};
+    int testdata = 222;
+    void *data =&testdata;
+
+    StackNode test1 = push(&test,data);
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // Ein paar Werte prüfen (dürfen alles sein, nur kein Segfault)
+    for (unsigned int i = 0; i < n; i++)
+        TEST_ASSERT_TRUE(arr[i] >= 0);
+
+    free(arr);
+}
+
+
+
+
+
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_returns_valid_array);
+    RUN_TEST(test_createNumbers_contains_exactly_one_duplicate);
+    RUN_TEST(test_getDuplicated_finds_correct_duplicate);
+
+    return UNITY_END();
+}