test: drop redundant parentheses in ASSERT_OK() and friends

This reverts 278e3adf50e36518c5a5dd798ca998e7eac5436e, and drop more
redundant parentheses, as they unfortunately does not suppress the
false-positive warnings by coverity.

diff --git a/src/libsystemd/sd-device/test-sd-device-monitor.c b/src/libsystemd/sd-device/test-sd-device-monitor.c
index 01681792ca3408427c91ce4de17b28766fae4921..1cdeabbf21e5016999cb4590a73d8815c93b1a8a 100644 (file)
--- a/src/libsystemd/sd-device/test-sd-device-monitor.c
+++ b/src/libsystemd/sd-device/test-sd-device-monitor.c
@@ -376,13 +376,13 @@ TEST(sd_device_monitor_receive) {
 
         ASSERT_OK(device_monitor_send(monitor_server, &sa, device));
 
-        ASSERT_OK((fd = sd_device_monitor_get_fd(monitor_client)));
+        ASSERT_OK(fd = sd_device_monitor_get_fd(monitor_client));
 
         for (;;) {
                 usec_t timeout;
                 int events;
 
-                ASSERT_OK((events = sd_device_monitor_get_events(monitor_client)));
+                ASSERT_OK(events = sd_device_monitor_get_events(monitor_client));
                 ASSERT_EQ(events, (int) EPOLLIN);
                 ASSERT_OK(sd_device_monitor_get_timeout(monitor_client, &timeout));
                 ASSERT_EQ(timeout, USEC_INFINITY);

diff --git a/src/libsystemd/sd-device/test-sd-device.c b/src/libsystemd/sd-device/test-sd-device.c
index e9d24570daadb8e2fe3ef497125b9527b98e7ed9..86926ec48465ace0626ddacc458aeb813a8998ab 100644 (file)
--- a/src/libsystemd/sd-device/test-sd-device.c
+++ b/src/libsystemd/sd-device/test-sd-device.c
@@ -39,12 +39,12 @@ static void test_sd_device_one(sd_device *d) {
         ASSERT_OK(sd_device_new_from_syspath(&dev, syspath));
         ASSERT_OK(sd_device_get_syspath(dev, &val));
         ASSERT_STREQ(syspath, val);
-        ASSERT_NULL((dev = sd_device_unref(dev)));
+        ASSERT_NULL(dev = sd_device_unref(dev));
 
         ASSERT_OK(sd_device_new_from_path(&dev, syspath));
         ASSERT_OK(sd_device_get_syspath(dev, &val));
         ASSERT_STREQ(syspath, val);
-        ASSERT_NULL((dev = sd_device_unref(dev)));
+        ASSERT_NULL(dev = sd_device_unref(dev));
 
         r = sd_device_get_ifindex(d, &ifindex);
         if (r < 0)
@@ -69,7 +69,7 @@ static void test_sd_device_one(sd_device *d) {
                 } else {
                         ASSERT_OK(sd_device_get_syspath(dev, &val));
                         ASSERT_STREQ(syspath, val);
-                        ASSERT_NULL((dev = sd_device_unref(dev)));
+                        ASSERT_NULL(dev = sd_device_unref(dev));
                 }
 
                 /* This does not require the interface really exists on the network namespace.
@@ -77,7 +77,7 @@ static void test_sd_device_one(sd_device *d) {
                 ASSERT_OK(sd_device_new_from_ifname(&dev, sysname));
                 ASSERT_OK(sd_device_get_syspath(dev, &val));
                 ASSERT_STREQ(syspath, val);
-                ASSERT_NULL((dev = sd_device_unref(dev)));
+                ASSERT_NULL(dev = sd_device_unref(dev));
         }
 
         r = sd_device_get_subsystem(d, &subsystem);
@@ -99,7 +99,7 @@ static void test_sd_device_one(sd_device *d) {
                 else {
                         ASSERT_OK(sd_device_get_syspath(dev, &val));
                         ASSERT_STREQ(syspath, val);
-                        ASSERT_NULL((dev = sd_device_unref(dev)));
+                        ASSERT_NULL(dev = sd_device_unref(dev));
                 }
 
                 /* The device ID depends on subsystem. */
@@ -115,11 +115,11 @@ static void test_sd_device_one(sd_device *d) {
                 } else {
                         ASSERT_OK(sd_device_get_syspath(dev, &val));
                         ASSERT_STREQ(syspath, val);
-                        ASSERT_NULL((dev = sd_device_unref(dev)));
+                        ASSERT_NULL(dev = sd_device_unref(dev));
                 }
 
                 /* These require udev database, and reading database requires device ID. */
-                ASSERT_OK((r = sd_device_get_is_initialized(d)));
+                ASSERT_OK(r = sd_device_get_is_initialized(d));
                 if (r > 0) {
                         r = sd_device_get_usec_since_initialized(d, &usec);
                         if (r < 0)
@@ -145,7 +145,7 @@ static void test_sd_device_one(sd_device *d) {
                 else {
                         ASSERT_OK(sd_device_get_syspath(dev, &val));
                         ASSERT_STREQ(syspath, val);
-                        ASSERT_NULL((dev = sd_device_unref(dev)));
+                        ASSERT_NULL(dev = sd_device_unref(dev));
                 }
 
                 r = sd_device_new_from_path(&dev, devname);
@@ -154,7 +154,7 @@ static void test_sd_device_one(sd_device *d) {
                 else {
                         ASSERT_OK(sd_device_get_syspath(dev, &val));
                         ASSERT_STREQ(syspath, val);
-                        ASSERT_NULL((dev = sd_device_unref(dev)));
+                        ASSERT_NULL(dev = sd_device_unref(dev));
 
                         _cleanup_close_ int fd = -EBADF;
                         fd = sd_device_open(d, O_CLOEXEC| O_NONBLOCK | (is_block ? O_RDONLY : O_NOCTTY | O_PATH));
@@ -173,18 +173,18 @@ static void test_sd_device_one(sd_device *d) {
                 ASSERT_OK(sd_device_new_from_devnum(&dev, is_block ? 'b' : 'c', devnum));
                 ASSERT_OK(sd_device_get_syspath(dev, &val));
                 ASSERT_STREQ(syspath, val);
-                ASSERT_NULL((dev = sd_device_unref(dev)));
+                ASSERT_NULL(dev = sd_device_unref(dev));
 
                 ASSERT_OK(asprintf(&p, "/dev/%s/%u:%u", is_block ? "block" : "char", major(devnum), minor(devnum)));
                 ASSERT_OK(sd_device_new_from_devname(&dev, p));
                 ASSERT_OK(sd_device_get_syspath(dev, &val));
                 ASSERT_STREQ(syspath, val);
-                ASSERT_NULL((dev = sd_device_unref(dev)));
+                ASSERT_NULL(dev = sd_device_unref(dev));
 
                 ASSERT_OK(sd_device_new_from_path(&dev, p));
                 ASSERT_OK(sd_device_get_syspath(dev, &val));
                 ASSERT_STREQ(syspath, val);
-                ASSERT_NULL((dev = sd_device_unref(dev)));
+                ASSERT_NULL(dev = sd_device_unref(dev));
         }
 
         ASSERT_OK(sd_device_get_devpath(d, &val));
@@ -216,8 +216,8 @@ static void test_sd_device_one(sd_device *d) {
                 ASSERT_TRUE(ERRNO_IS_NEG_PRIVILEGE(r) || IN_SET(r, -ENOENT, -EINVAL));
         else {
                 unsigned x;
-                ASSERT_OK((r = device_get_sysattr_unsigned(d, "nsid", &x)));
-                ASSERT_EQ((x > 0), (r > 0));
+                ASSERT_OK(r = device_get_sysattr_unsigned(d, "nsid", &x));
+                ASSERT_EQ(x > 0, r > 0);
         }
 }
 
@@ -687,7 +687,7 @@ TEST(sd_device_new_from_path) {
                 ASSERT_OK(sd_device_new_from_path(&d, syspath));
                 ASSERT_OK(sd_device_get_syspath(d, &s));
                 ASSERT_STREQ(s, syspath);
-                ASSERT_NULL((d = sd_device_unref(d)));
+                ASSERT_NULL(d = sd_device_unref(d));
 
                 ASSERT_OK(sd_device_get_devname(dev, &devpath));
                 r = sd_device_new_from_path(&d, devpath);
@@ -696,7 +696,7 @@ TEST(sd_device_new_from_path) {
                 else {
                         ASSERT_OK(sd_device_get_syspath(d, &s));
                         ASSERT_STREQ(s, syspath);
-                        ASSERT_NULL((d = sd_device_unref(d)));
+                        ASSERT_NULL(d = sd_device_unref(d));
                 }
 
                 ASSERT_NOT_NULL((path = path_join(tmpdir, sysname)));
@@ -720,7 +720,7 @@ static void test_devname_from_devnum_one(const char *path) {
 
         ASSERT_OK(devname_from_devnum(st.st_mode, st.st_rdev, &resolved));
         ASSERT_TRUE(path_equal(path, resolved));
-        ASSERT_NULL((resolved = mfree(resolved)));
+        ASSERT_NULL(resolved = mfree(resolved));
         ASSERT_OK(devname_from_stat_rdev(&st, &resolved));
         ASSERT_TRUE(path_equal(path, resolved));
 }

diff --git a/src/libsystemd/sd-event/test-event.c b/src/libsystemd/sd-event/test-event.c
index 79a3d30356f6a2b5e0a93d33471f448394069a58..6394507994fba68b8797f0ec7d8bdd84ac70e376 100644 (file)
--- a/src/libsystemd/sd-event/test-event.c
+++ b/src/libsystemd/sd-event/test-event.c
@@ -572,7 +572,7 @@ TEST(pidfd) {
 
         assert_se(pid > 1);
 
-        ASSERT_OK((pidfd = pidfd_open(pid, 0)));
+        ASSERT_OK(pidfd = pidfd_open(pid, 0));
 
         pid2 = fork();
         if (pid2 == 0)

diff --git a/src/libsystemd/sd-journal/test-journal-interleaving.c b/src/libsystemd/sd-journal/test-journal-interleaving.c
index 80bb436ea57923aebf1885ec3f14d75a0836e98e..6e9c87c023d12425d0e2ed171177c558748ce7b7 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal-interleaving.c
+++ b/src/libsystemd/sd-journal/test-journal-interleaving.c
@@ -236,7 +236,7 @@ static void test_cursor(sd_journal *j) {
         ASSERT_OK(sd_journal_seek_head(j));
 
         for (;;) {
-                ASSERT_OK((r = sd_journal_next(j)));
+                ASSERT_OK(r = sd_journal_next(j));
                 if (r == 0)
                         break;
 

diff --git a/src/libsystemd/sd-netlink/test-netlink.c b/src/libsystemd/sd-netlink/test-netlink.c
index 9862904e306235ec23bf398db3a74cbfc6a4ae40..a68a37e2823b0f1f12047d07a2bad4dd7a816604 100644 (file)
--- a/src/libsystemd/sd-netlink/test-netlink.c
+++ b/src/libsystemd/sd-netlink/test-netlink.c
@@ -100,7 +100,7 @@ TEST(message_address) {
         ASSERT_OK(sd_rtnl_message_new_addr(rtnl, &message, RTM_GETADDR, ifindex, AF_INET));
         ASSERT_OK(sd_netlink_message_set_request_dump(message, true));
 
-        ASSERT_OK((r = sd_netlink_call(rtnl, message, 0, &reply)));
+        ASSERT_OK(r = sd_netlink_call(rtnl, message, 0, &reply));
 
         /* If the loopback device is down we won't get any results. */
         if (r > 0) {
@@ -134,7 +134,7 @@ TEST(message_route) {
         ASSERT_OK(sd_netlink_message_read_u32(req, RTA_OIF, &u32_data));
         ASSERT_EQ(u32_data, index);
 
-        ASSERT_NULL((req = sd_netlink_message_unref(req)));
+        ASSERT_NULL(req = sd_netlink_message_unref(req));
 }
 
 static int link_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
@@ -173,7 +173,7 @@ TEST(netlink_event_loop) {
         ASSERT_OK(sd_event_run(event, 0));
 
         ASSERT_OK(sd_netlink_detach_event(rtnl));
-        ASSERT_NULL((rtnl = sd_netlink_unref(rtnl)));
+        ASSERT_NULL(rtnl = sd_netlink_unref(rtnl));
 }
 
 static void test_async_destroy(void *userdata) {
@@ -226,7 +226,7 @@ TEST(netlink_call_async) {
         ASSERT_OK(sd_netlink_wait(rtnl, 0));
         ASSERT_OK(sd_netlink_process(rtnl, &reply));
 
-        ASSERT_NULL((rtnl = sd_netlink_unref(rtnl)));
+        ASSERT_NULL(rtnl = sd_netlink_unref(rtnl));
 }
 
 struct test_async_object {
@@ -307,7 +307,7 @@ TEST(async_destroy_callback) {
         ASSERT_PTR_EQ(test_async_object_ref(t), t);
         ASSERT_EQ(t->n_ref, 2U);
 
-        ASSERT_NULL((slot = sd_netlink_slot_unref(slot)));
+        ASSERT_NULL(slot = sd_netlink_slot_unref(slot));
         ASSERT_EQ(t->n_ref, 1U);
 
         ASSERT_NULL(sd_netlink_message_unref(m));
@@ -320,7 +320,7 @@ TEST(async_destroy_callback) {
         ASSERT_PTR_EQ(test_async_object_ref(t), t);
         ASSERT_EQ(t->n_ref, 2U);
 
-        ASSERT_NULL((rtnl = sd_netlink_unref(rtnl)));
+        ASSERT_NULL(rtnl = sd_netlink_unref(rtnl));
         ASSERT_EQ(t->n_ref, 1U);
 }
 
@@ -329,7 +329,7 @@ static int pipe_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata)
 
         (*counter)--;
 
-        ASSERT_OK((r = sd_netlink_message_get_errno(m)));
+        ASSERT_OK(r = sd_netlink_message_get_errno(m));
         log_info_errno(r, "%d left in pipe. got reply: %m", *counter);
         return 1;
 }
@@ -356,7 +356,7 @@ TEST(pipe) {
                 ASSERT_OK(sd_netlink_process(rtnl, NULL));
         }
 
-        ASSERT_NULL((rtnl = sd_netlink_unref(rtnl)));
+        ASSERT_NULL(rtnl = sd_netlink_unref(rtnl));
 }
 
 TEST(message_container) {
@@ -403,10 +403,10 @@ TEST(sd_netlink_add_match) {
         ASSERT_OK(sd_netlink_add_match(rtnl, &s2, RTM_NEWLINK, link_handler, NULL, NULL, NULL));
         ASSERT_OK(sd_netlink_add_match(rtnl, NULL, RTM_NEWLINK, link_handler, NULL, NULL, NULL));
 
-        ASSERT_NULL((s1 = sd_netlink_slot_unref(s1)));
-        ASSERT_NULL((s2 = sd_netlink_slot_unref(s2)));
+        ASSERT_NULL(s1 = sd_netlink_slot_unref(s1));
+        ASSERT_NULL(s2 = sd_netlink_slot_unref(s2));
 
-        ASSERT_NULL((rtnl = sd_netlink_unref(rtnl)));
+        ASSERT_NULL(rtnl = sd_netlink_unref(rtnl));
 }
 
 TEST(dump_addresses) {
@@ -578,23 +578,23 @@ TEST(genl) {
 
         ASSERT_OK(sd_genl_add_match(genl, NULL, CTRL_GENL_NAME, "notify", 0, genl_ctrl_match_callback, NULL, NULL, "genl-ctrl-notify"));
 
-        ASSERT_NULL((m = sd_netlink_message_unref(m)));
+        ASSERT_NULL(m = sd_netlink_message_unref(m));
         ASSERT_FAIL(sd_genl_message_new(genl, "should-not-exist", CTRL_CMD_GETFAMILY, &m));
         ASSERT_ERROR(sd_genl_message_new(genl, "should-not-exist", CTRL_CMD_GETFAMILY, &m), EOPNOTSUPP);
 
         /* These families may not be supported by kernel. Hence, ignore results. */
         (void) sd_genl_message_new(genl, FOU_GENL_NAME, 0, &m);
-        ASSERT_NULL((m = sd_netlink_message_unref(m)));
+        ASSERT_NULL(m = sd_netlink_message_unref(m));
         (void) sd_genl_message_new(genl, L2TP_GENL_NAME, 0, &m);
-        ASSERT_NULL((m = sd_netlink_message_unref(m)));
+        ASSERT_NULL(m = sd_netlink_message_unref(m));
         (void) sd_genl_message_new(genl, MACSEC_GENL_NAME, 0, &m);
-        ASSERT_NULL((m = sd_netlink_message_unref(m)));
+        ASSERT_NULL(m = sd_netlink_message_unref(m));
         (void) sd_genl_message_new(genl, NL80211_GENL_NAME, 0, &m);
-        ASSERT_NULL((m = sd_netlink_message_unref(m)));
+        ASSERT_NULL(m = sd_netlink_message_unref(m));
         (void) sd_genl_message_new(genl, NETLBL_NLTYPE_UNLABELED_NAME, 0, &m);
 
         for (;;) {
-                ASSERT_OK((r = sd_event_run(event, 500 * USEC_PER_MSEC)));
+                ASSERT_OK(r = sd_event_run(event, 500 * USEC_PER_MSEC));
                 if (r == 0)
                         return;
         }
@@ -636,8 +636,8 @@ TEST(rtnl_set_link_name) {
                 return (void) log_tests_skipped("dummy network interface is not supported");
         ASSERT_OK(r);
 
-        ASSERT_NULL((message = sd_netlink_message_unref(message)));
-        ASSERT_NULL((reply = sd_netlink_message_unref(reply)));
+        ASSERT_NULL(message = sd_netlink_message_unref(message));
+        ASSERT_NULL(reply = sd_netlink_message_unref(reply));
 
         ASSERT_OK(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, 0));
         ASSERT_OK(sd_netlink_message_append_string(message, IFLA_IFNAME, "test-netlink"));
@@ -664,7 +664,7 @@ TEST(rtnl_set_link_name) {
         ASSERT_ERROR(rtnl_set_link_name(&rtnl, ifindex, "testlongalternativename", NULL), EINVAL);
         ASSERT_OK(rtnl_set_link_name(&rtnl, ifindex, "test-shortname", STRV_MAKE("testlongalternativename", "test-shortname", "test-additional-name")));
 
-        ASSERT_NULL((alternative_names = strv_free(alternative_names)));
+        ASSERT_NULL(alternative_names = strv_free(alternative_names));
         ASSERT_OK(rtnl_get_link_alternative_names(&rtnl, ifindex, &alternative_names));
         ASSERT_TRUE(strv_contains(alternative_names, "testlongalternativename"));
         ASSERT_TRUE(strv_contains(alternative_names, "test-additional-name"));
@@ -672,7 +672,7 @@ TEST(rtnl_set_link_name) {
 
         ASSERT_OK(rtnl_delete_link_alternative_names(&rtnl, ifindex, STRV_MAKE("testlongalternativename")));
 
-        ASSERT_NULL((alternative_names = strv_free(alternative_names)));
+        ASSERT_NULL(alternative_names = strv_free(alternative_names));
         ASSERT_OK_EQ(rtnl_get_link_alternative_names(&rtnl, ifindex, &alternative_names), ifindex);
         ASSERT_FALSE(strv_contains(alternative_names, "testlongalternativename"));
         ASSERT_TRUE(strv_contains(alternative_names, "test-additional-name"));
@@ -682,7 +682,7 @@ TEST(rtnl_set_link_name) {
         ASSERT_OK_EQ(rtnl_resolve_link_alternative_name(&rtnl, "test-additional-name", NULL), ifindex);
         ASSERT_OK_EQ(rtnl_resolve_link_alternative_name(&rtnl, "test-additional-name", &resolved), ifindex);
         ASSERT_STREQ(resolved, "test-shortname");
-        ASSERT_NULL((resolved = mfree(resolved)));
+        ASSERT_NULL(resolved = mfree(resolved));
 
         ASSERT_OK(rtnl_rename_link(&rtnl, "test-shortname", "test-shortname"));
         ASSERT_OK(rtnl_rename_link(&rtnl, "test-shortname", "test-shortname2"));
@@ -691,12 +691,12 @@ TEST(rtnl_set_link_name) {
         ASSERT_OK_EQ(rtnl_resolve_link_alternative_name(&rtnl, "test-additional-name", NULL), ifindex);
         ASSERT_OK_EQ(rtnl_resolve_link_alternative_name(&rtnl, "test-additional-name", &resolved), ifindex);
         ASSERT_STREQ(resolved, "test-shortname3");
-        ASSERT_NULL((resolved = mfree(resolved)));
+        ASSERT_NULL(resolved = mfree(resolved));
 
         ASSERT_OK_EQ(rtnl_resolve_link_alternative_name(&rtnl, "test-shortname3", NULL), ifindex);
         ASSERT_OK_EQ(rtnl_resolve_link_alternative_name(&rtnl, "test-shortname3", &resolved), ifindex);
         ASSERT_STREQ(resolved, "test-shortname3");
-        ASSERT_NULL((resolved = mfree(resolved)));
+        ASSERT_NULL(resolved = mfree(resolved));
 }
 
 DEFINE_TEST_MAIN(LOG_DEBUG);

diff --git a/src/locale/test-localed-util.c b/src/locale/test-localed-util.c
index f700642cc58e39a951baec76f7c7feb3a6adba2f..d6221edbafe54f9fd4956701911aa1e1dc4b5e9e 100644 (file)
--- a/src/locale/test-localed-util.c
+++ b/src/locale/test-localed-util.c
@@ -33,10 +33,10 @@ TEST(find_converted_keymap) {
                         }, &ans));
         ASSERT_NULL(ans);
 
-        ASSERT_OK((r = find_converted_keymap(
+        ASSERT_OK(r = find_converted_keymap(
                         &(X11Context) {
                                 .layout  = (char*) "pl",
-                        }, &ans)));
+                        }, &ans));
         if (r == 0)
                 return (void) log_tests_skipped("keymaps are not installed");
 
@@ -115,7 +115,7 @@ TEST(vconsole_convert_to_x11) {
         /* "gh" has no mapping in kbd-model-map and kbd provides a converted keymap for this layout. */
         log_info("/* test with a converted keymap (gh:) */");
         ASSERT_OK(free_and_strdup(&vc.keymap, "gh"));
-        ASSERT_OK((r = vconsole_convert_to_x11(&vc, x11_context_verify, &xc)));
+        ASSERT_OK(r = vconsole_convert_to_x11(&vc, x11_context_verify, &xc));
         if (r == 0)
                 return (void) log_tests_skipped("keymaps are not installed");
 

diff --git a/src/test/test-acl-util.c b/src/test/test-acl-util.c
index f7e0f5ca4d41b77376a44a879f3799516e7f256a..bd68f58baeb8d68a281f73d563b5a6d19ee3cec7 100644 (file)
--- a/src/test/test-acl-util.c
+++ b/src/test/test-acl-util.c
@@ -29,7 +29,7 @@ TEST_RET(add_acls_for_user) {
                         return log_tests_skipped_errno(r, "Could not find %s binary: %m", s);
         }
 
-        ASSERT_OK((fd = mkostemp_safe(fn)));
+        ASSERT_OK(fd = mkostemp_safe(fn));
 
         /* Use the mode that user journal files use */
         ASSERT_OK_ZERO_ERRNO(fchmod(fd, 0640));
@@ -86,7 +86,7 @@ TEST_RET(fd_acl_make_read_only) {
                         return log_tests_skipped_errno(r, "Could not find %s binary: %m", s);
         }
 
-        ASSERT_OK((fd = mkostemp_safe(fn)));
+        ASSERT_OK(fd = mkostemp_safe(fn));
 
         /* make it more exciting */
         (void) fd_add_uid_acl_permission(fd, 1, ACL_READ|ACL_WRITE|ACL_EXECUTE);

diff --git a/src/test/test-calendarspec.c b/src/test/test-calendarspec.c
index 0fc3a43a23b7e340196d09f09269150899dbde4b..005d9b0771bd1e5c7e32b0e52de8f5f1fb2bd547 100644 (file)
--- a/src/test/test-calendarspec.c
+++ b/src/test/test-calendarspec.c
@@ -97,7 +97,7 @@ TEST(hourly_bug_4031) {
 
         ASSERT_OK(calendar_spec_from_string("hourly", &c));
         n = now(CLOCK_REALTIME);
-        ASSERT_OK((r = calendar_spec_next_usec(c, n, &u)));
+        ASSERT_OK(r = calendar_spec_next_usec(c, n, &u));
 
         log_info("Now: %s (%"PRIu64")", FORMAT_TIMESTAMP_STYLE(n, TIMESTAMP_US), n);
         log_info("Next hourly: %s (%"PRIu64")", r < 0 ? STRERROR(r) : FORMAT_TIMESTAMP_STYLE(u, TIMESTAMP_US), u);

diff --git a/src/test/test-chase.c b/src/test/test-chase.c
index 16f470a08ea70c44ebe1c375f51c7abba5995ba3..09baae64fd0caf8e41679ca8c612a96c91ce6b89 100644 (file)
--- a/src/test/test-chase.c
+++ b/src/test/test-chase.c
@@ -468,7 +468,7 @@ TEST(chaseat) {
         struct stat st;
         const char *p;
 
-        ASSERT_OK((tfd = mkdtemp_open(NULL, 0, &t)));
+        ASSERT_OK(tfd = mkdtemp_open(NULL, 0, &t));
 
         /* Test that AT_FDCWD with CHASE_AT_RESOLVE_IN_ROOT resolves against / and not the current working
          * directory. */
@@ -520,7 +520,7 @@ TEST(chaseat) {
         /* Test that absolute path or not are the same when resolving relative to a directory file
          * descriptor and that we always get a relative path back. */
 
-        ASSERT_OK((fd = openat(tfd, "def", O_CREAT|O_CLOEXEC, 0700)));
+        ASSERT_OK(fd = openat(tfd, "def", O_CREAT|O_CLOEXEC, 0700));
         fd = safe_close(fd);
         ASSERT_OK(symlinkat("/def", tfd, "qed"));
         ASSERT_OK(chaseat(tfd, "qed", CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
@@ -536,7 +536,7 @@ TEST(chaseat) {
 
         /* Test CHASE_PARENT */
 
-        ASSERT_OK((fd = open_mkdir_at(tfd, "chase", O_CLOEXEC, 0755)));
+        ASSERT_OK(fd = open_mkdir_at(tfd, "chase", O_CLOEXEC, 0755));
         ASSERT_OK(symlinkat("/def", fd, "parent"));
         fd = safe_close(fd);
 
@@ -668,24 +668,24 @@ TEST(chaseat) {
 
         /* Test chase_and_open_parent_at() */
 
-        ASSERT_OK((fd = chase_and_open_parent_at(tfd, "chase/parent", CHASE_AT_RESOLVE_IN_ROOT|CHASE_NOFOLLOW, &result)));
+        ASSERT_OK(fd = chase_and_open_parent_at(tfd, "chase/parent", CHASE_AT_RESOLVE_IN_ROOT|CHASE_NOFOLLOW, &result));
         ASSERT_OK(faccessat(fd, result, F_OK, AT_SYMLINK_NOFOLLOW));
         ASSERT_STREQ(result, "parent");
         fd = safe_close(fd);
         result = mfree(result);
 
-        ASSERT_OK((fd = chase_and_open_parent_at(tfd, "chase", CHASE_AT_RESOLVE_IN_ROOT, &result)));
+        ASSERT_OK(fd = chase_and_open_parent_at(tfd, "chase", CHASE_AT_RESOLVE_IN_ROOT, &result));
         ASSERT_OK(faccessat(fd, result, F_OK, 0));
         ASSERT_STREQ(result, "chase");
         fd = safe_close(fd);
         result = mfree(result);
 
-        ASSERT_OK((fd = chase_and_open_parent_at(tfd, "/", CHASE_AT_RESOLVE_IN_ROOT, &result)));
+        ASSERT_OK(fd = chase_and_open_parent_at(tfd, "/", CHASE_AT_RESOLVE_IN_ROOT, &result));
         ASSERT_STREQ(result, ".");
         fd = safe_close(fd);
         result = mfree(result);
 
-        ASSERT_OK((fd = chase_and_open_parent_at(tfd, ".", CHASE_AT_RESOLVE_IN_ROOT, &result)));
+        ASSERT_OK(fd = chase_and_open_parent_at(tfd, ".", CHASE_AT_RESOLVE_IN_ROOT, &result));
         ASSERT_STREQ(result, ".");
         fd = safe_close(fd);
         result = mfree(result);

diff --git a/src/test/test-compress.c b/src/test/test-compress.c
index 9688e10df4a35cb4a542e20e6f2b4d94313f8ddc..b9ef3644e1c79a4a4ae59799d6dd346446462781 100644 (file)
--- a/src/test/test-compress.c
+++ b/src/test/test-compress.c
@@ -188,7 +188,7 @@ _unused_ static void test_compress_stream(const char *compression,
 
         log_debug("/* create source from %s */", srcfile);
 
-        ASSERT_OK((src = open(srcfile, O_RDONLY|O_CLOEXEC)));
+        ASSERT_OK(src = open(srcfile, O_RDONLY|O_CLOEXEC));
 
         log_debug("/* test compression */");
 

diff --git a/src/test/test-condition.c b/src/test/test-condition.c
index be5fe67879e879342240905b29f5c4eb8fe06639..9334a8ca89ab3dbb853eff5dee9c4e874be1f1e9 100644 (file)
--- a/src/test/test-condition.c
+++ b/src/test/test-condition.c
@@ -250,7 +250,7 @@ TEST(condition_test_architecture) {
         const char *sa;
         Architecture a;
 
-        ASSERT_OK((a = uname_architecture()));
+        ASSERT_OK(a = uname_architecture());
         ASSERT_NOT_NULL((sa = architecture_to_string(a)));
 
         ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, sa, false, false)));

diff --git a/src/test/test-conf-parser.c b/src/test/test-conf-parser.c
index 233f58b90e196521fb25d1c905740122d0d7a726..a4309c0134f2f4af7aec28b3dcefeb17cb8cae2a 100644 (file)
--- a/src/test/test-conf-parser.c
+++ b/src/test/test-conf-parser.c
@@ -409,7 +409,7 @@ TEST(config_parse_standard_file_with_dropins_full) {
         _cleanup_close_ int rfd = -EBADF;
         int r;
 
-        ASSERT_OK((rfd = mkdtemp_open("/tmp/test-config-parse-XXXXXX", 0, &root)));
+        ASSERT_OK(rfd = mkdtemp_open("/tmp/test-config-parse-XXXXXX", 0, &root));
         assert_se(mkdir_p_root(root, "/etc/kernel/install.conf.d", UID_INVALID, GID_INVALID, 0755));
         assert_se(mkdir_p_root(root, "/run/kernel/install.conf.d", UID_INVALID, GID_INVALID, 0755));
         assert_se(mkdir_p_root(root, "/usr/lib/kernel/install.conf.d", UID_INVALID, GID_INVALID, 0755));

diff --git a/src/test/test-dev-setup.c b/src/test/test-dev-setup.c
index bdf562584c27fa0a69d707e9b6a59241578a4f03..dd6b30079a991f9c8bf0db474632385e8d42ce3d 100644 (file)
--- a/src/test/test-dev-setup.c
+++ b/src/test/test-dev-setup.c
@@ -30,29 +30,29 @@ int main(int argc, char *argv[]) {
         f = prefix_roota(p, "/run/systemd/inaccessible/reg");
         ASSERT_OK_ERRNO(stat(f, &st));
         ASSERT_TRUE(S_ISREG(st.st_mode));
-        ASSERT_EQ((st.st_mode & 07777), 0000U);
+        ASSERT_EQ(st.st_mode & 07777, 0000U);
 
         f = prefix_roota(p, "/run/systemd/inaccessible/dir");
         ASSERT_OK_ERRNO(stat(f, &st));
         ASSERT_TRUE(S_ISDIR(st.st_mode));
-        ASSERT_EQ((st.st_mode & 07777), 0000U);
+        ASSERT_EQ(st.st_mode & 07777, 0000U);
 
         f = prefix_roota(p, "/run/systemd/inaccessible/fifo");
         ASSERT_OK_ERRNO(stat(f, &st));
         ASSERT_TRUE(S_ISFIFO(st.st_mode));
-        ASSERT_EQ((st.st_mode & 07777), 0000U);
+        ASSERT_EQ(st.st_mode & 07777, 0000U);
 
         f = prefix_roota(p, "/run/systemd/inaccessible/sock");
         ASSERT_OK_ERRNO(stat(f, &st));
         ASSERT_TRUE(S_ISSOCK(st.st_mode));
-        ASSERT_EQ((st.st_mode & 07777), 0000U);
+        ASSERT_EQ(st.st_mode & 07777, 0000U);
 
         f = prefix_roota(p, "/run/systemd/inaccessible/chr");
         if (stat(f, &st) < 0)
                 ASSERT_EQ(errno, ENOENT);
         else {
                 ASSERT_TRUE(S_ISCHR(st.st_mode));
-                ASSERT_EQ((st.st_mode & 07777), 0000U);
+                ASSERT_EQ(st.st_mode & 07777, 0000U);
         }
 
         f = prefix_roota(p, "/run/systemd/inaccessible/blk");
@@ -60,7 +60,7 @@ int main(int argc, char *argv[]) {
                 ASSERT_EQ(errno, ENOENT);
         else {
                 ASSERT_TRUE(S_ISBLK(st.st_mode));
-                ASSERT_EQ((st.st_mode & 07777), 0000U);
+                ASSERT_EQ(st.st_mode & 07777, 0000U);
         }
 
         return EXIT_SUCCESS;

diff --git a/src/test/test-fs-util.c b/src/test/test-fs-util.c
index 3becf8f9ab7fa51b774ac8290d7e331fcc1aae40..0670bb7f8e40c7f8890f9b4f37a2e601412597b7 100644 (file)
--- a/src/test/test-fs-util.c
+++ b/src/test/test-fs-util.c
@@ -610,7 +610,7 @@ TEST(openat_report_new) {
         _cleanup_close_ int tfd = -EBADF, fd = -EBADF;
         bool b;
 
-        ASSERT_OK((tfd = mkdtemp_open(NULL, 0, &t)));
+        ASSERT_OK(tfd = mkdtemp_open(NULL, 0, &t));
 
         fd = openat_report_new(tfd, "test", O_RDWR|O_CREAT, 0666, &b);
         ASSERT_OK(fd);

diff --git a/src/test/test-hostname-setup.c b/src/test/test-hostname-setup.c
index 8243d600e182854112f192b0b923498e89b34510..9348313984eb46a5f71a21957264df913ebabd81 100644 (file)
--- a/src/test/test-hostname-setup.c
+++ b/src/test/test-hostname-setup.c
@@ -87,19 +87,19 @@ TEST(hostname_substitute_wildcards) {
         ASSERT_NOT_NULL((buf = strdup("")));
         ASSERT_OK(hostname_substitute_wildcards(buf));
         ASSERT_STREQ(buf, "");
-        ASSERT_NULL((buf = mfree(buf)));
+        ASSERT_NULL(buf = mfree(buf));
 
         ASSERT_NOT_NULL((buf = strdup("hogehoge")));
         ASSERT_OK(hostname_substitute_wildcards(buf));
         ASSERT_STREQ(buf, "hogehoge");
-        ASSERT_NULL((buf = mfree(buf)));
+        ASSERT_NULL(buf = mfree(buf));
 
         ASSERT_NOT_NULL((buf = strdup("hoge??hoge??foo?")));
         ASSERT_OK(hostname_substitute_wildcards(buf));
         log_debug("hostname_substitute_wildcards(\"hoge??hoge??foo?\"): → \"%s\"", buf);
         ASSERT_EQ(fnmatch("hoge??hoge??foo?", buf, /* flags= */ 0), 0);
         ASSERT_TRUE(hostname_is_valid(buf, /* flags= */ 0));
-        ASSERT_NULL((buf = mfree(buf)));
+        ASSERT_NULL(buf = mfree(buf));
 }
 
 TEST(hostname_setup) {

diff --git a/src/test/test-json.c b/src/test/test-json.c
index 5cbcf9f68f1efabbc4572d1e5d90b28303ee1c75..8dd5746495ee64a5801fd1418408032f1f6a4116 100644 (file)
--- a/src/test/test-json.c
+++ b/src/test/test-json.c
@@ -1366,7 +1366,7 @@ TEST(fd_info) {
         fd = safe_close(fd);
 
         /* regular file */
-        ASSERT_OK((fd = open_tmpfile_unlinkable(NULL, O_RDWR)));
+        ASSERT_OK(fd = open_tmpfile_unlinkable(NULL, O_RDWR));
         ASSERT_OK(json_variant_new_fd_info(&v, fd));
         ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
         v = sd_json_variant_unref(v);

diff --git a/src/test/test-mount-util.c b/src/test/test-mount-util.c
index ccaaacc812d7d6f14ded94180835746313c74a4f..ce6a43101e540acf93c2157b1d3633d1d138e1f2 100644 (file)
--- a/src/test/test-mount-util.c
+++ b/src/test/test-mount-util.c
@@ -540,7 +540,7 @@ TEST(path_is_network_fs_harder) {
         _cleanup_close_ int dir_fd = -EBADF;
         int r;
 
-        ASSERT_OK((dir_fd = open("/", O_PATH | O_CLOEXEC)));
+        ASSERT_OK(dir_fd = open("/", O_PATH | O_CLOEXEC));
         FOREACH_STRING(s,
                        "/", "/dev/", "/proc/", "/run/", "/sys/", "/tmp/", "/usr/", "/var/tmp/",
                        "", ".", "../../../", "/this/path/should/not/exist/for/test-mount-util/") {

diff --git a/src/test/test-namespace.c b/src/test/test-namespace.c
index 25393baf73f1f60816bcdf5e5305d3015dd91dc9..cae65a14b107c7319c72c2084d3902a081a11999 100644 (file)
--- a/src/test/test-namespace.c
+++ b/src/test/test-namespace.c
@@ -184,11 +184,11 @@ TEST(fd_is_namespace) {
         ASSERT_OK_ZERO(fd_is_namespace(fd, NAMESPACE_NET));
         fd = safe_close(fd);
 
-        ASSERT_OK((fd = namespace_open_by_type(NAMESPACE_IPC)));
+        ASSERT_OK(fd = namespace_open_by_type(NAMESPACE_IPC));
         ASSERT_OK_POSITIVE(fd_is_namespace(fd, NAMESPACE_IPC));
         fd = safe_close(fd);
 
-        ASSERT_OK((fd = namespace_open_by_type(NAMESPACE_NET)));
+        ASSERT_OK(fd = namespace_open_by_type(NAMESPACE_NET));
         ASSERT_OK_POSITIVE(fd_is_namespace(fd, NAMESPACE_NET));
 }
 

diff --git a/src/test/test-netlink-manual.c b/src/test/test-netlink-manual.c
index 913998ad50f4d102cf5efd55134e621450fd1c0c..d12eee42cb6e49a5c57268d117e4556e0d258aff 100644 (file)
--- a/src/test/test-netlink-manual.c
+++ b/src/test/test-netlink-manual.c
@@ -84,7 +84,7 @@ static int test_tunnel_configure(sd_netlink *rtnl) {
 
         ASSERT_OK_POSITIVE(sd_netlink_call(rtnl, m, -1, NULL));
 
-        ASSERT_NULL((m = sd_netlink_message_unref(m)));
+        ASSERT_NULL(m = sd_netlink_message_unref(m));
 
         /* sit */
         assert_se(sd_rtnl_message_new_link(rtnl, &n, RTM_NEWLINK, 0) >= 0);
@@ -110,7 +110,7 @@ static int test_tunnel_configure(sd_netlink *rtnl) {
 
         ASSERT_OK_POSITIVE(sd_netlink_call(rtnl, n, -1, NULL));
 
-        ASSERT_NULL((n = sd_netlink_message_unref(n)));
+        ASSERT_NULL(n = sd_netlink_message_unref(n));
 
         return EXIT_SUCCESS;
 }
@@ -126,7 +126,7 @@ int main(int argc, char *argv[]) {
 
         r = test_tunnel_configure(rtnl);
 
-        ASSERT_NULL((rtnl = sd_netlink_unref(rtnl)));
+        ASSERT_NULL(rtnl = sd_netlink_unref(rtnl));
 
         return r;
 }

diff --git a/src/test/test-terminal-util.c b/src/test/test-terminal-util.c
index f454d3ea60ad668ae8bb85f2e1770f4f8f00d415..a5616c81212f5ff70c7949d39bd9d06123b55e83 100644 (file)
--- a/src/test/test-terminal-util.c
+++ b/src/test/test-terminal-util.c
@@ -319,8 +319,8 @@ TEST(terminal_new_session) {
         _cleanup_close_ int pty_fd = -EBADF, peer_fd = -EBADF;
         int r;
 
-        ASSERT_OK((pty_fd = openpt_allocate(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK, NULL)));
-        ASSERT_OK((peer_fd = pty_open_peer(pty_fd, O_RDWR|O_NOCTTY|O_CLOEXEC)));
+        ASSERT_OK(pty_fd = openpt_allocate(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK, NULL));
+        ASSERT_OK(peer_fd = pty_open_peer(pty_fd, O_RDWR|O_NOCTTY|O_CLOEXEC));
 
         r = safe_fork_full("test-term-session",
                            (int[]) { peer_fd, peer_fd, peer_fd },

diff --git a/src/test/test-unit-file.c b/src/test/test-unit-file.c
index 1561265a3e4568e4de52760628cacd15ccb16fee..c7779237b549208f87b2f1f62d534c1253face9e 100644 (file)
--- a/src/test/test-unit-file.c
+++ b/src/test/test-unit-file.c
@@ -122,7 +122,7 @@ static bool test_unit_file_remove_from_name_map_trail(const LookupPaths *lp, siz
 
         ASSERT_OK_ERRNO(unlink(path));
 
-        ASSERT_OK((r = unit_file_remove_from_name_map(lp, &cache_timestamp_hash, &unit_ids, &unit_names, &path_cache, path)));
+        ASSERT_OK(r = unit_file_remove_from_name_map(lp, &cache_timestamp_hash, &unit_ids, &unit_names, &path_cache, path));
         if (r > 0)
                 return false; /* someone touches unit files. Retrying. */
 

diff --git a/src/test/test-user-util.c b/src/test/test-user-util.c
index 0255c5775a958f95016ac549afac02430cd0504f..bf8dd16d5ba66f5b64534093841bb26c59af074c 100644 (file)
--- a/src/test/test-user-util.c
+++ b/src/test/test-user-util.c
@@ -444,7 +444,7 @@ TEST(gid_lists_ops) {
         assert_se(nresult >= 0);
         assert_se(memcmp_nn(result2, ELEMENTSOF(result2), res4, nresult) == 0);
 
-        ASSERT_OK((nresult = getgroups_alloc(&gids)));
+        ASSERT_OK(nresult = getgroups_alloc(&gids));
         assert_se(gids || nresult == 0);
 }