diff --git a/tests/unit/util/CMakeLists.txt b/tests/unit/util/CMakeLists.txt index a78fab2bfd5..a8f1f4e76db 100644 --- a/tests/unit/util/CMakeLists.txt +++ b/tests/unit/util/CMakeLists.txt @@ -4,4 +4,9 @@ cmake_minimum_required(VERSION 3.20.0) project(util) find_package(Zephyr COMPONENTS unittest REQUIRED HINTS $ENV{ZEPHYR_BASE}) -target_sources(testbinary PRIVATE main.c maincxx.cxx ${ZEPHYR_BASE}/lib/utils/dec.c) +target_sources(testbinary PRIVATE main.c ${ZEPHYR_BASE}/lib/utils/dec.c) + +if(CONFIG_CPP) + # When testing for C++ force test file C++ compilation + set_source_files_properties(main.c ${ZEPHYR_BASE}/lib/utils/dec.c PROPERTIES LANGUAGE CXX) +endif() diff --git a/tests/unit/util/main.c b/tests/unit/util/main.c index 3c93968db46..d5698fc85f5 100644 --- a/tests/unit/util/main.c +++ b/tests/unit/util/main.c @@ -8,308 +8,614 @@ #include #include -#include "test.inc" +ZTEST(util, test_u8_to_dec) { + char text[4]; + uint8_t len; + + len = u8_to_dec(text, sizeof(text), 0); + zassert_equal(len, 1, "Length of 0 is not 1"); + zassert_equal(strcmp(text, "0"), 0, + "Value=0 is not converted to \"0\""); + + len = u8_to_dec(text, sizeof(text), 1); + zassert_equal(len, 1, "Length of 1 is not 1"); + zassert_equal(strcmp(text, "1"), 0, + "Value=1 is not converted to \"1\""); + + len = u8_to_dec(text, sizeof(text), 11); + zassert_equal(len, 2, "Length of 11 is not 2"); + zassert_equal(strcmp(text, "11"), 0, + "Value=10 is not converted to \"11\""); + + len = u8_to_dec(text, sizeof(text), 100); + zassert_equal(len, 3, "Length of 100 is not 3"); + zassert_equal(strcmp(text, "100"), 0, + "Value=100 is not converted to \"100\""); + + len = u8_to_dec(text, sizeof(text), 101); + zassert_equal(len, 3, "Length of 101 is not 3"); + zassert_equal(strcmp(text, "101"), 0, + "Value=101 is not converted to \"101\""); + + len = u8_to_dec(text, sizeof(text), 255); + zassert_equal(len, 3, "Length of 255 is not 3"); + zassert_equal(strcmp(text, "255"), 0, + "Value=255 is not converted to \"255\""); + + memset(text, 0, sizeof(text)); + len = u8_to_dec(text, 2, 123); + zassert_equal(len, 2, + "Length of converted value using 2 byte buffer isn't 2"); + zassert_equal( + strcmp(text, "12"), 0, + "Value=123 is not converted to \"12\" using 2-byte buffer"); + + memset(text, 0, sizeof(text)); + len = u8_to_dec(text, 1, 123); + zassert_equal(len, 1, + "Length of converted value using 1 byte buffer isn't 1"); + zassert_equal( + strcmp(text, "1"), 0, + "Value=123 is not converted to \"1\" using 1-byte buffer"); + + memset(text, 0, sizeof(text)); + len = u8_to_dec(text, 0, 123); + zassert_equal(len, 0, + "Length of converted value using 0 byte buffer isn't 0"); +} + +ZTEST(util, test_COND_CODE_1) { + #define TEST_DEFINE_1 1 + #define TEST_DEFINE_0 0 + /* Test validates that expected code has been injected. Failure would + * be seen in compilation (lack of variable or ununsed variable. + */ + COND_CODE_1(1, (uint32_t x0 = 1;), (uint32_t y0;)) + zassert_true((x0 == 1)); + + COND_CODE_1(NOT_EXISTING_DEFINE, (uint32_t x1 = 1;), (uint32_t y1 = 1;)) + zassert_true((y1 == 1)); + + COND_CODE_1(TEST_DEFINE_1, (uint32_t x2 = 1;), (uint32_t y2 = 1;)) + zassert_true((x2 == 1)); + + COND_CODE_1(2, (uint32_t x3 = 1;), (uint32_t y3 = 1;)) + zassert_true((y3 == 1)); +} + +ZTEST(util, test_COND_CODE_0) { + /* Test validates that expected code has been injected. Failure would + * be seen in compilation (lack of variable or ununsed variable. + */ + COND_CODE_0(0, (uint32_t x0 = 1;), (uint32_t y0;)) + zassert_true((x0 == 1)); + + COND_CODE_0(NOT_EXISTING_DEFINE, (uint32_t x1 = 1;), (uint32_t y1 = 1;)) + zassert_true((y1 == 1)); + + COND_CODE_0(TEST_DEFINE_0, (uint32_t x2 = 1;), (uint32_t y2 = 1;)) + zassert_true((x2 == 1)); + + COND_CODE_0(2, (uint32_t x3 = 1;), (uint32_t y3 = 1;)) + zassert_true((y3 == 1)); +} + +#undef ZERO +#undef SEVEN +#undef A_BUILD_ERROR +#define ZERO 0 +#define SEVEN 7 +#define A_BUILD_ERROR (this would be a build error if you used || or &&) +ZTEST(util, test_UTIL_OR) { + zassert_equal(UTIL_OR(SEVEN, A_BUILD_ERROR), 7); + zassert_equal(UTIL_OR(7, 0), 7); + zassert_equal(UTIL_OR(SEVEN, ZERO), 7); + zassert_equal(UTIL_OR(0, 7), 7); + zassert_equal(UTIL_OR(ZERO, SEVEN), 7); + zassert_equal(UTIL_OR(0, 0), 0); + zassert_equal(UTIL_OR(ZERO, ZERO), 0); +} + +ZTEST(util, test_UTIL_AND) { + zassert_equal(UTIL_AND(ZERO, A_BUILD_ERROR), 0); + zassert_equal(UTIL_AND(7, 0), 0); + zassert_equal(UTIL_AND(SEVEN, ZERO), 0); + zassert_equal(UTIL_AND(0, 7), 0); + zassert_equal(UTIL_AND(ZERO, SEVEN), 0); + zassert_equal(UTIL_AND(0, 0), 0); + zassert_equal(UTIL_AND(ZERO, ZERO), 0); + zassert_equal(UTIL_AND(7, 7), 7); + zassert_equal(UTIL_AND(7, SEVEN), 7); + zassert_equal(UTIL_AND(SEVEN, 7), 7); + zassert_equal(UTIL_AND(SEVEN, SEVEN), 7); +} + +ZTEST(util, test_IF_ENABLED) { + #define test_IF_ENABLED_FLAG_A 1 + #define test_IF_ENABLED_FLAG_B 0 + + IF_ENABLED(test_IF_ENABLED_FLAG_A, (goto skipped;)) + /* location should be skipped if IF_ENABLED macro is correct. */ + zassert_false(true, "location should be skipped"); +skipped: + IF_ENABLED(test_IF_ENABLED_FLAG_B, (zassert_false(true, "");)) -#if __cplusplus -extern "C" { -#endif + IF_ENABLED(test_IF_ENABLED_FLAG_C, (zassert_false(true, "");)) -ZTEST(util_cxx, test_u8_to_dec) { - run_u8_to_dec(); -} + zassert_true(true, ""); -ZTEST(util_cxx, test_COND_CODE_1) { - run_COND_CODE_1(); + #undef test_IF_ENABLED_FLAG_A + #undef test_IF_ENABLED_FLAG_B } -ZTEST(util_cxx, test_COND_CODE_0) { - run_COND_CODE_0(); -} +ZTEST(util, test_LISTIFY) { + int ab0 = 1; + int ab1 = 1; +#define A_PTR(x, name0, name1) &UTIL_CAT(UTIL_CAT(name0, name1), x) -ZTEST(util_cxx, test_UTIL_OR) { - run_UTIL_OR(); -} + int *a[] = { LISTIFY(2, A_PTR, (,), a, b) }; -ZTEST(util_cxx, test_UTIL_AND) { - run_UTIL_AND(); + zassert_equal(ARRAY_SIZE(a), 2); + zassert_equal(a[0], &ab0); + zassert_equal(a[1], &ab1); } -ZTEST(util_cxx, test_IF_ENABLED) { - run_IF_ENABLED(); -} +ZTEST(util, test_MACRO_MAP_CAT) { + int item_a_item_b_item_c_ = 1; -ZTEST(util_cxx, test_IF_DISABLED) { - run_IF_DISABLED(); +#undef FOO +#define FOO(x) item_##x##_ + zassert_equal(MACRO_MAP_CAT(FOO, a, b, c), 1, "MACRO_MAP_CAT"); +#undef FOO } -ZTEST(util_cxx, test_LISTIFY) { - run_LISTIFY(); -} +static int inc_func(bool cleanup) +{ + static int a; -ZTEST(util_cxx, test_MACRO_MAP_CAT) { - run_MACRO_MAP_CAT(); -} + if (cleanup) { + a = 1; + } -ZTEST(util_cxx, test_z_max_z_min_z_clamp) { - run_z_max_z_min_z_clamp(); + return a++; } -ZTEST(util_cxx, test_CLAMP) { - run_CLAMP(); +/* Test checks if @ref Z_MAX, @ref Z_MIN and @ref Z_CLAMP return correct result + * and perform single evaluation of input arguments. + */ +ZTEST(util, test_z_max_z_min_z_clamp) { + zassert_equal(Z_MAX(inc_func(true), 0), 1, "Unexpected macro result"); + /* Z_MAX should have call inc_func only once */ + zassert_equal(inc_func(false), 2, "Unexpected return value"); + + zassert_equal(Z_MIN(inc_func(false), 2), 2, "Unexpected macro result"); + /* Z_MIN should have call inc_func only once */ + zassert_equal(inc_func(false), 4, "Unexpected return value"); + + zassert_equal(Z_CLAMP(inc_func(false), 1, 3), 3, "Unexpected macro result"); + /* Z_CLAMP should have call inc_func only once */ + zassert_equal(inc_func(false), 6, "Unexpected return value"); + + zassert_equal(Z_CLAMP(inc_func(false), 10, 15), 10, + "Unexpected macro result"); + /* Z_CLAMP should have call inc_func only once */ + zassert_equal(inc_func(false), 8, "Unexpected return value"); +} + +ZTEST(util, test_CLAMP) { + zassert_equal(CLAMP(5, 3, 7), 5, "Unexpected clamp result"); + zassert_equal(CLAMP(3, 3, 7), 3, "Unexpected clamp result"); + zassert_equal(CLAMP(7, 3, 7), 7, "Unexpected clamp result"); + zassert_equal(CLAMP(1, 3, 7), 3, "Unexpected clamp result"); + zassert_equal(CLAMP(8, 3, 7), 7, "Unexpected clamp result"); + + zassert_equal(CLAMP(-5, -7, -3), -5, "Unexpected clamp result"); + zassert_equal(CLAMP(-9, -7, -3), -7, "Unexpected clamp result"); + zassert_equal(CLAMP(1, -7, -3), -3, "Unexpected clamp result"); + + zassert_equal(CLAMP(0xffffffffaULL, 0xffffffff0ULL, 0xfffffffffULL), + 0xffffffffaULL, "Unexpected clamp result"); +} + +ZTEST(util, test_IN_RANGE) { + zassert_true(IN_RANGE(0, 0, 0), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(1, 0, 1), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(1, 0, 2), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(-1, -2, 2), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(-3, -5, -1), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(0, 0, UINT64_MAX), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(UINT64_MAX, 0, UINT64_MAX), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(0, INT64_MIN, INT64_MAX), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(INT64_MIN, INT64_MIN, INT64_MAX), "Unexpected IN_RANGE result"); + zassert_true(IN_RANGE(INT64_MAX, INT64_MIN, INT64_MAX), "Unexpected IN_RANGE result"); + + zassert_false(IN_RANGE(5, 0, 2), "Unexpected IN_RANGE result"); + zassert_false(IN_RANGE(5, 10, 0), "Unexpected IN_RANGE result"); + zassert_false(IN_RANGE(-1, 0, 1), "Unexpected IN_RANGE result"); +} + +ZTEST(util, test_FOR_EACH) { + #define FOR_EACH_MACRO_TEST(arg) *buf++ = arg + + uint8_t array[3] = {0}; + uint8_t *buf = array; + + FOR_EACH(FOR_EACH_MACRO_TEST, (;), 1, 2, 3); + + zassert_equal(array[0], 1, "Unexpected value %d", array[0]); + zassert_equal(array[1], 2, "Unexpected value %d", array[1]); + zassert_equal(array[2], 3, "Unexpected value %d", array[2]); +} + +ZTEST(util, test_FOR_EACH_NONEMPTY_TERM) { + #define SQUARE(arg) (arg * arg) + #define SWALLOW_VA_ARGS_1(...) EMPTY + #define SWALLOW_VA_ARGS_2(...) + #define REPEAT_VA_ARGS(...) __VA_ARGS__ + + uint8_t array[] = { + FOR_EACH_NONEMPTY_TERM(SQUARE, (,)) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,),) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), ,) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), EMPTY, EMPTY) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), SWALLOW_VA_ARGS_1(a, b)) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), SWALLOW_VA_ARGS_2(c, d)) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), 1) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), 2, 3) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), REPEAT_VA_ARGS(4)) + FOR_EACH_NONEMPTY_TERM(SQUARE, (,), REPEAT_VA_ARGS(5, 6)) + 255 + }; + + size_t size = ARRAY_SIZE(array); + + zassert_equal(size, 7, "Unexpected size %d", size); + zassert_equal(array[0], 1, "Unexpected value %d", array[0]); + zassert_equal(array[1], 4, "Unexpected value %d", array[1]); + zassert_equal(array[2], 9, "Unexpected value %d", array[2]); + zassert_equal(array[3], 16, "Unexpected value %d", array[3]); + zassert_equal(array[4], 25, "Unexpected value %d", array[4]); + zassert_equal(array[5], 36, "Unexpected value %d", array[5]); + zassert_equal(array[6], 255, "Unexpected value %d", array[6]); +} + +static void fsum(uint32_t incr, uint32_t *sum) +{ + *sum = *sum + incr; } -ZTEST(util_cxx, test_IN_RANGE) { - run_IN_RANGE(); -} +ZTEST(util, test_FOR_EACH_FIXED_ARG) { + uint32_t sum = 0; -ZTEST(util_cxx, test_FOR_EACH) { - run_FOR_EACH(); -} + FOR_EACH_FIXED_ARG(fsum, (;), &sum, 1, 2, 3); -ZTEST(util_cxx, test_FOR_EACH_NONEMPTY_TERM) { - run_FOR_EACH_NONEMPTY_TERM(); + zassert_equal(sum, 6, "Unexpected value %d", sum); } -ZTEST(util_cxx, test_FOR_EACH_FIXED_ARG) { - run_FOR_EACH_FIXED_ARG(); -} +ZTEST(util, test_FOR_EACH_IDX) { + #define FOR_EACH_IDX_MACRO_TEST(n, arg) uint8_t a##n = arg -ZTEST(util_cxx, test_FOR_EACH_IDX) { - run_FOR_EACH_IDX(); -} + FOR_EACH_IDX(FOR_EACH_IDX_MACRO_TEST, (;), 1, 2, 3); -ZTEST(util_cxx, test_FOR_EACH_IDX_FIXED_ARG) { - run_FOR_EACH_IDX_FIXED_ARG(); -} + zassert_equal(a0, 1, "Unexpected value %d", a0); + zassert_equal(a1, 2, "Unexpected value %d", a1); + zassert_equal(a2, 3, "Unexpected value %d", a2); -ZTEST(util_cxx, test_IS_EMPTY) { - run_IS_EMPTY(); -} + #define FOR_EACH_IDX_MACRO_TEST2(n, arg) array[n] = arg + uint8_t array[32] = {0}; -ZTEST(util_cxx, test_IS_EQ) { - run_IS_EQ(); -} + FOR_EACH_IDX(FOR_EACH_IDX_MACRO_TEST2, (;), 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15); + for (int i = 0; i < 15; i++) { + zassert_equal(array[i], i + 1, + "Unexpected value: %d", array[i]); + } + zassert_equal(array[15], 0, "Unexpected value: %d", array[15]); -ZTEST(util_cxx, test_LIST_DROP_EMPTY) { - run_LIST_DROP_EMPTY(); -} + #define FOR_EACH_IDX_MACRO_TEST3(n, arg) &a##n -ZTEST(util_cxx, test_nested_FOR_EACH) { - run_nested_FOR_EACH(); -} + uint8_t *a[] = { + FOR_EACH_IDX(FOR_EACH_IDX_MACRO_TEST3, (,), 1, 2, 3) + }; -ZTEST(util_cxx, test_GET_ARG_N) { - run_GET_ARG_N(); + zassert_equal(ARRAY_SIZE(a), 3, "Unexpected value:%zu", ARRAY_SIZE(a)); } -ZTEST(util_cxx, test_GET_ARGS_LESS_N) { - run_GET_ARGS_LESS_N(); -} +ZTEST(util, test_FOR_EACH_IDX_FIXED_ARG) { + #undef FOO + #define FOO(n, arg, fixed_arg) \ + uint8_t fixed_arg##n = arg -ZTEST(util_cxx, test_mixing_GET_ARG_and_FOR_EACH) { - run_mixing_GET_ARG_and_FOR_EACH(); -} + FOR_EACH_IDX_FIXED_ARG(FOO, (;), a, 1, 2, 3); -ZTEST(util_cxx, test_IS_ARRAY_ELEMENT) -{ - run_IS_ARRAY_ELEMENT(); + zassert_equal(a0, 1, "Unexpected value %d", a0); + zassert_equal(a1, 2, "Unexpected value %d", a1); + zassert_equal(a2, 3, "Unexpected value %d", a2); } -ZTEST(util_cxx, test_ARRAY_INDEX) -{ - run_ARRAY_INDEX(); +ZTEST(util, test_IS_EMPTY) { + #define test_IS_EMPTY_REAL_EMPTY + #define test_IS_EMPTY_NOT_EMPTY XXX_DO_NOT_REPLACE_XXX + zassert_true(IS_EMPTY(test_IS_EMPTY_REAL_EMPTY), + "Expected to be empty"); + zassert_false(IS_EMPTY(test_IS_EMPTY_NOT_EMPTY), + "Expected to be non-empty"); + zassert_false(IS_EMPTY("string"), + "Expected to be non-empty"); + zassert_false(IS_EMPTY(&test_IS_EMPTY), + "Expected to be non-empty"); } -ZTEST(util_cxx, test_PART_OF_ARRAY) -{ - run_PART_OF_ARRAY(); -} +ZTEST(util, test_IS_EQ) { + zassert_true(IS_EQ(0, 0), "Unexpected IS_EQ result"); + zassert_true(IS_EQ(1, 1), "Unexpected IS_EQ result"); + zassert_true(IS_EQ(7, 7), "Unexpected IS_EQ result"); -ZTEST(util_cxx, test_ARRAY_INDEX_FLOOR) -{ - run_ARRAY_INDEX_FLOOR(); -} - -ZTEST(util_cxx, test_BIT_MASK) -{ - run_BIT_MASK(); + zassert_false(IS_EQ(0, 1), "Unexpected IS_EQ result"); + zassert_false(IS_EQ(1, 7), "Unexpected IS_EQ result"); + zassert_false(IS_EQ(7, 0), "Unexpected IS_EQ result"); } -ZTEST(util_cxx, test_BIT_MASK64) -{ - run_BIT_MASK64(); -} +ZTEST(util, test_LIST_DROP_EMPTY) { + /* + * The real definition should be: + * #define TEST_BROKEN_LIST ,Henry,,Dorsett,Case, + * but checkpatch complains, so below equivalent is defined. + */ + #define TEST_BROKEN_LIST EMPTY, Henry, EMPTY, Dorsett, Case, + #define TEST_FIXED_LIST LIST_DROP_EMPTY(TEST_BROKEN_LIST) + static const char *const arr[] = { + FOR_EACH(STRINGIFY, (,), TEST_FIXED_LIST) + }; -ZTEST(util_cxx, test_IS_BIT_MASK) -{ - run_IS_BIT_MASK(); + zassert_equal(ARRAY_SIZE(arr), 3, "Failed to cleanup list"); + zassert_equal(strcmp(arr[0], "Henry"), 0, "Failed at 0"); + zassert_equal(strcmp(arr[1], "Dorsett"), 0, "Failed at 1"); + zassert_equal(strcmp(arr[2], "Case"), 0, "Failed at 0"); } -ZTEST(util_cxx, test_IS_SHIFTED_BIT_MASK) -{ - run_IS_SHIFTED_BIT_MASK(); -} +ZTEST(util, test_nested_FOR_EACH) { + #define FOO_1(x) a##x = x + #define FOO_2(x) int x -ZTEST(util_cxx, test_DIV_ROUND_UP) -{ - run_DIV_ROUND_UP(); -} + FOR_EACH(FOO_2, (;), FOR_EACH(FOO_1, (,), 0, 1, 2)); -ZTEST(util_cxx, test_DIV_ROUND_CLOSEST) -{ - run_DIV_ROUND_CLOSEST(); + zassert_equal(a0, 0); + zassert_equal(a1, 1); + zassert_equal(a2, 2); } -ZTEST_SUITE(util_cxx, NULL, NULL, NULL, NULL, NULL); +ZTEST(util, test_GET_ARG_N) { + int a = GET_ARG_N(1, 10, 100, 1000); + int b = GET_ARG_N(2, 10, 100, 1000); + int c = GET_ARG_N(3, 10, 100, 1000); -#if __cplusplus + zassert_equal(a, 10); + zassert_equal(b, 100); + zassert_equal(c, 1000); } -#endif -ZTEST(util_cc, test_u8_to_dec) { - run_u8_to_dec(); -} +ZTEST(util, test_GET_ARGS_LESS_N) { + uint8_t a[] = { GET_ARGS_LESS_N(0, 1, 2, 3) }; + uint8_t b[] = { GET_ARGS_LESS_N(1, 1, 2, 3) }; + uint8_t c[] = { GET_ARGS_LESS_N(2, 1, 2, 3) }; -ZTEST(util_cc, test_COND_CODE_1) { - run_COND_CODE_1(); -} + zassert_equal(sizeof(a), 3); -ZTEST(util_cc, test_COND_CODE_0) { - run_COND_CODE_0(); -} + zassert_equal(sizeof(b), 2); + zassert_equal(b[0], 2); + zassert_equal(b[1], 3); -ZTEST(util_cc, test_UTIL_OR) { - run_UTIL_OR(); + zassert_equal(sizeof(c), 1); + zassert_equal(c[0], 3); } -ZTEST(util_cc, test_UTIL_AND) { - run_UTIL_AND(); -} +ZTEST(util, test_mixing_GET_ARG_and_FOR_EACH) { + #undef TEST_MACRO + #define TEST_MACRO(x) x, + int i; -ZTEST(util_cc, test_IF_ENABLED) { - run_IF_ENABLED(); -} + i = GET_ARG_N(3, FOR_EACH(TEST_MACRO, (), 1, 2, 3, 4, 5)); + zassert_equal(i, 3); -ZTEST(util_cc, test_IF_DISABLED) { - run_IF_DISABLED(); -} + i = GET_ARG_N(2, 1, GET_ARGS_LESS_N(2, 1, 2, 3, 4, 5)); + zassert_equal(i, 3); -ZTEST(util_cc, test_LISTIFY) { - run_LISTIFY(); -} + #undef TEST_MACRO + #undef TEST_MACRO2 + #define TEST_MACRO(x) GET_ARG_N(3, 1, 2, x), + #define TEST_MACRO2(...) FOR_EACH(TEST_MACRO, (), __VA_ARGS__) + int a[] = { + LIST_DROP_EMPTY(TEST_MACRO2(1, 2, 3, 4)), 5 + }; -ZTEST(util_cc, test_MACRO_MAP_CAT) { - run_MACRO_MAP_CAT(); + zassert_equal(ARRAY_SIZE(a), 5); + zassert_equal(a[0], 1); + zassert_equal(a[1], 2); + zassert_equal(a[2], 3); + zassert_equal(a[3], 4); + zassert_equal(a[4], 5); } -ZTEST(util_cc, test_z_max_z_min_z_clamp) { - run_z_max_z_min_z_clamp(); -} +ZTEST(util, test_IS_ARRAY_ELEMENT) +{ + size_t i; + size_t array[3]; + uint8_t *const alias = (uint8_t *)array; -ZTEST(util_cc, test_CLAMP) { - run_CLAMP(); -} + zassert_false(IS_ARRAY_ELEMENT(array, &array[-1])); + zassert_false(IS_ARRAY_ELEMENT(array, &array[ARRAY_SIZE(array)])); + zassert_false(IS_ARRAY_ELEMENT(array, &alias[1])); -ZTEST(util_cc, test_IN_RANGE) { - run_IN_RANGE(); + for (i = 0; i < ARRAY_SIZE(array); ++i) { + zassert_true(IS_ARRAY_ELEMENT(array, &array[i])); + } } -ZTEST(util_cc, test_FOR_EACH) { - run_FOR_EACH(); -} +ZTEST(util, test_ARRAY_INDEX) +{ + size_t i; + size_t array[] = {0, 1, 2, 3}; -ZTEST(util_cc, test_FOR_EACH_NONEMPTY_TERM) { - run_FOR_EACH_NONEMPTY_TERM(); + for (i = 0; i < ARRAY_SIZE(array); ++i) { + zassert_equal(array[ARRAY_INDEX(array, &array[i])], i); + } } -ZTEST(util_cc, test_FOR_EACH_FIXED_ARG) { - run_FOR_EACH_FIXED_ARG(); -} +ZTEST(util, test_PART_OF_ARRAY) +{ + size_t i; + size_t array[3]; + uint8_t *const alias = (uint8_t *)array; -ZTEST(util_cc, test_FOR_EACH_IDX) { - run_FOR_EACH_IDX(); -} + ARG_UNUSED(i); + ARG_UNUSED(alias); -ZTEST(util_cc, test_FOR_EACH_IDX_FIXED_ARG) { - run_FOR_EACH_IDX_FIXED_ARG(); -} + zassert_false(PART_OF_ARRAY(array, &array[-1])); + zassert_false(PART_OF_ARRAY(array, &array[ARRAY_SIZE(array)])); -ZTEST(util_cc, test_IS_EMPTY) { - run_IS_EMPTY(); -} + for (i = 0; i < ARRAY_SIZE(array); ++i) { + zassert_true(PART_OF_ARRAY(array, &array[i])); + } -ZTEST(util_cc, test_IS_EQ) { - run_IS_EQ(); + zassert_true(PART_OF_ARRAY(array, &alias[1])); } -ZTEST(util_cc, test_LIST_DROP_EMPTY) { - run_LIST_DROP_EMPTY(); -} +ZTEST(util, test_ARRAY_INDEX_FLOOR) +{ + size_t i; + size_t array[] = {0, 1, 2, 3}; + uint8_t *const alias = (uint8_t *)array; -ZTEST(util_cc, test_nested_FOR_EACH) { - run_nested_FOR_EACH(); -} + for (i = 0; i < ARRAY_SIZE(array); ++i) { + zassert_equal(array[ARRAY_INDEX_FLOOR(array, &array[i])], i); + } -ZTEST(util_cc, test_GET_ARG_N) { - run_GET_ARG_N(); + zassert_equal(array[ARRAY_INDEX_FLOOR(array, &alias[1])], 0); } -ZTEST(util_cc, test_GET_ARGS_LESS_N) { - run_GET_ARGS_LESS_N(); -} +ZTEST(util, test_BIT_MASK) +{ + uint32_t bitmask0 = BIT_MASK(0); + uint32_t bitmask1 = BIT_MASK(1); + uint32_t bitmask2 = BIT_MASK(2); + uint32_t bitmask31 = BIT_MASK(31); -ZTEST(util_cc, test_mixing_GET_ARG_and_FOR_EACH) { - run_mixing_GET_ARG_and_FOR_EACH(); + zassert_equal(0x00000000UL, bitmask0); + zassert_equal(0x00000001UL, bitmask1); + zassert_equal(0x00000003UL, bitmask2); + zassert_equal(0x7ffffffFUL, bitmask31); } -ZTEST(util_cc, test_IS_ARRAY_ELEMENT) +ZTEST(util, test_BIT_MASK64) { - run_IS_ARRAY_ELEMENT(); -} + uint64_t bitmask0 = BIT64_MASK(0); + uint64_t bitmask1 = BIT64_MASK(1); + uint64_t bitmask2 = BIT64_MASK(2); + uint64_t bitmask63 = BIT64_MASK(63); -ZTEST(util_cc, test_ARRAY_INDEX) -{ - run_ARRAY_INDEX(); + zassert_equal(0x0000000000000000ULL, bitmask0); + zassert_equal(0x0000000000000001ULL, bitmask1); + zassert_equal(0x0000000000000003ULL, bitmask2); + zassert_equal(0x7fffffffffffffffULL, bitmask63); } -ZTEST(util_cc, test_PART_OF_ARRAY) +ZTEST(util, test_IS_BIT_MASK) { - run_PART_OF_ARRAY(); -} - -ZTEST(util_cc, test_ARRAY_INDEX_FLOOR) + uint32_t zero32 = 0UL; + uint64_t zero64 = 0ULL; + uint32_t bitmask1 = 0x00000001UL; + uint32_t bitmask2 = 0x00000003UL; + uint32_t bitmask31 = 0x7fffffffUL; + uint32_t bitmask32 = 0xffffffffUL; + uint64_t bitmask63 = 0x7fffffffffffffffULL; + uint64_t bitmask64 = 0xffffffffffffffffULL; + + uint32_t not_bitmask32 = 0xfffffffeUL; + uint64_t not_bitmask64 = 0xfffffffffffffffeULL; + + zassert_true(IS_BIT_MASK(zero32)); + zassert_true(IS_BIT_MASK(zero64)); + zassert_true(IS_BIT_MASK(bitmask1)); + zassert_true(IS_BIT_MASK(bitmask2)); + zassert_true(IS_BIT_MASK(bitmask31)); + zassert_true(IS_BIT_MASK(bitmask32)); + zassert_true(IS_BIT_MASK(bitmask63)); + zassert_true(IS_BIT_MASK(bitmask64)); + zassert_false(IS_BIT_MASK(not_bitmask32)); + zassert_false(IS_BIT_MASK(not_bitmask64)); + + zassert_true(IS_BIT_MASK(0)); + zassert_true(IS_BIT_MASK(0x00000001UL)); + zassert_true(IS_BIT_MASK(0x00000003UL)); + zassert_true(IS_BIT_MASK(0x7fffffffUL)); + zassert_true(IS_BIT_MASK(0xffffffffUL)); + zassert_true(IS_BIT_MASK(0x7fffffffffffffffUL)); + zassert_true(IS_BIT_MASK(0xffffffffffffffffUL)); + zassert_false(IS_BIT_MASK(0xfffffffeUL)); + zassert_false(IS_BIT_MASK(0xfffffffffffffffeULL)); + zassert_false(IS_BIT_MASK(0x00000002UL)); + zassert_false(IS_BIT_MASK(0x8000000000000000ULL)); +} + +ZTEST(util, test_IS_SHIFTED_BIT_MASK) { - run_ARRAY_INDEX_FLOOR(); -} + uint32_t bitmask32_shift1 = 0xfffffffeUL; + uint32_t bitmask32_shift31 = 0x80000000UL; + uint64_t bitmask64_shift1 = 0xfffffffffffffffeULL; + uint64_t bitmask64_shift63 = 0x8000000000000000ULL; -ZTEST(util_cc, test_BIT_MASK) -{ - run_BIT_MASK(); -} + zassert_true(IS_SHIFTED_BIT_MASK(bitmask32_shift1, 1)); + zassert_true(IS_SHIFTED_BIT_MASK(bitmask32_shift31, 31)); + zassert_true(IS_SHIFTED_BIT_MASK(bitmask64_shift1, 1)); + zassert_true(IS_SHIFTED_BIT_MASK(bitmask64_shift63, 63)); -ZTEST(util_cc, test_BIT_MASK64) -{ - run_BIT_MASK64(); + zassert_true(IS_SHIFTED_BIT_MASK(0xfffffffeUL, 1)); + zassert_true(IS_SHIFTED_BIT_MASK(0xfffffffffffffffeULL, 1)); + zassert_true(IS_SHIFTED_BIT_MASK(0x80000000UL, 31)); + zassert_true(IS_SHIFTED_BIT_MASK(0x8000000000000000ULL, 63)); } -ZTEST(util_cc, test_IS_BIT_MASK) +ZTEST(util, test_DIV_ROUND_UP) { - run_IS_BIT_MASK(); + zassert_equal(DIV_ROUND_UP(0, 1), 0); + zassert_equal(DIV_ROUND_UP(1, 2), 1); + zassert_equal(DIV_ROUND_UP(3, 2), 2); } -ZTEST(util_cc, test_IS_SHIFTED_BIT_MASK) +ZTEST(util, test_DIV_ROUND_CLOSEST) { - run_IS_SHIFTED_BIT_MASK(); -} - -ZTEST(util_cc, test_DIV_ROUND_UP) + zassert_equal(DIV_ROUND_CLOSEST(0, 1), 0); + /* 5 / 2 = 2.5 -> 3 */ + zassert_equal(DIV_ROUND_CLOSEST(5, 2), 3); + zassert_equal(DIV_ROUND_CLOSEST(5, -2), -3); + zassert_equal(DIV_ROUND_CLOSEST(-5, 2), -3); + zassert_equal(DIV_ROUND_CLOSEST(-5, -2), 3); + /* 7 / 3 = 2.(3) -> 2 */ + zassert_equal(DIV_ROUND_CLOSEST(7, 3), 2); + zassert_equal(DIV_ROUND_CLOSEST(-7, 3), -2); +} + +ZTEST(util, test_IF_DISABLED) { - run_DIV_ROUND_UP(); -} + #define test_IF_DISABLED_FLAG_A 0 + #define test_IF_DISABLED_FLAG_B 1 -ZTEST(util_cc, test_DIV_ROUND_CLOSEST) -{ - run_DIV_ROUND_CLOSEST(); + IF_DISABLED(test_IF_DISABLED_FLAG_A, (goto skipped_a;)) + /* location should be skipped if IF_DISABLED macro is correct. */ + zassert_false(true, "location A should be skipped"); +skipped_a: + IF_DISABLED(test_IF_DISABLED_FLAG_B, (zassert_false(true, "");)) + + IF_DISABLED(test_IF_DISABLED_FLAG_C, (goto skipped_c;)) + /* location should be skipped if IF_DISABLED macro is correct. */ + zassert_false(true, "location C should be skipped"); +skipped_c: + + zassert_true(true, ""); + + #undef test_IF_DISABLED_FLAG_A + #undef test_IF_DISABLED_FLAG_B } -ZTEST_SUITE(util_cc, NULL, NULL, NULL, NULL, NULL); +ZTEST_SUITE(util, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/unit/util/maincxx.cxx b/tests/unit/util/maincxx.cxx deleted file mode 100644 index ad13cfa3a11..00000000000 --- a/tests/unit/util/maincxx.cxx +++ /dev/null @@ -1,11 +0,0 @@ -/* - * Copyright (c) 2019 Oticon A/S - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#include -#include -#include - -#include "test.inc" diff --git a/tests/unit/util/test.inc b/tests/unit/util/test.inc deleted file mode 100644 index f16f1039d45..00000000000 --- a/tests/unit/util/test.inc +++ /dev/null @@ -1,652 +0,0 @@ -/* - * Copyright (c) 2019 Oticon A/S - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#include -#include -#include - -/** - * @brief Test of u8_to_dec - * - * This test verifies conversion of various input values. - * - */ -void run_u8_to_dec(void) -{ - char text[4]; - uint8_t len; - - len = u8_to_dec(text, sizeof(text), 0); - zassert_equal(len, 1, "Length of 0 is not 1"); - zassert_equal(strcmp(text, "0"), 0, - "Value=0 is not converted to \"0\""); - - len = u8_to_dec(text, sizeof(text), 1); - zassert_equal(len, 1, "Length of 1 is not 1"); - zassert_equal(strcmp(text, "1"), 0, - "Value=1 is not converted to \"1\""); - - len = u8_to_dec(text, sizeof(text), 11); - zassert_equal(len, 2, "Length of 11 is not 2"); - zassert_equal(strcmp(text, "11"), 0, - "Value=10 is not converted to \"11\""); - - len = u8_to_dec(text, sizeof(text), 100); - zassert_equal(len, 3, "Length of 100 is not 3"); - zassert_equal(strcmp(text, "100"), 0, - "Value=100 is not converted to \"100\""); - - len = u8_to_dec(text, sizeof(text), 101); - zassert_equal(len, 3, "Length of 101 is not 3"); - zassert_equal(strcmp(text, "101"), 0, - "Value=101 is not converted to \"101\""); - - len = u8_to_dec(text, sizeof(text), 255); - zassert_equal(len, 3, "Length of 255 is not 3"); - zassert_equal(strcmp(text, "255"), 0, - "Value=255 is not converted to \"255\""); - - memset(text, 0, sizeof(text)); - len = u8_to_dec(text, 2, 123); - zassert_equal(len, 2, - "Length of converted value using 2 byte buffer isn't 2"); - zassert_equal( - strcmp(text, "12"), 0, - "Value=123 is not converted to \"12\" using 2-byte buffer"); - - memset(text, 0, sizeof(text)); - len = u8_to_dec(text, 1, 123); - zassert_equal(len, 1, - "Length of converted value using 1 byte buffer isn't 1"); - zassert_equal( - strcmp(text, "1"), 0, - "Value=123 is not converted to \"1\" using 1-byte buffer"); - - memset(text, 0, sizeof(text)); - len = u8_to_dec(text, 0, 123); - zassert_equal(len, 0, - "Length of converted value using 0 byte buffer isn't 0"); -} - -#define TEST_DEFINE_1 1 -#define TEST_DEFINE_0 0 - -void run_COND_CODE_1(void) -{ - /* Test validates that expected code has been injected. Failure would - * be seen in compilation (lack of variable or ununsed variable. - */ - COND_CODE_1(1, (uint32_t x0 = 1;), (uint32_t y0;)) - zassert_true((x0 == 1)); - - COND_CODE_1(NOT_EXISTING_DEFINE, (uint32_t x1 = 1;), (uint32_t y1 = 1;)) - zassert_true((y1 == 1)); - - COND_CODE_1(TEST_DEFINE_1, (uint32_t x2 = 1;), (uint32_t y2 = 1;)) - zassert_true((x2 == 1)); - - COND_CODE_1(2, (uint32_t x3 = 1;), (uint32_t y3 = 1;)) - zassert_true((y3 == 1)); -} - -void run_COND_CODE_0(void) -{ - /* Test validates that expected code has been injected. Failure would - * be seen in compilation (lack of variable or ununsed variable. - */ - COND_CODE_0(0, (uint32_t x0 = 1;), (uint32_t y0;)) - zassert_true((x0 == 1)); - - COND_CODE_0(NOT_EXISTING_DEFINE, (uint32_t x1 = 1;), (uint32_t y1 = 1;)) - zassert_true((y1 == 1)); - - COND_CODE_0(TEST_DEFINE_0, (uint32_t x2 = 1;), (uint32_t y2 = 1;)) - zassert_true((x2 == 1)); - - COND_CODE_0(2, (uint32_t x3 = 1;), (uint32_t y3 = 1;)) - zassert_true((y3 == 1)); -} - -#undef ZERO -#undef SEVEN -#undef A_BUILD_ERROR -#define ZERO 0 -#define SEVEN 7 -#define A_BUILD_ERROR (this would be a build error if you used || or &&) - -void run_UTIL_OR(void) -{ - zassert_equal(UTIL_OR(SEVEN, A_BUILD_ERROR), 7); - zassert_equal(UTIL_OR(7, 0), 7); - zassert_equal(UTIL_OR(SEVEN, ZERO), 7); - zassert_equal(UTIL_OR(0, 7), 7); - zassert_equal(UTIL_OR(ZERO, SEVEN), 7); - zassert_equal(UTIL_OR(0, 0), 0); - zassert_equal(UTIL_OR(ZERO, ZERO), 0); -} - -void run_UTIL_AND(void) -{ - zassert_equal(UTIL_AND(ZERO, A_BUILD_ERROR), 0); - zassert_equal(UTIL_AND(7, 0), 0); - zassert_equal(UTIL_AND(SEVEN, ZERO), 0); - zassert_equal(UTIL_AND(0, 7), 0); - zassert_equal(UTIL_AND(ZERO, SEVEN), 0); - zassert_equal(UTIL_AND(0, 0), 0); - zassert_equal(UTIL_AND(ZERO, ZERO), 0); - zassert_equal(UTIL_AND(7, 7), 7); - zassert_equal(UTIL_AND(7, SEVEN), 7); - zassert_equal(UTIL_AND(SEVEN, 7), 7); - zassert_equal(UTIL_AND(SEVEN, SEVEN), 7); -} - -void run_IF_ENABLED(void) -{ - #define test_IF_ENABLED_FLAG_A 1 - #define test_IF_ENABLED_FLAG_B 0 - - IF_ENABLED(test_IF_ENABLED_FLAG_A, (goto skipped;)) - /* location should be skipped if IF_ENABLED macro is correct. */ - zassert_false(true, "location should be skipped"); -skipped: - IF_ENABLED(test_IF_ENABLED_FLAG_B, (zassert_false(true, "");)) - - IF_ENABLED(test_IF_ENABLED_FLAG_C, (zassert_false(true, "");)) - - zassert_true(true, ""); - - #undef test_IF_ENABLED_FLAG_A - #undef test_IF_ENABLED_FLAG_B -} - -void run_IF_DISABLED(void) -{ - #define test_IF_DISABLED_FLAG_A 0 - #define test_IF_DISABLED_FLAG_B 1 - - IF_DISABLED(test_IF_DISABLED_FLAG_A, (goto skipped_a;)) - /* location should be skipped if IF_DISABLED macro is correct. */ - zassert_false(true, "location A should be skipped"); -skipped_a: - IF_DISABLED(test_IF_DISABLED_FLAG_B, (zassert_false(true, "");)) - - IF_DISABLED(test_IF_DISABLED_FLAG_C, (goto skipped_c;)) - /* location should be skipped if IF_DISABLED macro is correct. */ - zassert_false(true, "location C should be skipped"); -skipped_c: - - zassert_true(true, ""); - - #undef test_IF_DISABLED_FLAG_A - #undef test_IF_DISABLED_FLAG_B -} - -void run_LISTIFY(void) -{ - int ab0 = 1; - int ab1 = 1; -#define A_PTR(x, name0, name1) &UTIL_CAT(UTIL_CAT(name0, name1), x) - - int *a[] = { LISTIFY(2, A_PTR, (,), a, b) }; - - zassert_equal(ARRAY_SIZE(a), 2); - zassert_equal(a[0], &ab0); - zassert_equal(a[1], &ab1); -} - -void run_MACRO_MAP_CAT(void) -{ - int item_a_item_b_item_c_ = 1; - -#undef FOO -#define FOO(x) item_##x##_ - zassert_equal(MACRO_MAP_CAT(FOO, a, b, c), 1, "MACRO_MAP_CAT"); -#undef FOO -} - -static int inc_func(bool cleanup) -{ - static int a; - - if (cleanup) { - a = 1; - } - - return a++; -} - -/* Test checks if @ref Z_MAX, @ref Z_MIN and @ref Z_CLAMP return correct result - * and perform single evaluation of input arguments. - */ -void run_z_max_z_min_z_clamp(void) -{ - zassert_equal(Z_MAX(inc_func(true), 0), 1, "Unexpected macro result"); - /* Z_MAX should have call inc_func only once */ - zassert_equal(inc_func(false), 2, "Unexpected return value"); - - zassert_equal(Z_MIN(inc_func(false), 2), 2, "Unexpected macro result"); - /* Z_MIN should have call inc_func only once */ - zassert_equal(inc_func(false), 4, "Unexpected return value"); - - zassert_equal(Z_CLAMP(inc_func(false), 1, 3), 3, "Unexpected macro result"); - /* Z_CLAMP should have call inc_func only once */ - zassert_equal(inc_func(false), 6, "Unexpected return value"); - - zassert_equal(Z_CLAMP(inc_func(false), 10, 15), 10, - "Unexpected macro result"); - /* Z_CLAMP should have call inc_func only once */ - zassert_equal(inc_func(false), 8, "Unexpected return value"); -} - -void run_CLAMP(void) -{ - zassert_equal(CLAMP(5, 3, 7), 5, "Unexpected clamp result"); - zassert_equal(CLAMP(3, 3, 7), 3, "Unexpected clamp result"); - zassert_equal(CLAMP(7, 3, 7), 7, "Unexpected clamp result"); - zassert_equal(CLAMP(1, 3, 7), 3, "Unexpected clamp result"); - zassert_equal(CLAMP(8, 3, 7), 7, "Unexpected clamp result"); - - zassert_equal(CLAMP(-5, -7, -3), -5, "Unexpected clamp result"); - zassert_equal(CLAMP(-9, -7, -3), -7, "Unexpected clamp result"); - zassert_equal(CLAMP(1, -7, -3), -3, "Unexpected clamp result"); - - zassert_equal(CLAMP(0xffffffffaULL, 0xffffffff0ULL, 0xfffffffffULL), - 0xffffffffaULL, "Unexpected clamp result"); -} - -void run_IN_RANGE(void) -{ - zassert_true(IN_RANGE(0, 0, 0), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(1, 0, 1), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(1, 0, 2), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(-1, -2, 2), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(-3, -5, -1), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(0, 0, UINT64_MAX), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(UINT64_MAX, 0, UINT64_MAX), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(0, INT64_MIN, INT64_MAX), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(INT64_MIN, INT64_MIN, INT64_MAX), "Unexpected IN_RANGE result"); - zassert_true(IN_RANGE(INT64_MAX, INT64_MIN, INT64_MAX), "Unexpected IN_RANGE result"); - - zassert_false(IN_RANGE(5, 0, 2), "Unexpected IN_RANGE result"); - zassert_false(IN_RANGE(5, 10, 0), "Unexpected IN_RANGE result"); - zassert_false(IN_RANGE(-1, 0, 1), "Unexpected IN_RANGE result"); -} - -void run_FOR_EACH(void) -{ - #define FOR_EACH_MACRO_TEST(arg) *buf++ = arg - - uint8_t array[3] = {0}; - uint8_t *buf = array; - - FOR_EACH(FOR_EACH_MACRO_TEST, (;), 1, 2, 3); - - zassert_equal(array[0], 1, "Unexpected value %d", array[0]); - zassert_equal(array[1], 2, "Unexpected value %d", array[1]); - zassert_equal(array[2], 3, "Unexpected value %d", array[2]); -} - -void run_FOR_EACH_NONEMPTY_TERM(void) -{ - #define SQUARE(arg) (arg * arg) - #define SWALLOW_VA_ARGS_1(...) EMPTY - #define SWALLOW_VA_ARGS_2(...) - #define REPEAT_VA_ARGS(...) __VA_ARGS__ - - uint8_t array[] = { - FOR_EACH_NONEMPTY_TERM(SQUARE, (,)) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,),) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), ,) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), EMPTY, EMPTY) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), SWALLOW_VA_ARGS_1(a, b)) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), SWALLOW_VA_ARGS_2(c, d)) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), 1) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), 2, 3) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), REPEAT_VA_ARGS(4)) - FOR_EACH_NONEMPTY_TERM(SQUARE, (,), REPEAT_VA_ARGS(5, 6)) - 255 - }; - - size_t size = ARRAY_SIZE(array); - - zassert_equal(size, 7, "Unexpected size %d", size); - zassert_equal(array[0], 1, "Unexpected value %d", array[0]); - zassert_equal(array[1], 4, "Unexpected value %d", array[1]); - zassert_equal(array[2], 9, "Unexpected value %d", array[2]); - zassert_equal(array[3], 16, "Unexpected value %d", array[3]); - zassert_equal(array[4], 25, "Unexpected value %d", array[4]); - zassert_equal(array[5], 36, "Unexpected value %d", array[5]); - zassert_equal(array[6], 255, "Unexpected value %d", array[6]); -} - -static void fsum(uint32_t incr, uint32_t *sum) -{ - *sum = *sum + incr; -} - -void run_FOR_EACH_FIXED_ARG(void) -{ - uint32_t sum = 0; - - FOR_EACH_FIXED_ARG(fsum, (;), &sum, 1, 2, 3); - - zassert_equal(sum, 6, "Unexpected value %d", sum); -} - -void run_FOR_EACH_IDX(void) -{ - #define FOR_EACH_IDX_MACRO_TEST(n, arg) uint8_t a##n = arg - - FOR_EACH_IDX(FOR_EACH_IDX_MACRO_TEST, (;), 1, 2, 3); - - zassert_equal(a0, 1, "Unexpected value %d", a0); - zassert_equal(a1, 2, "Unexpected value %d", a1); - zassert_equal(a2, 3, "Unexpected value %d", a2); - - #define FOR_EACH_IDX_MACRO_TEST2(n, arg) array[n] = arg - uint8_t array[32] = {0}; - - FOR_EACH_IDX(FOR_EACH_IDX_MACRO_TEST2, (;), 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15); - for (int i = 0; i < 15; i++) { - zassert_equal(array[i], i + 1, - "Unexpected value: %d", array[i]); - } - zassert_equal(array[15], 0, "Unexpected value: %d", array[15]); - - #define FOR_EACH_IDX_MACRO_TEST3(n, arg) &a##n - - uint8_t *a[] = { - FOR_EACH_IDX(FOR_EACH_IDX_MACRO_TEST3, (,), 1, 2, 3) - }; - - zassert_equal(ARRAY_SIZE(a), 3, "Unexpected value:%zu", ARRAY_SIZE(a)); -} - -void run_FOR_EACH_IDX_FIXED_ARG(void) -{ - #undef FOO - #define FOO(n, arg, fixed_arg) \ - uint8_t fixed_arg##n = arg - - FOR_EACH_IDX_FIXED_ARG(FOO, (;), a, 1, 2, 3); - - zassert_equal(a0, 1, "Unexpected value %d", a0); - zassert_equal(a1, 2, "Unexpected value %d", a1); - zassert_equal(a2, 3, "Unexpected value %d", a2); -} - -void run_IS_EMPTY(void) -{ - #define test_IS_EMPTY_REAL_EMPTY - #define test_IS_EMPTY_NOT_EMPTY XXX_DO_NOT_REPLACE_XXX - zassert_true(IS_EMPTY(test_IS_EMPTY_REAL_EMPTY), - "Expected to be empty"); - zassert_false(IS_EMPTY(test_IS_EMPTY_NOT_EMPTY), - "Expected to be non-empty"); - zassert_false(IS_EMPTY("string"), - "Expected to be non-empty"); - zassert_false(IS_EMPTY(&test_IS_EMPTY), - "Expected to be non-empty"); -} - -void run_IS_EQ(void) -{ - zassert_true(IS_EQ(0, 0), "Unexpected IS_EQ result"); - zassert_true(IS_EQ(1, 1), "Unexpected IS_EQ result"); - zassert_true(IS_EQ(7, 7), "Unexpected IS_EQ result"); - - zassert_false(IS_EQ(0, 1), "Unexpected IS_EQ result"); - zassert_false(IS_EQ(1, 7), "Unexpected IS_EQ result"); - zassert_false(IS_EQ(7, 0), "Unexpected IS_EQ result"); -} - -void run_LIST_DROP_EMPTY(void) -{ - /* - * The real definition should be: - * #define TEST_BROKEN_LIST ,Henry,,Dorsett,Case, - * but checkpatch complains, so below equivalent is defined. - */ - #define TEST_BROKEN_LIST EMPTY, Henry, EMPTY, Dorsett, Case, - #define TEST_FIXED_LIST LIST_DROP_EMPTY(TEST_BROKEN_LIST) - static const char *const arr[] = { - FOR_EACH(STRINGIFY, (,), TEST_FIXED_LIST) - }; - - zassert_equal(ARRAY_SIZE(arr), 3, "Failed to cleanup list"); - zassert_equal(strcmp(arr[0], "Henry"), 0, "Failed at 0"); - zassert_equal(strcmp(arr[1], "Dorsett"), 0, "Failed at 1"); - zassert_equal(strcmp(arr[2], "Case"), 0, "Failed at 0"); -} - -void run_nested_FOR_EACH(void) -{ - #define FOO_1(x) a##x = x - #define FOO_2(x) int x - - FOR_EACH(FOO_2, (;), FOR_EACH(FOO_1, (,), 0, 1, 2)); - - zassert_equal(a0, 0); - zassert_equal(a1, 1); - zassert_equal(a2, 2); -} - -void run_GET_ARG_N(void) -{ - int a = GET_ARG_N(1, 10, 100, 1000); - int b = GET_ARG_N(2, 10, 100, 1000); - int c = GET_ARG_N(3, 10, 100, 1000); - - zassert_equal(a, 10); - zassert_equal(b, 100); - zassert_equal(c, 1000); -} - -void run_GET_ARGS_LESS_N(void) -{ - uint8_t a[] = { GET_ARGS_LESS_N(0, 1, 2, 3) }; - uint8_t b[] = { GET_ARGS_LESS_N(1, 1, 2, 3) }; - uint8_t c[] = { GET_ARGS_LESS_N(2, 1, 2, 3) }; - - zassert_equal(sizeof(a), 3); - - zassert_equal(sizeof(b), 2); - zassert_equal(b[0], 2); - zassert_equal(b[1], 3); - - zassert_equal(sizeof(c), 1); - zassert_equal(c[0], 3); -} - -void run_mixing_GET_ARG_and_FOR_EACH(void) -{ - #undef TEST_MACRO - #define TEST_MACRO(x) x, - int i; - - i = GET_ARG_N(3, FOR_EACH(TEST_MACRO, (), 1, 2, 3, 4, 5)); - zassert_equal(i, 3); - - i = GET_ARG_N(2, 1, GET_ARGS_LESS_N(2, 1, 2, 3, 4, 5)); - zassert_equal(i, 3); - - #undef TEST_MACRO - #undef TEST_MACRO2 - #define TEST_MACRO(x) GET_ARG_N(3, 1, 2, x), - #define TEST_MACRO2(...) FOR_EACH(TEST_MACRO, (), __VA_ARGS__) - int a[] = { - LIST_DROP_EMPTY(TEST_MACRO2(1, 2, 3, 4)), 5 - }; - - zassert_equal(ARRAY_SIZE(a), 5); - zassert_equal(a[0], 1); - zassert_equal(a[1], 2); - zassert_equal(a[2], 3); - zassert_equal(a[3], 4); - zassert_equal(a[4], 5); -} - -void run_IS_ARRAY_ELEMENT(void) -{ - size_t i; - size_t array[3]; - uint8_t *const alias = (uint8_t *)array; - - zassert_false(IS_ARRAY_ELEMENT(array, &array[-1])); - zassert_false(IS_ARRAY_ELEMENT(array, &array[ARRAY_SIZE(array)])); - zassert_false(IS_ARRAY_ELEMENT(array, &alias[1])); - - for (i = 0; i < ARRAY_SIZE(array); ++i) { - zassert_true(IS_ARRAY_ELEMENT(array, &array[i])); - } -} - -void run_ARRAY_INDEX(void) -{ - size_t i; - size_t array[] = {0, 1, 2, 3}; - - for (i = 0; i < ARRAY_SIZE(array); ++i) { - zassert_equal(array[ARRAY_INDEX(array, &array[i])], i); - } - - /* ARRAY_INDEX(array, &alias[1]) asserts with CONFIG_ASSERT=y */ -} - -void run_PART_OF_ARRAY(void) -{ - size_t i; - size_t array[3]; - uint8_t *const alias = (uint8_t *)array; - - ARG_UNUSED(i); - ARG_UNUSED(alias); - - zassert_false(PART_OF_ARRAY(array, &array[-1])); - zassert_false(PART_OF_ARRAY(array, &array[ARRAY_SIZE(array)])); - - for (i = 0; i < ARRAY_SIZE(array); ++i) { - zassert_true(PART_OF_ARRAY(array, &array[i])); - } - - zassert_true(PART_OF_ARRAY(array, &alias[1])); -} - -void run_ARRAY_INDEX_FLOOR(void) -{ - size_t i; - size_t array[] = {0, 1, 2, 3}; - uint8_t *const alias = (uint8_t *)array; - - for (i = 0; i < ARRAY_SIZE(array); ++i) { - zassert_equal(array[ARRAY_INDEX_FLOOR(array, &array[i])], i); - } - - zassert_equal(array[ARRAY_INDEX_FLOOR(array, &alias[1])], 0); -} - -void run_BIT_MASK(void) -{ - uint32_t bitmask0 = BIT_MASK(0); - uint32_t bitmask1 = BIT_MASK(1); - uint32_t bitmask2 = BIT_MASK(2); - uint32_t bitmask31 = BIT_MASK(31); - - zassert_equal(0x00000000UL, bitmask0); - zassert_equal(0x00000001UL, bitmask1); - zassert_equal(0x00000003UL, bitmask2); - zassert_equal(0x7ffffffFUL, bitmask31); -} - -void run_BIT_MASK64(void) -{ - uint64_t bitmask0 = BIT64_MASK(0); - uint64_t bitmask1 = BIT64_MASK(1); - uint64_t bitmask2 = BIT64_MASK(2); - uint64_t bitmask63 = BIT64_MASK(63); - - zassert_equal(0x0000000000000000ULL, bitmask0); - zassert_equal(0x0000000000000001ULL, bitmask1); - zassert_equal(0x0000000000000003ULL, bitmask2); - zassert_equal(0x7fffffffffffffffULL, bitmask63); -} - -void run_IS_BIT_MASK(void) -{ - uint32_t zero32 = 0UL; - uint64_t zero64 = 0ULL; - uint32_t bitmask1 = 0x00000001UL; - uint32_t bitmask2 = 0x00000003UL; - uint32_t bitmask31 = 0x7fffffffUL; - uint32_t bitmask32 = 0xffffffffUL; - uint64_t bitmask63 = 0x7fffffffffffffffULL; - uint64_t bitmask64 = 0xffffffffffffffffULL; - - uint32_t not_bitmask32 = 0xfffffffeUL; - uint64_t not_bitmask64 = 0xfffffffffffffffeULL; - - zassert_true(IS_BIT_MASK(zero32)); - zassert_true(IS_BIT_MASK(zero64)); - zassert_true(IS_BIT_MASK(bitmask1)); - zassert_true(IS_BIT_MASK(bitmask2)); - zassert_true(IS_BIT_MASK(bitmask31)); - zassert_true(IS_BIT_MASK(bitmask32)); - zassert_true(IS_BIT_MASK(bitmask63)); - zassert_true(IS_BIT_MASK(bitmask64)); - zassert_false(IS_BIT_MASK(not_bitmask32)); - zassert_false(IS_BIT_MASK(not_bitmask64)); - - zassert_true(IS_BIT_MASK(0)); - zassert_true(IS_BIT_MASK(0x00000001UL)); - zassert_true(IS_BIT_MASK(0x00000003UL)); - zassert_true(IS_BIT_MASK(0x7fffffffUL)); - zassert_true(IS_BIT_MASK(0xffffffffUL)); - zassert_true(IS_BIT_MASK(0x7fffffffffffffffUL)); - zassert_true(IS_BIT_MASK(0xffffffffffffffffUL)); - zassert_false(IS_BIT_MASK(0xfffffffeUL)); - zassert_false(IS_BIT_MASK(0xfffffffffffffffeULL)); - zassert_false(IS_BIT_MASK(0x00000002UL)); - zassert_false(IS_BIT_MASK(0x8000000000000000ULL)); -} - -void run_IS_SHIFTED_BIT_MASK(void) -{ - uint32_t bitmask32_shift1 = 0xfffffffeUL; - uint32_t bitmask32_shift31 = 0x80000000UL; - uint64_t bitmask64_shift1 = 0xfffffffffffffffeULL; - uint64_t bitmask64_shift63 = 0x8000000000000000ULL; - - zassert_true(IS_SHIFTED_BIT_MASK(bitmask32_shift1, 1)); - zassert_true(IS_SHIFTED_BIT_MASK(bitmask32_shift31, 31)); - zassert_true(IS_SHIFTED_BIT_MASK(bitmask64_shift1, 1)); - zassert_true(IS_SHIFTED_BIT_MASK(bitmask64_shift63, 63)); - - zassert_true(IS_SHIFTED_BIT_MASK(0xfffffffeUL, 1)); - zassert_true(IS_SHIFTED_BIT_MASK(0xfffffffffffffffeULL, 1)); - zassert_true(IS_SHIFTED_BIT_MASK(0x80000000UL, 31)); - zassert_true(IS_SHIFTED_BIT_MASK(0x8000000000000000ULL, 63)); -} - -void run_DIV_ROUND_UP(void) -{ - zassert_equal(DIV_ROUND_UP(0, 1), 0); - zassert_equal(DIV_ROUND_UP(1, 2), 1); - zassert_equal(DIV_ROUND_UP(3, 2), 2); -} - -void run_DIV_ROUND_CLOSEST(void) -{ - zassert_equal(DIV_ROUND_CLOSEST(0, 1), 0); - /* 5 / 2 = 2.5 -> 3 */ - zassert_equal(DIV_ROUND_CLOSEST(5, 2), 3); - zassert_equal(DIV_ROUND_CLOSEST(5, -2), -3); - zassert_equal(DIV_ROUND_CLOSEST(-5, 2), -3); - zassert_equal(DIV_ROUND_CLOSEST(-5, -2), 3); - /* 7 / 3 = 2.(3) -> 2 */ - zassert_equal(DIV_ROUND_CLOSEST(7, 3), 2); - zassert_equal(DIV_ROUND_CLOSEST(-7, 3), -2); -} diff --git a/tests/unit/util/testcase.yaml b/tests/unit/util/testcase.yaml index f78098c177e..e428516e6fc 100644 --- a/tests/unit/util/testcase.yaml +++ b/tests/unit/util/testcase.yaml @@ -1,6 +1,11 @@ +common: + tags: + - lib + - utilities tests: utilities.dec: - tags: - - lib - - utilities type: unit + utilities.dec.cpp: + type: unit + extra_configs: + - CONFIG_CPP=y