test: Wrap assert macros in ({ ... }) and fix missing semicolons

Wrap the assert macros in ({ ... }) so they can be safely used both as
right side argument as well as in conditionals without curly brackets
around them. In the process, find a bunch of missing semicolons, fix
them.

Reviewed-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Marek Vasut <marek.vasut+renesas@mailbox.org>

diff --git a/include/test/ut.h b/include/test/ut.h
index 2b0dab32f682ec47e113ab9ed42359f1901dbd39..dddf9ad241fe8575c78b0d16772e3b3c5c569296 100644 (file)
--- a/include/test/ut.h
+++ b/include/test/ut.h
@@ -125,36 +125,47 @@ int ut_check_console_dump(struct unit_test_state *uts, int total_bytes);
                 fmt, ##args)
 
 /* Assert that a condition is non-zero */
-#define ut_assert(cond)                                                        \
+#define ut_assert(cond) ({                                             \
+       int __ret = 0;                                                  \
+                                                                       \
        if (!(cond)) {                                                  \
                ut_fail(uts, __FILE__, __LINE__, __func__, #cond);      \
-               return CMD_RET_FAILURE;                                 \
-       }
+               __ret = CMD_RET_FAILURE;                                \
+       }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that a condition is non-zero, with printf() string */
-#define ut_assertf(cond, fmt, args...)                                 \
+#define ut_assertf(cond, fmt, args...) ({                              \
+       int __ret = 0;                                                  \
+                                                                       \
        if (!(cond)) {                                                  \
                ut_failf(uts, __FILE__, __LINE__, __func__, #cond,      \
                         fmt, ##args);                                  \
-               return CMD_RET_FAILURE;                                 \
-       }
+               __ret = CMD_RET_FAILURE;                                \
+       }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that two int expressions are equal */
-#define ut_asserteq(expr1, expr2) {                                    \
+#define ut_asserteq(expr1, expr2) ({                                   \
        unsigned int _val1 = (expr1), _val2 = (expr2);                  \
+       int __ret = 0;                                                  \
                                                                        \
        if (_val1 != _val2) {                                           \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr1 " == " #expr2,                          \
                         "Expected %#x (%d), got %#x (%d)",             \
                         _val1, _val1, _val2, _val2);                   \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that two 64 int expressions are equal */
-#define ut_asserteq_64(expr1, expr2) {                                 \
+#define ut_asserteq_64(expr1, expr2) ({                                        \
        u64 _val1 = (expr1), _val2 = (expr2);                           \
+       int __ret = 0;                                                  \
                                                                        \
        if (_val1 != _val2) {                                           \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
@@ -164,43 +175,49 @@ int ut_check_console_dump(struct unit_test_state *uts, int total_bytes);
                         (unsigned long long)_val1,                     \
                         (unsigned long long)_val2,                     \
                         (unsigned long long)_val2);                    \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that two string expressions are equal */
-#define ut_asserteq_str(expr1, expr2) {                                        \
+#define ut_asserteq_str(expr1, expr2) ({                               \
        const char *_val1 = (expr1), *_val2 = (expr2);                  \
+       int __ret = 0;                                                  \
                                                                        \
        if (strcmp(_val1, _val2)) {                                     \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr1 " = " #expr2,                           \
                         "Expected \"%s\", got \"%s\"", _val1, _val2);  \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /*
  * Assert that two string expressions are equal, up to length of the
  * first
  */
-#define ut_asserteq_strn(expr1, expr2) {                               \
+#define ut_asserteq_strn(expr1, expr2) ({                              \
        const char *_val1 = (expr1), *_val2 = (expr2);                  \
        int _len = strlen(_val1);                                       \
+       int __ret = 0;                                                  \
                                                                        \
        if (memcmp(_val1, _val2, _len)) {                               \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr1 " = " #expr2,                           \
                         "Expected \"%.*s\", got \"%.*s\"",             \
                         _len, _val1, _len, _val2);                     \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that two memory areas are equal */
-#define ut_asserteq_mem(expr1, expr2, len) {                           \
+#define ut_asserteq_mem(expr1, expr2, len) ({                          \
        const u8 *_val1 = (u8 *)(expr1), *_val2 = (u8 *)(expr2);        \
        const uint __len = len;                                         \
+       int __ret = 0;                                                  \
                                                                        \
        if (memcmp(_val1, _val2, __len)) {                              \
                char __buf1[64 + 1] = "\0";                             \
@@ -211,128 +228,163 @@ int ut_check_console_dump(struct unit_test_state *uts, int total_bytes);
                         #expr1 " = " #expr2,                           \
                         "Expected \"%s\", got \"%s\"",                 \
                         __buf1, __buf2);                               \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that two pointers are equal */
-#define ut_asserteq_ptr(expr1, expr2) {                                        \
+#define ut_asserteq_ptr(expr1, expr2) ({                               \
        const void *_val1 = (expr1), *_val2 = (expr2);                  \
+       int __ret = 0;                                                  \
                                                                        \
        if (_val1 != _val2) {                                           \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr1 " = " #expr2,                           \
                         "Expected %p, got %p", _val1, _val2);          \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that two addresses (converted from pointers) are equal */
-#define ut_asserteq_addr(expr1, expr2) {                               \
+#define ut_asserteq_addr(expr1, expr2) ({                              \
        ulong _val1 = map_to_sysmem(expr1);                             \
        ulong _val2 = map_to_sysmem(expr2);                             \
+       int __ret = 0;                                                  \
                                                                        \
        if (_val1 != _val2) {                                           \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr1 " = " #expr2,                           \
                         "Expected %lx, got %lx", _val1, _val2);        \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that a pointer is NULL */
-#define ut_assertnull(expr) {                                  \
+#define ut_assertnull(expr) ({                                         \
        const void *_val = (expr);                                      \
+       int __ret = 0;                                                  \
                                                                        \
-       if (_val) {                                             \
+       if (_val) {                                                     \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr " != NULL",                              \
                         "Expected NULL, got %p", _val);                \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that a pointer is not NULL */
-#define ut_assertnonnull(expr) {                                       \
+#define ut_assertnonnull(expr) ({                                      \
        const void *_val = (expr);                                      \
+       int __ret = 0;                                                  \
                                                                        \
-       if (!_val) {                                            \
+       if (!_val) {                                                    \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr " = NULL",                               \
                         "Expected non-null, got NULL");                \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that a pointer is not an error pointer */
-#define ut_assertok_ptr(expr) {                                                \
+#define ut_assertok_ptr(expr) ({                                       \
        const void *_val = (expr);                                      \
+       int __ret = 0;                                                  \
                                                                        \
        if (IS_ERR(_val)) {                                             \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         #expr " = NULL",                               \
                         "Expected pointer, got error %ld",             \
                         PTR_ERR(_val));                                \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
-}
+       __ret;                                                          \
+})
 
 /* Assert that an operation succeeds (returns 0) */
 #define ut_assertok(cond)      ut_asserteq(0, cond)
 
 /* Assert that the next console output line matches */
-#define ut_assert_nextline(fmt, args...)                               \
+#define ut_assert_nextline(fmt, args...) ({                            \
+       int __ret = 0;                                                  \
+                                                                       \
        if (ut_check_console_line(uts, fmt, ##args)) {                  \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         "console", "\nExpected '%s',\n     got '%s'",  \
                         uts->expect_str, uts->actual_str);             \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that the next console output line matches up to the length */
-#define ut_assert_nextlinen(fmt, args...)                              \
+#define ut_assert_nextlinen(fmt, args...) ({                           \
+       int __ret = 0;                                                  \
+                                                                       \
        if (ut_check_console_linen(uts, fmt, ##args)) {                 \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         "console", "\nExpected '%s',\n     got '%s'",  \
                         uts->expect_str, uts->actual_str);             \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that there is a 'next' console output line, and skip it */
-#define ut_assert_skipline()                                           \
+#define ut_assert_skipline() ({                                                \
+       int __ret = 0;                                                  \
+                                                                       \
        if (ut_check_skipline(uts)) {                                   \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         "console", "\nExpected a line, got end");      \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that a following console output line matches */
-#define ut_assert_skip_to_line(fmt, args...)                           \
+#define ut_assert_skip_to_line(fmt, args...) ({                                \
+       int __ret = 0;                                                  \
+                                                                       \
        if (ut_check_skip_to_line(uts, fmt, ##args)) {                  \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         "console", "\nExpected '%s',\n     got to '%s'", \
                         uts->expect_str, uts->actual_str);             \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that there is no more console output */
-#define ut_assert_console_end()                                                \
+#define ut_assert_console_end() ({                                     \
+       int __ret = 0;                                                  \
+                                                                       \
        if (ut_check_console_end(uts)) {                                \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         "console", "Expected no more output, got '%s'",\
                         uts->actual_str);                              \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that the next lines are print_buffer() dump at an address */
-#define ut_assert_nextlines_are_dump(total_bytes)                      \
+#define ut_assert_nextlines_are_dump(total_bytes) ({                   \
+       int __ret = 0;                                                  \
+                                                                       \
        if (ut_check_console_dump(uts, total_bytes)) {                  \
                ut_failf(uts, __FILE__, __LINE__, __func__,             \
                         "console",                                     \
                        "Expected dump of length %x bytes, got '%s'",   \
                         total_bytes, uts->actual_str);                 \
-               return CMD_RET_FAILURE;                                 \
+               __ret = CMD_RET_FAILURE;                                \
        }                                                               \
+       __ret;                                                          \
+})
 
 /* Assert that the next console output line is empty */
 #define ut_assert_nextline_empty()                                     \

diff --git a/test/cmd/pwm.c b/test/cmd/pwm.c
index 2fc0b5e4070460cc82d9f1debe3ed34e76d19364..cf7ee0e0e6504bbfc225f81a075bdfcef86105f0 100644 (file)
--- a/test/cmd/pwm.c
+++ b/test/cmd/pwm.c
@@ -27,11 +27,11 @@ static int dm_test_pwm_cmd(struct unit_test_state *uts)
        /* pwm <invert> <pwm_dev_num> <channel> <polarity> */
        /* cros-ec-pwm doesn't support invert */
        ut_asserteq(1, run_command("pwm invert 0 0 1", 0));
-       ut_assert_nextline("error(-38)")
+       ut_assert_nextline("error(-38)");
        ut_assert_console_end();
 
        ut_asserteq(1, run_command("pwm invert 0 0 0", 0));
-       ut_assert_nextline("error(-38)")
+       ut_assert_nextline("error(-38)");
        ut_assert_console_end();
 
        /* pwm <config> <pwm_dev_num> <channel> <period_ns> <duty_ns> */

diff --git a/test/dm/acpigen.c b/test/dm/acpigen.c
index 3ec2743af9f6d203a060ba052eaf09c29effa909..15b2b6f64a0316a585b9b48d71e122eccb12b6d1 100644 (file)
--- a/test/dm/acpigen.c
+++ b/test/dm/acpigen.c
@@ -1083,7 +1083,7 @@ static int dm_test_acpi_write_name(struct unit_test_state *uts)
        ut_asserteq(NAME_OP, *ptr++);
        ptr += 10;
        ut_asserteq(STRING_PREFIX, *ptr++);
-       ut_asserteq_str("baldrick", (char *)ptr)
+       ut_asserteq_str("baldrick", (char *)ptr);
        ptr += 9;
 
        ut_asserteq(NAME_OP, *ptr++);

diff --git a/test/dm/misc.c b/test/dm/misc.c
index 1506fdefe324e26433b94258c9db16d6663b1fd5..8bdd8c64bca2bd411efac6148b2f37aa7caec7d4 100644 (file)
--- a/test/dm/misc.c
+++ b/test/dm/misc.c
@@ -51,13 +51,13 @@ static int dm_test_misc(struct unit_test_state *uts)
        /* Read back last issued ioctl */
        ut_assertok(misc_call(dev, 2, NULL, 0, &last_ioctl,
                              sizeof(last_ioctl)));
-       ut_asserteq(6, last_ioctl)
+       ut_asserteq(6, last_ioctl);
 
        ut_assertok(misc_ioctl(dev, 23, NULL));
        /* Read back last issued ioctl */
        ut_assertok(misc_call(dev, 2, NULL, 0, &last_ioctl,
                              sizeof(last_ioctl)));
-       ut_asserteq(23, last_ioctl)
+       ut_asserteq(23, last_ioctl);
 
        /* Enable / disable tests */
 

diff --git a/test/dm/phy.c b/test/dm/phy.c
index df4c73fc701f052457e3def379a8a44750d2ee31..4d4a083dd0fde5bd7102ae81cc8ace83b573fc83 100644 (file)
--- a/test/dm/phy.c
+++ b/test/dm/phy.c
@@ -28,22 +28,22 @@ static int dm_test_phy_base(struct unit_test_state *uts)
        /*
         * Get the same phy port in 2 different ways and compare.
         */
-       ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1))
-       ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2))
+       ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1));
+       ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2));
        ut_asserteq(phy1_method1.id, phy1_method2.id);
 
        /*
         * Get the second phy port. Check that the same phy provider (device)
         * provides this 2nd phy port, but that the IDs are different
         */
-       ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2))
+       ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
        ut_asserteq_ptr(phy1_method2.dev, phy2.dev);
        ut_assert(phy1_method1.id != phy2.id);
 
        /*
         * Get the third phy port. Check that the phy provider is different
         */
-       ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3))
+       ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
        ut_assert(phy2.dev != phy3.dev);
 
        /* Try to get a non-existing phy */

diff --git a/test/dm/scmi.c b/test/dm/scmi.c
index 93c7d08f43fee87722b0819521bfb33c6d7f7dec..d87e2731ce42a89b25c190e93ff295254726f0f0 100644 (file)
--- a/test/dm/scmi.c
+++ b/test/dm/scmi.c
@@ -187,10 +187,10 @@ static int dm_test_scmi_resets(struct unit_test_state *uts)
        ut_assertnonnull(agent);
 
        /* Test SCMI resect controller manipulation */
-       ut_assert(!agent->reset[0].asserted)
+       ut_assert(!agent->reset[0].asserted);
 
        ut_assertok(reset_assert(&scmi_devices->reset[0]));
-       ut_assert(agent->reset[0].asserted)
+       ut_assert(agent->reset[0].asserted);
 
        ut_assertok(reset_deassert(&scmi_devices->reset[0]));
        ut_assert(!agent->reset[0].asserted);

diff --git a/test/lib/kconfig.c b/test/lib/kconfig.c
index 472d2c57280c6f83ddd0e78eb8740902bb9f1305..76225ba8ffa9479c5030dcffee69cbf6d7c059c8 100644 (file)
--- a/test/lib/kconfig.c
+++ b/test/lib/kconfig.c
@@ -15,12 +15,12 @@ static int lib_test_is_enabled(struct unit_test_state *uts)
 {
        ulong val;
 
-       ut_asserteq(1, IS_ENABLED(CONFIG_CMDLINE))
-       ut_asserteq(0, IS_ENABLED(CONFIG__UNDEFINED))
+       ut_asserteq(1, IS_ENABLED(CONFIG_CMDLINE));
+       ut_asserteq(0, IS_ENABLED(CONFIG__UNDEFINED));
 
-       ut_asserteq(1, CONFIG_IS_ENABLED(CMDLINE))
-       ut_asserteq(0, CONFIG_IS_ENABLED(OF_PLATDATA))
-       ut_asserteq(0, CONFIG_IS_ENABLED(_UNDEFINED))
+       ut_asserteq(1, CONFIG_IS_ENABLED(CMDLINE));
+       ut_asserteq(0, CONFIG_IS_ENABLED(OF_PLATDATA));
+       ut_asserteq(0, CONFIG_IS_ENABLED(_UNDEFINED));
 
        ut_asserteq(0xc000,
                    IF_ENABLED_INT(CONFIG_BLOBLIST_FIXED, CONFIG_BLOBLIST_ADDR));

diff --git a/test/lib/kconfig_spl.c b/test/lib/kconfig_spl.c
index c89ceaec66f8dda5868dd6a7b75de897eb217bdd..8f8a3411b14fed40a04468156c6f93fb215342fb 100644 (file)
--- a/test/lib/kconfig_spl.c
+++ b/test/lib/kconfig_spl.c
@@ -15,9 +15,9 @@ static int lib_test_spl_is_enabled(struct unit_test_state *uts)
 {
        ulong val;
 
-       ut_asserteq(0, CONFIG_IS_ENABLED(CMDLINE))
-       ut_asserteq(1, CONFIG_IS_ENABLED(OF_PLATDATA))
-       ut_asserteq(0, CONFIG_IS_ENABLED(_UNDEFINED))
+       ut_asserteq(0, CONFIG_IS_ENABLED(CMDLINE));
+       ut_asserteq(1, CONFIG_IS_ENABLED(OF_PLATDATA));
+       ut_asserteq(0, CONFIG_IS_ENABLED(_UNDEFINED));
 
        /*
         * This fails if CONFIG_TEST_KCONFIG_ENABLE is not enabled, since the

diff --git a/test/unicode_ut.c b/test/unicode_ut.c
index 382b7965161825e3ee9de17c52f23d92507c5d1f..b27d7116b9eed5952b1d7457821951455c53c922 100644 (file)
--- a/test/unicode_ut.c
+++ b/test/unicode_ut.c
@@ -192,7 +192,7 @@ static int unicode_test_utf8_get(struct unit_test_state *uts)
                if (!code)
                        break;
        }
-       ut_asserteq_ptr(s, d2 + 9)
+       ut_asserteq_ptr(s, d2 + 9);
 
        /* Check characters less than 0x10000 */
        s = d3;
@@ -203,7 +203,7 @@ static int unicode_test_utf8_get(struct unit_test_state *uts)
                if (!code)
                        break;
        }
-       ut_asserteq_ptr(s, d3 + 9)
+       ut_asserteq_ptr(s, d3 + 9);
 
        /* Check character greater 0xffff */
        s = d4;
@@ -228,7 +228,7 @@ static int unicode_test_utf8_put(struct unit_test_state *uts)
 
        /* Commercial at, translates to one character */
        pos = buffer;
-       ut_assert(!utf8_put('@', &pos))
+       ut_assert(!utf8_put('@', &pos));
        ut_asserteq(1, pos - buffer);
        ut_asserteq('@', buffer[0]);
        ut_assert(!buffer[1]);