#include "unity.h"
#include "stack.h"


void setUp(void)
{

}
void tearDown(void)
{

}

void test_push_data_NULL(void)
{
    int test = 30;
    StackNode *stack = NULL;
    //data = NULL -> stack bleibt NULL
    TEST_ASSERT_NULL(push(NULL,NULL));
}
void test_push_erster_push(void)
{
    int test = 20;
    StackNode *stack = NULL;
    StackNode expected = {&test, NULL};
    stack = push(stack, &test);
    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_PTR(&test, stack->data);
    TEST_ASSERT_EQUAL_MEMORY(&expected, stack, sizeof(StackNode));
    TEST_ASSERT_NULL(stack->next);
}
void test_push_zweiter_push(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    int test2 = 40;
    stack = push(stack, &test2);
    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_PTR(&test2, stack->data);
    TEST_ASSERT_NOT_NULL(stack->next);
    TEST_ASSERT_EQUAL_PTR(&test, stack->next->data);
    TEST_ASSERT_NULL(stack->next->next);
}
void test_push_dritter_push(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    int test2 = 40;
    stack = push(stack, &test2);
    int test3 = 60;
    stack = push(stack, &test3);
    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_PTR(&test3, stack->data);
    TEST_ASSERT_NOT_NULL(stack->next);
    TEST_ASSERT_EQUAL_PTR(&test2, stack->next->data);
    TEST_ASSERT_NOT_NULL(stack->next->next);
    TEST_ASSERT_EQUAL_PTR(&test, stack->next->next->data);
    TEST_ASSERT_NULL(stack->next->next->next);
}

void test_pop_Stack_ungleich_NULL_zwei_pushes(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    int test2 = 40;
    stack = push(stack, &test2);
    stack = pop(stack);
    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_PTR(&test, stack->data);
    TEST_ASSERT_NULL(stack->next);
}

void test_pop_Stack_ungleich_NULL_drei_pushes(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    int test2 = 40;
    stack = push(stack, &test2);
    int test3 = 60;
    stack = push(stack, &test3);
    stack = pop(stack);
    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_PTR(&test2, stack->data);
    TEST_ASSERT_NOT_NULL(stack->next);
    TEST_ASSERT_EQUAL_PTR(&test, stack->next->data);
    TEST_ASSERT_NULL(stack->next->next);
}

void test_pop_stack_gleich_NULL(void)
{
    StackNode *stack = NULL;
    stack = pop(stack);
    TEST_ASSERT_NULL(stack);
}

int main(void)
{
    UNITY_BEGIN();
    RUN_TEST(test_push_data_NULL);
    RUN_TEST(test_push_erster_push);
    RUN_TEST(test_push_zweiter_push);
    RUN_TEST(test_push_dritter_push);
    RUN_TEST(test_pop_stack_gleich_NULL);
    RUN_TEST(test_pop_Stack_ungleich_NULL_zwei_pushes);
    RUN_TEST(test_pop_Stack_ungleich_NULL_drei_pushes);

    return UNITY_END();
}





/*TEST_ASSERT_NULL(ptr)	ptr == NULL
TEST_ASSERT_NOT_NULL(ptr)	ptr != NULL
TEST_ASSERT_EQUAL_PTR(expected, actual)	gleiche Adresse
TEST_ASSERT_EQUAL_MEMORY(exp, act, size)	gleicher Speicherinhalt
TEST_ASSERT_EQUAL_INT_ARRAY(a, b, len)	prüft Array-Speicher als ints
TEST_ASSERT_EQUAL_UINT8_ARRAY(a, b, len)	prüft Byte-Array*/