src/test/test-list.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2013 Jan Janssen
   4 ***/
   5
   6 #include "list.h"
   7 #include "util.h"
   8
   9 int main(int argc, const char *argv[]) {
  10         size_t i;
  11         typedef struct list_item {
  12                 LIST_FIELDS(struct list_item, item);
  13         } list_item;
  14         LIST_HEAD(list_item, head);
  15         LIST_HEAD(list_item, head2);
  16         list_item items[4];
  17         list_item *cursor;
  18
  19         LIST_HEAD_INIT(head);
  20         LIST_HEAD_INIT(head2);
  21         assert_se(head == NULL);
  22         assert_se(head2 == NULL);
  23
  24         for (i = 0; i < ELEMENTSOF(items); i++) {
  25                 LIST_INIT(item, &items[i]);
  26                 assert_se(LIST_JUST_US(item, &items[i]));
  27                 LIST_PREPEND(item, head, &items[i]);
  28         }
  29
  30         i = 0;
  31         LIST_FOREACH_OTHERS(item, cursor, &items[2]) {
  32                 i++;
  33                 assert_se(cursor != &items[2]);
  34         }
  35         assert_se(i == ELEMENTSOF(items)-1);
  36
  37         i = 0;
  38         LIST_FOREACH_OTHERS(item, cursor, &items[0]) {
  39                 i++;
  40                 assert_se(cursor != &items[0]);
  41         }
  42         assert_se(i == ELEMENTSOF(items)-1);
  43
  44         i = 0;
  45         LIST_FOREACH_OTHERS(item, cursor, &items[3]) {
  46                 i++;
  47                 assert_se(cursor != &items[3]);
  48         }
  49         assert_se(i == ELEMENTSOF(items)-1);
  50
  51         assert_se(!LIST_JUST_US(item, head));
  52
  53         assert_se(items[0].item_next == NULL);
  54         assert_se(items[1].item_next == &items[0]);
  55         assert_se(items[2].item_next == &items[1]);
  56         assert_se(items[3].item_next == &items[2]);
  57
  58         assert_se(items[0].item_prev == &items[1]);
  59         assert_se(items[1].item_prev == &items[2]);
  60         assert_se(items[2].item_prev == &items[3]);
  61         assert_se(items[3].item_prev == NULL);
  62
  63         LIST_FIND_HEAD(item, &items[0], cursor);
  64         assert_se(cursor == &items[3]);
  65
  66         LIST_FIND_TAIL(item, &items[3], cursor);
  67         assert_se(cursor == &items[0]);
  68
  69         LIST_REMOVE(item, head, &items[1]);
  70         assert_se(LIST_JUST_US(item, &items[1]));
  71
  72         assert_se(items[0].item_next == NULL);
  73         assert_se(items[2].item_next == &items[0]);
  74         assert_se(items[3].item_next == &items[2]);
  75
  76         assert_se(items[0].item_prev == &items[2]);
  77         assert_se(items[2].item_prev == &items[3]);
  78         assert_se(items[3].item_prev == NULL);
  79
  80         LIST_INSERT_AFTER(item, head, &items[3], &items[1]);
  81         assert_se(items[0].item_next == NULL);
  82         assert_se(items[2].item_next == &items[0]);
  83         assert_se(items[1].item_next == &items[2]);
  84         assert_se(items[3].item_next == &items[1]);
  85
  86         assert_se(items[0].item_prev == &items[2]);
  87         assert_se(items[2].item_prev == &items[1]);
  88         assert_se(items[1].item_prev == &items[3]);
  89         assert_se(items[3].item_prev == NULL);
  90
  91         LIST_REMOVE(item, head, &items[1]);
  92         assert_se(LIST_JUST_US(item, &items[1]));
  93
  94         assert_se(items[0].item_next == NULL);
  95         assert_se(items[2].item_next == &items[0]);
  96         assert_se(items[3].item_next == &items[2]);
  97
  98         assert_se(items[0].item_prev == &items[2]);
  99         assert_se(items[2].item_prev == &items[3]);
 100         assert_se(items[3].item_prev == NULL);
 101
 102         LIST_INSERT_BEFORE(item, head, &items[2], &items[1]);
 103         assert_se(items[0].item_next == NULL);
 104         assert_se(items[2].item_next == &items[0]);
 105         assert_se(items[1].item_next == &items[2]);
 106         assert_se(items[3].item_next == &items[1]);
 107
 108         assert_se(items[0].item_prev == &items[2]);
 109         assert_se(items[2].item_prev == &items[1]);
 110         assert_se(items[1].item_prev == &items[3]);
 111         assert_se(items[3].item_prev == NULL);
 112
 113         LIST_REMOVE(item, head, &items[0]);
 114         assert_se(LIST_JUST_US(item, &items[0]));
 115
 116         assert_se(items[2].item_next == NULL);
 117         assert_se(items[1].item_next == &items[2]);
 118         assert_se(items[3].item_next == &items[1]);
 119
 120         assert_se(items[2].item_prev == &items[1]);
 121         assert_se(items[1].item_prev == &items[3]);
 122         assert_se(items[3].item_prev == NULL);
 123
 124         LIST_INSERT_BEFORE(item, head, &items[3], &items[0]);
 125         assert_se(items[2].item_next == NULL);
 126         assert_se(items[1].item_next == &items[2]);
 127         assert_se(items[3].item_next == &items[1]);
 128         assert_se(items[0].item_next == &items[3]);
 129
 130         assert_se(items[2].item_prev == &items[1]);
 131         assert_se(items[1].item_prev == &items[3]);
 132         assert_se(items[3].item_prev == &items[0]);
 133         assert_se(items[0].item_prev == NULL);
 134         assert_se(head == &items[0]);
 135
 136         LIST_REMOVE(item, head, &items[0]);
 137         assert_se(LIST_JUST_US(item, &items[0]));
 138
 139         assert_se(items[2].item_next == NULL);
 140         assert_se(items[1].item_next == &items[2]);
 141         assert_se(items[3].item_next == &items[1]);
 142
 143         assert_se(items[2].item_prev == &items[1]);
 144         assert_se(items[1].item_prev == &items[3]);
 145         assert_se(items[3].item_prev == NULL);
 146
 147         LIST_INSERT_BEFORE(item, head, NULL, &items[0]);
 148         assert_se(items[0].item_next == NULL);
 149         assert_se(items[2].item_next == &items[0]);
 150         assert_se(items[1].item_next == &items[2]);
 151         assert_se(items[3].item_next == &items[1]);
 152
 153         assert_se(items[0].item_prev == &items[2]);
 154         assert_se(items[2].item_prev == &items[1]);
 155         assert_se(items[1].item_prev == &items[3]);
 156         assert_se(items[3].item_prev == NULL);
 157
 158         LIST_REMOVE(item, head, &items[0]);
 159         assert_se(LIST_JUST_US(item, &items[0]));
 160
 161         assert_se(items[2].item_next == NULL);
 162         assert_se(items[1].item_next == &items[2]);
 163         assert_se(items[3].item_next == &items[1]);
 164
 165         assert_se(items[2].item_prev == &items[1]);
 166         assert_se(items[1].item_prev == &items[3]);
 167         assert_se(items[3].item_prev == NULL);
 168
 169         LIST_REMOVE(item, head, &items[1]);
 170         assert_se(LIST_JUST_US(item, &items[1]));
 171
 172         assert_se(items[2].item_next == NULL);
 173         assert_se(items[3].item_next == &items[2]);
 174
 175         assert_se(items[2].item_prev == &items[3]);
 176         assert_se(items[3].item_prev == NULL);
 177
 178         LIST_REMOVE(item, head, &items[2]);
 179         assert_se(LIST_JUST_US(item, &items[2]));
 180         assert_se(LIST_JUST_US(item, head));
 181
 182         LIST_REMOVE(item, head, &items[3]);
 183         assert_se(LIST_JUST_US(item, &items[3]));
 184
 185         assert_se(head == NULL);
 186
 187         for (i = 0; i < ELEMENTSOF(items); i++) {
 188                 assert_se(LIST_JUST_US(item, &items[i]));
 189                 LIST_APPEND(item, head, &items[i]);
 190         }
 191
 192         assert_se(!LIST_JUST_US(item, head));
 193
 194         assert_se(items[0].item_next == &items[1]);
 195         assert_se(items[1].item_next == &items[2]);
 196         assert_se(items[2].item_next == &items[3]);
 197         assert_se(items[3].item_next == NULL);
 198
 199         assert_se(items[0].item_prev == NULL);
 200         assert_se(items[1].item_prev == &items[0]);
 201         assert_se(items[2].item_prev == &items[1]);
 202         assert_se(items[3].item_prev == &items[2]);
 203
 204         for (i = 0; i < ELEMENTSOF(items); i++)
 205                 LIST_REMOVE(item, head, &items[i]);
 206
 207         assert_se(head == NULL);
 208
 209         for (i = 0; i < ELEMENTSOF(items) / 2; i++) {
 210                 LIST_INIT(item, &items[i]);
 211                 assert_se(LIST_JUST_US(item, &items[i]));
 212                 LIST_PREPEND(item, head, &items[i]);
 213         }
 214
 215         for (i = ELEMENTSOF(items) / 2; i < ELEMENTSOF(items); i++) {
 216                 LIST_INIT(item, &items[i]);
 217                 assert_se(LIST_JUST_US(item, &items[i]));
 218                 LIST_PREPEND(item, head2, &items[i]);
 219         }
 220
 221         assert_se(items[0].item_next == NULL);
 222         assert_se(items[1].item_next == &items[0]);
 223         assert_se(items[2].item_next == NULL);
 224         assert_se(items[3].item_next == &items[2]);
 225
 226         assert_se(items[0].item_prev == &items[1]);
 227         assert_se(items[1].item_prev == NULL);
 228         assert_se(items[2].item_prev == &items[3]);
 229         assert_se(items[3].item_prev == NULL);
 230
 231         LIST_JOIN(item, head2, head);
 232         assert_se(head == NULL);
 233
 234         assert_se(items[0].item_next == NULL);
 235         assert_se(items[1].item_next == &items[0]);
 236         assert_se(items[2].item_next == &items[1]);
 237         assert_se(items[3].item_next == &items[2]);
 238
 239         assert_se(items[0].item_prev == &items[1]);
 240         assert_se(items[1].item_prev == &items[2]);
 241         assert_se(items[2].item_prev == &items[3]);
 242         assert_se(items[3].item_prev == NULL);
 243
 244         LIST_JOIN(item, head, head2);
 245         assert_se(head2 == NULL);
 246         assert_se(!LIST_IS_EMPTY(head));
 247
 248         for (i = 0; i < ELEMENTSOF(items); i++)
 249                 LIST_REMOVE(item, head, &items[i]);
 250
 251         assert_se(head == NULL);
 252
 253         return 0;
 254 }