tests/test-bitops.c

   1 /*
   2  * Test bitops routines
   3  *
   4  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
   5  * See the COPYING.LIB file in the top-level directory.
   6  *
   7  */
   8
   9 #include "qemu/osdep.h"
  10 #include "qemu/bitops.h"
  11
  12 typedef struct {
  13     uint32_t value;
  14     int start;
  15     int length;
  16     int32_t result;
  17 } S32Test;
  18
  19 typedef struct {
  20     uint64_t value;
  21     int start;
  22     int length;
  23     int64_t result;
  24 } S64Test;
  25
  26 static const S32Test test_s32_data[] = {
  27     { 0x38463983, 4, 4, -8 },
  28     { 0x38463983, 12, 8, 0x63 },
  29     { 0x38463983, 0, 32, 0x38463983 },
  30 };
  31
  32 static const S64Test test_s64_data[] = {
  33     { 0x8459826734967223ULL, 60, 4, -8 },
  34     { 0x8459826734967223ULL, 0, 64, 0x8459826734967223LL },
  35 };
  36
  37 static void test_sextract32(void)
  38 {
  39     int i;
  40
  41     for (i = 0; i < ARRAY_SIZE(test_s32_data); i++) {
  42         const S32Test *test = &test_s32_data[i];
  43         int32_t r = sextract32(test->value, test->start, test->length);
  44
  45         g_assert_cmpint(r, ==, test->result);
  46     }
  47 }
  48
  49 static void test_sextract64(void)
  50 {
  51     int i;
  52
  53     for (i = 0; i < ARRAY_SIZE(test_s32_data); i++) {
  54         const S32Test *test = &test_s32_data[i];
  55         int64_t r = sextract64(test->value, test->start, test->length);
  56
  57         g_assert_cmpint(r, ==, test->result);
  58     }
  59
  60     for (i = 0; i < ARRAY_SIZE(test_s64_data); i++) {
  61         const S64Test *test = &test_s64_data[i];
  62         int64_t r = sextract64(test->value, test->start, test->length);
  63
  64         g_assert_cmpint(r, ==, test->result);
  65     }
  66 }
  67
  68 typedef struct {
  69     uint32_t unshuffled;
  70     uint32_t shuffled;
  71 } Shuffle32Test;
  72
  73 typedef struct {
  74     uint64_t unshuffled;
  75     uint64_t shuffled;
  76 } Shuffle64Test;
  77
  78 static const Shuffle32Test test_shuffle32_data[] = {
  79     { 0x0000FFFF, 0x55555555 },
  80     { 0x000081C5, 0x40015011 },
  81 };
  82
  83 static const Shuffle64Test test_shuffle64_data[] = {
  84     { 0x00000000FFFFFFFFULL, 0x5555555555555555ULL },
  85     { 0x00000000493AB02CULL, 0x1041054445000450ULL },
  86 };
  87
  88 static void test_half_shuffle32(void)
  89 {
  90     int i;
  91
  92     for (i = 0; i < ARRAY_SIZE(test_shuffle32_data); i++) {
  93         const Shuffle32Test *test = &test_shuffle32_data[i];
  94         uint32_t r = half_shuffle32(test->unshuffled);
  95
  96         g_assert_cmpint(r, ==, test->shuffled);
  97     }
  98 }
  99
 100 static void test_half_shuffle64(void)
 101 {
 102     int i;
 103
 104     for (i = 0; i < ARRAY_SIZE(test_shuffle64_data); i++) {
 105         const Shuffle64Test *test = &test_shuffle64_data[i];
 106         uint64_t r = half_shuffle64(test->unshuffled);
 107
 108         g_assert_cmpint(r, ==, test->shuffled);
 109     }
 110 }
 111
 112 static void test_half_unshuffle32(void)
 113 {
 114     int i;
 115
 116     for (i = 0; i < ARRAY_SIZE(test_shuffle32_data); i++) {
 117         const Shuffle32Test *test = &test_shuffle32_data[i];
 118         uint32_t r = half_unshuffle32(test->shuffled);
 119
 120         g_assert_cmpint(r, ==, test->unshuffled);
 121     }
 122 }
 123
 124 static void test_half_unshuffle64(void)
 125 {
 126     int i;
 127
 128     for (i = 0; i < ARRAY_SIZE(test_shuffle64_data); i++) {
 129         const Shuffle64Test *test = &test_shuffle64_data[i];
 130         uint64_t r = half_unshuffle64(test->shuffled);
 131
 132         g_assert_cmpint(r, ==, test->unshuffled);
 133     }
 134 }
 135
 136 int main(int argc, char **argv)
 137 {
 138     g_test_init(&argc, &argv, NULL);
 139     g_test_add_func("/bitops/sextract32", test_sextract32);
 140     g_test_add_func("/bitops/sextract64", test_sextract64);
 141     g_test_add_func("/bitops/half_shuffle32", test_half_shuffle32);
 142     g_test_add_func("/bitops/half_shuffle64", test_half_shuffle64);
 143     g_test_add_func("/bitops/half_unshuffle32", test_half_unshuffle32);
 144     g_test_add_func("/bitops/half_unshuffle64", test_half_unshuffle64);
 145     return g_test_run();
 146 }