diff --git a/bintree.c b/bintree.c
index f8a8321..2c166c9 100644
--- a/bintree.c
+++ b/bintree.c
@@ -12,7 +12,7 @@ static StackNode *stack = NULL;
 
 	TreeNode* createNode(const void *data, size_t dataSize) {
 		TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
-		if (newNode == NULL) {
+		if (!newNode) {
 			// Fehlerbehandlung: Speicher konnte nicht alloziiert werden
 			return NULL;
 		}
@@ -82,7 +82,7 @@ void *nextTreeData(TreeNode *root)
 		if (stack == NULL) {
 			return NULL;
 		}
-		TreeNode *node = (TreeNode*) top(stack);
+		const TreeNode *node = top(stack);
 		stack = pop(stack);
 
 		TreeNode *right = node->right;
diff --git a/bintree.o b/bintree.o
new file mode 100644
index 0000000..01ca21d
Binary files /dev/null and b/bintree.o differ
diff --git a/bintree_tests.c b/bintree_tests.c
index 8b13789..a307225 100644
--- a/bintree_tests.c
+++ b/bintree_tests.c
@@ -1 +1,164 @@
+#include "bintree.h"
+#include "numbers.h"
+#include <stdio.h>
 
+
+void createTreeTest()
+{
+  TreeNode* root = NULL;
+  int data1 = 1;
+      int data2 = 2;
+      int data3 = 3;
+      int data4 = 4;
+      int data5 = 5;
+      int dataDup = 4;
+      int isDuplicate = 0;
+      int passedTests = 0;
+
+  root = addToTree(root,&data3, sizeof(int),compareFct,&isDuplicate);
+  if(*(int*) root->data == data3 && isDuplicate == 0)
+       {       passedTests++;
+  printf("PASS1\n");}
+
+  root = addToTree(root,&data4, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data5, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data2, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data1, sizeof(int),compareFct,&isDuplicate);
+  if(*(int*) root->data == data3 && *(int*) root->left->left->data == data1 && *(int*)root->left->data == data2 && *(int*)root->right->right->data == data5 && *(int*)root->right->data == data4 && isDuplicate == 0)
+    {passedTests++;
+      printf("PASS2\n");
+      }
+  root = addToTree(root,&dataDup, sizeof(int),compareFct,&isDuplicate);
+  if(isDuplicate == 1)
+    {passedTests++;
+    printf("PASS3\n");}
+
+  if(passedTests == 3)
+    printf("PASS");
+  else
+    printf("FAIL");
+  printf("passedTests: %d\n", passedTests);
+  printf(" CreateBinTreeTest\n");
+  clearTree(root);
+}
+void binTreeSizeTest()
+    {
+  TreeNode* root = NULL;
+  int data1 = 1;
+  int data2 = 2;
+  int data3 = 3;
+  int data4 = 4;
+  int data5 = 5;
+  int isDuplicate = 0;
+
+
+  root = addToTree(root,&data3, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data4, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data5, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data2, sizeof(int),compareFct,&isDuplicate);
+  root = addToTree(root,&data1, sizeof(int),compareFct,&isDuplicate);
+  if(treeSize(root) == 5)
+    printf("PASS");
+  else
+    printf("FAIL");
+  printf(" CreateBinTreeSizeTest\n");
+    clearTree(root);
+  }
+
+ void nextTreeDataTest()
+{
+    printf("Starte nextTreeDataTest \n");
+    TreeNode* root = NULL;
+    int data1 = 1;
+    int data2 = 2;
+    int data3 = 3;
+    int data4 = 4;
+    int isDuplicate = 0;
+    int data5 = 5;
+
+    // Baum aufbauen
+    root = addToTree(root, &data3, sizeof(int), compareFct, &isDuplicate);
+    root = addToTree(root, &data4, sizeof(int), compareFct, &isDuplicate);
+    root = addToTree(root, &data5, sizeof(int), compareFct, &isDuplicate);
+    root = addToTree(root, &data2, sizeof(int), compareFct, &isDuplicate);
+    root = addToTree(root, &data1, sizeof(int), compareFct, &isDuplicate);
+
+    void* receivedData;
+    int expectedValue;
+    int testPassed = 1; // Flag, um den Gesamtstatus zu verfolgen
+
+    // Test 1: Erster Aufruf mit root
+    expectedValue = 1;
+    receivedData = nextTreeData(root);
+    if (receivedData != NULL && *(int*)receivedData == expectedValue) {
+
+    } else {
+
+        testPassed = 0;
+    }
+
+    // Test 2: Zweiter Wert
+    expectedValue = 2;
+    receivedData = nextTreeData(NULL);
+    if (receivedData != NULL && *(int*)receivedData == expectedValue) {
+
+    } else {
+
+        testPassed = 0;
+    }
+
+    // Test 3: Dritter Wert
+    expectedValue = 3;
+    receivedData = nextTreeData(NULL);
+    if (receivedData != NULL && *(int*)receivedData == expectedValue) {
+
+    } else {
+
+        testPassed = 0;
+    }
+
+    // Test 4: Vierter Wert
+    expectedValue = 4;
+    receivedData = nextTreeData(NULL);
+    if (receivedData != NULL && *(int*)receivedData == expectedValue) {
+
+    } else {
+
+        testPassed = 0;
+    }
+
+    // Test 5: Fünfter Wert
+    expectedValue = 5;
+    receivedData = nextTreeData(NULL);
+    if (receivedData != NULL && *(int*)receivedData == expectedValue) {
+
+    } else {
+        testPassed = 0;
+    }
+
+    // Test 6: Kein weiterer Wert erwartet
+    receivedData = nextTreeData(NULL);
+    if (receivedData == NULL) {
+
+    } else {
+
+        testPassed = 0;
+    }
+
+    if (testPassed) {
+        printf("PASS");
+    } else {
+        printf("FAIL");
+    }
+    clearTree(root);
+}
+
+
+
+int main()
+  {
+      nextTreeDataTest();
+      createTreeTest();
+      binTreeSizeTest();
+      return 0;
+  }
diff --git a/doble.exe b/doble.exe
new file mode 100644
index 0000000..b486d68
Binary files /dev/null and b/doble.exe differ
diff --git a/highscore.o b/highscore.o
new file mode 100644
index 0000000..e9b31f1
Binary files /dev/null and b/highscore.o differ
diff --git a/highscores.txt b/highscores.txt
index 8b13789..63db366 100644
--- a/highscores.txt
+++ b/highscores.txt
@@ -1 +1,10 @@
-
+test;11955
+test;9982
+test;9978
+test;9975
+test;9974
+test;9967
+test;9962
+test;9960
+test;9949
+test;9902
diff --git a/main.o b/main.o
new file mode 100644
index 0000000..a5219de
Binary files /dev/null and b/main.o differ
diff --git a/makefile b/makefile
index c77b9f5..a57b536 100644
--- a/makefile
+++ b/makefile
@@ -39,12 +39,14 @@ stackTests: stack.o test_stack.c $(unity_strc)
 		$(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runStackTests
 numbersTests: numbers.o bintree.o stack.o test_numbers.c $(unity_strc)
 		$(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runNumbersTests
+binTreeTests: numbers.o bintree.o bintree_tests.c $(unity_strc) stack.o
+		$(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runBinTreeTests
 # --------------------------
 # Clean
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble doble_initial runStackTests runNumbersTests
+	del /f *.o doble doble_initial runStackTests runNumbersTests runBinTreeTests
 else
-	rm -f *.o doble doble_initial runStackTests runNumbersTests
+	rm -f *.o doble doble_initial runStackTests runNumbersTests runBinTreeTests
 endif
\ No newline at end of file
diff --git a/numbers.c b/numbers.c
index 56ac257..e58161e 100644
--- a/numbers.c
+++ b/numbers.c
@@ -25,6 +25,8 @@ unsigned int *createNumbers(unsigned int len)
 	TreeNode *root = NULL;
 	srand(time(NULL));
 	unsigned int *numbers = malloc(sizeof(unsigned int)*len);
+	unsigned int duplicate = 0;
+	unsigned int duplicateIdx = 0;
 	int counter = 0;
 	while (treeSize(root) < len) {
 		unsigned int num = rand()%(2*len)+1;
@@ -35,9 +37,17 @@ unsigned int *createNumbers(unsigned int len)
 			counter++;
 		}
 	}
-	unsigned int duplicate = rand()%(len);
-	unsigned int duplicateIdx = rand()%(len);
-	numbers[duplicate] = numbers[duplicateIdx];
+
+		srand(time(NULL));
+		duplicate = rand()%(len);
+		duplicateIdx = rand()%(len);
+
+	while (duplicateIdx == duplicate || duplicateIdx == duplicate+1 || duplicateIdx == duplicate-1) {
+		srand(time(NULL));
+		duplicateIdx = rand()%(len);
+	}
+	numbers[duplicateIdx] = numbers[duplicate];
+	clearTree(root);
 	return numbers;
 }
 
diff --git a/numbers.o b/numbers.o
new file mode 100644
index 0000000..be54845
Binary files /dev/null and b/numbers.o differ
diff --git a/runBinTreeTests.exe b/runBinTreeTests.exe
new file mode 100644
index 0000000..6f89061
Binary files /dev/null and b/runBinTreeTests.exe differ
diff --git a/runNumbersTests.exe b/runNumbersTests.exe
new file mode 100644
index 0000000..cdc8335
Binary files /dev/null and b/runNumbersTests.exe differ
diff --git a/stack.c b/stack.c
index 98beac3..ad95163 100644
--- a/stack.c
+++ b/stack.c
@@ -13,10 +13,10 @@ StackNode *push(StackNode *stack, void *data)
 
 
     // 1. Einen neuen StackNode erstellen
-    StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));
+    StackNode* newNode = malloc(sizeof(StackNode));
 
     // Überprüfen, ob die Speicherreservierung erfolgreich war
-    if (newNode == NULL)
+    if (!newNode)
     {
         // Wenn malloc fehlschlägt, geben wir NULL zurück, um einen Fehler anzuzeigen.
         return NULL;
@@ -68,7 +68,7 @@ StackNode *pop(StackNode *stack)
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
-    if (stack == NULL)
+    if (!stack)
     {
         return NULL;
     }
diff --git a/stack.o b/stack.o
index 13ef785..6ea9464 100644
Binary files a/stack.o and b/stack.o differ
diff --git a/timer.o b/timer.o
new file mode 100644
index 0000000..5af0f96
Binary files /dev/null and b/timer.o differ