tests/test_list.c

   1 #include <CUnit/CUnit.h>
   2
   3 #include "list.h"
   4
   5 #include "test_list.h"
   6
   7 void test_list_new(void)
   8 {
   9   struct list *l = list_new();
  10
  11   CU_ASSERT_PTR_NOT_NULL_FATAL(l);
  12   CU_ASSERT_PTR_NULL(l->first);
  13   CU_ASSERT_PTR_NULL(l->last);
  14
  15   list_free(l);
  16 }
  17
  18 void test_list_copy(void)
  19 {
  20   struct list *l = list_new();
  21   struct list *m;
  22
  23   list_append(l, (void *)1);
  24   list_append(l, (void *)2);
  25   list_append(l, (void *)3);
  26
  27   m = list_copy(l);
  28
  29   CU_ASSERT_EQUAL(list_length(l), list_length(m));
  30   CU_ASSERT_PTR_NOT_EQUAL(l, m);
  31
  32   for (struct list_item *item_l = l->first, *item_m = m->first;
  33       item_l != NULL && item_m != NULL;
  34       item_l = item_l->next, item_m = item_m->next) {
  35     CU_ASSERT_PTR_EQUAL(item_l->data, item_m->data);
  36     CU_ASSERT_PTR_NOT_EQUAL(item_l, item_m);
  37   }
  38
  39   list_free(m);
  40   list_free(l);
  41 }
  42
  43 void test_list_free(void)
  44 {
  45   struct list *l = list_new();
  46
  47   list_append(l, (void *)1);
  48   list_append(l, (void *)2);
  49   list_append(l, (void *)3);
  50
  51   list_free(l);
  52
  53   CU_PASS("list_free() didn't crash");
  54 }
  55
  56 void test_list_length(void)
  57 {
  58   struct list *l = list_new();
  59
  60   CU_ASSERT(list_length(l) == 0);
  61
  62   list_append(l, (void *)1);
  63   CU_ASSERT(list_length(l) == 1);
  64
  65   list_append(l, (void *)2);
  66   CU_ASSERT(list_length(l) == 2);
  67
  68   list_append(l, (void *)3);
  69   CU_ASSERT(list_length(l) == 3);
  70
  71   list_append(l, (void *)4);
  72   CU_ASSERT(list_length(l) == 4);
  73
  74   list_free(l);
  75 }
  76
  77 void test_list_append(void)
  78 {
  79   struct list *l = list_new();
  80
  81   list_append(l, (void *)1);
  82
  83   CU_ASSERT_PTR_EQUAL(l->first, l->last);
  84   CU_ASSERT_PTR_NULL(l->first->previous);
  85   CU_ASSERT_PTR_NULL(l->last->next);
  86
  87   CU_ASSERT_PTR_EQUAL(l->first->data, (void *)1);
  88
  89   list_append(l, (void *)2);
  90
  91   CU_ASSERT_PTR_NOT_EQUAL(l->first, l->last);
  92   CU_ASSERT_PTR_EQUAL(l->first->next, l->last);
  93   CU_ASSERT_PTR_EQUAL(l->last->previous, l->first);
  94   CU_ASSERT_PTR_NULL(l->first->previous);
  95   CU_ASSERT_PTR_NULL(l->last->next);
  96
  97   CU_ASSERT_PTR_EQUAL(l->last->data, (void *)2);
  98
  99   list_append(l, (void *)3);
 100
 101   CU_ASSERT_PTR_EQUAL(l->first->next, l->last->previous);
 102   CU_ASSERT_PTR_EQUAL(l->last->previous->previous, l->first);
 103   CU_ASSERT_PTR_NULL(l->first->previous);
 104   CU_ASSERT_PTR_NULL(l->last->next);
 105
 106   CU_ASSERT_PTR_EQUAL(l->last->data, (void *)3);
 107
 108   list_free(l);
 109 }
 110
 111 void test_list_delete_item(void)
 112 {
 113   struct list *l = list_new();
 114
 115   list_append(l, (void *)1);
 116
 117   list_delete_item(l, l->first);
 118
 119   CU_ASSERT_PTR_NULL(l->first);
 120   CU_ASSERT_PTR_NULL(l->last);
 121
 122   list_append(l, (void *)1);
 123   list_append(l, (void *)2);
 124   list_append(l, (void *)3);
 125
 126   list_delete_item(l, l->first->next);
 127
 128   CU_ASSERT_PTR_EQUAL(l->first->next, l->last);
 129   CU_ASSERT_PTR_EQUAL(l->last->previous, l->first);
 130
 131   CU_ASSERT_PTR_EQUAL(l->first->data, (void *)1)
 132   CU_ASSERT_PTR_EQUAL(l->last->data, (void *)3)
 133
 134   list_free(l);
 135 }
 136
 137 void test_list_delete(void)
 138 {
 139   struct list *l = list_new();
 140
 141   list_append(l, (void *)1);
 142   list_append(l, (void *)2);
 143   list_append(l, (void *)3);
 144
 145   list_delete(l, (void *)2);
 146
 147   CU_ASSERT_PTR_EQUAL(l->first->next, l->last);
 148   CU_ASSERT_PTR_EQUAL(l->last->previous, l->first);
 149
 150   CU_ASSERT_PTR_EQUAL(l->first->data, (void *)1)
 151   CU_ASSERT_PTR_EQUAL(l->last->data, (void *)3)
 152
 153   list_delete(l, (void *)1);
 154   list_delete(l, (void *)3);
 155
 156   CU_ASSERT(list_length(l) == 0);
 157
 158   list_delete(l, (void *)4);
 159
 160   list_free(l);
 161 }
 162
 163 void test_list_find(void)
 164 {
 165   struct list *l = list_new();
 166
 167   list_append(l, (void *)1);
 168   list_append(l, (void *)2);
 169   list_append(l, (void *)3);
 170
 171   CU_ASSERT_PTR_EQUAL(list_find(l, (void *)2), l->first->next);
 172   CU_ASSERT_PTR_NULL(list_find(l, (void *)4));
 173   CU_ASSERT_PTR_NULL(list_find(l, NULL));
 174
 175   list_free(l);
 176 }
 177
 178 CU_TestInfo list_tests[] = {
 179   { "test_list_new", test_list_new },
 180   { "test_list_copy", test_list_copy },
 181   { "test_list_free", test_list_free },
 182   { "test_list_length", test_list_length },
 183   { "test_list_append", test_list_append },
 184   { "test_list_delete_item", test_list_delete_item },
 185   { "test_list_delete", test_list_delete },
 186   { "test_list_find", test_list_find },
 187   CU_TEST_INFO_NULL,
 188 };