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_get_nibble)
  30 {
  31     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  32     uint8_t result = get_nibble(data, sizeof(data), 0);
  33     ck_assert_int_eq(result, 0x1);
  34     result = get_nibble(data, sizeof(data), 1);
  35     ck_assert_int_eq(result, 0x2);
  36     result = get_nibble(data, sizeof(data), 2);
  37     ck_assert_int_eq(result, 0x3);
  38 }
  39 END_TEST
  40
  41 START_TEST (test_get_bits_out_of_range)
  42 {
  43     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  44     uint8_t result[4];
  45     fail_if(copy_bits_right_aligned(data, sizeof(data), 25, 16, result,
  46                 sizeof(result)));
  47 }
  48 END_TEST
  49
  50 START_TEST (test_get_bits)
  51 {
  52     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  53     uint8_t result[4] = {0};
  54     fail_unless(copy_bits_right_aligned(data, sizeof(data), 0, 16, result,
  55                 sizeof(result)));
  56     ck_assert_int_eq(result[2], 0x12);
  57     ck_assert_int_eq(result[3], 0x34);
  58 }
  59 END_TEST
  60
  61 START_TEST (test_copy_bytes)
  62 {
  63     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  64     uint8_t result[4] = {0};
  65     fail_unless(copy_bytes_right_aligned(data, sizeof(data), 1, 3, result,
  66                 sizeof(result)));
  67     ck_assert_int_eq(result[1], 0x34);
  68     ck_assert_int_eq(result[2], 0x56);
  69     ck_assert_int_eq(result[3], 0x78);
  70 }
  71 END_TEST
  72
  73 START_TEST (test_get_uneven_bits)
  74 {
  75     uint8_t data[4] = {0x12, 0x34, 0x56, 0x78};
  76     uint8_t result[4] = {0};
  77     fail_unless(copy_bits_right_aligned(data, sizeof(data), 4, 12, result,
  78                 sizeof(result)));
  79     ck_assert_int_eq(result[2], 0x2);
  80     ck_assert_int_eq(result[3], 0x34);
  81 }
  82 END_TEST
  83
  84 Suite* bitfieldSuite(void) {
  85     Suite* s = suite_create("bitfield");
  86     TCase *tc_core = tcase_create("core");
  87     tcase_add_test(tc_core, test_get_byte);
  88     tcase_add_test(tc_core, test_get_nibble);
  89     tcase_add_test(tc_core, test_set_nibble);
  90     tcase_add_test(tc_core, test_get_bits);
  91     tcase_add_test(tc_core, test_copy_bytes);
  92     tcase_add_test(tc_core, test_get_bits_out_of_range);
  93     tcase_add_test(tc_core, test_get_uneven_bits);
  94     suite_add_tcase(s, tc_core);
  95
  96     return s;
  97 }
  98
  99 int main(void) {
 100     int numberFailed;
 101     Suite* s = bitfieldSuite();
 102     SRunner *sr = srunner_create(s);
 103     // Don't fork so we can actually use gdb
 104     srunner_set_fork_status(sr, CK_NOFORK);
 105     srunner_run_all(sr, CK_NORMAL);
 106     numberFailed = srunner_ntests_failed(sr);
 107     srunner_free(sr);
 108     return (numberFailed == 0) ? 0 : 1;
 109 }