migration: do cleanup operation after completion
[kvmfornfv.git] / qemu / tests / test-hbitmap.c
1 /*
2  * Hierarchical bitmap unit-tests.
3  *
4  * Copyright (C) 2012 Red Hat Inc.
5  *
6  * Author: Paolo Bonzini <pbonzini@redhat.com>
7  *
8  * This work is licensed under the terms of the GNU GPL, version 2 or later.
9  * See the COPYING file in the top-level directory.
10  */
11
12 #include <glib.h>
13 #include <stdarg.h>
14 #include <string.h>
15 #include <sys/types.h>
16 #include "qemu/hbitmap.h"
17
18 #define LOG_BITS_PER_LONG          (BITS_PER_LONG == 32 ? 5 : 6)
19
20 #define L1                         BITS_PER_LONG
21 #define L2                         (BITS_PER_LONG * L1)
22 #define L3                         (BITS_PER_LONG * L2)
23
24 typedef struct TestHBitmapData {
25     HBitmap       *hb;
26     unsigned long *bits;
27     size_t         size;
28     size_t         old_size;
29     int            granularity;
30 } TestHBitmapData;
31
32
33 /* Check that the HBitmap and the shadow bitmap contain the same data,
34  * ignoring the same "first" bits.
35  */
36 static void hbitmap_test_check(TestHBitmapData *data,
37                                uint64_t first)
38 {
39     uint64_t count = 0;
40     size_t pos;
41     int bit;
42     HBitmapIter hbi;
43     int64_t i, next;
44
45     hbitmap_iter_init(&hbi, data->hb, first);
46
47     i = first;
48     for (;;) {
49         next = hbitmap_iter_next(&hbi);
50         if (next < 0) {
51             next = data->size;
52         }
53
54         while (i < next) {
55             pos = i >> LOG_BITS_PER_LONG;
56             bit = i & (BITS_PER_LONG - 1);
57             i++;
58             g_assert_cmpint(data->bits[pos] & (1UL << bit), ==, 0);
59         }
60
61         if (next == data->size) {
62             break;
63         }
64
65         pos = i >> LOG_BITS_PER_LONG;
66         bit = i & (BITS_PER_LONG - 1);
67         i++;
68         count++;
69         g_assert_cmpint(data->bits[pos] & (1UL << bit), !=, 0);
70     }
71
72     if (first == 0) {
73         g_assert_cmpint(count << data->granularity, ==, hbitmap_count(data->hb));
74     }
75 }
76
77 /* This is provided instead of a test setup function so that the sizes
78    are kept in the test functions (and not in main()) */
79 static void hbitmap_test_init(TestHBitmapData *data,
80                               uint64_t size, int granularity)
81 {
82     size_t n;
83     data->hb = hbitmap_alloc(size, granularity);
84
85     n = (size + BITS_PER_LONG - 1) / BITS_PER_LONG;
86     if (n == 0) {
87         n = 1;
88     }
89     data->bits = g_new0(unsigned long, n);
90     data->size = size;
91     data->granularity = granularity;
92     if (size) {
93         hbitmap_test_check(data, 0);
94     }
95 }
96
97 static inline size_t hbitmap_test_array_size(size_t bits)
98 {
99     size_t n = (bits + BITS_PER_LONG - 1) / BITS_PER_LONG;
100     return n ? n : 1;
101 }
102
103 static void hbitmap_test_truncate_impl(TestHBitmapData *data,
104                                        size_t size)
105 {
106     size_t n;
107     size_t m;
108     data->old_size = data->size;
109     data->size = size;
110
111     if (data->size == data->old_size) {
112         return;
113     }
114
115     n = hbitmap_test_array_size(size);
116     m = hbitmap_test_array_size(data->old_size);
117     data->bits = g_realloc(data->bits, sizeof(unsigned long) * n);
118     if (n > m) {
119         memset(&data->bits[m], 0x00, sizeof(unsigned long) * (n - m));
120     }
121
122     /* If we shrink to an uneven multiple of sizeof(unsigned long),
123      * scrub the leftover memory. */
124     if (data->size < data->old_size) {
125         m = size % (sizeof(unsigned long) * 8);
126         if (m) {
127             unsigned long mask = (1ULL << m) - 1;
128             data->bits[n-1] &= mask;
129         }
130     }
131
132     hbitmap_truncate(data->hb, size);
133 }
134
135 static void hbitmap_test_teardown(TestHBitmapData *data,
136                                   const void *unused)
137 {
138     if (data->hb) {
139         hbitmap_free(data->hb);
140         data->hb = NULL;
141     }
142     if (data->bits) {
143         g_free(data->bits);
144         data->bits = NULL;
145     }
146 }
147
148 /* Set a range in the HBitmap and in the shadow "simple" bitmap.
149  * The two bitmaps are then tested against each other.
150  */
151 static void hbitmap_test_set(TestHBitmapData *data,
152                              uint64_t first, uint64_t count)
153 {
154     hbitmap_set(data->hb, first, count);
155     while (count-- != 0) {
156         size_t pos = first >> LOG_BITS_PER_LONG;
157         int bit = first & (BITS_PER_LONG - 1);
158         first++;
159
160         data->bits[pos] |= 1UL << bit;
161     }
162
163     if (data->granularity == 0) {
164         hbitmap_test_check(data, 0);
165     }
166 }
167
168 /* Reset a range in the HBitmap and in the shadow "simple" bitmap.
169  */
170 static void hbitmap_test_reset(TestHBitmapData *data,
171                                uint64_t first, uint64_t count)
172 {
173     hbitmap_reset(data->hb, first, count);
174     while (count-- != 0) {
175         size_t pos = first >> LOG_BITS_PER_LONG;
176         int bit = first & (BITS_PER_LONG - 1);
177         first++;
178
179         data->bits[pos] &= ~(1UL << bit);
180     }
181
182     if (data->granularity == 0) {
183         hbitmap_test_check(data, 0);
184     }
185 }
186
187 static void hbitmap_test_reset_all(TestHBitmapData *data)
188 {
189     size_t n;
190
191     hbitmap_reset_all(data->hb);
192
193     n = (data->size + BITS_PER_LONG - 1) / BITS_PER_LONG;
194     if (n == 0) {
195         n = 1;
196     }
197     memset(data->bits, 0, n * sizeof(unsigned long));
198
199     if (data->granularity == 0) {
200         hbitmap_test_check(data, 0);
201     }
202 }
203
204 static void hbitmap_test_check_get(TestHBitmapData *data)
205 {
206     uint64_t count = 0;
207     uint64_t i;
208
209     for (i = 0; i < data->size; i++) {
210         size_t pos = i >> LOG_BITS_PER_LONG;
211         int bit = i & (BITS_PER_LONG - 1);
212         unsigned long val = data->bits[pos] & (1UL << bit);
213         count += hbitmap_get(data->hb, i);
214         g_assert_cmpint(hbitmap_get(data->hb, i), ==, val != 0);
215     }
216     g_assert_cmpint(count, ==, hbitmap_count(data->hb));
217 }
218
219 static void test_hbitmap_zero(TestHBitmapData *data,
220                                const void *unused)
221 {
222     hbitmap_test_init(data, 0, 0);
223 }
224
225 static void test_hbitmap_unaligned(TestHBitmapData *data,
226                                    const void *unused)
227 {
228     hbitmap_test_init(data, L3 + 23, 0);
229     hbitmap_test_set(data, 0, 1);
230     hbitmap_test_set(data, L3 + 22, 1);
231 }
232
233 static void test_hbitmap_iter_empty(TestHBitmapData *data,
234                                     const void *unused)
235 {
236     hbitmap_test_init(data, L1, 0);
237 }
238
239 static void test_hbitmap_iter_partial(TestHBitmapData *data,
240                                       const void *unused)
241 {
242     hbitmap_test_init(data, L3, 0);
243     hbitmap_test_set(data, 0, L3);
244     hbitmap_test_check(data, 1);
245     hbitmap_test_check(data, L1 - 1);
246     hbitmap_test_check(data, L1);
247     hbitmap_test_check(data, L1 * 2 - 1);
248     hbitmap_test_check(data, L2 - 1);
249     hbitmap_test_check(data, L2);
250     hbitmap_test_check(data, L2 + 1);
251     hbitmap_test_check(data, L2 + L1);
252     hbitmap_test_check(data, L2 + L1 * 2 - 1);
253     hbitmap_test_check(data, L2 * 2 - 1);
254     hbitmap_test_check(data, L2 * 2);
255     hbitmap_test_check(data, L2 * 2 + 1);
256     hbitmap_test_check(data, L2 * 2 + L1);
257     hbitmap_test_check(data, L2 * 2 + L1 * 2 - 1);
258     hbitmap_test_check(data, L3 / 2);
259 }
260
261 static void test_hbitmap_set_all(TestHBitmapData *data,
262                                  const void *unused)
263 {
264     hbitmap_test_init(data, L3, 0);
265     hbitmap_test_set(data, 0, L3);
266 }
267
268 static void test_hbitmap_get_all(TestHBitmapData *data,
269                                  const void *unused)
270 {
271     hbitmap_test_init(data, L3, 0);
272     hbitmap_test_set(data, 0, L3);
273     hbitmap_test_check_get(data);
274 }
275
276 static void test_hbitmap_get_some(TestHBitmapData *data,
277                                   const void *unused)
278 {
279     hbitmap_test_init(data, 2 * L2, 0);
280     hbitmap_test_set(data, 10, 1);
281     hbitmap_test_check_get(data);
282     hbitmap_test_set(data, L1 - 1, 1);
283     hbitmap_test_check_get(data);
284     hbitmap_test_set(data, L1, 1);
285     hbitmap_test_check_get(data);
286     hbitmap_test_set(data, L2 - 1, 1);
287     hbitmap_test_check_get(data);
288     hbitmap_test_set(data, L2, 1);
289     hbitmap_test_check_get(data);
290 }
291
292 static void test_hbitmap_set_one(TestHBitmapData *data,
293                                  const void *unused)
294 {
295     hbitmap_test_init(data, 2 * L2, 0);
296     hbitmap_test_set(data, 10, 1);
297     hbitmap_test_set(data, L1 - 1, 1);
298     hbitmap_test_set(data, L1, 1);
299     hbitmap_test_set(data, L2 - 1, 1);
300     hbitmap_test_set(data, L2, 1);
301 }
302
303 static void test_hbitmap_set_two_elem(TestHBitmapData *data,
304                                       const void *unused)
305 {
306     hbitmap_test_init(data, 2 * L2, 0);
307     hbitmap_test_set(data, L1 - 1, 2);
308     hbitmap_test_set(data, L1 * 2 - 1, 4);
309     hbitmap_test_set(data, L1 * 4, L1 + 1);
310     hbitmap_test_set(data, L1 * 8 - 1, L1 + 1);
311     hbitmap_test_set(data, L2 - 1, 2);
312     hbitmap_test_set(data, L2 + L1 - 1, 8);
313     hbitmap_test_set(data, L2 + L1 * 4, L1 + 1);
314     hbitmap_test_set(data, L2 + L1 * 8 - 1, L1 + 1);
315 }
316
317 static void test_hbitmap_set(TestHBitmapData *data,
318                              const void *unused)
319 {
320     hbitmap_test_init(data, L3 * 2, 0);
321     hbitmap_test_set(data, L1 - 1, L1 + 2);
322     hbitmap_test_set(data, L1 * 3 - 1, L1 + 2);
323     hbitmap_test_set(data, L1 * 5, L1 * 2 + 1);
324     hbitmap_test_set(data, L1 * 8 - 1, L1 * 2 + 1);
325     hbitmap_test_set(data, L2 - 1, L1 + 2);
326     hbitmap_test_set(data, L2 + L1 * 2 - 1, L1 + 2);
327     hbitmap_test_set(data, L2 + L1 * 4, L1 * 2 + 1);
328     hbitmap_test_set(data, L2 + L1 * 7 - 1, L1 * 2 + 1);
329     hbitmap_test_set(data, L2 * 2 - 1, L3 * 2 - L2 * 2);
330 }
331
332 static void test_hbitmap_set_twice(TestHBitmapData *data,
333                                    const void *unused)
334 {
335     hbitmap_test_init(data, L1 * 3, 0);
336     hbitmap_test_set(data, 0, L1 * 3);
337     hbitmap_test_set(data, L1, 1);
338 }
339
340 static void test_hbitmap_set_overlap(TestHBitmapData *data,
341                                      const void *unused)
342 {
343     hbitmap_test_init(data, L3 * 2, 0);
344     hbitmap_test_set(data, L1 - 1, L1 + 2);
345     hbitmap_test_set(data, L1 * 2 - 1, L1 * 2 + 2);
346     hbitmap_test_set(data, 0, L1 * 3);
347     hbitmap_test_set(data, L1 * 8 - 1, L2);
348     hbitmap_test_set(data, L2, L1);
349     hbitmap_test_set(data, L2 - L1 - 1, L1 * 8 + 2);
350     hbitmap_test_set(data, L2, L3 - L2 + 1);
351     hbitmap_test_set(data, L3 - L1, L1 * 3);
352     hbitmap_test_set(data, L3 - 1, 3);
353     hbitmap_test_set(data, L3 - 1, L2);
354 }
355
356 static void test_hbitmap_reset_empty(TestHBitmapData *data,
357                                      const void *unused)
358 {
359     hbitmap_test_init(data, L3, 0);
360     hbitmap_test_reset(data, 0, L3);
361 }
362
363 static void test_hbitmap_reset(TestHBitmapData *data,
364                                const void *unused)
365 {
366     hbitmap_test_init(data, L3 * 2, 0);
367     hbitmap_test_set(data, L1 - 1, L1 + 2);
368     hbitmap_test_reset(data, L1 * 2 - 1, L1 * 2 + 2);
369     hbitmap_test_set(data, 0, L1 * 3);
370     hbitmap_test_reset(data, L1 * 8 - 1, L2);
371     hbitmap_test_set(data, L2, L1);
372     hbitmap_test_reset(data, L2 - L1 - 1, L1 * 8 + 2);
373     hbitmap_test_set(data, L2, L3 - L2 + 1);
374     hbitmap_test_reset(data, L3 - L1, L1 * 3);
375     hbitmap_test_set(data, L3 - 1, 3);
376     hbitmap_test_reset(data, L3 - 1, L2);
377     hbitmap_test_set(data, 0, L3 * 2);
378     hbitmap_test_reset(data, 0, L1);
379     hbitmap_test_reset(data, 0, L2);
380     hbitmap_test_reset(data, L3, L3);
381     hbitmap_test_set(data, L3 / 2, L3);
382 }
383
384 static void test_hbitmap_reset_all(TestHBitmapData *data,
385                                    const void *unused)
386 {
387     hbitmap_test_init(data, L3 * 2, 0);
388     hbitmap_test_set(data, L1 - 1, L1 + 2);
389     hbitmap_test_reset_all(data);
390     hbitmap_test_set(data, 0, L1 * 3);
391     hbitmap_test_reset_all(data);
392     hbitmap_test_set(data, L2, L1);
393     hbitmap_test_reset_all(data);
394     hbitmap_test_set(data, L2, L3 - L2 + 1);
395     hbitmap_test_reset_all(data);
396     hbitmap_test_set(data, L3 - 1, 3);
397     hbitmap_test_reset_all(data);
398     hbitmap_test_set(data, 0, L3 * 2);
399     hbitmap_test_reset_all(data);
400     hbitmap_test_set(data, L3 / 2, L3);
401     hbitmap_test_reset_all(data);
402 }
403
404 static void test_hbitmap_granularity(TestHBitmapData *data,
405                                      const void *unused)
406 {
407     /* Note that hbitmap_test_check has to be invoked manually in this test.  */
408     hbitmap_test_init(data, L1, 1);
409     hbitmap_test_set(data, 0, 1);
410     g_assert_cmpint(hbitmap_count(data->hb), ==, 2);
411     hbitmap_test_check(data, 0);
412     hbitmap_test_set(data, 2, 1);
413     g_assert_cmpint(hbitmap_count(data->hb), ==, 4);
414     hbitmap_test_check(data, 0);
415     hbitmap_test_set(data, 0, 3);
416     g_assert_cmpint(hbitmap_count(data->hb), ==, 4);
417     hbitmap_test_reset(data, 0, 1);
418     g_assert_cmpint(hbitmap_count(data->hb), ==, 2);
419 }
420
421 static void test_hbitmap_iter_granularity(TestHBitmapData *data,
422                                           const void *unused)
423 {
424     HBitmapIter hbi;
425
426     /* Note that hbitmap_test_check has to be invoked manually in this test.  */
427     hbitmap_test_init(data, 131072 << 7, 7);
428     hbitmap_iter_init(&hbi, data->hb, 0);
429     g_assert_cmpint(hbitmap_iter_next(&hbi), <, 0);
430
431     hbitmap_test_set(data, ((L2 + L1 + 1) << 7) + 8, 8);
432     hbitmap_iter_init(&hbi, data->hb, 0);
433     g_assert_cmpint(hbitmap_iter_next(&hbi), ==, (L2 + L1 + 1) << 7);
434     g_assert_cmpint(hbitmap_iter_next(&hbi), <, 0);
435
436     hbitmap_iter_init(&hbi, data->hb, (L2 + L1 + 2) << 7);
437     g_assert_cmpint(hbitmap_iter_next(&hbi), <, 0);
438
439     hbitmap_test_set(data, (131072 << 7) - 8, 8);
440     hbitmap_iter_init(&hbi, data->hb, 0);
441     g_assert_cmpint(hbitmap_iter_next(&hbi), ==, (L2 + L1 + 1) << 7);
442     g_assert_cmpint(hbitmap_iter_next(&hbi), ==, 131071 << 7);
443     g_assert_cmpint(hbitmap_iter_next(&hbi), <, 0);
444
445     hbitmap_iter_init(&hbi, data->hb, (L2 + L1 + 2) << 7);
446     g_assert_cmpint(hbitmap_iter_next(&hbi), ==, 131071 << 7);
447     g_assert_cmpint(hbitmap_iter_next(&hbi), <, 0);
448 }
449
450 static void hbitmap_test_set_boundary_bits(TestHBitmapData *data, ssize_t diff)
451 {
452     size_t size = data->size;
453
454     /* First bit */
455     hbitmap_test_set(data, 0, 1);
456     if (diff < 0) {
457         /* Last bit in new, shortened map */
458         hbitmap_test_set(data, size + diff - 1, 1);
459
460         /* First bit to be truncated away */
461         hbitmap_test_set(data, size + diff, 1);
462     }
463     /* Last bit */
464     hbitmap_test_set(data, size - 1, 1);
465     if (data->granularity == 0) {
466         hbitmap_test_check_get(data);
467     }
468 }
469
470 static void hbitmap_test_check_boundary_bits(TestHBitmapData *data)
471 {
472     size_t size = MIN(data->size, data->old_size);
473
474     if (data->granularity == 0) {
475         hbitmap_test_check_get(data);
476         hbitmap_test_check(data, 0);
477     } else {
478         /* If a granularity was set, note that every distinct
479          * (bit >> granularity) value that was set will increase
480          * the bit pop count by 2^granularity, not just 1.
481          *
482          * The hbitmap_test_check facility does not currently tolerate
483          * non-zero granularities, so test the boundaries and the population
484          * count manually.
485          */
486         g_assert(hbitmap_get(data->hb, 0));
487         g_assert(hbitmap_get(data->hb, size - 1));
488         g_assert_cmpint(2 << data->granularity, ==, hbitmap_count(data->hb));
489     }
490 }
491
492 /* Generic truncate test. */
493 static void hbitmap_test_truncate(TestHBitmapData *data,
494                                   size_t size,
495                                   ssize_t diff,
496                                   int granularity)
497 {
498     hbitmap_test_init(data, size, granularity);
499     hbitmap_test_set_boundary_bits(data, diff);
500     hbitmap_test_truncate_impl(data, size + diff);
501     hbitmap_test_check_boundary_bits(data);
502 }
503
504 static void test_hbitmap_truncate_nop(TestHBitmapData *data,
505                                       const void *unused)
506 {
507     hbitmap_test_truncate(data, L2, 0, 0);
508 }
509
510 /**
511  * Grow by an amount smaller than the granularity, without crossing
512  * a granularity alignment boundary. Effectively a NOP.
513  */
514 static void test_hbitmap_truncate_grow_negligible(TestHBitmapData *data,
515                                                   const void *unused)
516 {
517     size_t size = L2 - 1;
518     size_t diff = 1;
519     int granularity = 1;
520
521     hbitmap_test_truncate(data, size, diff, granularity);
522 }
523
524 /**
525  * Shrink by an amount smaller than the granularity, without crossing
526  * a granularity alignment boundary. Effectively a NOP.
527  */
528 static void test_hbitmap_truncate_shrink_negligible(TestHBitmapData *data,
529                                                     const void *unused)
530 {
531     size_t size = L2;
532     ssize_t diff = -1;
533     int granularity = 1;
534
535     hbitmap_test_truncate(data, size, diff, granularity);
536 }
537
538 /**
539  * Grow by an amount smaller than the granularity, but crossing over
540  * a granularity alignment boundary.
541  */
542 static void test_hbitmap_truncate_grow_tiny(TestHBitmapData *data,
543                                             const void *unused)
544 {
545     size_t size = L2 - 2;
546     ssize_t diff = 1;
547     int granularity = 1;
548
549     hbitmap_test_truncate(data, size, diff, granularity);
550 }
551
552 /**
553  * Shrink by an amount smaller than the granularity, but crossing over
554  * a granularity alignment boundary.
555  */
556 static void test_hbitmap_truncate_shrink_tiny(TestHBitmapData *data,
557                                               const void *unused)
558 {
559     size_t size = L2 - 1;
560     ssize_t diff = -1;
561     int granularity = 1;
562
563     hbitmap_test_truncate(data, size, diff, granularity);
564 }
565
566 /**
567  * Grow by an amount smaller than sizeof(long), and not crossing over
568  * a sizeof(long) alignment boundary.
569  */
570 static void test_hbitmap_truncate_grow_small(TestHBitmapData *data,
571                                              const void *unused)
572 {
573     size_t size = L2 + 1;
574     size_t diff = sizeof(long) / 2;
575
576     hbitmap_test_truncate(data, size, diff, 0);
577 }
578
579 /**
580  * Shrink by an amount smaller than sizeof(long), and not crossing over
581  * a sizeof(long) alignment boundary.
582  */
583 static void test_hbitmap_truncate_shrink_small(TestHBitmapData *data,
584                                                const void *unused)
585 {
586     size_t size = L2;
587     size_t diff = sizeof(long) / 2;
588
589     hbitmap_test_truncate(data, size, -diff, 0);
590 }
591
592 /**
593  * Grow by an amount smaller than sizeof(long), while crossing over
594  * a sizeof(long) alignment boundary.
595  */
596 static void test_hbitmap_truncate_grow_medium(TestHBitmapData *data,
597                                               const void *unused)
598 {
599     size_t size = L2 - 1;
600     size_t diff = sizeof(long) / 2;
601
602     hbitmap_test_truncate(data, size, diff, 0);
603 }
604
605 /**
606  * Shrink by an amount smaller than sizeof(long), while crossing over
607  * a sizeof(long) alignment boundary.
608  */
609 static void test_hbitmap_truncate_shrink_medium(TestHBitmapData *data,
610                                                 const void *unused)
611 {
612     size_t size = L2 + 1;
613     size_t diff = sizeof(long) / 2;
614
615     hbitmap_test_truncate(data, size, -diff, 0);
616 }
617
618 /**
619  * Grow by an amount larger than sizeof(long).
620  */
621 static void test_hbitmap_truncate_grow_large(TestHBitmapData *data,
622                                              const void *unused)
623 {
624     size_t size = L2;
625     size_t diff = 8 * sizeof(long);
626
627     hbitmap_test_truncate(data, size, diff, 0);
628 }
629
630 /**
631  * Shrink by an amount larger than sizeof(long).
632  */
633 static void test_hbitmap_truncate_shrink_large(TestHBitmapData *data,
634                                                const void *unused)
635 {
636     size_t size = L2;
637     size_t diff = 8 * sizeof(long);
638
639     hbitmap_test_truncate(data, size, -diff, 0);
640 }
641
642 static void hbitmap_test_add(const char *testpath,
643                                    void (*test_func)(TestHBitmapData *data, const void *user_data))
644 {
645     g_test_add(testpath, TestHBitmapData, NULL, NULL, test_func,
646                hbitmap_test_teardown);
647 }
648
649 int main(int argc, char **argv)
650 {
651     g_test_init(&argc, &argv, NULL);
652     hbitmap_test_add("/hbitmap/size/0", test_hbitmap_zero);
653     hbitmap_test_add("/hbitmap/size/unaligned", test_hbitmap_unaligned);
654     hbitmap_test_add("/hbitmap/iter/empty", test_hbitmap_iter_empty);
655     hbitmap_test_add("/hbitmap/iter/partial", test_hbitmap_iter_partial);
656     hbitmap_test_add("/hbitmap/iter/granularity", test_hbitmap_iter_granularity);
657     hbitmap_test_add("/hbitmap/get/all", test_hbitmap_get_all);
658     hbitmap_test_add("/hbitmap/get/some", test_hbitmap_get_some);
659     hbitmap_test_add("/hbitmap/set/all", test_hbitmap_set_all);
660     hbitmap_test_add("/hbitmap/set/one", test_hbitmap_set_one);
661     hbitmap_test_add("/hbitmap/set/two-elem", test_hbitmap_set_two_elem);
662     hbitmap_test_add("/hbitmap/set/general", test_hbitmap_set);
663     hbitmap_test_add("/hbitmap/set/twice", test_hbitmap_set_twice);
664     hbitmap_test_add("/hbitmap/set/overlap", test_hbitmap_set_overlap);
665     hbitmap_test_add("/hbitmap/reset/empty", test_hbitmap_reset_empty);
666     hbitmap_test_add("/hbitmap/reset/general", test_hbitmap_reset);
667     hbitmap_test_add("/hbitmap/reset/all", test_hbitmap_reset_all);
668     hbitmap_test_add("/hbitmap/granularity", test_hbitmap_granularity);
669
670     hbitmap_test_add("/hbitmap/truncate/nop", test_hbitmap_truncate_nop);
671     hbitmap_test_add("/hbitmap/truncate/grow/negligible",
672                      test_hbitmap_truncate_grow_negligible);
673     hbitmap_test_add("/hbitmap/truncate/shrink/negligible",
674                      test_hbitmap_truncate_shrink_negligible);
675     hbitmap_test_add("/hbitmap/truncate/grow/tiny",
676                      test_hbitmap_truncate_grow_tiny);
677     hbitmap_test_add("/hbitmap/truncate/shrink/tiny",
678                      test_hbitmap_truncate_shrink_tiny);
679     hbitmap_test_add("/hbitmap/truncate/grow/small",
680                      test_hbitmap_truncate_grow_small);
681     hbitmap_test_add("/hbitmap/truncate/shrink/small",
682                      test_hbitmap_truncate_shrink_small);
683     hbitmap_test_add("/hbitmap/truncate/grow/medium",
684                      test_hbitmap_truncate_grow_medium);
685     hbitmap_test_add("/hbitmap/truncate/shrink/medium",
686                      test_hbitmap_truncate_shrink_medium);
687     hbitmap_test_add("/hbitmap/truncate/grow/large",
688                      test_hbitmap_truncate_grow_large);
689     hbitmap_test_add("/hbitmap/truncate/shrink/large",
690                      test_hbitmap_truncate_shrink_large);
691     g_test_run();
692
693     return 0;
694 }