weitere test funktionen bearbeitet

stack.c

@@ -10,24 +10,54 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
+    // Neues Stack-Element erstellen
+    StackNode *newNode = malloc(sizeof(StackNode));
+    if (!newNode) {
+        return stack; // oder NULL, je nach Fehlerstrategie
+    }
 
+    
+    newNode->data = data;
+    newNode->next = stack; // bisheriger Stack wird nach unten geschoben
+
+    return newNode; // neuer Kopf des Stacks
 }
 
 // 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)
 {
+   if (stack == NULL)
+        return NULL;
 
+    StackNode *newTop = stack->next;
+
+    // Daten gehen verloren!
+    // Caller KANN sie nicht freigeben.
+    free(stack);
+
+    return newTop;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
+    if (stack == NULL)
+        return NULL;   // kein Element im Stack
 
+    return stack->data;
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
+    StackNode *current = stack;
+
+    while (current != NULL) 
+    {
+        StackNode *next = current->next;
+        free(current);
+        current = next;
+    }
 
 }

stack.h

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

test_stack.c

@@ -0,0 +1,78 @@
+#include <stdlib.h>
+#include "stack.h"
+#include "unity.h"
+
+void test_push_and_top(void);
+
+void test_pop(void);
+
+void test_clearStack(void);
+
+void setUp(void) {}
+
+void tearDown(void) {}
+
+
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_push_and_top);
+    RUN_TEST(test_pop);
+    RUN_TEST(test_clearStack);
+
+    return UNITY_END();
+}
+
+
+void test_push_and_top(void)
+{
+    StackNode *stack = NULL;
+
+    int a = 10;
+    int b = 20;
+    int c = 30;
+
+    stack = push(stack, &a);
+    stack = push(stack, &b);
+    stack = push(stack, &c);
+
+    TEST_ASSERT_EQUAL_INT(30, *(int*)top(stack));
+
+    clearStack(&stack);
+    TEST_ASSERT_NULL(stack);
+}
+
+void test_pop(void)
+{
+    StackNode *stack = NULL;
+
+    int x = 111;
+    int y = 222;
+
+    stack = push(stack, &x);
+    stack = push(stack, &y);
+
+    // pop removes y
+    stack = pop(stack);
+    TEST_ASSERT_EQUAL_INT(111, *(int*)top(stack));
+
+    // pop removes x
+    stack = pop(stack);
+    TEST_ASSERT_NULL(stack);
+}
+
+void test_clearStack(void)
+{
+    StackNode *stack = NULL;
+
+    int x = 5;
+    int y = 6;
+
+    stack = push(stack, &x);
+    stack = push(stack, &y);
+
+    clearStack(&stack);
+
+    TEST_ASSERT_NULL(stack);
+}