tests/bitfield_tests.c

   1 #include <check.h>
   2 #include <stdint.h>
   3 #include <bitfield/bitfield.h>
   4
   5 START_TEST (test_get_byte)
   6 {
   7     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
   8     uint8_t result = get_byte(data, sizeof(data), 0);
   9     ck_assert_int_eq(result, 0x12);
  10     result = get_byte(data, sizeof(data), 3);
  11     ck_assert_int_eq(result, 0x78);
  12 }
  13 END_TEST
  14
  15 START_TEST (test_set_nibble)
  16 {
  17     uint8_t data[4] = {0};
  18     fail_unless(set_nibble(0, 0x1, data, sizeof(data)));
  19     fail_unless(set_nibble(1, 0x2, data, sizeof(data)));
  20     fail_unless(set_nibble(2, 0x3, data, sizeof(data)));
  21     fail_unless(set_nibble(3, 0x4, data, sizeof(data)));
  22     fail_unless(set_nibble(4, 0x5, data, sizeof(data)));
  23     ck_assert_int_eq(data[0], 0x12);
  24     ck_assert_int_eq(data[1], 0x34);
  25     ck_assert_int_eq(data[2], 0x50);
  26 }
  27 END_TEST
  28
  29 START_TEST (test_set_bitfield)
  30 {
  31     uint8_t data[4] = {0};
  32     fail_unless(set_bitfield(0x12, 0, 8, data, sizeof(data)));
  33     fail_unless(set_bitfield(bitmask(3), 10, 3, data, sizeof(data)));
  34     ck_assert_int_eq(data[0], 0x12);
  35     ck_assert_int_eq(data[1], 0x38);
  36 }
  37 END_TEST
  38
  39 START_TEST (test_set_bitfield_doesnt_fit)
  40 {
  41     uint8_t data[4] = {0};
  42     fail_if(set_bitfield(0xffff, 0, 8, data, sizeof(data)));
  43     ck_assert_int_eq(data[0], 0);
  44     ck_assert_int_eq(data[1], 0);
  45     ck_assert_int_eq(data[2], 0);
  46     ck_assert_int_eq(data[3], 0);
  47 }
  48 END_TEST
  49
  50 START_TEST (test_get_nibble)
  51 {
  52     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  53     uint8_t result = get_nibble(data, sizeof(data), 0);
  54     ck_assert_int_eq(result, 0x1);
  55     result = get_nibble(data, sizeof(data), 1);
  56     ck_assert_int_eq(result, 0x2);
  57     result = get_nibble(data, sizeof(data), 2);
  58     ck_assert_int_eq(result, 0x3);
  59 }
  60 END_TEST
  61
  62 START_TEST (test_get_bits_out_of_range)
  63 {
  64     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  65     uint8_t result[4];
  66     fail_if(copy_bits_right_aligned(data, sizeof(data), 25, 16, result,
  67                 sizeof(result)));
  68 }
  69 END_TEST
  70
  71 START_TEST (test_get_bits)
  72 {
  73     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  74     uint8_t result[4] = {0};
  75     fail_unless(copy_bits_right_aligned(data, sizeof(data), 0, 16, result,
  76                 sizeof(result)));
  77     ck_assert_int_eq(result[2], 0x12);
  78     ck_assert_int_eq(result[3], 0x34);
  79 }
  80 END_TEST
  81
  82 START_TEST (test_copy_bytes)
  83 {
  84     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  85     uint8_t result[4] = {0};
  86     fail_unless(copy_bytes_right_aligned(data, sizeof(data), 1, 3, result,
  87                 sizeof(result)));
  88     ck_assert_int_eq(result[1], 0x34);
  89     ck_assert_int_eq(result[2], 0x56);
  90     ck_assert_int_eq(result[3], 0x78);
  91 }
  92 END_TEST
  93
  94 START_TEST (test_get_uneven_bits)
  95 {
  96     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  97     uint8_t result[4] = {0};
  98     fail_unless(copy_bits_right_aligned(data, sizeof(data), 4, 12, result,
  99                 sizeof(result)));
 100     ck_assert_int_eq(result[2], 0x2);
 101     ck_assert_int_eq(result[3], 0x34);
 102 }
 103 END_TEST
 104
 105 Suite* bitfieldSuite(void) {
 106     Suite* s = suite_create("bitfield");
 107     TCase *tc_core = tcase_create("core");
 108     tcase_add_test(tc_core, test_get_byte);
 109     tcase_add_test(tc_core, test_get_nibble);
 110     tcase_add_test(tc_core, test_set_nibble);
 111     tcase_add_test(tc_core, test_set_bitfield);
 112     tcase_add_test(tc_core, test_set_bitfield_doesnt_fit);
 113     tcase_add_test(tc_core, test_get_bits);
 114     tcase_add_test(tc_core, test_copy_bytes);
 115     tcase_add_test(tc_core, test_get_bits_out_of_range);
 116     tcase_add_test(tc_core, test_get_uneven_bits);
 117     suite_add_tcase(s, tc_core);
 118
 119     return s;
 120 }
 121
 122 int main(void) {
 123     int numberFailed;
 124     Suite* s = bitfieldSuite();
 125     SRunner *sr = srunner_create(s);
 126     // Don't fork so we can actually use gdb
 127     srunner_set_fork_status(sr, CK_NOFORK);
 128     srunner_run_all(sr, CK_NORMAL);
 129     numberFailed = srunner_ntests_failed(sr);
 130     srunner_free(sr);
 131     return (numberFailed == 0) ? 0 : 1;
 132 }