From adaf02803c71e1afcdc2b44f7352a6503d1d28e5 Mon Sep 17 00:00:00 2001
From: Jakob <hofmannja99210@th-nuernberg.de>
Date: Wed, 3 Dec 2025 14:10:36 +0100
Subject: [PATCH] anfang unit tests

---
 makefile        |  4 +--
 numbers.c       | 35 ++++++++++++++++++++------
 numbers.h       |  2 +-
 test__numbers.c | 67 ++++++++++++++++++++++++++++++++++++-------------
 4 files changed, 80 insertions(+), 28 deletions(-)

diff --git a/makefile b/makefile
index 1f15f75..18aaf7e 100644
--- a/makefile
+++ b/makefile
@@ -35,8 +35,8 @@ $(program_obj_filesobj_files): %.o: %.c
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
-	echo "needs to be implemented"
+
+
 
 # --------------------------
 # Clean
diff --git a/numbers.c b/numbers.c
index f3d8d50..61ddf4d 100644
--- a/numbers.c
+++ b/numbers.c
@@ -17,12 +17,13 @@ unsigned int RANDOM_SEED = 0;
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.
 
-unsigned int setSeed(seed)
+unsigned int setSeed(unsigned int seed)
 {
   RANDOM_SEED = seed;
+  return RANDOM_SEED;
 }
 
-unsigned int createchecknumber(unsigned int len, unsigned int *numbers)
+void createchecknumber(unsigned int len, unsigned int numbers[])
 {
   for (unsigned int i = 0; i < len; i++)
   {
@@ -67,7 +68,7 @@ unsigned int *createNumbers(unsigned int len)
   unsigned int *numbers = malloc(sizeof(unsigned int) * len);
   if (numbers == NULL)
   {
-    return NULL;
+    return 0;
   }
 
   createchecknumber(len, numbers);
@@ -86,9 +87,12 @@ unsigned int *createNumbers(unsigned int len)
   } while (i == j);
 
   numbers[i] = numbers[j];
+
+  return numbers;
+
 }
 
-unsigned int *sortnumbers(unsigned int numbers[], unsigned int len)
+void sortnumbers(unsigned int numbers[], unsigned int len)
 {
   for (unsigned int j = 0; j < len - 1; j++)
   {
@@ -103,20 +107,35 @@ unsigned int *sortnumbers(unsigned int numbers[], unsigned int len)
       }
     }
   }
-  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)
 {
-  sortnumbers(numbers, len);
+  unsigned int *copynumbers = malloc(sizeof(unsigned int) * len);
+  if (copynumbers == NULL)
+  {
+    return 0;
+  }
+
+  for (unsigned int i = 0; i < len; i++)
+  {
+    copynumbers[i] = numbers[i];
+  }
+
+  sortnumbers(copynumbers, len);
 
   for (unsigned i = 0; i < len - 1; i++)
   {
-    if (numbers[i] == numbers[i+1])
+    if (copynumbers[i] == copynumbers[i+1])
     {
-      return numbers[i];
+      unsigned int a = copynumbers[i];
+      free (copynumbers);
+      return a;
     }
   }
+
+  free (copynumbers);
+
   return 0;
 }
diff --git a/numbers.h b/numbers.h
index ee567c9..f5d44d8 100644
--- a/numbers.h
+++ b/numbers.h
@@ -7,7 +7,7 @@ extern unsigned int RANDOM_SEED;
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.
 
-unsigned int setSeed(seed);
+unsigned int setSeed(unsigned int seed);
 
 unsigned int *createNumbers(unsigned int len);
 //funktion mit srand(time)
diff --git a/test__numbers.c b/test__numbers.c
index a6ba333..f8df0f8 100644
--- a/test__numbers.c
+++ b/test__numbers.c
@@ -1,40 +1,73 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
+#include "unity/unity.h"
 #include "numbers.h"
 
-void test_enough_numbers() {
+void test_length_and_duplicate()
+{
     setSeed(1);
-    unsigned int len = 20;
-    unsigned int *numbers = createNumbers(len);
+    unsigned int len = 10;
+    unsigned int *test_numbers = createNumbers(len);
 
-    if(numbers == NULL)
+    if (test_numbers == NULL)
     {
         return;
     }
 
+    /*
+    setSeed(1);
+    unsigned int len = 10;
+    unsigned int *test_numbers = createNumbers(len);
 
-    free(numbers);
+    if (test_numbers == NULL)
+    {
+        return;
+    }
+
+    unsigned int expected[10] = {20, 8, 13, 19, 17, 16, 12, 0, 15, 14};
+
+    for (unsigned int i = 0; i < len; i++)
+    {
+        if (test_numbers[i] != expected[i])
+        {
+            free(test_numbers);
+            return;
+        }
+    }
+
+    free(test_numbers);
+    */
 }
 
-void test_no_duplicates_except_one() {
+void test_duplicate_value()
+{
+    unsigned int test_numbers[6] = {1, 2, 3, 4, 5, 5};
+    unsigned int dupli = 0;
+
+    dupli = getDuplicate(test_numbers, 6);
+
+    TEST_ASSERT_EQUAL(5, dupli);
 
 }
 
-void test_is_duplicated() {
+void test_duplicate_value_if_false()
+{
+    unsigned int test_numbers[6] = {1, 2, 3, 4, 5, 6};
+    unsigned int dupli = 0;
+
+    dupli = getDuplicate(test_numbers, 6);
+
+    TEST_ASSERT_EQUAL(0, dupli);
 
 }
 
-int main(void) {
+int main(void)
+{
     UNITY_BEGIN();
 
-    RUN_TEST(test_enough_numbers);
-    RUN_TEST(test_is_duplicated);
-    RUN_TEST(test_no_duplicates_except_one);
-
-    int result = UNITY_END();
-    print_test_result(result);
-
-    return result;
+    RUN_TEST(test_length_and_duplicate);
+    RUN_TEST(test_duplicate_value);
+    RUN_TEST(test_duplicate_value_if_false);
+    return UNITY_END();
 }
-