unity test fertig geschrieben

stack.c

@@ -7,14 +7,9 @@
     * `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)
+// *ist das ganze konstrukt
 // *data soll gepusht werden
 StackNode *push(StackNode *stack, void *data)
 {
@@ -46,9 +41,9 @@ 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;
 }

stackunitytest.c

@@ -10,7 +10,7 @@ void tearDown(void)
 {
 
 }
-
+// 1. Test: push wenn data NULL ist -> stack bleibt NULL
 void test_push_data_NULL(void)
 {
     int test = 30;
@@ -18,6 +18,8 @@ void test_push_data_NULL(void)
     //data = NULL -> stack bleibt NULL
     TEST_ASSERT_NULL(push(NULL,NULL));
 }
+
+// 2. Test: push data ungleich NULL -> data wird erneuert und next bleibt NULL
 void test_push_erster_push(void)
 {
     int test = 20;
@@ -29,6 +31,8 @@ void test_push_erster_push(void)
     TEST_ASSERT_EQUAL_MEMORY(&expected, stack, sizeof(StackNode));
     TEST_ASSERT_NULL(stack->next);
 }
+
+//3. Test: zweimal pushen -> data wird zur zweiten Variable; next wird zur ersten
 void test_push_zweiter_push(void)
 {
     int test = 20;
@@ -42,6 +46,8 @@ void test_push_zweiter_push(void)
     TEST_ASSERT_EQUAL_PTR(&test, stack->next->data);
     TEST_ASSERT_NULL(stack->next->next);
 }
+
+// 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;
@@ -60,7 +66,28 @@ void test_push_dritter_push(void)
     TEST_ASSERT_NULL(stack->next->next->next);
 }
 
-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);
+}
+
+
+// 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);
+}
+
+// 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;
@@ -73,7 +100,9 @@ void test_pop_Stack_ungleich_NULL_zwei_pushes(void)
     TEST_ASSERT_NULL(stack->next);
 }
 
-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;
@@ -90,13 +119,52 @@ void test_pop_Stack_ungleich_NULL_drei_pushes(void)
     TEST_ASSERT_NULL(stack->next->next);
 }
 
-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);
 }
 
+
+// 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));
+}
+
+
+// 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));
+}
+
+
+// 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));
+}
+
+
+
 int main(void)
 {
     UNITY_BEGIN();
@@ -105,8 +173,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_drei_pushes);
+    RUN_TEST(test_pop_Stack_ungleich_NULL_eine_Node);
+    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();
 }