riedmannel100005/info2aufgabe3
1
1
Fork 0
generated from freudenreichan/info2Praktikum-DobleSpiel
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test push pop

Browse Source
This commit is contained in:
Elena Riedmann 2026-06-09 10:18:08 +02:00
parent 8539f2e3a8
commit 599e4d7e75
5 changed files with 475 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
highscores.txt
View File

@ -1,2 +1,7 @@
elena;24999
player_name;14999
player_name;6999 player_name;6999
elena;4999
player1;3999 player1;3999
elena;2999
elena;2999

10
makefile
View File

@ -53,12 +53,18 @@ unity.o:
test_bintree: stack.o bintree.o unity.o test_bintree: stack.o bintree.o unity.o
$(CC) $(FLAGS) -Iunity test_bintree.c $^ -o runTest_bintree $(CC) $(FLAGS) -Iunity test_bintree.c $^ -o runTest_bintree
# --------------------------
#Test: test_push_pop
# --------------------------
test_push_pop: stack.o unity.o
$(CC) $(FLAGS) -Iunity test_push_pop.c $^ -o runTest_push_pop
# -------------------------- # --------------------------
# Clean # Clean
# -------------------------- # --------------------------
clean: clean:
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
del /f *.o doble runTest_numbers runTest_bintree del /f *.o doble runTest_numbers runTest_bintree runTest_push_pop
else else
rm -f *.o doble runTest_numbers runTest_bintree rm -f *.o doble runTest_numbers runTest_bintree runTest_push_pop
endif endif

BIN
test_push_pop Executable file
View File

Binary file not shown.

231
test_push_pop.c Normal file
View File

@ -0,0 +1,231 @@
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
/* ============================================================================
* UNIT TESTS FOR STACK PUSH AND POP OPERATIONS
*
* This test suite covers:
* - push(): Add integer values to the stack
* - pop(): Remove values from the stack
* - top(): Retrieve the top element without removing it
* - clearStack(): Clean up stack memory
* ========================================================================== */
// ============================================================================
// HELPER FUNCTIONS FOR TESTING
// ============================================================================
// Create an integer value on the heap
int *createIntValue(int value)
{
int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL)
{
*ptr = value;
}
return ptr;
}
// Count elements in the stack
int countStackElements(StackNode *stack)
{
int count = 0;
StackNode *current = stack;
while (current != NULL)
{
count++;
current = current->next;
}
return count;
}
// ============================================================================
// TEST FUNCTIONS
// ============================================================================
void test_push_single_value(void)
{
printf("\nTEST 1: Push and retrieve a single integer value\n");
printf("================================================\n");
StackNode *stack = NULL;
// Push a single value
int *value1 = createIntValue(42);
stack = push(stack, value1);
// Check if value is on top
int *result = (int *)top(stack);
if (result != NULL && *result == 42)
{
printf("✓ Push and top() successful: value = %d\n", *result);
}
else
{
printf("✗ FAILED: Expected 42, got %d\n", result != NULL ? *result : -1);
}
// Clean up
stack = pop(stack);
free(value1);
printf("Test 1 completed\n");
}
void test_push_multiple_values(void)
{
printf("\nTEST 2: Push multiple integer values (LIFO principle)\n");
printf("====================================================\n");
StackNode *stack = NULL;
// Push multiple values
int values[] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; i++)
{
int *val = createIntValue(values[i]);
stack = push(stack, val);
printf("Pushed: %d\n", values[i]);
}
printf("\nStack size: %d elements\n", countStackElements(stack));
// Pop and verify LIFO order (should be 50, 40, 30, 20, 10)
printf("\nPopping values (should be in reverse order):\n");
int expected_order[] = {50, 40, 30, 20, 10};
int all_correct = 1;
for (int i = 0; i < 5; i++)
{
int *topVal = (int *)top(stack);
if (topVal != NULL && *topVal == expected_order[i])
{
printf("✓ Pop %d: value = %d (correct)\n", i + 1, *topVal);
free(topVal);
stack = pop(stack);
}
else
{
printf("✗ Pop %d: Expected %d, got %d\n", i + 1, expected_order[i], topVal != NULL ? *topVal : -1);
all_correct = 0;
if (topVal != NULL)
free(topVal);
stack = pop(stack);
}
}
if (all_correct)
{
printf("\n✓ LIFO principle verified!\n");
}
else
{
printf("\n✗ LIFO principle test FAILED!\n");
}
printf("Test 2 completed\n");
}
void test_push_pop_alternating(void)
{
printf("\nTEST 3: Alternating push and pop operations\n");
printf("===========================================\n");
StackNode *stack = NULL;
// Push first value
int *val1 = createIntValue(100);
stack = push(stack, val1);
printf("Pushed: 100\n");
// Pop it
int *top1 = (int *)top(stack);
printf("Top: %d\n", *top1);
free(top1);
stack = pop(stack);
printf("Popped: 100\n");
// Push multiple new values
int *val2 = createIntValue(200);
int *val3 = createIntValue(300);
stack = push(stack, val2);
printf("Pushed: 200\n");
stack = push(stack, val3);
printf("Pushed: 300\n");
// Pop and verify
int *top2 = (int *)top(stack);
if (*top2 == 300)
{
printf("✓ Top is 300 (correct)\n");
}
free(top2);
stack = pop(stack);
int *top3 = (int *)top(stack);
if (*top3 == 200)
{
printf("✓ Top is 200 (correct)\n");
}
free(top3);
stack = pop(stack);
clearStack(stack);
printf("Test 3 completed\n");
}
void test_empty_stack(void)
{
printf("\nTEST 4: Empty stack handling\n");
printf("============================\n");
StackNode *stack = NULL;
printf("Initial stack size: %d\n", countStackElements(stack));
if (stack == NULL)
{
printf("✓ Empty stack correctly represented as NULL\n");
}
// Push a value
int *val = createIntValue(123);
stack = push(stack, val);
printf("After push: stack size = %d\n", countStackElements(stack));
// Pop to make it empty again
stack = pop(stack);
free(val);
printf("After pop: stack size = %d\n", countStackElements(stack));
if (stack == NULL)
{
printf("✓ Stack correctly empty after popping last element\n");
}
printf("Test 4 completed\n");
}
// ============================================================================
// MAIN TEST RUNNER
// ============================================================================
int main(void)
{
printf("╔════════════════════════════════════════════════════════════╗\n");
printf("║ STACK PUSH & POP TEST SUITE ║\n");
printf("║ Testing integer value handling in LIFO stack operations ║\n");
printf("╚════════════════════════════════════════════════════════════╝\n");
// Run all tests
test_push_single_value();
test_push_multiple_values();
test_push_pop_alternating();
test_empty_stack();
printf("\n╔════════════════════════════════════════════════════════════╗\n");
printf("║ ALL TESTS COMPLETED ║\n");
printf("╚════════════════════════════════════════════════════════════╝\n");
return 0;
}

231
test_stack.c Normal file
View File

@ -0,0 +1,231 @@
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
/* ============================================================================
* UNIT TESTS FOR STACK PUSH AND POP OPERATIONS
*
* This test suite covers:
* - push(): Add integer values to the stack
* - pop(): Remove values from the stack
* - top(): Retrieve the top element without removing it
* - clearStack(): Clean up stack memory
* ========================================================================== */
// ============================================================================
// HELPER FUNCTIONS FOR TESTING
// ============================================================================
// Create an integer value on the heap
int *createIntValue(int value)
{
int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL)
{
*ptr = value;
}
return ptr;
}
// Count elements in the stack
int countStackElements(StackNode *stack)
{
int count = 0;
StackNode *current = stack;
while (current != NULL)
{
count++;
current = current->next;
}
return count;
}
// ============================================================================
// TEST FUNCTIONS
// ============================================================================
void test_push_single_value(void)
{
printf("\nTEST 1: Push and retrieve a single integer value\n");
printf("================================================\n");
StackNode *stack = NULL;
// Push a single value
int *value1 = createIntValue(42);
stack = push(stack, value1);
// Check if value is on top
int *result = (int *)top(stack);
if (result != NULL && *result == 42)
{
printf("✓ Push and top() successful: value = %d\n", *result);
}
else
{
printf("✗ FAILED: Expected 42, got %d\n", result != NULL ? *result : -1);
}
// Clean up
stack = pop(stack);
free(value1);
printf("Test 1 completed\n");
}
void test_push_multiple_values(void)
{
printf("\nTEST 2: Push multiple integer values (LIFO principle)\n");
printf("====================================================\n");
StackNode *stack = NULL;
// Push multiple values
int values[] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; i++)
{
int *val = createIntValue(values[i]);
stack = push(stack, val);
printf("Pushed: %d\n", values[i]);
}
printf("\nStack size: %d elements\n", countStackElements(stack));
// Pop and verify LIFO order (should be 50, 40, 30, 20, 10)
printf("\nPopping values (should be in reverse order):\n");
int expected_order[] = {50, 40, 30, 20, 10};
int all_correct = 1;
for (int i = 0; i < 5; i++)
{
int *topVal = (int *)top(stack);
if (topVal != NULL && *topVal == expected_order[i])
{
printf("✓ Pop %d: value = %d (correct)\n", i + 1, *topVal);
free(topVal);
stack = pop(stack);
}
else
{
printf("✗ Pop %d: Expected %d, got %d\n", i + 1, expected_order[i], topVal != NULL ? *topVal : -1);
all_correct = 0;
if (topVal != NULL)
free(topVal);
stack = pop(stack);
}
}
if (all_correct)
{
printf("\n✓ LIFO principle verified!\n");
}
else
{
printf("\n✗ LIFO principle test FAILED!\n");
}
printf("Test 2 completed\n");
}
void test_push_pop_alternating(void)
{
printf("\nTEST 3: Alternating push and pop operations\n");
printf("===========================================\n");
StackNode *stack = NULL;
// Push first value
int *val1 = createIntValue(100);
stack = push(stack, val1);
printf("Pushed: 100\n");
// Pop it
int *top1 = (int *)top(stack);
printf("Top: %d\n", *top1);
free(top1);
stack = pop(stack);
printf("Popped: 100\n");
// Push multiple new values
int *val2 = createIntValue(200);
int *val3 = createIntValue(300);
stack = push(stack, val2);
printf("Pushed: 200\n");
stack = push(stack, val3);
printf("Pushed: 300\n");
// Pop and verify
int *top2 = (int *)top(stack);
if (*top2 == 300)
{
printf("✓ Top is 300 (correct)\n");
}
free(top2);
stack = pop(stack);
int *top3 = (int *)top(stack);
if (*top3 == 200)
{
printf("✓ Top is 200 (correct)\n");
}
free(top3);
stack = pop(stack);
clearStack(stack);
printf("Test 3 completed\n");
}
void test_empty_stack(void)
{
printf("\nTEST 4: Empty stack handling\n");
printf("============================\n");
StackNode *stack = NULL;
printf("Initial stack size: %d\n", countStackElements(stack));
if (stack == NULL)
{
printf("✓ Empty stack correctly represented as NULL\n");
}
// Push a value
int *val = createIntValue(123);
stack = push(stack, val);
printf("After push: stack size = %d\n", countStackElements(stack));
// Pop to make it empty again
stack = pop(stack);
free(val);
printf("After pop: stack size = %d\n", countStackElements(stack));
if (stack == NULL)
{
printf("✓ Stack correctly empty after popping last element\n");
}
printf("Test 4 completed\n");
}
// ============================================================================
// MAIN TEST RUNNER
// ============================================================================
int main(void)
{
printf("╔════════════════════════════════════════════════════════════╗\n");
printf("║ STACK PUSH & POP TEST SUITE ║\n");
printf("║ Testing integer value handling in LIFO stack operations ║\n");
printf("╚════════════════════════════════════════════════════════════╝\n");
// Run all tests
test_push_single_value();
test_push_multiple_values();
test_push_pop_alternating();
test_empty_stack();
printf("\n╔════════════════════════════════════════════════════════════╗\n");
printf("║ ALL TESTS COMPLETED ║\n");
printf("╚════════════════════════════════════════════════════════════╝\n");
return 0;
}