box-o-sand/lcthw-remnants-2/liblcthw/tests/lcthw/list_tests.c

#include "../minunit.h"
#include <lcthw/list.h>
#include <assert.h>

static List *list = NULL;
char *test1 = "test1 data";
char *test2 = "test2 data";
char *test3 = "test3 data";
char *test4 = "test4 data";


char *test_create()
{
  list = List_create();
  mu_assert(list != NULL, "Failed to create list.");

  return NULL;
}


char *test_destroy()
{
  List_clear_destroy(list);

  return NULL;
}


char *test_push_pop()
{
  List_push(list, test1);
  mu_assert(List_last(list) == test1, "Wrong last value.");

  List_push(list, test2);
  mu_assert(List_last(list) == test2, "Wrong last value");

  List_push(list, test3);
  mu_assert(List_last(list) == test3, "Wrong last value");
  mu_assert(List_count(list) == 3, "Wrong count on push.");

  char *val = List_pop(list);
  mu_assert(val == test3, "Wrong value on pop.");

  val = List_pop(list);
  mu_assert(val == test2, "Wrong value on pop.");

  val = List_pop(list);
  mu_assert(val == test1, "Wrong value on pop.");
  mu_assert(List_count(list) == 0, "Wrong count after pop.");

  return NULL;
}

char *test_unshift()
{
  List_unshift(list, test1);
  mu_assert(List_first(list) == test1, "Wrong first value.");

  List_unshift(list, test2);
  mu_assert(List_first(list) == test2, "Wrong first value.");

  List_unshift(list, test3);
  mu_assert(List_first(list) == test3, "Wrong first value.");
  mu_assert(List_count(list) == 3, "Wrong count on unshift.");

  return NULL;
}

char *test_remove()
{
  // we only need to test the middle remove case since push/shift
  // already tests the other cases

  char *val = List_remove(list, list->first->next);
  mu_assert(val == test2, "Wrong removed element.");
  mu_assert(List_count(list) == 2, "Wrong count after remove.");
  mu_assert(List_first(list) == test3, "Wrong first after remove.");
  mu_assert(List_last(list) == test1, "Wrong last after remove.");

  return NULL;
}


char *test_shift()
{
  mu_assert(List_count(list) != 0, "Wrong count before shift.");

  char *val = List_shift(list);
  mu_assert(val == test3, "Wrong value on shift.");

  val = List_shift(list);
  mu_assert(val == test1, "Wrong value on shift.");
  mu_assert(List_count(list) == 0, "Wrong count after shift.");

  return NULL;
}


char *test_copy()
{
  list = List_create();

  mu_assert(List_count(list) == 0, "Wrong count before copy.");
  List_push(list, test1);
  List_push(list, test2);
  List_push(list, test3);
  List_push(list, test4);

  mu_assert(List_count(list) == 4, "Wrong count after push.");

  List *copy = List_copy(list);
  mu_assert(copy != list, "Copy and list have same address.");
  mu_assert(List_count(copy) == 4, "Copy has wrong count.");

  return NULL;
}


char *test_split()
{
  mu_assert(List_count(list) == 4, "Wrong count before split.");

  List *a = List_create();
  List *b = List_create();
  List *tmp = List_copy(list);

  int rc = -1;
  rc = List_split(tmp, test2, a, b);
  mu_assert(rc == 0, "Failed to split.");
  mu_assert(List_count(a) == 2, "List 'a' has wrong count.");
  mu_assert(List_count(b) == 2, "List 'b' has wrong count.");

  List_destroy(a);
  List_destroy(b);

  a = List_create();
  b = List_create();
  tmp = List_copy(list);

  rc = List_split(tmp, test1, a, b);
  mu_assert(rc == 0, "Failed to split.");
  mu_assert(List_count(a) == 1, "List 'a' has wrong count.");
  mu_assert(List_count(b) == 3, "List 'b' has wrong count.");

  List_destroy(a);
  List_destroy(b);

  a = List_create();
  b = List_create();
  tmp = List_copy(list);

  rc = List_split(tmp, test3, a, b);
  mu_assert(rc == 0, "Failed to split.");
  mu_assert(List_count(a) == 3, "List 'a' has wrong count.");
  mu_assert(List_count(b) == 1, "List 'b' has wrong count.");

  List_destroy(a);
  List_destroy(b);

  a = List_create();
  b = List_create();
  tmp = List_copy(list);

  rc = List_split(tmp, test4, a, b);
  mu_assert(rc == 0, "Failed to split.");
  mu_assert(List_count(a) == 4, "List 'a' has wrong count.");
  mu_assert(List_count(b) == 0, "List 'b' has wrong count.");

  return NULL;
}


char *test_join()
{
  mu_assert(List_count(list) == 4, "Wrong count before join.");

  List *b = List_create();
  List_push(b, test4);
  mu_assert(List_count(b) == 1, "List 'b' has wrong count.");

  List_join(list, b);
  mu_assert(List_count(list) == 5, "Wrong count after join.");

  return NULL;
}



char *all_tests() {
  mu_suite_start();

  mu_run_test(test_create);
  mu_run_test(test_push_pop);
  mu_run_test(test_unshift);
  mu_run_test(test_remove);
  mu_run_test(test_shift);
  mu_run_test(test_destroy);
  mu_run_test(test_copy);
  mu_run_test(test_split);
  mu_run_test(test_join);

  return NULL;
}

RUN_TESTS(all_tests);