Fertig

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;

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

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

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

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);
+		srand(time(NULL));
-	numbers[duplicate] = numbers[duplicateIdx];
+		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;
 }
 

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;
     }