qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

test-bitmap.c (4676B)


      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 }