Standardize on snake_case naming as this is a C library.

3 files changed, 36 insertions, 36 deletions

diff --git a/tests/8byte_tests.c b/tests/8byte_tests.c
index 140c4ef..f4188bf 100644
--- a/tests/8byte_tests.c
+++ b/tests/8byte_tests.c
@@ -15,7 +15,7 @@ END_TEST
 START_TEST (test_one_bit_not_swapped)
 {
     uint64_t data = 0x80;
-    uint64_t result = getBitField(data, 0, 1, false);
+    uint64_t result = get_bit_field(data, 0, 1, false);
     fail_if(result == 1);
 }
 END_TEST
@@ -23,7 +23,7 @@ END_TEST
 START_TEST (test_one_bit)
 {
     uint64_t data = 0x8000000000000000;
-    uint64_t result = getBitField(data, 0, 1, false);
+    uint64_t result = get_bit_field(data, 0, 1, false);
     fail_unless(result == 0x1,
             "First bit in 0x%llx was 0x%llx instead of 0x1", data, result);
 }
@@ -32,7 +32,7 @@ END_TEST
 START_TEST (test_32_bit_parse)
 {
     uint64_t data = 0x0402574d555a0401;
-    uint64_t result = getBitField(data, 16, 32, false);
+    uint64_t result = get_bit_field(data, 16, 32, false);
     uint64_t expectedValue = 0x574d555a;
     fail_unless(result == expectedValue,
             "Field retrieved in 0x%llx was 0x%llx instead of 0x%llx", data,
@@ -43,7 +43,7 @@ END_TEST
 START_TEST (test_16_bit_parse)
 {
     uint64_t data = 0xF34DFCFF00000000;
-    uint64_t result = getBitField(data, 16, 16, false);
+    uint64_t result = get_bit_field(data, 16, 16, false);
     uint64_t expectedValue = 0xFCFF;
     fail_unless(result == expectedValue,
             "Field retrieved in 0x%llx was 0x%llx instead of 0x%llx", data,
@@ -54,13 +54,13 @@ END_TEST
 START_TEST (test_one_byte)
 {
     uint64_t data = 0xFA00000000000000;
-    uint64_t result = getBitField(data, 0, 4, false);
+    uint64_t result = get_bit_field(data, 0, 4, false);
     fail_unless(result == 0xF,
             "First 4 bits in 0x%llx was 0x%llx instead of 0xF", data, result);
-    result = getBitField(data, 4, 4, false);
+    result = get_bit_field(data, 4, 4, false);
     fail_unless(result == 0xA,
             "First 4 bits in 0x%llx was 0x%llx instead of 0xA", data, result);
-    result = getBitField(data, 0, 8, false);
+    result = get_bit_field(data, 0, 8, false);
     fail_unless(result == 0xFA,
             "All bits in 0x%llx were 0x%llx instead of 0x%llx", data, result, data);
 }
@@ -69,19 +69,19 @@ END_TEST
 START_TEST (test_multi_byte)
 {
     uint64_t data = 0x12FA000000000000;
-    uint64_t result = getBitField(data, 0, 4, false);
+    uint64_t result = get_bit_field(data, 0, 4, false);
     fail_unless(result == 0x1,
             "First 4 bits in 0x%llx was 0x%llx instead of 0xF", (data >> 60) & 0xF,
             result);
-    result = getBitField(data, 4, 4, false);
+    result = get_bit_field(data, 4, 4, false);
     fail_unless(result == 0x2,
             "Second 4 bits in 0x%llx was 0x%llx instead of 0xA", (data >> 56) & 0xF,
             result);
-    result = getBitField(data, 8, 4, false);
+    result = get_bit_field(data, 8, 4, false);
     fail_unless(result == 0xF,
             "First 4 bits in 0x%llx was 0x%llx instead of 0x1", (data >> 52) & 0xF,
             result);
-    result = getBitField(data, 12, 4, false);
+    result = get_bit_field(data, 12, 4, false);
     fail_unless(result == 0xA,
             "Second 4 bits in 0x%llx was 0x%llx instead of 0x2", (data >> 48) % 0xF,
             result);
@@ -91,7 +91,7 @@ END_TEST
 START_TEST (test_get_multi_byte)
 {
     uint64_t data = 0x12FA000000000000;
-    uint64_t result = getBitField(data, 0, 9, false);
+    uint64_t result = get_bit_field(data, 0, 9, false);
     ck_assert_int_eq(result, 0x25);
 }
 END_TEST
@@ -99,24 +99,24 @@ END_TEST
 START_TEST (test_get_off_byte_boundary)
 {
     uint64_t data = 0x000012FA00000000;
-    uint64_t result = getBitField(data, 12, 8, false);
+    uint64_t result = get_bit_field(data, 12, 8, false);
     ck_assert_int_eq(result, 0x01);
 } END_TEST
 
 START_TEST (test_set_field)
 {
     uint64_t data = 0;
-    setBitField(&data, 1, 0, 1);
-    uint64_t result = getBitField(data, 0, 1, false);
+    set_bit_field(&data, 1, 0, 1);
+    uint64_t result = get_bit_field(data, 0, 1, false);
     ck_assert_int_eq(result, 0x1);
     data = 0;
-    setBitField(&data, 1, 1, 1);
-    result = getBitField(data, 1, 1, false);
+    set_bit_field(&data, 1, 1, 1);
+    result = get_bit_field(data, 1, 1, false);
     ck_assert_int_eq(result, 0x1);
 
     data = 0;
-    setBitField(&data, 0xf, 3, 4);
-    result = getBitField(data, 3, 4, false);
+    set_bit_field(&data, 0xf, 3, 4);
+    result = get_bit_field(data, 3, 4, false);
     ck_assert_int_eq(result, 0xf);
 }
 END_TEST
@@ -124,14 +124,14 @@ END_TEST
 START_TEST (test_set_doesnt_clobber_existing_data)
 {
     uint64_t data = 0xFFFC4DF300000000;
-    setBitField(&data, 0x4fc8, 16, 16);
-    uint64_t result = getBitField(data, 16, 16, false);
+    set_bit_field(&data, 0x4fc8, 16, 16);
+    uint64_t result = get_bit_field(data, 16, 16, false);
     fail_unless(result == 0x4fc8,
             "Field retrieved in 0x%llx was 0x%llx instead of 0x%x", data, result,
             0xc84f);
 
     data = 0x8000000000000000;
-    setBitField(&data, 1, 21, 1);
+    set_bit_field(&data, 1, 21, 1);
     fail_unless(data == 0x8000040000000000LLU,
             "Expected combined value 0x8000040000000000 but got 0x%llx%llx",
             data >> 32, data);
@@ -141,8 +141,8 @@ END_TEST
 START_TEST (test_set_off_byte_boundary)
 {
     uint64_t data = 0xFFFC4DF300000000;
-    setBitField(&data, 0x12, 12, 8);
-    uint64_t result = getBitField(data, 12, 12, false);
+    set_bit_field(&data, 0x12, 12, 8);
+    uint64_t result = get_bit_field(data, 12, 12, false);
     ck_assert_int_eq(result,0x12d);
 }
 END_TEST
@@ -150,15 +150,15 @@ END_TEST
 START_TEST (test_set_odd_number_of_bits)
 {
     uint64_t data = 0xFFFC4DF300000000LLU;
-    setBitField(&data, 0x12, 11, 5);
-    uint64_t result = getBitField(data, 11, 5, false);
+    set_bit_field(&data, 0x12, 11, 5);
+    uint64_t result = get_bit_field(data, 11, 5, false);
     fail_unless(result == 0x12,
             "Field set in 0x%llx%llx%llx%llx was 0x%llx instead of 0x%llx", data, result,
             0x12);
 
     data = 0xFFFC4DF300000000LLU;
-    setBitField(&data, 0x2, 11, 5);
-    result = getBitField(data, 11, 5, false);
+    set_bit_field(&data, 0x2, 11, 5);
+    result = get_bit_field(data, 11, 5, false);
     fail_unless(result == 0x2,
             "Field set in 0x%llx%llx%llx%llx was 0x%llx instead of 0x%llx", data, result,
             0x2);
@@ -168,23 +168,23 @@ END_TEST
 START_TEST(test_nth_byte)
 {
     uint64_t data = 0x00000000F34DFCFF;
-    uint8_t result = nthByte(data, 0);
+    uint8_t result = nth_byte(data, 0);
     uint8_t expected = 0x0;
     ck_assert_int_eq(result, expected);
 
-    result = nthByte(data, 4);
+    result = nth_byte(data, 4);
     expected = 0xF3;
     ck_assert_int_eq(result, expected);
 
-    result = nthByte(data, 5);
+    result = nth_byte(data, 5);
     expected = 0x4D;
     ck_assert_int_eq(result, expected);
 
-    result = nthByte(data, 6);
+    result = nth_byte(data, 6);
     expected = 0xFC;
     ck_assert_int_eq(result, expected);
 
-    result = nthByte(data, 7);
+    result = nth_byte(data, 7);
     expected = 0xFF;
     ck_assert_int_eq(result, expected);
 }
diff --git a/tests/read_tests.c b/tests/read_tests.c
index f5f0f0c..62ced1f 100644
--- a/tests/read_tests.c
+++ b/tests/read_tests.c
@@ -6,7 +6,7 @@ const uint64_t BIG_ENDIAN_TEST_DATA = __builtin_bswap64(0xEB00000000000000);
 
 START_TEST (test_parse_float)
 {
-    float result = parseFloat(BIG_ENDIAN_TEST_DATA, 2, 4, 1001.0, -30000.0);
+    float result = bitfield_parse_float(BIG_ENDIAN_TEST_DATA, 2, 4, 1001.0, -30000.0);
     float correctResult = 0xA * 1001.0 - 30000.0;
     fail_unless(result == correctResult,
             "parse is incorrect: %f but should be %f", result, correctResult);
diff --git a/tests/write_tests.c b/tests/write_tests.c
index da5ee89..ed555f6 100644
--- a/tests/write_tests.c
+++ b/tests/write_tests.c
@@ -4,14 +4,14 @@
 
 START_TEST (test_encode_can_signal)
 {
-    uint64_t value = encodeFloat(0, 1, 3, 1, 0);
+    uint64_t value = bitfield_encode_float(0, 1, 3, 1, 0);
     ck_assert_int_eq(value, 0);
 }
 END_TEST
 
 START_TEST (test_encode_can_signal_rounding_precision)
 {
-    uint64_t value = encodeFloat(50, 2, 19, 0.001, 0);
+    uint64_t value = bitfield_encode_float(50, 2, 19, 0.001, 0);
     ck_assert_int_eq(value, 0x061a800000000000LLU);
 }
 END_TEST