Parenthesize argument substitutions in macros commonly used by tests.

Without parentheses around arguments macros like TEST_ASSERT_SUCCESS
could produce incorrect results if passed e.g. a ternary expression.

Signed-off-by: Marat Khalili <[email protected]>
---
Very curious how none of the code-checking tools we have like Coverity
flagged this trivial issue.

To highlight non-whitespace changes: git show --word-diff --anchored='/*'

 app/test/test.h            | 86 +++++++++++++++++++-------------------
 lib/eal/include/rte_test.h | 12 +++---
 2 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/app/test/test.h b/app/test/test.h
index 1f12fc5397a8..ad2347d3fe26 100644
--- a/app/test/test.h
+++ b/app/test/test.h
@@ -44,52 +44,24 @@
 
 /* Compare two buffers with offset (length and offset in bytes) */
 #define TEST_ASSERT_BUFFERS_ARE_EQUAL_OFFSET(a, b, len, off, msg, ...) do { \
-       const uint8_t *_a_with_off = (const uint8_t *)a + off;              \
-       const uint8_t *_b_with_off = (const uint8_t *)b + off;              \
+       const uint8_t *_a_with_off = (const uint8_t *)(a) + (off);          \
+       const uint8_t *_b_with_off = (const uint8_t *)(b) + (off);          \
        TEST_ASSERT_BUFFERS_ARE_EQUAL(_a_with_off, _b_with_off, len, msg);  \
 } while (0)
 
 /* Compare two buffers (length in bits) */
-#define TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(a, b, len, msg, ...) do {    \
-       uint8_t _last_byte_a, _last_byte_b;                       \
-       uint8_t _last_byte_mask, _last_byte_bits;                  \
-       TEST_ASSERT_BUFFERS_ARE_EQUAL(a, b, (len >> 3), msg);     \
-       if (len % 8) {                                              \
-               _last_byte_bits = len % 8;                   \
-               _last_byte_mask = ~((1 << (8 - _last_byte_bits)) - 1); \
-               _last_byte_a = ((const uint8_t *)a)[len >> 3];            \
-               _last_byte_b = ((const uint8_t *)b)[len >> 3];            \
-               _last_byte_a &= _last_byte_mask;                     \
-               _last_byte_b &= _last_byte_mask;                    \
-               if (_last_byte_a != _last_byte_b) {                  \
-                       printf("TestCase %s() line %d failed: "              \
-                               msg "\n", __func__, __LINE__, ##__VA_ARGS__);\
-                       TEST_TRACE_FAILURE(__FILE__, __LINE__, __func__);    \
-                       return TEST_FAILED;                                  \
-               }                                                        \
-       }                                                            \
-} while (0)
-
-/* Compare two buffers with offset (length and offset in bits) */
-#define TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(a, b, len, off, msg, ...) do 
{        \
-       uint8_t _first_byte_a, _first_byte_b;                                 \
-       uint8_t _first_byte_mask, _first_byte_bits;                           \
-       uint32_t _len_without_first_byte = (off % 8) ?                       \
-                               len - (8 - (off % 8)) :                       \
-                               len;                                          \
-       uint32_t _off_in_bytes = (off % 8) ? (off >> 3) + 1 : (off >> 3);     \
-       const uint8_t *_a_with_off = (const uint8_t *)a + _off_in_bytes;      \
-       const uint8_t *_b_with_off = (const uint8_t *)b + _off_in_bytes;      \
-       TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(_a_with_off, _b_with_off,           \
-                               _len_without_first_byte, msg);                \
-       if (off % 8) {                                                        \
-               _first_byte_bits = 8 - (off % 8);                             \
-               _first_byte_mask = (1 << _first_byte_bits) - 1;               \
-               _first_byte_a = *(_a_with_off - 1);                           \
-               _first_byte_b = *(_b_with_off - 1);                           \
-               _first_byte_a &= _first_byte_mask;                            \
-               _first_byte_b &= _first_byte_mask;                            \
-               if (_first_byte_a != _first_byte_b) {                         \
+#define TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(a, b, len, msg, ...) do {           \
+       uint8_t _last_byte_a, _last_byte_b;                                   \
+       uint8_t _last_byte_mask, _last_byte_bits;                             \
+       TEST_ASSERT_BUFFERS_ARE_EQUAL(a, b, ((len) >> 3), msg);               \
+       if ((len) % 8) {                                                      \
+               _last_byte_bits = (len) % 8;                                  \
+               _last_byte_mask = ~((1 << (8 - _last_byte_bits)) - 1);        \
+               _last_byte_a = ((const uint8_t *)(a))[(len) >> 3];            \
+               _last_byte_b = ((const uint8_t *)(b))[(len) >> 3];            \
+               _last_byte_a &= _last_byte_mask;                              \
+               _last_byte_b &= _last_byte_mask;                              \
+               if (_last_byte_a != _last_byte_b) {                           \
                        printf("TestCase %s() line %d failed: "               \
                                msg "\n", __func__, __LINE__, ##__VA_ARGS__); \
                        TEST_TRACE_FAILURE(__FILE__, __LINE__, __func__);     \
@@ -98,6 +70,34 @@
        }                                                                     \
 } while (0)
 
+/* Compare two buffers with offset (length and offset in bits) */
+#define TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(a, b, len, off, msg, ...) do 
{ \
+       uint8_t _first_byte_a, _first_byte_b;                                   
\
+       uint8_t _first_byte_mask, _first_byte_bits;                             
\
+       uint32_t _len_without_first_byte = ((off) % 8) ?                        
\
+                               (len) - (8 - ((off) % 8)) :                     
\
+                               (len);                                          
\
+       uint32_t _off_in_bytes = ((off) % 8) ? ((off) >> 3) + 1 : ((off) >> 3); 
\
+       const uint8_t *_a_with_off = (const uint8_t *)(a) + _off_in_bytes;      
\
+       const uint8_t *_b_with_off = (const uint8_t *)(b) + _off_in_bytes;      
\
+       TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(_a_with_off, _b_with_off,             
\
+                               _len_without_first_byte, msg);                  
\
+       if ((off) % 8) {                                                        
\
+               _first_byte_bits = 8 - ((off) % 8);                             
\
+               _first_byte_mask = (1 << _first_byte_bits) - 1;                 
\
+               _first_byte_a = *(_a_with_off - 1);                             
\
+               _first_byte_b = *(_b_with_off - 1);                             
\
+               _first_byte_a &= _first_byte_mask;                              
\
+               _first_byte_b &= _first_byte_mask;                              
\
+               if (_first_byte_a != _first_byte_b) {                           
\
+                       printf("TestCase %s() line %d failed: "                 
\
+                               msg "\n", __func__, __LINE__, ##__VA_ARGS__);   
\
+                       TEST_TRACE_FAILURE(__FILE__, __LINE__, __func__);       
\
+                       return TEST_FAILED;                                     
\
+               }                                                               
\
+       }                                                                       
\
+} while (0)
+
 #define TEST_ASSERT_NOT_EQUAL RTE_TEST_ASSERT_NOT_EQUAL
 
 #define TEST_ASSERT_SUCCESS RTE_TEST_ASSERT_SUCCESS
@@ -198,7 +198,7 @@ void add_test_command(struct test_command *t);
 #define REGISTER_TEST_COMMAND(cmd, func) \
        static struct test_command test_struct_##cmd = { \
                .command = RTE_STR(cmd), \
-               .callback = func, \
+               .callback = (func), \
        }; \
        RTE_INIT(test_register_##cmd) \
        { \
diff --git a/lib/eal/include/rte_test.h b/lib/eal/include/rte_test.h
index 62c8f165af59..d132d3156b5a 100644
--- a/lib/eal/include/rte_test.h
+++ b/lib/eal/include/rte_test.h
@@ -26,21 +26,21 @@
 } while (0)
 
 #define RTE_TEST_ASSERT_EQUAL(a, b, msg, ...) \
-       RTE_TEST_ASSERT(a == b, msg, ##__VA_ARGS__)
+       RTE_TEST_ASSERT((a) == (b), msg, ##__VA_ARGS__)
 
 #define RTE_TEST_ASSERT_NOT_EQUAL(a, b, msg, ...) \
-       RTE_TEST_ASSERT(a != b, msg, ##__VA_ARGS__)
+       RTE_TEST_ASSERT((a) != (b), msg, ##__VA_ARGS__)
 
 #define RTE_TEST_ASSERT_SUCCESS(val, msg, ...) \
-       RTE_TEST_ASSERT(val == 0, msg, ##__VA_ARGS__)
+       RTE_TEST_ASSERT((val) == 0, msg, ##__VA_ARGS__)
 
 #define RTE_TEST_ASSERT_FAIL(val, msg, ...) \
-       RTE_TEST_ASSERT(val != 0, msg, ##__VA_ARGS__)
+       RTE_TEST_ASSERT((val) != 0, msg, ##__VA_ARGS__)
 
 #define RTE_TEST_ASSERT_NULL(val, msg, ...) \
-       RTE_TEST_ASSERT(val == NULL, msg, ##__VA_ARGS__)
+       RTE_TEST_ASSERT((val) == NULL, msg, ##__VA_ARGS__)
 
 #define RTE_TEST_ASSERT_NOT_NULL(val, msg, ...) \
-       RTE_TEST_ASSERT(val != NULL, msg, ##__VA_ARGS__)
+       RTE_TEST_ASSERT((val) != NULL, msg, ##__VA_ARGS__)
 
 #endif /* _RTE_TEST_H_ */
-- 
2.43.0

Reply via email to