Doble/test_stack.c

#include <stdio.h>
#include <stdlib.h>
#include "unity.h"
#include "stack.h"

// -------------------------------------------------------------
// ---------------------- Tests für push ------------------------
// -------------------------------------------------------------

void test_push_single_element(void) {
    StackNode *stack = NULL;

    int *value = malloc(sizeof(int));
    *value = 10;

    stack = push(stack, value);

    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_INT(10, *(int*)top(stack));

    clearStack(stack);
    free(value);
}

void test_push_multiple_elements(void) {
    StackNode *stack = NULL;

    int *a = malloc(sizeof(int));
    int *b = malloc(sizeof(int));
    int *c = malloc(sizeof(int));

    *a = 10;
    *b = 20;
    *c = 30;

    stack = push(stack, a);   // Stack: [10]
    stack = push(stack, b);   // Stack: [20, 10]
    stack = push(stack, c);   // Stack: [30, 20, 10]

    TEST_ASSERT_EQUAL_INT(30, *(int*)top(stack));

    clearStack(stack);
    free(a);
    free(b);
    free(c);
}

// -------------------------------------------------------------
// ----------------------- Tests für top ------------------------
// -------------------------------------------------------------

void test_top_on_empty_stack_returns_null(void) {
    StackNode *stack = NULL;

    TEST_ASSERT_NULL(top(stack));
}

void test_top_after_pushes(void) {
    StackNode *stack = NULL;

    int *a = malloc(sizeof(int));
    int *b = malloc(sizeof(int));

    *a = 42;
    *b = 99;

    stack = push(stack, a);  // [42]
    stack = push(stack, b);  // [99, 42]

    TEST_ASSERT_EQUAL_INT(99, *(int*)top(stack));

    clearStack(stack);
    free(a); free(b);
}

// -------------------------------------------------------------
// ----------------------- Tests für pop ------------------------
// -------------------------------------------------------------

void test_pop_on_empty_stack_returns_null(void) {
    StackNode *stack = NULL;

    stack = pop(stack);

    TEST_ASSERT_NULL(stack);
}

void test_pop_removes_elements_in_lifo_order(void) {
    StackNode *stack = NULL;

    int *a = malloc(sizeof(int));
    int *b = malloc(sizeof(int));
    int *c = malloc(sizeof(int));

    *a = 10;
    *b = 20;
    *c = 30;

    stack = push(stack, a);  // [10]
    stack = push(stack, b);  // [20, 10]
    stack = push(stack, c);  // [30, 20, 10]

    stack = pop(stack);      // remove 30
    TEST_ASSERT_EQUAL_INT(20, *(int*)top(stack));

    stack = pop(stack);      // remove 20
    TEST_ASSERT_EQUAL_INT(10, *(int*)top(stack));

    stack = pop(stack);      // remove 10
    TEST_ASSERT_NULL(stack);

    free(a); free(b); free(c);
}

// -------------------------------------------------------------
// -------------------- Tests für clearStack --------------------
// -------------------------------------------------------------

void test_clearStack_empties_stack(void) {
    StackNode *stack = NULL;

    int *a = malloc(sizeof(int));
    int *b = malloc(sizeof(int));

    *a = 5;
    *b = 15;

    stack = push(stack, a);
    stack = push(stack, b);

    clearStack(stack);

    // Danach ist der Stack frei, aber 'stack' zeigt noch auf alten Wert
    // Caller muss selbst auf NULL setzen
    stack = NULL;

    TEST_ASSERT_NULL(stack);

    free(a); free(b);
}

void setUp(void) {
    // keine Vorbereitung nötig
}

void tearDown(void) {
    // kein Aufräumen notwendig, da jede Testfunktion selbst aufräumt
}
// -------------------------------------------------------------
// --------------------------- MAIN -----------------------------
// -------------------------------------------------------------

int main(void) {
    UNITY_BEGIN();

    RUN_TEST(test_push_single_element);
    RUN_TEST(test_push_multiple_elements);

    RUN_TEST(test_top_on_empty_stack_returns_null);
    RUN_TEST(test_top_after_pushes);

    RUN_TEST(test_pop_on_empty_stack_returns_null);
    RUN_TEST(test_pop_removes_elements_in_lifo_order);

    RUN_TEST(test_clearStack_empties_stack);

    return UNITY_END();
}