push test im teststack verbessert

bintree.c

@@ -70,11 +70,14 @@ void *nextTreeData(TreeNode *root) {
 
     TreeNode *curr = root;
     while (curr != NULL) {
-      stack = push(stack, curr);
+      StackNode *oldStack = stack;
+      StackNode *newStack = push(stack, curr);
+      if (newStack == oldStack)
+        return NULL; // push fehlgeschlagen
+      stack = newStack;
       curr = curr->left;
     }
   }
-
   if (stack == NULL)
     return NULL; // alles durchlaufen
 
@@ -85,10 +88,13 @@ void *nextTreeData(TreeNode *root) {
   // Rechten Teilbaum pushen
   TreeNode *curr = node->right;
   while (curr != NULL) {
-    stack = push(stack, curr);
+    StackNode *oldStack = stack;
+    StackNode *newStack = push(stack, curr);
+    if (newStack == oldStack)
+      return NULL; // push fehlgeschlagen
+    stack = newStack;
     curr = curr->left;
   }
-
   return node->data;
 }
 

highscores.txt

@@ -1,7 +1,10 @@
+Kristin;9944
+Kristin;7947
 Kristin;6962
 Kristin;5975
 krisp;4986
 krisp;4985
 Kristin;4972
 player1;3999
+Kristin;3992
 krisp;3991

stack.c

@@ -6,6 +6,7 @@
 
   void *data;
   struct StackNode *next;
+  struct StackNode *prev;
 
 } StackNode;*/
 
@@ -16,12 +17,13 @@
  * `clearStack`: gibt den gesamten Speicher frei. */
 
 // [A] -> [B] -> [C] -> NULL
-// head -> stack.next
+// stack -> stack.next
 
+// Funktion zum erstellen neuer nodes
 StackNode *createNode(void *data) {
-
+  // Speicher reservieren
   StackNode *node = malloc(sizeof(StackNode));
-
+  // Speicher konnte nicht reserviert werden
   if (node == NULL)
     return NULL;
 
@@ -37,46 +39,57 @@ StackNode *push(StackNode *stack, void *data) {
 
   StackNode *newNode = createNode(data);
 
+  // Fehler beim Reservieren des Speichers, stack wird unverändert zurückgegeben
   if (newNode == NULL) {
     return stack;
   }
 
+  // der aktuelle Kopf wird der nächste Node
   newNode->next = stack;
+
+  // bisheriger Kopf bekommt Pointer auf oberstes Element
   if (stack != NULL) {
     stack->prev = newNode;
   }
 
-  return newNode;
+  return newNode; // neuer Kopf wird zurückgegeben
 }
 
 // Deletes the top element of the stack (latest added element) and releases its
 // memory. (Pointer to data has to be freed by caller.)
 StackNode *pop(StackNode *stack) {
 
+  // Stack ohne Elemente
   if (stack == NULL)
     return NULL;
 
+  // Element unter Kopf wird als nextNode gespeichert
   StackNode *nextNode = stack->next;
   if (nextNode != NULL) {
-    nextNode->prev = NULL;
+    nextNode->prev = NULL; // der Zeiger zum Kopf wird auf NULL gesetzt
   }
 
   free(stack);
 
-  stack = NULL;
+  stack = NULL; // Speicher des Kopfes freigeben
 
-  return nextNode;
+  return nextNode; // neuen Kopf zurückgeben
 }
 
 // Returns the data of the top element.
-void *top(StackNode *stack) { return stack ? stack->data : NULL; }
+void *top(StackNode *stack) {
+  // wenn stack leer ist, wird NULL zurückgegeben
+  // Zeiger auf Daten des obersten Elements
+  return stack ? stack->data : NULL;
+}
 
 // Clears stack and releases all memory.
-void clearStack(StackNode **stack) {
+void clearStack(StackNode **stack) { // Zeiger auf den Zeiger auf den Stackkopf
-
+  // verändert den Zeiger selbst, mit *stack lokale Kopie
+  // im Aufruf &stack verwenden
   while (*stack != NULL) {
-    StackNode *next = (*stack)->next;
+    StackNode *next = (*stack)->next; // nächstes Element speichern
-    free(*stack);
+    free(*stack);                     // aktuelles Element freigeben
-    *stack = next;
+    *stack = next;                    // Zeiger auf nächsten Knoten setzen
   }
 }

test_stack.c

@@ -5,31 +5,62 @@
 
 #include "stack.h"
 
+// StackNode *createNode(void *data) testen
 void test_createNode(void) {
 
   int testInt = 26;
-  StackNode *testNode = createNode(&testInt);
+  StackNode *testNode = createNode(&testInt); // Adresse des testInts
 
-  TEST_ASSERT_NOT_NULL(testNode);
+  TEST_ASSERT_NOT_NULL(
-  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data);
+      testNode); // Speicher konnte reserviert werden, malloc ist nicht NULL
-  TEST_ASSERT_NULL(testNode->next);
+  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data); // data pointer gesetzt
+  TEST_ASSERT_NULL(testNode->next); // vorheriger und nächster Eintrag NULL
   TEST_ASSERT_NULL(testNode->prev);
 
-  free(testNode);
+  free(testNode); // Speicher freigeben
 }
 
+// StackNode *push(StackNode *stack, void *data) testen
 void test_pushDataToStack(void) {
 
-  int testInt = 27;
+  int testInts[] = {27, 28};
 
-  StackNode *testNode = push(NULL, &testInt);
+  StackNode *testStack = NULL; // leeren testStack initialisieren
 
-  TEST_ASSERT_NOT_NULL(testNode);
+  testStack =
-  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data);
+      push(testStack, &testInts[0]); // leerer Stack mit Adresse des testInts
-  TEST_ASSERT_NULL(testNode->next);
-  TEST_ASSERT_NULL(testNode->prev);
 
-  free(testNode);
+  TEST_ASSERT_NOT_NULL(testStack); // im Fehlerfall wird testStack unverändert
+                                   // zurückgegeben -> bei Fehler NULL
+  TEST_ASSERT_EQUAL_PTR(&testInts[0], testStack->data); // data pointer gesetzt
+  TEST_ASSERT_NULL(testStack->next); // vorheriger und nächster pointer auf NULL
+                                     // gesetzt, da es nur einen Knoten gibt
+  TEST_ASSERT_NULL(testStack->prev);
+
+  // zweiter Push
+  StackNode *oldHead = testStack;
+
+  testStack = push(testStack, &testInts[1]);
+
+  TEST_ASSERT_NOT_NULL(testStack);
+  TEST_ASSERT_NOT_EQUAL(
+      oldHead,
+      testStack); // bei malloc Fehler wird der head unverändert zurückgegeben
+
+  TEST_ASSERT_EQUAL_PTR(&testInts[0],
+                        oldHead->data); // data pointer wurden richtig gesetzt
+  TEST_ASSERT_EQUAL_PTR(&testInts[1], testStack->data);
+
+  TEST_ASSERT_EQUAL_PTR(oldHead, testStack->next);
+  TEST_ASSERT_EQUAL_PTR(testStack, oldHead->prev);
+  TEST_ASSERT_NULL(testStack->prev);
+
+  // Speicherfreigabe
+  testStack->next = NULL;
+  oldHead->prev = NULL;
+
+  free(oldHead);
+  free(testStack);
 }
 
 void test_deleteTopElement(void) {