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


void setUp(void)
{

}
void tearDown(void)
{

}
// 1. Test: push wenn data NULL ist -> stack bleibt NULL
void test_push_data_NULL(void)
{
    int test = 30;
    StackNode *stack = NULL;
    //data = NULL -> stack bleibt NULL
    TEST_ASSERT_NULL(push(NULL,NULL));
}

// 2. Test: push data ungleich NULL -> data wird erneuert und next bleibt 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);
}

//3. Test: zweimal pushen -> data wird zur zweiten Variable; next wird zur ersten
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);
}

// 4. Test: dreimal pushen -> data wird zur dritten variable; next zur zweiten; zweiter next zur dritten
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);
}


// 5. Test: pop wenn Stack gleich NULL -> Stack bleibt NULL
void test_pop_stack_gleich_NULL(void)
{
    StackNode *stack = NULL;
    stack = pop(stack);
    TEST_ASSERT_NULL(stack);
}


// 6. Test: pop mit einer Node -> Stack wird wieder NULL
void test_pop_Stack_ungleich_NULL_eine_Node(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    stack = pop(stack);
    TEST_ASSERT_NULL(stack);
}

// 7. Test: pop mit zwei Nodes -> data wird zur ersten Variable; next wird Null
void test_pop_Stack_ungleich_NULL_zwei_Nodes(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);
}


// 8. Test: pop mikt drei Nodes -> data wird zur zweiten Variable; next zur ersten; next von next wird NULL
void test_pop_Stack_ungleich_NULL_drei_Nodes(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);
}


// 9. Test: top wenn stack gleich NULL -> gibt null zurück
void test_top_stack_gleich_NULL(void)
{
    StackNode *stack = NULL;
    TEST_ASSERT_NULL(stack);
}


// 10. Test: top wenn eine Node -> gibt erste Variable aus
void test_top_stack_ungleich_NULL_eine_Node(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    TEST_ASSERT_EQUAL_PTR(&test, top(stack));
}


// 11. Test: top bei zwei Nodes -> gibt zweite Variable aus
void test_top_stack_ungleich_NULL_zwei_Node(void)
{
    int test = 20;
    StackNode *stack = NULL;
    stack = push(stack, &test);
    int test2 = 40;
    stack = push(stack, &test2);
    TEST_ASSERT_EQUAL_PTR(&test2, top(stack));
}


// 12. Test: top bei drei Nodes -> gibt dritte Variable
void test_top_stack_ungleich_NULL_drei_Node(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_EQUAL_PTR(&test3, top(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_eine_Node);
    RUN_TEST(test_pop_Stack_ungleich_NULL_zwei_Nodes);
    RUN_TEST(test_pop_Stack_ungleich_NULL_drei_Nodes);
    RUN_TEST(test_top_stack_gleich_NULL);
    RUN_TEST(test_top_stack_ungleich_NULL_eine_Node);
    RUN_TEST(test_top_stack_ungleich_NULL_zwei_Node);
    RUN_TEST(test_top_stack_ungleich_NULL_drei_Node);

    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*/