tests: Write our own assert()

The cassert `assert()` function is only provided when NDEBUG is not
defined. Otherwise `assert()` becomes a no-op breaking our test cases.
Since we rely on the behavior of assert to validate the tests, we always
want to provide one for the test implementation. This functionality will
be useful once code coverage is added since that forces NDEBUG to be
passed to the preprocessor.

Tested:
    Test cases still work correctly if unmodified, and any changes that
    should cause the asserts to fail still fail as expected.

Change-Id: I8d4132058308566310c58b7ae3e121eae55d37f5
Signed-off-by: William A. Kennington III <wak@google.com>

2 files changed, 177 insertions, 152 deletions

diff --git a/test/message/append.cpp b/test/message/append.cpp
index b067e18..34ed454 100644
--- a/test/message/append.cpp
+++ b/test/message/append.cpp
@@ -5,6 +5,18 @@
 #include <unordered_map>
 #include <set>
 
+// Make sure even in non-debug mode we use asserts
+#define TEST_ASSERT(n)                                                         \
+    do                                                                         \
+    {                                                                          \
+        if (!(n))                                                              \
+        {                                                                      \
+            fprintf(stderr, "%s:%d %s: Assertion `%s` failed\n", __FILE__,     \
+                    __LINE__, __func__, #n);                                   \
+            abort();                                                           \
+        }                                                                      \
+    } while (0)
+
 // Global to share the dbus type string between client and server.
 static std::string verifyTypeString;
 
@@ -45,7 +57,8 @@ void* server(void* b)
         if (sd_bus_message_is_method_call(m, INTERFACE, TEST_METHOD))
         {
             // Verify the message type matches what the test expects.
-            assert(verifyTypeString == sd_bus_message_get_signature(m, true));
+            TEST_ASSERT(verifyTypeString ==
+                        sd_bus_message_get_signature(m, true));
             if (verifyCallback)
             {
                 verifyCallback(m);
@@ -97,7 +110,7 @@ void runTests()
             {
                 int32_t i = 0;
                 sd_bus_message_read_basic(m, 'i', &i);
-                assert(i == 1);
+                TEST_ASSERT(i == 1);
             }
         };
         verifyCallback = &verify::op;
@@ -117,8 +130,8 @@ void runTests()
             {
                 int32_t a = 0, b = 0;
                 sd_bus_message_read(m, "ii", &a, &b);
-                assert(a == 1);
-                assert(b == 1);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 1);
             }
         };
         verifyCallback = &verify::op;
@@ -138,11 +151,11 @@ void runTests()
             {
                 int32_t a = 0, b = 0, c = 0, d = 0, e = 0;
                 sd_bus_message_read(m, "iiiii", &a, &b, &c, &d, &e);
-                assert(a == 1);
-                assert(b == 2);
-                assert(c == 3);
-                assert(d == 4);
-                assert(e == 5);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 2);
+                TEST_ASSERT(c == 3);
+                TEST_ASSERT(d == 4);
+                TEST_ASSERT(e == 5);
             }
         };
         verifyCallback = &verify::op;
@@ -166,12 +179,12 @@ void runTests()
                 bool t1, t2, f1, f2, f3;
                 double d;
                 sd_bus_message_read(m, "bbbbbd", &t1, &t2, &f1, &f2, &f3, &d);
-                assert(t1);
-                assert(t2);
-                assert(!f1);
-                assert(!f2);
-                assert(!f3);
-                assert(d == 1.1);
+                TEST_ASSERT(t1);
+                TEST_ASSERT(t2);
+                TEST_ASSERT(!f1);
+                TEST_ASSERT(!f2);
+                TEST_ASSERT(!f3);
+                TEST_ASSERT(d == 1.1);
             }
         };
         verifyCallback = &verify::op;
@@ -191,7 +204,7 @@ void runTests()
             {
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("asdf", s));
+                TEST_ASSERT(0 == strcmp("asdf", s));
             }
         };
         verifyCallback = &verify::op;
@@ -223,7 +236,7 @@ void runTests()
             {
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("1234", s));
+                TEST_ASSERT(0 == strcmp("1234", s));
             }
         };
         verifyCallback = &verify::op;
@@ -252,16 +265,16 @@ void runTests()
                            *s6 = nullptr;
                 sd_bus_message_read(m, "isssssssi", &a, &s0, &s1, &s2, &s3, &s4,
                                     &s5, &s6, &b);
-                assert(a == 1);
-                assert(b == 5);
-                assert(0 == strcmp("asdf", s0));
-                assert(0 == strcmp("ASDF", s1));
-                assert(0 == strcmp("jkl;", s2));
-                assert(0 == strcmp("JKL:", s3));
-                assert(0 == strcmp("1234", s4));
-                assert(0 == strcmp("5678", s5));
-                assert(0 == strcmp("!@#$", s6));
-                assert(b == 5);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 5);
+                TEST_ASSERT(0 == strcmp("asdf", s0));
+                TEST_ASSERT(0 == strcmp("ASDF", s1));
+                TEST_ASSERT(0 == strcmp("jkl;", s2));
+                TEST_ASSERT(0 == strcmp("JKL:", s3));
+                TEST_ASSERT(0 == strcmp("1234", s4));
+                TEST_ASSERT(0 == strcmp("5678", s5));
+                TEST_ASSERT(0 == strcmp("!@#$", s6));
+                TEST_ASSERT(b == 5);
             }
         };
         verifyCallback = &verify::op;
@@ -284,10 +297,10 @@ void runTests()
                 int32_t a = 0, b = 0;
                 const char *s0 = nullptr, *s1 = nullptr;
                 sd_bus_message_read(m, "iogi", &a, &s0, &s1, &b);
-                assert(a == 1);
-                assert(b == 4);
-                assert(0 == strcmp("/asdf", s0));
-                assert(0 == strcmp("iii", s1));
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 4);
+                TEST_ASSERT(0 == strcmp("/asdf", s0));
+                TEST_ASSERT(0 == strcmp("iii", s1));
             }
         };
         verifyCallback = &verify::op;
@@ -308,25 +321,25 @@ void runTests()
             {
                 int32_t a = 0;
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 auto rc =
                     sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("1", s));
+                TEST_ASSERT(0 == strcmp("1", s));
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("2", s));
+                TEST_ASSERT(0 == strcmp("2", s));
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("3", s));
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(0 == strcmp("3", s));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
 
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -347,42 +360,42 @@ void runTests()
             {
                 int32_t a = 0;
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 auto rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY,
                                                          "{si}");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
                                                     "si");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("asdf", s));
+                TEST_ASSERT(0 == strcmp("asdf", s));
                 sd_bus_message_read_basic(m, 'i', &a);
-                assert(a == 3);
+                TEST_ASSERT(a == 3);
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
                 rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
                                                     "si");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("jkl;", s));
+                TEST_ASSERT(0 == strcmp("jkl;", s));
                 sd_bus_message_read_basic(m, 'i', &a);
-                assert(a == 4);
+                TEST_ASSERT(a == 4);
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -403,42 +416,42 @@ void runTests()
             {
                 int32_t a = 0;
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 auto rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY,
                                                          "{si}");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
                                                     "si");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
                 sd_bus_message_read_basic(m, 'i', &a);
-                assert((0 == strcmp("asdf", s) && a == 3) ||
-                       (a = 4 && 0 == strcmp("jkl;", s)));
+                TEST_ASSERT((0 == strcmp("asdf", s) && a == 3) ||
+                            (a = 4 && 0 == strcmp("jkl;", s)));
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
                 rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
                                                     "si");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 sd_bus_message_read_basic(m, 's', &s);
                 sd_bus_message_read_basic(m, 'i', &a);
-                assert((0 == strcmp("asdf", s) && a == 3) ||
-                       (a = 4 && 0 == strcmp("jkl;", s)));
+                TEST_ASSERT((0 == strcmp("asdf", s) && a == 3) ||
+                            (a = 4 && 0 == strcmp("jkl;", s)));
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -459,24 +472,24 @@ void runTests()
             {
                 int32_t a = 0;
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 auto rc =
                     sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("asdf", s));
+                TEST_ASSERT(0 == strcmp("asdf", s));
 
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("jkl;", s));
+                TEST_ASSERT(0 == strcmp("jkl;", s));
 
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -497,25 +510,25 @@ void runTests()
             {
                 int32_t a = 0;
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 auto rc =
                     sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 const char* s = nullptr;
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("1", s));
+                TEST_ASSERT(0 == strcmp("1", s));
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("2", s));
+                TEST_ASSERT(0 == strcmp("2", s));
                 sd_bus_message_read_basic(m, 's', &s);
-                assert(0 == strcmp("3", s));
-                assert(1 == sd_bus_message_at_end(m, false));
+                TEST_ASSERT(0 == strcmp("3", s));
+                TEST_ASSERT(1 == sd_bus_message_at_end(m, false));
 
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -539,21 +552,21 @@ void runTests()
                 const char* c = nullptr;
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 auto rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT,
                                                          "ids");
-                assert(0 <= rc);
+                TEST_ASSERT(0 <= rc);
 
                 sd_bus_message_read(m, "ids", &a, &b, &c);
-                assert(a == 3);
-                assert(b == 4.1);
-                assert(0 == strcmp(c, "asdf"));
+                TEST_ASSERT(a == 3);
+                TEST_ASSERT(b == 4.1);
+                TEST_ASSERT(0 == strcmp(c, "asdf"));
 
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -576,20 +589,20 @@ void runTests()
                 double b = 0;
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, "d");
                 sd_bus_message_read(m, "d", &b);
-                assert(b == 3.1);
+                TEST_ASSERT(b == 3.1);
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, "i");
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 4);
+                TEST_ASSERT(a == 4);
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -614,29 +627,29 @@ void runTests()
                 const char* c = nullptr;
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 1);
+                TEST_ASSERT(a == 1);
 
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv");
                 sd_bus_message_read(m, "s", &c);
-                assert(0 == strcmp("asdf", c));
+                TEST_ASSERT(0 == strcmp("asdf", c));
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, "i");
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 3);
+                TEST_ASSERT(a == 3);
                 sd_bus_message_exit_container(m);
                 sd_bus_message_exit_container(m);
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv");
                 sd_bus_message_read(m, "s", &c);
-                assert(0 == strcmp("jkl;", c));
+                TEST_ASSERT(0 == strcmp("jkl;", c));
                 sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, "d");
                 sd_bus_message_read(m, "d", &b);
-                assert(b == 4.1);
+                TEST_ASSERT(b == 4.1);
                 sd_bus_message_exit_container(m);
                 sd_bus_message_exit_container(m);
                 sd_bus_message_exit_container(m);
 
                 sd_bus_message_read(m, "i", &a);
-                assert(a == 2);
+                TEST_ASSERT(a == 2);
             }
         };
         verifyCallback = &verify::op;
diff --git a/test/message/read.cpp b/test/message/read.cpp
index 4eb6437..90fb0fc 100644
--- a/test/message/read.cpp
+++ b/test/message/read.cpp
@@ -5,6 +5,18 @@
 #include <unordered_map>
 #include <set>
 
+// Make sure even in non-debug mode we use asserts
+#define TEST_ASSERT(n)                                                         \
+    do                                                                         \
+    {                                                                          \
+        if (!(n))                                                              \
+        {                                                                      \
+            fprintf(stderr, "%s:%d %s: Assertion `%s` failed\n", __FILE__,     \
+                    __LINE__, __func__, #n);                                   \
+            abort();                                                           \
+        }                                                                      \
+    } while (0)
+
 // Global to share the dbus type string between client and server.
 static std::string verifyTypeString;
 
@@ -45,7 +57,7 @@ void* server(void* b)
         if (m.is_method_call(INTERFACE, TEST_METHOD))
         {
             // Verify the message type matches what the test expects.
-            assert(verifyTypeString == m.get_signature());
+            TEST_ASSERT(verifyTypeString == m.get_signature());
 
             if (verifyCallback)
             {
@@ -100,7 +112,7 @@ void runTests()
             {
                 int32_t i = 0;
                 m.read(i);
-                assert(i == 1);
+                TEST_ASSERT(i == 1);
             }
         };
         verifyCallback = &verify::op;
@@ -120,8 +132,8 @@ void runTests()
             {
                 int32_t a = 0, b = 0;
                 m.read(a, b);
-                assert(a == 1);
-                assert(b == 1);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 1);
             }
         };
         verifyCallback = &verify::op;
@@ -141,11 +153,11 @@ void runTests()
             {
                 int32_t a = 0, b = 0, c = 0, d = 0, e = 0;
                 m.read(a, b, c, d, e);
-                assert(a == 1);
-                assert(b == 2);
-                assert(c == 3);
-                assert(d == 4);
-                assert(e == 5);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 2);
+                TEST_ASSERT(c == 3);
+                TEST_ASSERT(d == 4);
+                TEST_ASSERT(e == 5);
             }
         };
         verifyCallback = &verify::op;
@@ -169,12 +181,12 @@ void runTests()
                 bool t1, t2, f1, f2, f3;
                 double d;
                 m.read(t1, t2, f1, f2, f3, d);
-                assert(t1);
-                assert(t2);
-                assert(!f1);
-                assert(!f2);
-                assert(!f3);
-                assert(d == 1.1);
+                TEST_ASSERT(t1);
+                TEST_ASSERT(t2);
+                TEST_ASSERT(!f1);
+                TEST_ASSERT(!f2);
+                TEST_ASSERT(!f3);
+                TEST_ASSERT(d == 1.1);
             }
         };
         verifyCallback = &verify::op;
@@ -194,7 +206,7 @@ void runTests()
             {
                 const char* s = nullptr;
                 m.read(s);
-                assert(0 == strcmp("asdf", s));
+                TEST_ASSERT(0 == strcmp("asdf", s));
             }
         };
         verifyCallback = &verify::op;
@@ -217,12 +229,12 @@ void runTests()
                 int32_t a = 0, b = 0;
                 std::string s0, s1, s2, s3;
                 m.read(a, s0, s1, s2, s3, b);
-                assert(a == 1);
-                assert(b == 5);
-                assert(s0 == "asdf"s);
-                assert(s1 == "ASDF"s);
-                assert(s2 == "jkl;"s);
-                assert(s3 == "JKL:");
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 5);
+                TEST_ASSERT(s0 == "asdf"s);
+                TEST_ASSERT(s1 == "ASDF"s);
+                TEST_ASSERT(s2 == "jkl;"s);
+                TEST_ASSERT(s3 == "JKL:");
             }
         };
         verifyCallback = &verify::op;
@@ -246,10 +258,10 @@ void runTests()
                 sdbusplus::message::object_path o;
                 sdbusplus::message::signature s;
                 m.read(a, o, s, b);
-                assert(a == 1);
-                assert(b == 4);
-                assert(std::string(o) == "/asdf"s);
-                assert(std::string(s) == "iii"s);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 4);
+                TEST_ASSERT(std::string(o) == "/asdf"s);
+                TEST_ASSERT(std::string(s) == "iii"s);
             }
         };
         verifyCallback = &verify::op;
@@ -271,12 +283,12 @@ void runTests()
                 int32_t a = 0;
                 std::vector<std::string> s;
                 m.read(a, s);
-                assert(a == 1);
-                assert(s[0] == "1");
-                assert(s[1] == "2");
-                assert(s[2] == "3");
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(s[0] == "1");
+                TEST_ASSERT(s[1] == "2");
+                TEST_ASSERT(s[2] == "3");
                 decltype(s) s2 = {"1", "2", "3"};
-                assert(s == s2);
+                TEST_ASSERT(s == s2);
             }
         };
         verifyCallback = &verify::op;
@@ -299,11 +311,11 @@ void runTests()
                 std::map<std::string, int> s{};
 
                 m.read(a, s, b);
-                assert(a == 1);
-                assert(s.size() == 2);
-                assert(s["asdf"] == 3);
-                assert(s["jkl;"] == 4);
-                assert(b == 2);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(s.size() == 2);
+                TEST_ASSERT(s["asdf"] == 3);
+                TEST_ASSERT(s["jkl;"] == 4);
+                TEST_ASSERT(b == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -326,11 +338,11 @@ void runTests()
                 std::unordered_map<std::string, int> s{};
 
                 m.read(a, s, b);
-                assert(a == 1);
-                assert(s.size() == 2);
-                assert(s["asdf"] == 3);
-                assert(s["jkl;"] == 4);
-                assert(b == 2);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(s.size() == 2);
+                TEST_ASSERT(s["asdf"] == 3);
+                TEST_ASSERT(s["jkl;"] == 4);
+                TEST_ASSERT(b == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -353,11 +365,11 @@ void runTests()
                 std::set<std::string> s{};
 
                 m.read(a, s, b);
-                assert(a == 1);
-                assert(s.size() == 2);
-                assert(s.find("asdf") != s.end());
-                assert(s.find("jkl;") != s.end());
-                assert(b == 2);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(s.size() == 2);
+                TEST_ASSERT(s.find("asdf") != s.end());
+                TEST_ASSERT(s.find("jkl;") != s.end());
+                TEST_ASSERT(b == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -380,9 +392,9 @@ void runTests()
                 std::tuple<int, double, std::string> c{};
 
                 m.read(a, c, b);
-                assert(a == 1);
-                assert(b == 2);
-                assert(c == std::make_tuple(3, 4.1, "asdf"s));
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(b == 2);
+                TEST_ASSERT(c == std::make_tuple(3, 4.1, "asdf"s));
             }
         };
         verifyCallback = &verify::op;
@@ -405,10 +417,10 @@ void runTests()
                 sdbusplus::message::variant<int, double> a1{}, a2{};
 
                 m.read(a, a1, a2, b);
-                assert(a == 1);
-                assert(a1 == 3.1);
-                assert(a2 == 4);
-                assert(b == 2);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(a1 == 3.1);
+                TEST_ASSERT(a2 == 4);
+                TEST_ASSERT(b == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -431,10 +443,10 @@ void runTests()
                 sdbusplus::message::variant<uint8_t, double> a1{}, a2{};
 
                 m.read(a, a1, a2, b);
-                assert(a == 1);
-                assert(a1 == 3.1);
-                assert(a2 == uint8_t());
-                assert(b == 2);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(a1 == 3.1);
+                TEST_ASSERT(a2 == uint8_t());
+                TEST_ASSERT(b == 2);
             }
         };
         verifyCallback = &verify::op;
@@ -459,10 +471,10 @@ void runTests()
                     a1{};
 
                 m.read(a, a1, b);
-                assert(a == 1);
-                assert(a1["asdf"] == 3);
-                assert(a1["jkl;"] == 4.1);
-                assert(b == 2);
+                TEST_ASSERT(a == 1);
+                TEST_ASSERT(a1["asdf"] == 3);
+                TEST_ASSERT(a1["jkl;"] == 4.1);
+                TEST_ASSERT(b == 2);
             }
         };
         verifyCallback = &verify::op;