From a0857b909071e8f52d0f62b49bfcad1fb2fab3df Mon Sep 17 00:00:00 2001 From: Aryadev Chavali Date: Sun, 28 Apr 2024 19:08:20 +0530 Subject: [PATCH] test WORD_NTH_* and WORD_SAFE_SUB, ~refactored general testing code The new general testing procedure is making a structure for tests that include all the samples and expected results, then iterating over them to run the test. --- test/lib/test-base.h | 156 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 130 insertions(+), 26 deletions(-) diff --git a/test/lib/test-base.h b/test/lib/test-base.h index 6d07f6a..5c79034 100644 --- a/test/lib/test-base.h +++ b/test/lib/test-base.h @@ -16,52 +16,156 @@ #include #include -void testing_lib_bytes_to_hword(void) +void testing_lib_base_word_safe_sub(void) { - const byte_t tests[][4] = {{0, 0, 0, 0}, - {0xFF, 0xFF, 0xFF, 0xFF}, - {1}, - {0, 0, 0, 0b10000000}, - {0x89, 0xab, 0xcd, 0xef}}; - - const hword_t expected[ARR_SIZE(tests)] = {0, HWORD_MAX, 1, 1 << 31, - 0xefcdab89}; - + const struct TestCase + { + word_t a; + word_t b; + word_t expected; + } tests[] = { + {0xFF, 0, 0xFF}, + {1LU << 32, 1LU << 31, 1LU << 31}, + {0, 100, 0}, + {~(1LU << 62), ~(1LU << 63), 1LU << 62}, + }; for (size_t i = 0; i < ARR_SIZE(tests); ++i) { - const hword_t got = convert_bytes_to_hword(tests[i]); - if (expected[i] != got) + const struct TestCase test = tests[i]; + const word_t res = test.expected; + const word_t got = WORD_SAFE_SUB(test.a, test.b); + INFO(__func__, "Testing(a=0x%lX, b=0x%lX)\n", test.a, test.b); + if (got != res) { - FAIL(__func__, "[%lu] -> Expected 0x%x got 0x%x\n", i, expected[i], got); + FAIL(__func__, "[%lu] -> Expected 0x%lX got 0x%lX\n", i, res, got); assert(false); } } } -void testing_lib_bytes_to_word(void) +void testing_lib_base_word_nth_byte(void) { - const byte_t tests[][8] = {{0, 0, 0, 0}, - {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, - {0x01, 0, 0, 0, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0, 0, 0b10000000}, - {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}}; + const struct TestCase + { + word_t word; + size_t n; + byte_t expected; + } tests[] = { + {0, 0, 0}, + {0x0123456789abcdef, 0, 0xef}, + {0x0123456789abcdef, 1, 0xcd}, + {0x0123456789abcdef, 2, 0xab}, + {0x0123456789abcdef, 3, 0x89}, + {0x0123456789abcdef, 4, 0x67}, + {0x0123456789abcdef, 5, 0x45}, + {0x0123456789abcdef, 6, 0x23}, + {0x0123456789abcdef, 7, 0x01}, + }; - const word_t expected[ARR_SIZE(tests)] = {0, WORD_MAX, 1, 1LU << 63, - - 0xefcdab8967452301}; for (size_t i = 0; i < ARR_SIZE(tests); ++i) { - const word_t got = convert_bytes_to_word(tests[i]); - if (expected[i] != got) + const word_t w = tests[i].word; + const size_t n = tests[i].n; + const byte_t expected = tests[i].expected; + INFO(__func__, "Testing(0x%lX, %lu)\n", w, n); + const byte_t got = WORD_NTH_BYTE(w, n); + if (got != expected) { - FAIL(__func__, "[%lu] -> Expected 0x%lx got 0x%lx\n", i, expected[i], + FAIL(__func__, "[%lu] -> Expected 0x%x got 0x%x\n", i, expected, got); + assert(false); + } + } +} + +void testing_lib_base_word_nth_hword(void) +{ + const struct TestCase + { + word_t word; + size_t n; + hword_t expected; + } tests[] = { + {0, 0, 0}, + {0x0123456789abcdef, 0, 0x89abcdef}, + {0x0123456789abcdef, 1, 0x01234567}, + {~(1LU << 63), 0, 0xFFFFFFFF}, + {~(1LU << 63), 1, 0x7FFFFFFF}, + }; + + for (size_t i = 0; i < ARR_SIZE(tests); ++i) + { + const word_t w = tests[i].word; + const size_t n = tests[i].n; + const hword_t expected = tests[i].expected; + INFO(__func__, "Testing(0x%lX, %lu)\n", w, n); + const hword_t got = WORD_NTH_HWORD(w, n); + if (got != expected) + { + FAIL(__func__, "[%lu] -> Expected 0x%x got 0x%x\n", i, expected, got); + assert(false); + } + } +} + +void testing_lib_base_bytes_to_hword(void) +{ + const struct TestCase + { + byte_t bytes[4]; + hword_t expected; + } tests[] = {{{0, 0, 0, 0}, 0}, + {{0xFF, 0xFF, 0xFF, 0xFF}, HWORD_MAX}, + {{1, 0, 0, 0}, 1}, + {{0, 0, 0, 0b10000000}, 1 << 31}, + {{0x89, 0xab, 0xcd, 0xef}, 0xefcdab89}}; + + for (size_t i = 0; i < ARR_SIZE(tests); ++i) + { + const hword_t got = convert_bytes_to_hword(tests[i].bytes); + INFO(__func__, "Testing(0x%X, 0x%X, 0x%X, 0x%X)\n", tests[i].bytes[0], + tests[i].bytes[1], tests[i].bytes[2], tests[i].bytes[3]); + if (tests[i].expected != got) + { + FAIL(__func__, "[%lu] -> Expected 0x%x got 0x%x\n", i, tests[i].expected, got); assert(false); } } } -TEST_SUITE(test_lib, CREATE_TEST(testing_lib_base_bytes_to_hword), +void testing_lib_base_bytes_to_word(void) +{ + const struct TestCase + { + byte_t bytes[8]; + word_t expected; + } tests[] = { + {{0, 0, 0, 0}, 0}, + {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, WORD_MAX}, + {{0x01, 0, 0, 0, 0, 0, 0, 0}, 1}, + {{0, 0, 0, 0, 0, 0, 0, 0b10000000}, 1LU << 63}, + {{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, 0xefcdab8967452301}}; + + for (size_t i = 0; i < ARR_SIZE(tests); ++i) + { + INFO(__func__, "Testing(0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X)\n", + tests[i].bytes[0], tests[i].bytes[1], tests[i].bytes[2], + tests[i].bytes[3], tests[i].bytes[4], tests[i].bytes[5], + tests[i].bytes[6], tests[i].bytes[7]); + const word_t got = convert_bytes_to_word(tests[i].bytes); + if (tests[i].expected != got) + { + FAIL(__func__, "[%lu] -> Expected 0x%lx got 0x%lx\n", i, + tests[i].expected, got); + assert(false); + } + } +} + +TEST_SUITE(test_lib, CREATE_TEST(testing_lib_base_word_safe_sub), + CREATE_TEST(testing_lib_base_word_nth_byte), + CREATE_TEST(testing_lib_base_word_nth_hword), + CREATE_TEST(testing_lib_base_bytes_to_hword), CREATE_TEST(testing_lib_base_bytes_to_word)); #endif