tests/unit/test-bitmap.c

   1 /*
   2  * SPDX-License-Identifier: GPL-2.0-or-later
   3  *
   4  * Bitmap.c unit-tests.
   5  *
   6  * Copyright (C) 2019, Red Hat, Inc.
   7  *
   8  * Author: Peter Xu <peterx@redhat.com>
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qemu/bitmap.h"
  13
  14 #define BMAP_SIZE  1024
  15
  16 static void check_bitmap_copy_with_offset(void)
  17 {
  18     unsigned long *bmap1, *bmap2, *bmap3, total;
  19
  20     bmap1 = bitmap_new(BMAP_SIZE);
  21     bmap2 = bitmap_new(BMAP_SIZE);
  22     bmap3 = bitmap_new(BMAP_SIZE);
  23
  24     bmap1[0] = g_test_rand_int();
  25     bmap1[1] = g_test_rand_int();
  26     bmap1[2] = g_test_rand_int();
  27     bmap1[3] = g_test_rand_int();
  28     total = BITS_PER_LONG * 4;
  29
  30     /* Shift 115 bits into bmap2 */
  31     bitmap_copy_with_dst_offset(bmap2, bmap1, 115, total);
  32     /* Shift another 85 bits into bmap3 */
  33     bitmap_copy_with_dst_offset(bmap3, bmap2, 85, total + 115);
  34     /* Shift back 200 bits back */
  35     bitmap_copy_with_src_offset(bmap2, bmap3, 200, total);
  36
  37     g_assert_cmpmem(bmap1, total / BITS_PER_LONG,
  38                     bmap2, total / BITS_PER_LONG);
  39
  40     bitmap_clear(bmap1, 0, BMAP_SIZE);
  41     /* Set bits in bmap1 are 100-245 */
  42     bitmap_set(bmap1, 100, 145);
  43
  44     /* Set bits in bmap2 are 60-205 */
  45     bitmap_copy_with_src_offset(bmap2, bmap1, 40, 250);
  46     g_assert_cmpint(find_first_bit(bmap2, 60), ==, 60);
  47     g_assert_cmpint(find_next_zero_bit(bmap2, 205, 60), ==, 205);
  48     g_assert(test_bit(205, bmap2) == 0);
  49
  50     /* Set bits in bmap3 are 135-280 */
  51     bitmap_copy_with_dst_offset(bmap3, bmap1, 35, 250);
  52     g_assert_cmpint(find_first_bit(bmap3, 135), ==, 135);
  53     g_assert_cmpint(find_next_zero_bit(bmap3, 280, 135), ==, 280);
  54     g_assert(test_bit(280, bmap3) == 0);
  55
  56     g_free(bmap1);
  57     g_free(bmap2);
  58     g_free(bmap3);
  59 }
  60
  61 typedef void (*bmap_set_func)(unsigned long *map, long i, long len);
  62 static void bitmap_set_case(bmap_set_func set_func)
  63 {
  64     unsigned long *bmap;
  65     int offset;
  66
  67     bmap = bitmap_new(BMAP_SIZE);
  68
  69     /* Set one bit at offset in second word */
  70     for (offset = 0; offset <= BITS_PER_LONG; offset++) {
  71         bitmap_clear(bmap, 0, BMAP_SIZE);
  72         set_func(bmap, BITS_PER_LONG + offset, 1);
  73         g_assert_cmpint(find_first_bit(bmap, 2 * BITS_PER_LONG),
  74                         ==, BITS_PER_LONG + offset);
  75         g_assert_cmpint(find_next_zero_bit(bmap,
  76                                            3 * BITS_PER_LONG,
  77                                            BITS_PER_LONG + offset),
  78                         ==, BITS_PER_LONG + offset + 1);
  79     }
  80
  81     /* Both Aligned, set bits [BITS_PER_LONG, 3*BITS_PER_LONG] */
  82     set_func(bmap, BITS_PER_LONG, 2 * BITS_PER_LONG);
  83     g_assert_cmpuint(bmap[1], ==, -1ul);
  84     g_assert_cmpuint(bmap[2], ==, -1ul);
  85     g_assert_cmpint(find_first_bit(bmap, BITS_PER_LONG), ==, BITS_PER_LONG);
  86     g_assert_cmpint(find_next_zero_bit(bmap, 3 * BITS_PER_LONG, BITS_PER_LONG),
  87                     ==, 3 * BITS_PER_LONG);
  88
  89     for (offset = 0; offset <= BITS_PER_LONG; offset++) {
  90         bitmap_clear(bmap, 0, BMAP_SIZE);
  91         /* End Aligned, set bits [BITS_PER_LONG - offset, 3*BITS_PER_LONG] */
  92         set_func(bmap, BITS_PER_LONG - offset, 2 * BITS_PER_LONG + offset);
  93         g_assert_cmpuint(bmap[1], ==, -1ul);
  94         g_assert_cmpuint(bmap[2], ==, -1ul);
  95         g_assert_cmpint(find_first_bit(bmap, BITS_PER_LONG),
  96                         ==, BITS_PER_LONG - offset);
  97         g_assert_cmpint(find_next_zero_bit(bmap,
  98                                            3 * BITS_PER_LONG,
  99                                            BITS_PER_LONG - offset),
 100                         ==, 3 * BITS_PER_LONG);
 101     }
 102
 103     for (offset = 0; offset <= BITS_PER_LONG; offset++) {
 104         bitmap_clear(bmap, 0, BMAP_SIZE);
 105         /* Start Aligned, set bits [BITS_PER_LONG, 3*BITS_PER_LONG + offset] */
 106         set_func(bmap, BITS_PER_LONG, 2 * BITS_PER_LONG + offset);
 107         g_assert_cmpuint(bmap[1], ==, -1ul);
 108         g_assert_cmpuint(bmap[2], ==, -1ul);
 109         g_assert_cmpint(find_first_bit(bmap, BITS_PER_LONG),
 110                         ==, BITS_PER_LONG);
 111         g_assert_cmpint(find_next_zero_bit(bmap,
 112                                            3 * BITS_PER_LONG + offset,
 113                                            BITS_PER_LONG),
 114                         ==, 3 * BITS_PER_LONG + offset);
 115     }
 116
 117     g_free(bmap);
 118 }
 119
 120 static void check_bitmap_set(void)
 121 {
 122     bitmap_set_case(bitmap_set);
 123     bitmap_set_case(bitmap_set_atomic);
 124 }
 125
 126 int main(int argc, char **argv)
 127 {
 128     g_test_init(&argc, &argv, NULL);
 129
 130     g_test_add_func("/bitmap/bitmap_copy_with_offset",
 131                     check_bitmap_copy_with_offset);
 132     g_test_add_func("/bitmap/bitmap_set",
 133                     check_bitmap_set);
 134
 135     g_test_run();
 136
 137     return 0;
 138 }