small fixes

stack.c

@@ -7,15 +7,11 @@
     * `top`: liefert das oberste Element zurück,
     * `clearStack`: gibt den gesamten Speicher frei. */
         
-/*typedef struct Stack{
-    void *data;   Zeiger auf den Nutzerdaten
-    struct Stack *next;     Zeiger auf den Eintrag drunter
-} StackNode;        Stack oder StackNode kann beides als Namen für struct verwendet werden*/  
- // stack->next --> greift auf Struct zu und zeigt auf dann auf next       
 
 // Pushes data as pointer onto the stack.
-// *stack ist Zeiger auf neustes oberste Element im Stack (wird zurückgegeben)
+// *stack zeiger auf das ganze konstrukt
-// *data soll gepusht werden
+// *data soll oben drauf gepusht werden; daten die davor drin waren werden runtergeschoben
+// stack wird zurückgegeben
 StackNode *push(StackNode *stack, void *data)
 {
     if(data != NULL)
@@ -42,18 +38,20 @@ StackNode *push(StackNode *stack, void *data)
 
 // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
 // freed by caller.)
+// data wird entfernt-> next wird der neue stack
 StackNode *pop(StackNode *stack)
 {
     if(stack != NULL)
     {
-        StackNode *nextNode = stack->next;
+        StackNode *nextNode = stack->next; //zeiger der auf next zeigt da der Kopf entfernt wird
         free(stack);
-        stack = nextNode;
+        stack = nextNode; //next wird der neue stack
     }
     return stack;
 }
 
 // Returns the data of the top element.
+// gibt das oberste Element aus (data)
 void *top(StackNode *stack)
 {
     if(stack == 0)

stack.h

@@ -9,8 +9,8 @@ The latest element is taken from the stack. */
 
 //TODO: passenden Datentyp als struct anlegen
 typedef struct Stack{
-    void *data;
+    void *data; //zeiger auf variable
-    struct Stack *next;
+    struct Stack *next; // zeiger auf ein weiteres stack (data und next)
 } StackNode;
 
 // Pushes data as pointer onto the stack.

stackunitytest.c

@@ -10,14 +10,17 @@ void tearDown(void)
 {
 
 }
-
+// 1. Test: push wenn data NULL ist -> stack bleibt NULL
 void test_push_data_NULL(void)
 {
     int test = 30;
     StackNode *stack = NULL;
     //data = NULL -> stack bleibt NULL
     TEST_ASSERT_NULL(push(NULL,NULL));
+    clearStack(stack);
 }
+
+// 2. Test: push data ungleich NULL -> data wird erneuert und next bleibt NULL
 void test_push_erster_push(void)
 {
     int test = 20;
@@ -28,7 +31,10 @@ void test_push_erster_push(void)
     TEST_ASSERT_EQUAL_PTR(&test, stack->data);
     TEST_ASSERT_EQUAL_MEMORY(&expected, stack, sizeof(StackNode));
     TEST_ASSERT_NULL(stack->next);
+    clearStack(stack);
 }
+
+//3. Test: zweimal pushen -> data wird zur zweiten Variable; next wird zur ersten
 void test_push_zweiter_push(void)
 {
     int test = 20;
@@ -41,7 +47,10 @@ void test_push_zweiter_push(void)
     TEST_ASSERT_NOT_NULL(stack->next);
     TEST_ASSERT_EQUAL_PTR(&test, stack->next->data);
     TEST_ASSERT_NULL(stack->next->next);
+    clearStack(stack);
 }
+
+// 4. Test: dreimal pushen -> data wird zur dritten variable; next zur zweiten; zweiter next zur dritten
 void test_push_dritter_push(void)
 {
     int test = 20;
@@ -58,9 +67,33 @@ void test_push_dritter_push(void)
     TEST_ASSERT_NOT_NULL(stack->next->next);
     TEST_ASSERT_EQUAL_PTR(&test, stack->next->next->data);
     TEST_ASSERT_NULL(stack->next->next->next);
+    clearStack(stack);
 }
 
-void test_pop_Stack_ungleich_NULL_zwei_pushes(void)
+
+// 5. Test: pop wenn Stack gleich NULL -> Stack bleibt NULL
+void test_pop_stack_gleich_NULL(void)
+{
+    StackNode *stack = NULL;
+    stack = pop(stack);
+    TEST_ASSERT_NULL(stack);
+    clearStack(stack);
+}
+
+
+// 6. Test: pop mit einer Node -> Stack wird wieder NULL
+void test_pop_Stack_ungleich_NULL_eine_Node(void)
+{
+    int test = 20;
+    StackNode *stack = NULL;
+    stack = push(stack, &test);
+    stack = pop(stack);
+    TEST_ASSERT_NULL(stack);
+    clearStack(stack);
+}
+
+// 7. Test: pop mit zwei Nodes -> data wird zur ersten Variable; next wird Null
+void test_pop_Stack_ungleich_NULL_zwei_Nodes(void)
 {
     int test = 20;
     StackNode *stack = NULL;
@@ -71,9 +104,12 @@ void test_pop_Stack_ungleich_NULL_zwei_pushes(void)
     TEST_ASSERT_NOT_NULL(stack);
     TEST_ASSERT_EQUAL_PTR(&test, stack->data);
     TEST_ASSERT_NULL(stack->next);
+    clearStack(stack);
 }
 
-void test_pop_Stack_ungleich_NULL_drei_pushes(void)
+
+// 8. Test: pop mikt drei Nodes -> data wird zur zweiten Variable; next zur ersten; next von next wird NULL
+void test_pop_Stack_ungleich_NULL_drei_Nodes(void)
 {
     int test = 20;
     StackNode *stack = NULL;
@@ -88,15 +124,59 @@ void test_pop_Stack_ungleich_NULL_drei_pushes(void)
     TEST_ASSERT_NOT_NULL(stack->next);
     TEST_ASSERT_EQUAL_PTR(&test, stack->next->data);
     TEST_ASSERT_NULL(stack->next->next);
+    clearStack(stack);
 }
 
-void test_pop_stack_gleich_NULL(void)
+
+// 9. Test: top wenn stack gleich NULL -> gibt null zurück
+void test_top_stack_gleich_NULL(void)
 {
     StackNode *stack = NULL;
-    stack = pop(stack);
     TEST_ASSERT_NULL(stack);
+    clearStack(stack);
 }
 
+
+// 10. Test: top wenn eine Node -> gibt erste Variable aus
+void test_top_stack_ungleich_NULL_eine_Node(void)
+{
+    int test = 20;
+    StackNode *stack = NULL;
+    stack = push(stack, &test);
+    TEST_ASSERT_EQUAL_PTR(&test, top(stack));
+    clearStack(stack);
+}
+
+
+// 11. Test: top bei zwei Nodes -> gibt zweite Variable aus
+void test_top_stack_ungleich_NULL_zwei_Node(void)
+{
+    int test = 20;
+    StackNode *stack = NULL;
+    stack = push(stack, &test);
+    int test2 = 40;
+    stack = push(stack, &test2);
+    TEST_ASSERT_EQUAL_PTR(&test2, top(stack));
+    clearStack(stack);
+}
+
+
+// 12. Test: top bei drei Nodes -> gibt dritte Variable
+void test_top_stack_ungleich_NULL_drei_Node(void)
+{
+    int test = 20;
+    StackNode *stack = NULL;
+    stack = push(stack, &test);
+    int test2 = 40;
+    stack = push(stack, &test2);
+    int test3 = 60;
+    stack = push(stack, &test3);
+    TEST_ASSERT_EQUAL_PTR(&test3, top(stack));
+    clearStack(stack);
+}
+
+
+
 int main(void)
 {
     UNITY_BEGIN();
@@ -105,8 +185,13 @@ int main(void)
     RUN_TEST(test_push_zweiter_push);
     RUN_TEST(test_push_dritter_push);
     RUN_TEST(test_pop_stack_gleich_NULL);
-    RUN_TEST(test_pop_Stack_ungleich_NULL_zwei_pushes);
+    RUN_TEST(test_pop_Stack_ungleich_NULL_eine_Node);
-    RUN_TEST(test_pop_Stack_ungleich_NULL_drei_pushes);
+    RUN_TEST(test_pop_Stack_ungleich_NULL_zwei_Nodes);
+    RUN_TEST(test_pop_Stack_ungleich_NULL_drei_Nodes);
+    RUN_TEST(test_top_stack_gleich_NULL);
+    RUN_TEST(test_top_stack_ungleich_NULL_eine_Node);
+    RUN_TEST(test_top_stack_ungleich_NULL_zwei_Node);
+    RUN_TEST(test_top_stack_ungleich_NULL_drei_Node);
 
     return UNITY_END();
 }