qemu

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

test-bitops.c (3605B)

      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 }