info2Praktikum-DobleSpiel/test_stack.c

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

#include "stack.h"

// StackNode *createNode(void *data) testen
void test_createNode(void) {

  int testInt = 26;
  StackNode *testNode = createNode(&testInt); // Adresse des testInts

  TEST_ASSERT_NOT_NULL(
      testNode); // Speicher konnte reserviert werden, malloc ist nicht NULL
  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data); // data pointer gesetzt
  TEST_ASSERT_NULL(testNode->next); // vorheriger und nächster Eintrag NULL
  TEST_ASSERT_NULL(testNode->prev);

  free(testNode); // Speicher freigeben
}

// StackNode *push(StackNode *stack, void *data) testen
void test_pushDataToStack(void) {

  int testInts[] = {27, 28};

  StackNode *testStack = NULL; // leeren testStack initialisieren

  testStack =
      push(testStack, &testInts[0]); // leerer Stack mit Adresse des testInts

  TEST_ASSERT_NOT_NULL(testStack); // im Fehlerfall wird testStack unverändert
                                   // zurückgegeben -> bei Fehler NULL
  TEST_ASSERT_EQUAL_PTR(&testInts[0], testStack->data); // data pointer gesetzt
  TEST_ASSERT_NULL(testStack->next); // vorheriger und nächster pointer auf NULL
                                     // gesetzt, da es nur einen Knoten gibt
  TEST_ASSERT_NULL(testStack->prev);

  // zweiter Push
  StackNode *oldHead = testStack; // bisherigen head speichern
  testStack = push(testStack, &testInts[1]);

  TEST_ASSERT_NOT_NULL(testStack);
  TEST_ASSERT_NOT_EQUAL(
      oldHead,
      testStack); // bei malloc Fehler wird der head unverändert zurückgegeben

  TEST_ASSERT_EQUAL_PTR(&testInts[0],
                        oldHead->data); // data pointer wurden richtig gesetzt
  TEST_ASSERT_EQUAL_PTR(&testInts[1], testStack->data);

  // richtige Verkettung: NULL <- testStack -> testStack->next -> oldHead ->
  // NULL
  TEST_ASSERT_EQUAL_PTR(oldHead, testStack->next);
  TEST_ASSERT_EQUAL_PTR(testStack, oldHead->prev);
  TEST_ASSERT_NULL(testStack->prev);

  // Speicherfreigabe
  testStack->next = NULL; // pointer ungültig machen, damit nicht ausversehen
                          // später aufgerufen
  oldHead->prev = NULL;

  free(oldHead);
  free(testStack);
}

void test_deleteTopElement(void) {

  int testInts[] = {10, 20, 30};
  StackNode *stack = NULL;

  for (int i = 0; i < 3;
       i++) { // Stack mit drei Elementen, oberestes Element mit data 30
    stack = push(stack, &testInts[i]);
  }

  TEST_ASSERT_EQUAL_PTR(&testInts[2], stack->data); // oberstes Element ist 30

  stack = pop(stack); // oberstes Element löschen
  TEST_ASSERT_EQUAL_PTR(&testInts[1], stack->data);
  TEST_ASSERT_NULL(
      stack->prev); // pointer zum alten head wurde auf NULL gesetzt

  stack = pop(stack);
  TEST_ASSERT_EQUAL_PTR(&testInts[0], stack->data);
  TEST_ASSERT_NULL(stack->prev);

  stack = pop(stack); // bei leerem Stack wird NULL zurückgegeben
  TEST_ASSERT_NULL(stack);
}

void test_returnData(void) {

  int testInts[] = {10, 20, 30};
  StackNode *stack = NULL;

  for (int i = 0; i < 3; i++) {
    stack = push(stack, &testInts[i]);
  }

  TEST_ASSERT_EQUAL_PTR(&testInts[2],
                        top(stack)); // top gibt richtige Adresse zurück
  stack = pop(stack);                // oberstes Element löschen
  TEST_ASSERT_EQUAL_PTR(&testInts[1], top(stack));

  stack = pop(stack);
  TEST_ASSERT_EQUAL_PTR(&testInts[0], top(stack));

  stack = pop(stack); // bei leerem Stack wird NULL zurückgegeben
  TEST_ASSERT_NULL(stack);
}

void test_clearStack(void) {
  int testInts[] = {1, 2, 3, 4, 5};
  StackNode *stack = NULL;

  for (int i = 0; i < 5; i++) {
    stack = push(stack, &testInts[i]);
  }

  clearStack(&stack);

  TEST_ASSERT_NULL(stack);
}

void setUp(void) {}
void tearDown(void) {}

int main(void) {

  UNITY_BEGIN();

  printf("\n------------------------stack test------------------------\n\n");

  RUN_TEST(test_createNode);
  RUN_TEST(test_pushDataToStack);
  RUN_TEST(test_deleteTopElement);
  RUN_TEST(test_returnData);
  RUN_TEST(test_clearStack);

  return UNITY_END();
}