tal: add tal_dup_or_null and tal_dup_talarr helpers.
[ccan] / ccan / intmap / test / run-order.c
1 #include <ccan/intmap/intmap.c>
2 #include <ccan/tap/tap.h>
3 #include <stdio.h>
4
5 #define NUM 1000
6
7 typedef UINTMAP(unsigned int *) umap;
8 typedef SINTMAP(int *) smap;
9
10 static bool uint_iterate_check(intmap_index_t i, unsigned int *v, int64_t *prev)
11 {
12         if ((int64_t)i <= *prev)
13                 return false;
14         if (*v != i)
15                 return false;
16         *prev = i;
17         return true;
18 }
19
20 static bool check_umap(const umap *map)
21 {
22         /* This is a larger type than unsigned, and allows negative */
23         int64_t prev;
24         uint64_t i, last_idx;
25         unsigned int *v;
26         bool last = true;
27
28         /* Must be in order, must contain value. */
29         prev = -1;
30         for (v = uintmap_first(map, &i); v; v = uintmap_after(map, &i)) {
31                 if ((int64_t)i <= prev)
32                         return false;
33                 if (*v != i)
34                         return false;
35                 prev = i;
36                 last = (uintmap_last(map, &last_idx) == v);
37         }
38
39         if (!last)
40                 return false;
41
42         prev = INT_MAX;
43         for (v = uintmap_last(map, &i); v; v = uintmap_before(map, &i)) {
44                 if ((int64_t)i >= prev)
45                         return false;
46                 if (*v != i)
47                         return false;
48                 prev = i;
49                 last = (uintmap_first(map, &last_idx) == v);
50         }
51
52         if (!last)
53                 return false;
54
55         prev = -1;
56         return uintmap_iterate(map, uint_iterate_check, &prev);
57 }
58
59 static bool sint_iterate_check(sintmap_index_t i, int *v, int64_t *prev)
60 {
61         if (i <= *prev)
62                 return false;
63         if (*v != i)
64                 return false;
65         *prev = i;
66         return true;
67 }
68
69 static bool check_smap(const smap *map)
70 {
71         /* This is a larger type than int, and allows negative */
72         int64_t prev, i, last_idx;
73         int *v;
74         bool last = true;
75
76         /* Must be in order, must contain value. */
77         prev = -0x80000001ULL;
78         for (v = sintmap_first(map, &i); v; v = sintmap_after(map, &i)) {
79                 if (i <= prev)
80                         return false;
81                 if (*v != i)
82                         return false;
83                 last = (sintmap_last(map, &last_idx) == v);
84                 prev = i;
85         }
86
87         if (!last)
88                 return false;
89
90         prev = 0x80000001ULL;
91         for (v = sintmap_last(map, &i); v; v = sintmap_before(map, &i)) {
92                 if (i >= prev)
93                         return false;
94                 if (*v != i)
95                         return false;
96                 prev = i;
97                 last = (sintmap_first(map, &last_idx) == v);
98         }
99         if (!last)
100                 return false;
101
102         prev = -1;
103         return sintmap_iterate(map, sint_iterate_check, &prev);
104 }
105
106 int main(void)
107 {
108         umap umap;
109         smap smap;
110         int i;
111         unsigned int urandoms[NUM];
112         int srandoms[NUM];
113
114         plan_tests(6 * NUM + 2);
115         uintmap_init(&umap);
116         sintmap_init(&smap);
117
118         for (i = 0; i < NUM; i++) {
119                 urandoms[i] = random();
120                 srandoms[i] = random();
121         }
122         for (i = 0; i < NUM; i++) {
123                 /* In case we have duplicates. */
124                 while (!uintmap_add(&umap, urandoms[i], urandoms+i))
125                         urandoms[i] = random();
126                 ok1(check_umap(&umap));
127         }
128         for (i = 0; i < NUM; i++) {
129                 ok1(uintmap_del(&umap, urandoms[i]) == urandoms+i);
130                 ok1(check_umap(&umap));
131         }
132         ok1(uintmap_empty(&umap));
133
134         for (i = 0; i < NUM; i++) {
135                 /* In case we have duplicates. */
136                 while (!sintmap_add(&smap, srandoms[i], srandoms+i))
137                         srandoms[i] = random();
138                 ok1(check_smap(&smap));
139         }
140         for (i = 0; i < NUM; i++) {
141                 ok1(sintmap_del(&smap, srandoms[i]) == srandoms+i);
142                 ok1(check_smap(&smap));
143         }
144         ok1(sintmap_empty(&smap));
145
146         /* This exits depending on whether all tests passed */
147         return exit_status();
148 }