1 files changed, 16 insertions, 16 deletions

diff --git a/shared/n-acd/src/test-twice.c b/shared/n-acd/src/test-twice.c
index 157e8a2b96..b474502ee3 100644
--- a/shared/n-acd/src/test-twice.c
+++ b/shared/n-acd/src/test-twice.c
@@ -4,6 +4,8 @@
  * it on both ends. We expect the PROBE to fail on at least one of the devices.
  */
 
+#undef NDEBUG
+#include <c-stdaux.h>
 #include <stdlib.h>
 #include "test.h"
 
@@ -29,17 +31,17 @@ static void test_unused(int ifindex1, uint8_t *mac1, size_t n_mac1, int ifindex2
         int r, fd1, fd2, state1, state2;
 
         r = n_acd_new(&acd1);
-        assert(!r);
+        c_assert(!r);
         r = n_acd_new(&acd2);
-        assert(!r);
+        c_assert(!r);
 
         n_acd_get_fd(acd1, &fd1);
         n_acd_get_fd(acd2, &fd2);
 
         r = n_acd_start(acd1, &config1);
-        assert(!r);
+        c_assert(!r);
         r = n_acd_start(acd2, &config2);
-        assert(!r);
+        c_assert(!r);
 
         for (state1 = state2 = -1; state1 == -1 || state2 == -1; ) {
                 NAcdEvent *event;
@@ -47,31 +49,31 @@ static void test_unused(int ifindex1, uint8_t *mac1, size_t n_mac1, int ifindex2
                 pfds[1] = (struct pollfd){ .fd = fd2, .events = (state2 == -1) ? POLLIN : 0 };
 
                 r = poll(pfds, sizeof(pfds) / sizeof(*pfds), -1);
-                assert(r >= 0);
+                c_assert(r >= 0);
 
                 if (state1 == -1) {
                         r = n_acd_dispatch(acd1);
-                        assert(!r);
+                        c_assert(!r);
 
                         r = n_acd_pop_event(acd1, &event);
                         if (!r) {
-                                assert(event->event == N_ACD_EVENT_READY || event->event == N_ACD_EVENT_USED);
+                                c_assert(event->event == N_ACD_EVENT_READY || event->event == N_ACD_EVENT_USED);
                                 state1 = !!(event->event == N_ACD_EVENT_READY);
                         } else {
-                                assert(r == N_ACD_E_DONE);
+                                c_assert(r == N_ACD_E_DONE);
                         }
                 }
 
                 if (state2 == -1) {
                         r = n_acd_dispatch(acd2);
-                        assert(!r);
+                        c_assert(!r);
 
                         r = n_acd_pop_event(acd2, &event);
                         if (!r) {
-                                assert(event->event == N_ACD_EVENT_READY || event->event == N_ACD_EVENT_USED);
+                                c_assert(event->event == N_ACD_EVENT_READY || event->event == N_ACD_EVENT_USED);
                                 state2 = !!(event->event == N_ACD_EVENT_READY);
                         } else {
-                                assert(r == N_ACD_E_DONE);
+                                c_assert(r == N_ACD_E_DONE);
                         }
                 }
         }
@@ -79,16 +81,14 @@ static void test_unused(int ifindex1, uint8_t *mac1, size_t n_mac1, int ifindex2
         n_acd_free(acd1);
         n_acd_free(acd2);
 
-        assert(!state1 || !state2);
+        c_assert(!state1 || !state2);
 }
 
 int main(int argc, char **argv) {
         struct ether_addr mac1, mac2;
-        int r, ifindex1, ifindex2;
+        int ifindex1, ifindex2;
 
-        r = test_setup();
-        if (r)
-                return r;
+        test_setup();
 
         test_veth_new(&ifindex1, &mac1, &ifindex2, &mac2);
         test_unused(ifindex1, mac1.ether_addr_octet, sizeof(mac2.ether_addr_octet), ifindex2, mac2.ether_addr_octet, sizeof(mac2.ether_addr_octet));