Branch data     Line data    Source code

       1                 :            : #include <ccan/list/list.h>
       2                 :            : #include <ccan/tap/tap.h>
       3                 :            : #include <ccan/list/list.c>
       4                 :            : #include <stdarg.h>
       5                 :            : 
       6                 :         80 : static bool list_expect(struct list_head *h, ...)
       7                 :            : {
       8                 :            :         va_list ap;
       9                 :         80 :         struct list_node *n = &h->n, *expected;
      10                 :            : 
      11                 :         80 :         va_start(ap, h);
      12                 :        250 :         while ((expected = va_arg(ap, struct list_node *)) != NULL) {
      13                 :        170 :                 n = n->next;
      14                 :        170 :                 if (n != expected)
      15                 :          0 :                         return false;
      16                 :            :         }
      17                 :         80 :         return (n->next == &h->n);
      18                 :            : }
      19                 :            : 
      20                 :         10 : int main(void)
      21                 :            : {
      22                 :            :         struct list_head h1, h2;
      23                 :            :         struct list_node n[4];
      24                 :            : 
      25                 :            :         plan_tests(40);
      26                 :            : 
      27                 :         10 :         list_head_init(&h1);
      28                 :         10 :         list_head_init(&h2);
      29                 :            : 
      30                 :            :         /* Append an empty list to an empty list. */
      31                 :         10 :         list_append_list(&h1, &h2);
      32                 :         10 :         ok1(list_empty(&h1));
      33                 :         10 :         ok1(list_empty(&h2));
      34                 :         10 :         ok1(list_check(&h1, NULL));
      35                 :         10 :         ok1(list_check(&h2, NULL));
      36                 :            : 
      37                 :            :         /* Prepend an empty list to an empty list. */
      38                 :         10 :         list_prepend_list(&h1, &h2);
      39                 :         10 :         ok1(list_empty(&h1));
      40                 :         10 :         ok1(list_empty(&h2));
      41                 :         10 :         ok1(list_check(&h1, NULL));
      42                 :         10 :         ok1(list_check(&h2, NULL));
      43                 :            : 
      44                 :            :         /* Append an empty list to a non-empty list */
      45                 :         10 :         list_add(&h1, &n[0]);
      46                 :         10 :         list_append_list(&h1, &h2);
      47                 :         10 :         ok1(list_empty(&h2));
      48                 :         10 :         ok1(list_check(&h1, NULL));
      49                 :         10 :         ok1(list_check(&h2, NULL));
      50                 :         10 :         ok1(list_expect(&h1, &n[0], NULL));
      51                 :            : 
      52                 :            :         /* Prepend an empty list to a non-empty list */
      53                 :         10 :         list_prepend_list(&h1, &h2);
      54                 :         10 :         ok1(list_empty(&h2));
      55                 :         10 :         ok1(list_check(&h1, NULL));
      56                 :         10 :         ok1(list_check(&h2, NULL));
      57                 :         10 :         ok1(list_expect(&h1, &n[0], NULL));
      58                 :            : 
      59                 :            :         /* Append a non-empty list to an empty list. */
      60                 :         10 :         list_append_list(&h2, &h1);
      61                 :         10 :         ok1(list_empty(&h1));
      62                 :         10 :         ok1(list_check(&h1, NULL));
      63                 :         10 :         ok1(list_check(&h2, NULL));
      64                 :         10 :         ok1(list_expect(&h2, &n[0], NULL));
      65                 :            : 
      66                 :            :         /* Prepend a non-empty list to an empty list. */
      67                 :         10 :         list_prepend_list(&h1, &h2);
      68                 :         10 :         ok1(list_empty(&h2));
      69                 :         10 :         ok1(list_check(&h1, NULL));
      70                 :         10 :         ok1(list_check(&h2, NULL));
      71                 :         10 :         ok1(list_expect(&h1, &n[0], NULL));
      72                 :            : 
      73                 :            :         /* Prepend a non-empty list to non-empty list. */
      74                 :         10 :         list_add(&h2, &n[1]);
      75                 :         10 :         list_prepend_list(&h1, &h2);
      76                 :         10 :         ok1(list_empty(&h2));
      77                 :         10 :         ok1(list_check(&h1, NULL));
      78                 :         10 :         ok1(list_check(&h2, NULL));
      79                 :         10 :         ok1(list_expect(&h1, &n[1], &n[0], NULL));
      80                 :            : 
      81                 :            :         /* Append a non-empty list to non-empty list. */
      82                 :         10 :         list_add(&h2, &n[2]);
      83                 :         10 :         list_append_list(&h1, &h2);
      84                 :         10 :         ok1(list_empty(&h2));
      85                 :         10 :         ok1(list_check(&h1, NULL));
      86                 :         10 :         ok1(list_check(&h2, NULL));
      87                 :         10 :         ok1(list_expect(&h1, &n[1], &n[0], &n[2], NULL));
      88                 :            : 
      89                 :            :         /* Prepend a 2-entry list to a 2-entry list. */
      90                 :         10 :         list_del_from(&h1, &n[2]);
      91                 :         10 :         list_add(&h2, &n[2]);
      92                 :         10 :         list_add_tail(&h2, &n[3]);
      93                 :         10 :         list_prepend_list(&h1, &h2);
      94                 :         10 :         ok1(list_empty(&h2));
      95                 :         10 :         ok1(list_check(&h1, NULL));
      96                 :         10 :         ok1(list_check(&h2, NULL));
      97                 :         10 :         ok1(list_expect(&h1, &n[2], &n[3], &n[1], &n[0], NULL));
      98                 :            : 
      99                 :            :         /* Append a 2-entry list to a 2-entry list. */
     100                 :         10 :         list_del_from(&h1, &n[2]);
     101                 :         10 :         list_del_from(&h1, &n[3]);
     102                 :         10 :         list_add(&h2, &n[2]);
     103                 :         10 :         list_add_tail(&h2, &n[3]);
     104                 :         10 :         list_append_list(&h1, &h2);
     105                 :         10 :         ok1(list_empty(&h2));
     106                 :         10 :         ok1(list_check(&h1, NULL));
     107                 :         10 :         ok1(list_check(&h2, NULL));
     108                 :         10 :         ok1(list_expect(&h1, &n[1], &n[0], &n[2], &n[3], NULL));
     109                 :            : 
     110                 :         10 :         return exit_status();
     111                 :            : }