unit-tests/datastruct/bitset_t.c

   1 /*
   2  * Copyright (C) 2010 Red Hat, Inc. All rights reserved.
   3  *
   4  * This file is part of LVM2.
   5  *
   6  * This copyrighted material is made available to anyone wishing to use,
   7  * modify, copy, or redistribute it subject to the terms and conditions
   8  * of the GNU General Public License v.2.
   9  *
  10  * You should have received a copy of the GNU General Public License
  11  * along with this program; if not, write to the Free Software Foundation,
  12  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  13  */
  14
  15 #include "libdevmapper.h"
  16
  17 #include <assert.h>
  18
  19 enum {
  20         NR_BITS = 137
  21 };
  22
  23 static void test_get_next(struct dm_pool *mem)
  24 {
  25         int i, j, last, first;
  26         dm_bitset_t bs = dm_bitset_create(mem, NR_BITS);
  27
  28         for (i = 0; i < NR_BITS; i++)
  29                 assert(!dm_bit(bs, i));
  30
  31         for (i = 0, j = 1; i < NR_BITS; i += j, j++)
  32                 dm_bit_set(bs, i);
  33
  34         first = 1;
  35         for (i = 0, j = 1; i < NR_BITS; i += j, j++) {
  36                 if (first) {
  37                         last = dm_bit_get_first(bs);
  38                         first = 0;
  39                 } else
  40                         last = dm_bit_get_next(bs, last);
  41
  42                 assert(last == i);
  43         }
  44
  45         assert(dm_bit_get_next(bs, last) == -1);
  46 }
  47
  48 static void bit_flip(dm_bitset_t bs, int bit)
  49 {
  50         int old = dm_bit(bs, bit);
  51         if (old)
  52                 dm_bit_clear(bs, bit);
  53         else
  54                 dm_bit_set(bs, bit);
  55 }
  56
  57 static void test_equal(struct dm_pool *mem)
  58 {
  59         dm_bitset_t bs1 = dm_bitset_create(mem, NR_BITS);
  60         dm_bitset_t bs2 = dm_bitset_create(mem, NR_BITS);
  61
  62         int i, j;
  63         for (i = 0, j = 1; i < NR_BITS; i += j, j++) {
  64                 dm_bit_set(bs1, i);
  65                 dm_bit_set(bs2, i);
  66         }
  67
  68         assert(dm_bitset_equal(bs1, bs2));
  69         assert(dm_bitset_equal(bs2, bs1));
  70
  71         for (i = 0; i < NR_BITS; i++) {
  72                 bit_flip(bs1, i);
  73                 assert(!dm_bitset_equal(bs1, bs2));
  74                 assert(!dm_bitset_equal(bs2, bs1));
  75
  76                 assert(dm_bitset_equal(bs1, bs1)); /* comparing with self */
  77                 bit_flip(bs1, i);
  78         }
  79 }
  80
  81 static void test_and(struct dm_pool *mem)
  82 {
  83         dm_bitset_t bs1 = dm_bitset_create(mem, NR_BITS);
  84         dm_bitset_t bs2 = dm_bitset_create(mem, NR_BITS);
  85         dm_bitset_t bs3 = dm_bitset_create(mem, NR_BITS);
  86
  87         int i, j;
  88         for (i = 0, j = 1; i < NR_BITS; i += j, j++) {
  89                 dm_bit_set(bs1, i);
  90                 dm_bit_set(bs2, i);
  91         }
  92
  93         dm_bit_and(bs3, bs1, bs2);
  94
  95         assert(dm_bitset_equal(bs1, bs2));
  96         assert(dm_bitset_equal(bs1, bs3));
  97         assert(dm_bitset_equal(bs2, bs3));
  98
  99         dm_bit_clear_all(bs1);
 100         dm_bit_clear_all(bs2);
 101
 102         for (i = 0; i < NR_BITS; i++) {
 103                 if (i % 2)
 104                         dm_bit_set(bs1, i);
 105                 else
 106                         dm_bit_set(bs2, i);
 107         }
 108
 109         dm_bit_and(bs3, bs1, bs2);
 110         for (i = 0; i < NR_BITS; i++)
 111                 assert(!dm_bit(bs3, i));
 112 }
 113
 114 int main(int argc, char **argv)
 115 {
 116         typedef void (*test_fn)(struct dm_pool *);
 117         static test_fn tests[] = {
 118                 test_get_next,
 119                 test_equal,
 120                 test_and
 121         };
 122
 123         int i;
 124         for (i = 0; i < sizeof(tests) / sizeof(*tests); i++) {
 125                 struct dm_pool *mem = dm_pool_create("bitset test", 1024);
 126                 assert(mem);
 127                 tests[i](mem);
 128                 dm_pool_destroy(mem);
 129         }
 130
 131         return 0;
 132 }
 133