git.ozlabs.org Git - ccan/blob - ccan/list/test/run.c

   1 #include <ccan/list/list.h>
   2 #include <ccan/tap/tap.h>
   3 #include <ccan/list/list.c>
   4 #include "helper.h"
   5
   6 struct parent {
   7         const char *name;
   8         struct list_head children;
   9         unsigned int num_children;
  10 };
  11
  12 struct child {
  13         const char *name;
  14         struct list_node list;
  15 };
  16
  17 static LIST_HEAD(static_list);
  18
  19 int main(int argc, char *argv[])
  20 {
  21         struct parent parent;
  22         struct child c1, c2, c3, *c, *n;
  23         unsigned int i;
  24         struct list_head list = LIST_HEAD_INIT(list);
  25         opaque_t *q, *nq;
  26         struct list_head opaque_list = LIST_HEAD_INIT(opaque_list);
  27
  28         plan_tests(65);
  29         /* Test LIST_HEAD, LIST_HEAD_INIT, list_empty and check_list */
  30         ok1(list_empty(&static_list));
  31         ok1(list_check(&static_list, NULL));
  32         ok1(list_empty(&list));
  33         ok1(list_check(&list, NULL));
  34
  35         parent.num_children = 0;
  36         list_head_init(&parent.children);
  37         /* Test list_head_init */
  38         ok1(list_empty(&parent.children));
  39         ok1(list_check(&parent.children, NULL));
  40
  41         c2.name = "c2";
  42         list_add(&parent.children, &c2.list);
  43         /* Test list_add and !list_empty. */
  44         ok1(!list_empty(&parent.children));
  45         ok1(c2.list.next == &parent.children.n);
  46         ok1(c2.list.prev == &parent.children.n);
  47         ok1(parent.children.n.next == &c2.list);
  48         ok1(parent.children.n.prev == &c2.list);
  49         /* Test list_check */
  50         ok1(list_check(&parent.children, NULL));
  51
  52         c1.name = "c1";
  53         list_add(&parent.children, &c1.list);
  54         /* Test list_add and !list_empty. */
  55         ok1(!list_empty(&parent.children));
  56         ok1(c2.list.next == &parent.children.n);
  57         ok1(c2.list.prev == &c1.list);
  58         ok1(parent.children.n.next == &c1.list);
  59         ok1(parent.children.n.prev == &c2.list);
  60         ok1(c1.list.next == &c2.list);
  61         ok1(c1.list.prev == &parent.children.n);
  62         /* Test list_check */
  63         ok1(list_check(&parent.children, NULL));
  64
  65         c3.name = "c3";
  66         list_add_tail(&parent.children, &c3.list);
  67         /* Test list_add_tail and !list_empty. */
  68         ok1(!list_empty(&parent.children));
  69         ok1(parent.children.n.next == &c1.list);
  70         ok1(parent.children.n.prev == &c3.list);
  71         ok1(c1.list.next == &c2.list);
  72         ok1(c1.list.prev == &parent.children.n);
  73         ok1(c2.list.next == &c3.list);
  74         ok1(c2.list.prev == &c1.list);
  75         ok1(c3.list.next == &parent.children.n);
  76         ok1(c3.list.prev == &c2.list);
  77         /* Test list_check */
  78         ok1(list_check(&parent.children, NULL));
  79
  80         /* Test list_check_node */
  81         ok1(list_check_node(&c1.list, NULL));
  82         ok1(list_check_node(&c2.list, NULL));
  83         ok1(list_check_node(&c3.list, NULL));
  84
  85         /* Test list_top */
  86         ok1(list_top(&parent.children, struct child, list) == &c1);
  87
  88         /* Test list_tail */
  89         ok1(list_tail(&parent.children, struct child, list) == &c3);
  90
  91         /* Test list_for_each. */
  92         i = 0;
  93         list_for_each(&parent.children, c, list) {
  94                 switch (i++) {
  95                 case 0:
  96                         ok1(c == &c1);
  97                         break;
  98                 case 1:
  99                         ok1(c == &c2);
 100                         break;
 101                 case 2:
 102                         ok1(c == &c3);
 103                         break;
 104                 }
 105                 if (i > 2)
 106                         break;
 107         }
 108         ok1(i == 3);
 109
 110         /* Test list_for_each_rev. */
 111         i = 0;
 112         list_for_each_rev(&parent.children, c, list) {
 113                 switch (i++) {
 114                 case 0:
 115                         ok1(c == &c3);
 116                         break;
 117                 case 1:
 118                         ok1(c == &c2);
 119                         break;
 120                 case 2:
 121                         ok1(c == &c1);
 122                         break;
 123                 }
 124                 if (i > 2)
 125                         break;
 126         }
 127         ok1(i == 3);
 128
 129         /* Test list_for_each_safe, list_del and list_del_from. */
 130         i = 0;
 131         list_for_each_safe(&parent.children, c, n, list) {
 132                 switch (i++) {
 133                 case 0:
 134                         ok1(c == &c1);
 135                         list_del(&c->list);
 136                         break;
 137                 case 1:
 138                         ok1(c == &c2);
 139                         list_del_from(&parent.children, &c->list);
 140                         break;
 141                 case 2:
 142                         ok1(c == &c3);
 143                         list_del_from(&parent.children, &c->list);
 144                         break;
 145                 }
 146                 ok1(list_check(&parent.children, NULL));
 147                 if (i > 2)
 148                         break;
 149         }
 150         ok1(i == 3);
 151         ok1(list_empty(&parent.children));
 152
 153         /* Test list_for_each_off. */
 154         list_add_tail(&opaque_list,
 155                       (struct list_node *)create_opaque_blob());
 156         list_add_tail(&opaque_list,
 157                       (struct list_node *)create_opaque_blob());
 158         list_add_tail(&opaque_list,
 159                       (struct list_node *)create_opaque_blob());
 160
 161         i = 0;
 162
 163         list_for_each_off(&opaque_list, q, 0) {
 164           i++;
 165           ok1(if_blobs_know_the_secret(q));
 166         }
 167         ok1(i == 3);
 168
 169         /* Test list_for_each_safe_off, list_del_off and list_del_from_off. */
 170         i = 0;
 171         list_for_each_safe_off(&opaque_list, q, nq, 0) {
 172                 switch (i++) {
 173                 case 0:
 174                         ok1(if_blobs_know_the_secret(q));
 175                         list_del_off(q, 0);
 176                         destroy_opaque_blob(q);
 177                         break;
 178                 case 1:
 179                         ok1(if_blobs_know_the_secret(q));
 180                         list_del_from_off(&opaque_list, q, 0);
 181                         destroy_opaque_blob(q);
 182                         break;
 183                 case 2:
 184                         ok1(c == &c3);
 185                         list_del_from_off(&opaque_list, q, 0);
 186                         destroy_opaque_blob(q);
 187                         break;
 188                 }
 189                 ok1(list_check(&opaque_list, NULL));
 190                 if (i > 2)
 191                         break;
 192         }
 193         ok1(i == 3);
 194         ok1(list_empty(&opaque_list));
 195
 196         /* Test list_top/list_tail on empty list. */
 197         ok1(list_top(&parent.children, struct child, list) == NULL);
 198         ok1(list_tail(&parent.children, struct child, list) == NULL);
 199         return exit_status();
 200 }