From: Dirk Müller <d...@dmllr.de>

Otherwise the build fails with userspace-rcu 0.14 with

   error: implicit declaration of function 'assert' 
[-Werror=implicit-function-declaration]
   note: 'assert' is defined in header '<assert.h>'; did you forget to 
'#include <assert.h>'?

Until liburcu 0.13.0, this didn't show up as a compile error, because
"assert.h" was pulled in via config.h -> urcu.h.

But these assert() calls should have been cmocka assert macros
in the first place.

Signed-off-by: Dirk Müller <d...@dmllr.de>
Signed-off-by: Martin Wilck <mwi...@suse.com>
---
 tests/util.c | 44 +++++++++++++++++++++-----------------------
 tests/vpd.c  |  2 +-
 2 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/tests/util.c b/tests/util.c
index 9affb0e..d6083dc 100644
--- a/tests/util.c
+++ b/tests/util.c
@@ -193,7 +193,7 @@ static void test_bitmask_1(void **state)
        for (j = 0; j < BITARR_SZ; j++) {
                for (i = 0; i < 64; i++) {
                        b = 64 * j + i;
-                       assert(!is_bit_set_in_bitfield(b, bf));
+                       assert_false(is_bit_set_in_bitfield(b, bf));
                        set_bit_in_bitfield(b, bf);
                        for (k = 0; k < BITARR_SZ; k++) {
 #if 0
@@ -207,13 +207,13 @@ static void test_bitmask_1(void **state)
                        }
                        for (m = 0; m < 64; m++)
                                if (i == m)
-                                       assert(is_bit_set_in_bitfield(64 * j + 
m,
-                                                                     bf));
+                                       assert_true(is_bit_set_in_bitfield(64 * 
j + m,
+                                                                          bf));
                                else
-                                       assert(!is_bit_set_in_bitfield(64 * j + 
m,
-                                                                      bf));
+                                       assert_false(is_bit_set_in_bitfield(64 
* j + m,
+                                                                          bf));
                        clear_bit_in_bitfield(b, bf);
-                       assert(!is_bit_set_in_bitfield(b, bf));
+                       assert_false(is_bit_set_in_bitfield(b, bf));
                        for (k = 0; k < BITARR_SZ; k++)
                                assert_int_equal(arr[k], 0ULL);
                }
@@ -235,16 +235,16 @@ static void test_bitmask_2(void **state)
        for (j = 0; j < BITARR_SZ; j++) {
                for (i = 0; i < 64; i++) {
                        b = 64 * j + i;
-                       assert(!is_bit_set_in_bitfield(b, bf));
+                       assert_false(is_bit_set_in_bitfield(b, bf));
                        set_bit_in_bitfield(b, bf);
                        for (m = 0; m < 64; m++)
                                if (m <= i)
-                                       assert(is_bit_set_in_bitfield(64 * j + 
m,
-                                                                     bf));
+                                       assert_true(is_bit_set_in_bitfield(64 * 
j + m,
+                                                                          bf));
                                else
-                                       assert(!is_bit_set_in_bitfield(64 * j + 
m,
-                                                                      bf));
-                       assert(is_bit_set_in_bitfield(b, bf));
+                                       assert_false(is_bit_set_in_bitfield(64 
* j + m,
+                                                                           
bf));
+                       assert_true(is_bit_set_in_bitfield(b, bf));
                        for (k = 0; k < BITARR_SZ; k++) {
                                if (k < j || (k == j && i == 63))
                                        assert_int_equal(arr[k], ~0ULL);
@@ -260,16 +260,16 @@ static void test_bitmask_2(void **state)
        for (j = 0; j < BITARR_SZ; j++) {
                for (i = 0; i < 64; i++) {
                        b = 64 * j + i;
-                       assert(is_bit_set_in_bitfield(b, bf));
+                       assert_true(is_bit_set_in_bitfield(b, bf));
                        clear_bit_in_bitfield(b, bf);
                        for (m = 0; m < 64; m++)
                                if (m <= i)
-                                       assert(!is_bit_set_in_bitfield(64 * j + 
m,
-                                                                      bf));
+                                       assert_false(is_bit_set_in_bitfield(64 
* j + m,
+                                                                           
bf));
                                else
-                                       assert(is_bit_set_in_bitfield(64 * j + 
m,
-                                                                     bf));
-                       assert(!is_bit_set_in_bitfield(b, bf));
+                                       assert_true(is_bit_set_in_bitfield(64 * 
j + m,
+                                                                          bf));
+                       assert_false(is_bit_set_in_bitfield(b, bf));
                        for (k = 0; k < BITARR_SZ; k++) {
                                if (k < j || (k == j && i == 63))
                                        assert_int_equal(arr[k], 0ULL);
@@ -316,9 +316,8 @@ static void _test_bitmask_small(unsigned int n)
        uint32_t *arr;
        unsigned int size = maybe_swap_idx((n - 1) / 32) + 1, i;
 
-       assert(sizeof(bitfield_t) == 4 || sizeof(bitfield_t) == 8);
-       assert(n <= 64);
-       assert(n >= 1);
+       assert_true(sizeof(bitfield_t) == 4 || sizeof(bitfield_t) == 8);
+       assert_in_range(n, 1, 64);
 
        bf = alloc_bitfield(n);
        assert_non_null(bf);
@@ -366,8 +365,7 @@ static void _test_bitmask_small_2(unsigned int n)
        uint32_t *arr;
        unsigned int size = maybe_swap_idx((n - 1) / 32) + 1, i;
 
-       assert(n <= 128);
-       assert(n >= 65);
+       assert_in_range(n, 65, 128);
 
        bf = alloc_bitfield(n);
        assert_non_null(bf);
diff --git a/tests/vpd.c b/tests/vpd.c
index a7d2092..1b2d62d 100644
--- a/tests/vpd.c
+++ b/tests/vpd.c
@@ -119,7 +119,7 @@ static void hex2bin(unsigned char *dst, const char *src,
        const char *sc;
        unsigned char *ds;
 
-       assert(srclen % 2 == 0);
+       assert_true(srclen % 2 == 0);
        for (sc = src, ds = dst;
             sc < src + srclen &&  ds < dst + dstlen;
             sc += 2, ++ds)
-- 
2.39.2

--
dm-devel mailing list
dm-devel@redhat.com
https://listman.redhat.com/mailman/listinfo/dm-devel

Reply via email to