small changes

Reviewed-on: #3

I2_Dobble/Stack.md

@@ -0,0 +1,46 @@
+# stack.h
+*Aufgabe: passender Datentyp für ein Listenelement als struct anlegen*
+
+``` c
+typedef struct Node
+{
+void *data;
+struct Node* next;
+} StackNode;
+```
+
+* **typedef** nicht zwingend notwendig, aber erleich­tert später den Aufruf: `StackNode` vs `struct stackNode`
+* **Zeiger data** zeigt auf in Liste gespeicherten Wert
+* **Zeiger auf Node struct**, der auf das folgende Node zeiget (oder NULL ist, wenn kein folgendes vorhanden)
+* für jedes struct dieses Typs, dass wir später in den Stack.c Funktionen erstellen muss Speicher manuell zugewiesen werden!
+
+
+# stack.c
+
+### push:
+*neues Element oben auf die Liste legen*
+* Sicherheits-Überprüfung: falls übergebener Pointer für Daten kein Ziel hat (data = NULL) => alle unten beschriebenen Schritte werden übersprungen, Stack- Pointer wird unverändert zurück gegeben
+* Listenelement erstellen: (Standard Ablauf für Structs)
+  * Pointer initialisieren
+  * mit malloc an diesem Ort im Speicher in der richtigen Größe reservieren (hier Größe eines Listenelements)
+  * Speicher kann genutzt werden
+* data wird gespeichert
+* next passend setzen, entweder zuvor oberstes Element oder keines, wenn Liste leer war
+* stack-Pointer auf neues, oberstes Listetenelement zeigen lassen
+
+### pop:
+*oberstes Element von Liste löschen*
+* Sicherheits-Überprüfung: wenn Stack schon leer ist wird nichts entfernt (Stack = NULL bedeutet kein erstes Element existiert) - sonst würde nicht reservierter Speicher freigegeben
+* müssen alle Zeiger auf das Element ändern und den Speicher Freigeben - damit ist alles entfernt:
+* zum Löschen wird Speicher am Ort des stack-Zeigers freigegeben - damit ist das oberste Element weg
+* zuletzt wird der Stack-Zeiger neu gesetzt, um auch alle Pointer, die noch auf das gelöschte Element zeigen zu aktuallisieren
+
+### top:
+*gibt Daten-Zeiger des obersten Elements zurück*
+* Sicherheits-Überprüfung: existiert ein oberstes Element überhaupt? sonst würde man beim Versuch data auszulesen auf überhaupt nicht bzw anders zugewiesenen Speicher zugreifen!
+* zur normalen Ausgabe wird einfach der Zeigerwert der data-Variable des oberster Stackelements zurückgegeben
+
+### clear stack:
+*die Liste leeren inklusive Speicherfreigabe*
+* Funktionsprinzip: so lange das oberste Element mit pop-funktion entfernen, bis die Liste leer ist
+* da pop erkennt, wenn Liste leer und dann den Stack-Pointer NULL setzt dient das als Schleifenvariable

I2_Dobble/bintreeTest.c

@@ -14,7 +14,7 @@ void test_addToTree_single_element(void)
 {
     TreeNode *root = NULL;
     int value = 10;
-    int dup = -1;
+    int dup;
 
     root = addToTree(root, &value, sizeof(int), compare, &dup);
 
@@ -29,7 +29,7 @@ void test_addToTree_multiple_elements_and_size(void)
 {
     TreeNode *root = NULL;
     int values[] = {5, 3, 7, 1, 4};
-    int dup = -1;
+    int dup;
 
     for (int i = 0; i < 5; i++)
         root = addToTree(root, &values[i], sizeof(int), compare, &dup);
@@ -91,7 +91,7 @@ void test_treeSize_returns_correct_size()
     TreeNode *root = NULL;
     int values[] = {8, 3, 10, 1, 6, 14};
 
-    // ersten Baum aufbauen
+    //Baum aufbauen
     for (int i = 0; i < 6; i++)
         root = addToTree(root, &values[i], sizeof(int), compare, NULL);
 
@@ -108,6 +108,8 @@ int main(void)
 {
     UNITY_BEGIN();
     
+    printf("\n============================\n Bintree tests\n============================\n");
+
     RUN_TEST(test_addToTree_single_element);
     RUN_TEST(test_addToTree_multiple_elements_and_size);
     RUN_TEST(test_addToTree_duplicate_detection);

I2_Dobble/numbersTest.c

@@ -54,28 +54,6 @@ void test_getDuplicate_returns_correct_value(void)
     TEST_ASSERT_EQUAL_UINT(7, d);
 }
 
-void test_complete_function_of_numbers(void) 
-{
-    unsigned int len = 50;
-    unsigned int *arr = createNumbers(len);
-    TEST_ASSERT_NOT_NULL(arr);
-
-    unsigned int d1 = getDuplicate(arr, len);
-    TEST_ASSERT_NOT_EQUAL(0, d1);
-
-    int count = 0;
-
-    for (unsigned int i = 0; i < len; i++) 
-    {
-        if (arr[i] == d1) 
-            count++;
-    }
-
-    TEST_ASSERT_EQUAL(2, count);
-
-    free(arr);
-}
-
 void setUp(void) { }
 void tearDown(void) { }
 
@@ -83,11 +61,12 @@ int main(void)
 {
     UNITY_BEGIN();
 
+    printf("\n============================\n Numbers tests\n============================\n");
+
     RUN_TEST(test_createNumbers_no_null);
     RUN_TEST(test_createNumbers_has_exactly_one_duplicate);
     RUN_TEST(test_createNumbers_has_correct_value_range);
     RUN_TEST(test_getDuplicate_returns_correct_value);
-    RUN_TEST(test_complete_function_of_numbers);
 
     return UNITY_END();
 }

I2_Dobble/stack.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "stack.h"
 
-//TODO: grundlegende Stackfunktionen implementieren:
+//DONE: grundlegende Stackfunktionen implementieren:
 /*  * `push`: legt ein Element oben auf den Stack,
     * `pop`: entfernt das oberste Element,
     * `top`: liefert das oberste Element zurück,
@@ -10,47 +10,52 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
-    StackNode *newNode = malloc(sizeof(StackNode));
-    if (!newNode)
-        return stack;
-    
+    //        ,-→ Wenn keine Daten angegeben wird die Liste unverändert zurückgegeben
+    if (data != NULL)
+    {
+        StackNode *newNode;
+        newNode = (StackNode *)malloc(sizeof(StackNode));
         newNode->data = data;
-    newNode->next = stack;
         
-    return newNode;
+        //         ,-→ bedeutet Liste war leer - das neue Element hat keinen Nachfolger (next = NULL)
+        if (stack == NULL) {
+            newNode->next = NULL;
+        } else {
+            newNode->next = stack;
+        }
+        stack = newNode;
     }
     
-// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
-// freed by caller.)
+    return stack;
+}
+
+// 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 *newTopElement = stack->next;
+    if(stack != NULL)
+    {
+        StackNode *nextNode = stack->next;
         free(stack);
-
-    return newTopElement;
+        stack = nextNode;
+    }
+    return stack;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
-    if (!stack)
-        return NULL;
-
+    if (stack != NULL) {
         return stack->data;
+    } else {
+        return NULL;
+    } 
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
-    StackNode *current = stack;
-
-    while (current)
-    {
-        StackNode *next = current->next;
-        free(current);
-        current = next;
+    while (stack != NULL) {
+        stack = pop(stack);
     }
 }

I2_Dobble/stack.h

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

I2_Dobble/stackTest.c

@@ -1,9 +1,148 @@
 #include "stack.h"
-#include "unity.h"
-#include "unity_internals.h"
+#include "unity/unity.h"
+#include "unity/unity_internals.h"
 
-void setUp(void) { }
-void tearDown(void) { }
+/* wird nicht mehr gebraucht
+
+// Ein Blick in den Stack - listet den Stack-Inhalt der Reihe nach auf
+void inspectStack(StackNode *stack)
+{    
+    if (stack != NULL)
+    {
+        printf("Der Stack enthält die folgenden Elemente: %d", *(int*)stack->data);
+        while (stack->next != NULL)
+        {
+            printf(" %d", *(int*)stack->next->data);
+            stack = stack->next;
+        }
+        putchar('\n');
+    }
+    else
+    {
+        printf("Der Stack ist leer\n");
+    }
+}
+*/
+
+// Setup-Funktionen von Unity, die zumindest als Platzhalter definiert sein müssen
+void setUp(void) {};
+void tearDown(void) {};
+
+void test_createNodeAbortsOnZeroData(void)
+{
+    void *data = NULL;
+    StackNode *stack = NULL;
+    stack = push(stack, data);
+    TEST_ASSERT_EQUAL_PTR(stack, NULL);
+
+    clearStack(stack);
+}
+
+void test_createdNodeIsFirstInList(void)
+{
+    int data = 42;
+    StackNode *stack = NULL;
+    stack = push(stack, &data);
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(&data, stack->data);
+    TEST_ASSERT_NULL(stack->next);
+
+    clearStack(stack);
+}
+
+void test_createNodeCorrectOrder(void)
+{
+    int data[3] = {0, 1, 2};
+    StackNode *stack = NULL;
+    stack = push(stack, &data[2]);
+    stack = push(stack, &data[1]);
+    stack = push(stack, &data[0]);
+
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(&data[0], stack->data);
+    TEST_ASSERT_EQUAL_PTR(&data[1], stack->next->data);
+    TEST_ASSERT_EQUAL_PTR(&data[2], stack->next->next->data);
+    TEST_ASSERT_NULL(stack->next->next->next);
+
+    clearStack(stack);
+}
+
+void test_removeNodeAbortsOnZero(void)
+{
+    StackNode *stack = NULL;
+    TEST_ASSERT_NULL(pop(stack));
+
+    clearStack(stack);
+}
+
+void test_removeOnlyNodeEmptysList(void)
+{
+    int data = 42;
+    StackNode *stack = NULL;
+    stack = pop(push(stack, &data));
+
+    TEST_ASSERT_NULL(stack);
+
+    clearStack(stack);
+}
+
+void test_removeNodeRemovesFirst(void)
+{
+    int data[2] = {0, 1};
+    StackNode *stack = NULL;
+    stack = push(stack, &data[1]);
+    stack = push(stack, &data[0]);
+    stack = pop(stack);
+
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(&data[1], stack->data);
+    TEST_ASSERT_NULL(stack->next);
+
+    clearStack(stack);
+}
+
+void test_outputTopFailsOnZero(void)
+{
+    StackNode *stack = NULL;
+    
+    TEST_ASSERT_NULL(top(stack));
+
+    clearStack(stack);
+}
+
+void test_outputTopCorrect(void)
+{
+    int data[2] = {0, 1};
+    StackNode *stack = NULL;
+    stack = push(stack, &data[1]);
+    stack = push(stack, &data[0]);
+
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(top(stack), stack->data);
+
+    clearStack(stack);
+}
+
+
+/* Speicher freigabe lässt sich nicht mit Unity testen, am besten Programm mit valgrind ausführen
+void test_clearStackFreesMemory(void)
+{
+    int data[2] = {22, 17};
+    StackNode *lowNode = (StackNode *)malloc(sizeof(StackNode));
+    lowNode->next = NULL;
+    lowNode->data = &data[0];
+    StackNode *highNode = (StackNode *)malloc(sizeof(StackNode));
+    highNode->next = lowNode;
+    highNode->data = &data[1];
+    StackNode *stack = highNode;
+
+    clearStack(stack);
+
+    TEST_ASSERT_NULL(lowNode);
+    TEST_ASSERT_NULL(highNode);
+    TEST_ASSERT_NULL(stack);
+}
+*/
 
 void test_push_should_add_new_node_at_top(void)
 {
@@ -94,6 +233,21 @@ int main()
 {
     UNITY_BEGIN();
 
+    printf("\n============================\n Stack tests\n============================\n");
+    printf("-> Create Nodes (push)\n");
+    RUN_TEST(test_createNodeAbortsOnZeroData);
+    RUN_TEST(test_createdNodeIsFirstInList);
+    RUN_TEST(test_createNodeCorrectOrder);
+
+    printf("\n-> Remove Nodes (pop)\n");
+    RUN_TEST(test_removeNodeAbortsOnZero);
+    RUN_TEST(test_removeOnlyNodeEmptysList);
+    RUN_TEST(test_removeNodeRemovesFirst);
+
+    printf("\n-> Output Top (top)\n");
+    RUN_TEST(test_outputTopFailsOnZero);
+    RUN_TEST(test_outputTopCorrect);
+
     RUN_TEST(test_push_should_add_new_node_at_top);
     RUN_TEST(test_push_multiple_should_chain_nodes_correctly);
     RUN_TEST(test_top_should_return_null_on_empty_stack);

I2_Dobble/test_stack.c

@@ -0,0 +1,80 @@
+#include <bits/types/stack_t.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "stack.h"
+
+void inspectStack(StackNode *stack)
+{    
+    if (stack != NULL)
+    {
+        printf("Der Stack enthält die folgenden Elemente: %d", *(int*)stack->value);
+        while (stack->next != NULL)
+        {
+            printf(" %d", *(int*)stack->next->value);
+            stack = stack->next;
+        }
+        putchar('\n');
+    }
+    else
+    {
+        printf("Der Stack ist leer\n");
+    }
+}
+
+int main()
+{
+    StackNode *stack;
+    stack = NULL; // initialisierung mit NULL -> leere Liste
+    
+    printf("...ein Element wird eingefügt...\n");
+    int toBeRemoved = 42;
+    stack = push(stack, &toBeRemoved);
+    
+    inspectStack(stack);
+
+    printf("...das Element wird wieder entfernt...\n");
+    stack = pop(stack);
+    
+    inspectStack(stack);
+    
+    printf("...pop auf leeren Stack...\n");
+    stack = pop(stack);
+    
+    inspectStack(stack);
+    putchar('\n');
+
+    int data[5] = {1, 2, 3, 4, 5};
+
+    // alle 5 werte der reihe nach auf den Satck legen - 1 unten ... 5 oben
+    for (int i = 0; i < 5; i++)
+    {
+        stack = push(stack, &data[i]);
+    }
+
+    
+    //alle Elemente mit Test-Funktion ausgeben
+    inspectStack(stack);
+    
+    // Elemente stück für Stück ausgeben und entfernen
+    printf("1. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("2. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("3. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("4. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("5. Element war: %d\n", *(int*)top(stack));
+}
+
+/*
+int main()
+{
+    UNITY_BEGIN();
+
+    printf("============================\n Stack tests\n============================\n");
+    RUN_TEST(test_createNodeFailsOnZeroData);
+
+    return UNITY_END();
+}
+*/