hallerni98888/info2Praktikum-DobleSpiel
1
0
Fork 0
forked from freudenreichan/info2Praktikum-DobleSpiel
Code Pull Requests 1 Activity

added clear top top test

Browse Source
This commit is contained in:
Nick Haller 2025-11-24 18:49:39 +01:00
parent a027c070d2
commit b76ffa054a
6 changed files with 269 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.gitignore vendored
View File

@ -1,4 +1,4 @@
doble_initial.exe doble_initial.exe
highscores.txt highscores.txt
runStackTest.exe runStackTest.exe
stack.o stack.o

96
makefile
View File

@ -1,49 +1,49 @@
CC = gcc CC = gcc
FLAGS = -g -Wall -lm FLAGS = -g -Wall -lm
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
include makefile_windows.variables include makefile_windows.variables
else else
UNAME = $(shell uname) UNAME = $(shell uname)
ifeq ($(UNAME),Linux) ifeq ($(UNAME),Linux)
include makefile_linux.variables include makefile_linux.variables
else else
include makefile_mac.variables include makefile_mac.variables
endif endif
endif endif
raylibfolder = ./raylib raylibfolder = ./raylib
unityfolder = ./unity unityfolder = ./unity
# -------------------------- # --------------------------
# Initiales Programm bauen (zum ausprobieren) # Initiales Programm bauen (zum ausprobieren)
# -------------------------- # --------------------------
doble_initial: doble_initial:
$(CC) -o doble_initial $(BINARIES)/libdoble_complete.a $(CC) -o doble_initial $(BINARIES)/libdoble_complete.a
# -------------------------- # --------------------------
# Selbst implementiertes Programm bauen # Selbst implementiertes Programm bauen
# -------------------------- # --------------------------
program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o
doble : main.o $(program_obj_files) doble : main.o $(program_obj_files)
$(CC) $(FLAGS) $^ -o doble $(CC) $(FLAGS) $^ -o doble
$(program_obj_filesobj_files): %.o: %.c $(program_obj_filesobj_files): %.o: %.c
$(CC) -c $(FLAGS) $^ -o $@ $(CC) -c $(FLAGS) $^ -o $@
# -------------------------- # --------------------------
# Unit Tests # Unit Tests
# -------------------------- # --------------------------
unitTests: stack.o test_stack.c $(unityfolder)/unity.c unitTests: stack.o test_stack.c $(unityfolder)/unity.c
$(CC) $(FLAGS) -I$(unityfolder) -o runStackTest test_stack.c stack.o $(unityfolder)/unity.c $(CC) $(FLAGS) -I$(unityfolder) -o runStackTest test_stack.c stack.o $(unityfolder)/unity.c
# -------------------------- # --------------------------
# Clean # Clean
# -------------------------- # --------------------------
clean: clean:
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
del /f *.o doble del /f *.o doble
else else
rm -f *.o doble rm -f *.o doble
endif endif

180
stack.c
View File

@ -1,91 +1,91 @@
#include <stdlib.h> #include <stdlib.h>
#include "stack.h" #include "stack.h"
// TODO: grundlegende Stackfunktionen implementieren: // TODO: grundlegende Stackfunktionen implementieren:
/* * `push`: legt ein Element oben auf den Stack, /* * `push`: legt ein Element oben auf den Stack,
* `pop`: entfernt das oberste Element, * `pop`: entfernt das oberste Element,
* `top`: liefert das oberste Element zurück, * `top`: liefert das oberste Element zurück,
* `clearStack`: gibt den gesamten Speicher frei. */ * `clearStack`: gibt den gesamten Speicher frei. */
// Pushes data as pointer onto the stack. // Pushes data as pointer onto the stack.
StackNode *push(StackNode *stack, void *data) StackNode *push(StackNode *stack, void *data)
{ {
StackNode *tempNode, *newNode; StackNode *tempNode, *newNode;
newNode = malloc(sizeof(StackNode)); newNode = malloc(sizeof(StackNode));
newNode->value = 3; newNode->value = 3;
newNode->next = NULL; newNode->next = NULL;
if (stack == NULL) if (stack == NULL)
{ {
stack = newNode; stack = newNode;
return stack; return stack;
} }
tempNode = stack; tempNode = stack;
while (tempNode->next != NULL) while (tempNode->next != NULL)
{ {
tempNode = tempNode->next; tempNode = tempNode->next;
} }
tempNode->next = newNode; tempNode->next = newNode;
return stack; return stack;
} }
// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
// freed by caller.) // freed by caller.)
StackNode *pop(StackNode *stack) StackNode *pop(StackNode *stack)
{ {
StackNode *tempNode; StackNode *tempNode;
if (stack == NULL) if (stack == NULL)
{ {
return stack; return stack;
} }
tempNode = stack; tempNode = stack;
while (tempNode->next->next != NULL) while (tempNode->next->next != NULL)
{ {
tempNode = tempNode->next; tempNode = tempNode->next;
} }
free(tempNode->next); free(tempNode->next);
tempNode->next = NULL; tempNode->next = NULL;
return stack; return stack;
} }
// Returns the data of the top element. // Returns the data of the top element.
void *top(StackNode *stack) void *top(StackNode *stack)
{ {
StackNode *tempNode; StackNode *tempNode;
if (stack == NULL) if (stack == NULL)
{ {
return NULL; return NULL;
} }
tempNode = stack; tempNode = stack;
while (tempNode->next != NULL) while (tempNode->next != NULL)
{ {
tempNode = tempNode->next; tempNode = tempNode->next;
} }
return &tempNode->value; return &tempNode->value;
} }
// Clears stack and releases all memory. // Clears stack and releases all memory.
void clearStack(StackNode *stack) void clearStack(StackNode *stack)
{ {
StackNode *tempNode; StackNode *tempNode;
if (stack == NULL) if (stack == NULL)
{ {
return; return;
} }
tempNode = stack; tempNode = stack;
while (tempNode != NULL) while (tempNode != NULL)
{ {
tempNode = pop(tempNode); tempNode = pop(tempNode);
} }
} }

58
stack.h
View File

@ -1,29 +1,29 @@
#ifndef STACK_H #ifndef STACK_H
#define STACK_H #define STACK_H
/* A stack is a special type of queue which uses the LIFO (last in, first out) principle. /* 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. This means that with each new element all other elements are pushed deeper into the stack.
The latest element is taken from the stack. */ The latest element is taken from the stack. */
#include <stdlib.h> #include <stdlib.h>
//TODO: passenden Datentyp als struct anlegen //TODO: passenden Datentyp als struct anlegen
typedef struct Node { typedef struct Node {
int value; int value;
struct Node* next; struct Node* next;
} StackNode; } StackNode;
// Pushes data as pointer onto the stack. // Pushes data as pointer onto the stack.
StackNode *push(StackNode *stack, void *data); 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 // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
// freed by caller.) // freed by caller.)
StackNode *pop(StackNode *stack); StackNode *pop(StackNode *stack);
// Returns the data of the top element. // Returns the data of the top element.
void *top(StackNode *stack); void *top(StackNode *stack);
// Clears stack and releases all memory. // Clears stack and releases all memory.
void clearStack(StackNode *stack); void clearStack(StackNode *stack);
#endif #endif

115
test_stack.c
View File

@ -1,28 +1,89 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "stack.h" #include "stack.h"
#include "unity.h" #include "unity.h"
void test_pop(void) StackNode* setup(int value, StackNode* next) {
{ StackNode* node = malloc(sizeof(StackNode)); // allocate memory on heap
TEST_ASSERT_NULL(pop(NULL)); if (node == NULL) {
} perror("malloc failed");
exit(EXIT_FAILURE); // or handle the error differently
void setUp(void) { }
// Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden node->value = value;
} node->next = next;
return node;
void tearDown(void) { }
// Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
} void test_pop(void)
{
int main() StackNode* node2 = setup(3, NULL);
{ StackNode* node1 = setup(2, node2);
UNITY_BEGIN(); StackNode* header = setup(1, node1);
StackNode* temp;
printf("============================\nStack tests\n============================\n");
temp = pop(header);
RUN_TEST(test_pop); int after = 0;
while(temp)
return UNITY_END(); {
after++;
temp = temp->next;
}
TEST_ASSERT_EQUAL_INT(2, after);
TEST_ASSERT_NULL(node1->next);
}
void test_top(void)
{
StackNode* node2 = setup(3, NULL);
StackNode* node1 = setup(2, node2);
StackNode* header = setup(1, node1);
int data = *(int *)top(header);
TEST_ASSERT_EQUAL_INT(node2->value, data);
}
void test_clear()
{
StackNode* node2 = setup(3, NULL);
StackNode* node1 = setup(2, node2);
StackNode* header = setup(1, node1);
StackNode* temp;
clearStack(header);
temp = header;
int after = 0;
while(temp)
{
after++;
temp = temp->next;
}
TEST_ASSERT_NULL(after);
}
void setUp(void)
{
// Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
}
void tearDown(void)
{
// Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
}
int main()
{
UNITY_BEGIN();
printf("============================\nStack tests\n============================\n");
RUN_TEST(test_pop);
RUN_TEST(test_top);
RUN_TEST(test_clear);
return UNITY_END();
} }

20
unittest.h
View File

@ -1,10 +1,10 @@
#ifndef UNITTTESTS_H #ifndef UNITTTESTS_H
#define UNITTTESTS_H #define UNITTTESTS_H
#include <stdio.h> #include <stdio.h>
typedef int (*UnitTestType)(void); typedef int (*UnitTestType)(void);
#define RUN_UNIT_TEST(fct) printf("%80s: %d\n", #fct, fct()) #define RUN_UNIT_TEST(fct) printf("%80s: %d\n", #fct, fct())
#endif #endif