diff --git a/.gitignore b/.gitignore index 5222c2f..80f665a 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,3 @@ -highscores.txt +doble_initial.exe +*.o +*.exe \ No newline at end of file diff --git a/highscores.txt b/highscores.txt index 4edd5a7..ca5950d 100644 --- a/highscores.txt +++ b/highscores.txt @@ -1 +1,2 @@ +krisp;4986 player1;3999 diff --git a/makefile b/makefile index 1f15f75..514505e 100644 --- a/makefile +++ b/makefile @@ -29,21 +29,27 @@ program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o doble : main.o $(program_obj_files) $(CC) $(FLAGS) $^ -o doble -$(program_obj_filesobj_files): %.o: %.c +$(program_obj_files): %.o: %.c $(CC) -c $(FLAGS) $^ -o $@ # -------------------------- # Unit Tests # -------------------------- -unitTests: - echo "needs to be implemented" + +TEST_BIN = runTests + +unitTests: stack.o test_stack.o + $(CC) $(FLAGS) -I$(unityfolder) -o $(TEST_BIN) stack.o test_stack.o $(unityfolder)/unity.c + +test_stack.o: test_stack.c + $(CC) $(FLAGS) -I$(unityfolder) -c test_stack.c -o test_stack.o # -------------------------- # Clean # -------------------------- clean: ifeq ($(OS),Windows_NT) - del /f *.o doble -else rm -f *.o doble +else + del /f *.o doble endif \ No newline at end of file diff --git a/stack.c b/stack.c index e3a90d4..35e7708 100644 --- a/stack.c +++ b/stack.c @@ -1,33 +1,82 @@ -#include #include "stack.h" +#include +#include -//TODO: grundlegende Stackfunktionen implementieren: -/* * `push`: legt ein Element oben auf den Stack, - * `pop`: entfernt das oberste Element, - * `top`: liefert das oberste Element zurück, - * `clearStack`: gibt den gesamten Speicher frei. */ +/*typedef struct { -// Pushes data as pointer onto the stack. -StackNode *push(StackNode *stack, void *data) -{ + void *data; + struct StackNode *next; +} StackNode;*/ + +// TODO: grundlegende Stackfunktionen implementieren: +/* `push`: legt ein Element oben auf den Stack, + * `pop`: entfernt das oberste Element, + * `top`: liefert das oberste Element zurück, + * `clearStack`: gibt den gesamten Speicher frei. */ + +// [A] -> [B] -> [C] -> NULL +// head -> stack.next + +StackNode *createNode(void *data) { + + StackNode *node = + malloc(sizeof(StackNode)); // Speicher reservieren, Speicherplatz für das + // struct StackNode + + if (node == NULL) + return NULL; // Speicher konnte nicht reserviert werden + + node->data = data; // Zeiger auf data neuer node + node->next = NULL; // nächster Zeiger ist NULL, Ende der Liste + + return node; // pointer auf den neuen Knoten zurückgeben } -// 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) -{ +// Pushes data as pointer onto the stack. +StackNode *push(StackNode *stack, void *data) { + StackNode *newNode = createNode(data); // Speicher für neuen Knoten + // reservieren + + if (newNode == NULL) { // wenn Speicher nicht reserviert werden konnte, wird + // stack unverändert zurückgegeben + return stack; + } + + newNode->next = stack; // pointer verschieben + + return newNode; // Zeiger auf neuen Speicherbereich zurückgeben +} + +// 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 *nextNode = stack->next; + + free(stack); + + stack = NULL; + + return nextNode; } // Returns the data of the top element. -void *top(StackNode *stack) -{ - -} +void *top(StackNode *stack) { return stack != NULL ? stack->data : NULL; } // Clears stack and releases all memory. -void clearStack(StackNode *stack) -{ +StackNode *clearStack(StackNode *stack) { + while (stack != NULL) { + + StackNode *next = stack->next; + free(stack); + stack = next; + } + + return NULL; } \ No newline at end of file diff --git a/stack.h b/stack.h index f7d542d..f90d217 100644 --- a/stack.h +++ b/stack.h @@ -1,25 +1,34 @@ #ifndef STACK_H #define STACK_H -/* A stack is a special type of queue which uses the LIFO (last in, first out) principle. -This means that with each new element all other elements are pushed deeper into the stack. -The latest element is taken from the stack. */ +/* A stack is a special type of queue which uses the LIFO (last in, first out) +principle. This means that with each new element all other elements are pushed +deeper into the stack. The latest element is taken from the stack. */ #include -//TODO: passenden Datentyp als struct anlegen +// TODO: passenden Datentyp als struct anlegen + +typedef struct StackNode { + + void *data; + struct StackNode *next; + +} StackNode; + +StackNode *createNode(void *data); // Pushes data as pointer onto the stack. 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.) +// 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); // Returns the data of the top element. void *top(StackNode *stack); // Clears stack and releases all memory. -void clearStack(StackNode *stack); +StackNode *clearStack(StackNode *stack); #endif diff --git a/test_stack.c b/test_stack.c new file mode 100644 index 0000000..52ff263 --- /dev/null +++ b/test_stack.c @@ -0,0 +1,59 @@ +#include "unity.h" +#include +#include +#include + +#include "stack.h" + +void test_createNode(void) { + + int testInt = 26; + + StackNode *testNode = createNode(&testInt); + + TEST_ASSERT_NOT_NULL(testNode); + + TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data); + + TEST_ASSERT_NULL(testNode->next); + + free(testNode); +} + +void test_pushDataToStack(void) {} + +void test_deleteTopElement(void) {} + +void test_returnData(void) {} + +void test_clearStack(void) { + + int testInts[] = {1, 2, 3, 4, 5}; + StackNode *testStack = NULL; + + for (int i = 0; i < 5; i++) { + + testStack = push(testStack, &testInts[i]); + } + + testStack = clearStack(testStack); + TEST_ASSERT_NULL(testStack); +} + +void setUp(void) {} +void tearDown(void) {} + +int main(void) { + + UNITY_BEGIN(); + + printf("------------------------stack test------------------------\n"); + RUN_TEST(test_createNode); + RUN_TEST(test_pushDataToStack); + RUN_TEST(test_deleteTopElement); + RUN_TEST(test_returnData); + RUN_TEST(test_clearStack); + RUN_TEST(test_clearStack); + + return UNITY_END(); +}