src/test/test-bitmap.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "bitmap.h"
   4
   5 int main(int argc, const char *argv[]) {
   6         _cleanup_bitmap_free_ Bitmap *b = NULL, *b2 = NULL;
   7         unsigned n = UINT_MAX, i = 0;
   8
   9         b = bitmap_new();
  10         assert_se(b);
  11
  12         assert_se(bitmap_ensure_allocated(&b) == 0);
  13         bitmap_free(b);
  14         b = NULL;
  15         assert_se(bitmap_ensure_allocated(&b) == 0);
  16
  17         assert_se(bitmap_isset(b, 0) == false);
  18         assert_se(bitmap_isset(b, 1) == false);
  19         assert_se(bitmap_isset(b, 256) == false);
  20         assert_se(bitmap_isclear(b) == true);
  21
  22         assert_se(bitmap_set(b, 0) == 0);
  23         assert_se(bitmap_isset(b, 0) == true);
  24         assert_se(bitmap_isclear(b) == false);
  25         bitmap_unset(b, 0);
  26         assert_se(bitmap_isset(b, 0) == false);
  27         assert_se(bitmap_isclear(b) == true);
  28
  29         assert_se(bitmap_set(b, 1) == 0);
  30         assert_se(bitmap_isset(b, 1) == true);
  31         assert_se(bitmap_isclear(b) == false);
  32         bitmap_unset(b, 1);
  33         assert_se(bitmap_isset(b, 1) == false);
  34         assert_se(bitmap_isclear(b) == true);
  35
  36         assert_se(bitmap_set(b, 256) == 0);
  37         assert_se(bitmap_isset(b, 256) == true);
  38         assert_se(bitmap_isclear(b) == false);
  39         bitmap_unset(b, 256);
  40         assert_se(bitmap_isset(b, 256) == false);
  41         assert_se(bitmap_isclear(b) == true);
  42
  43         assert_se(bitmap_set(b, 32) == 0);
  44         bitmap_unset(b, 0);
  45         assert_se(bitmap_isset(b, 32) == true);
  46         bitmap_unset(b, 32);
  47
  48         BITMAP_FOREACH(n, NULL)
  49                 assert_not_reached("NULL bitmap");
  50
  51         assert_se(bitmap_set(b, 0) == 0);
  52         assert_se(bitmap_set(b, 1) == 0);
  53         assert_se(bitmap_set(b, 256) == 0);
  54
  55         BITMAP_FOREACH(n, b) {
  56                 assert_se(n == i);
  57                 if (i == 0)
  58                         i = 1;
  59                 else if (i == 1)
  60                         i = 256;
  61                 else if (i == 256)
  62                         i = UINT_MAX;
  63         }
  64
  65         assert_se(i == UINT_MAX);
  66
  67         i = 0;
  68
  69         BITMAP_FOREACH(n, b) {
  70                 assert_se(n == i);
  71                 if (i == 0)
  72                         i = 1;
  73                 else if (i == 1)
  74                         i = 256;
  75                 else if (i == 256)
  76                         i = UINT_MAX;
  77         }
  78
  79         assert_se(i == UINT_MAX);
  80
  81         b2 = bitmap_copy(b);
  82         assert_se(b2);
  83         assert_se(bitmap_equal(b, b2) == true);
  84         assert_se(bitmap_equal(b, b) == true);
  85         assert_se(bitmap_equal(b, NULL) == false);
  86         assert_se(bitmap_equal(NULL, b) == false);
  87         assert_se(bitmap_equal(NULL, NULL) == true);
  88
  89         bitmap_clear(b);
  90         assert_se(bitmap_isclear(b) == true);
  91         assert_se(bitmap_equal(b, b2) == false);
  92         bitmap_free(b2);
  93         b2 = NULL;
  94
  95         assert_se(bitmap_set(b, UINT_MAX) == -ERANGE);
  96
  97         bitmap_free(b);
  98         b = NULL;
  99         assert_se(bitmap_ensure_allocated(&b) == 0);
 100         assert_se(bitmap_ensure_allocated(&b2) == 0);
 101
 102         assert_se(bitmap_equal(b, b2));
 103         assert_se(bitmap_set(b, 0) == 0);
 104         bitmap_unset(b, 0);
 105         assert_se(bitmap_equal(b, b2));
 106
 107         assert_se(bitmap_set(b, 1) == 0);
 108         bitmap_clear(b);
 109         assert_se(bitmap_equal(b, b2));
 110
 111         assert_se(bitmap_set(b, 0) == 0);
 112         assert_se(bitmap_set(b2, 0) == 0);
 113         assert_se(bitmap_equal(b, b2));
 114
 115         return 0;
 116 }