test: wrap assignments in ASSERT_OK() and friends with parentheses

Hopefully fixes many CID reports.

diff --git a/src/libsystemd/sd-device/test-sd-device-monitor.c b/src/libsystemd/sd-device/test-sd-device-monitor.c
index 1cdeabbf21e5016999cb4590a73d8815c93b1a8a..01681792ca3408427c91ce4de17b28766fae4921 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-event/test-event.c b/src/libsystemd/sd-event/test-event.c
index 6394507994fba68b8797f0ec7d8bdd84ac70e376..79a3d30356f6a2b5e0a93d33471f448394069a58 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 f9b755a8ce356c3c5d7bfd63bfdfba0163356586..80bb436ea57923aebf1885ec3f14d75a0836e98e 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal-interleaving.c
+++ b/src/libsystemd/sd-journal/test-journal-interleaving.c
@@ -28,7 +28,7 @@ static JournalFile* test_open_internal(const char *name, JournalFileFlags flags)
         _cleanup_(mmap_cache_unrefp) MMapCache *m = NULL;
         JournalFile *f;
 
-        ASSERT_NOT_NULL(m = mmap_cache_new());
+        ASSERT_NOT_NULL((m = mmap_cache_new()));
         ASSERT_OK(journal_file_open(-EBADF, name, O_RDWR|O_CREAT, flags, 0644, UINT64_MAX, NULL, m, NULL, &f));
         return f;
 }
@@ -80,11 +80,11 @@ static void append_number(JournalFile *f, unsigned n, const sd_id128_t *boot_id,
         ASSERT_OK(asprintf(&p, "NUMBER=%u", n));
         iovec[n_iov++] = IOVEC_MAKE_STRING(p);
 
-        ASSERT_NOT_NULL(s = strjoin("LESS_THAN_FIVE=", yes_no(n < 5)));
+        ASSERT_NOT_NULL((s = strjoin("LESS_THAN_FIVE=", yes_no(n < 5))));
         iovec[n_iov++] = IOVEC_MAKE_STRING(s);
 
         if (boot_id) {
-                ASSERT_NOT_NULL(q = strjoin("_BOOT_ID=", SD_ID128_TO_STRING(*boot_id)));
+                ASSERT_NOT_NULL((q = strjoin("_BOOT_ID=", SD_ID128_TO_STRING(*boot_id))));
                 iovec[n_iov++] = IOVEC_MAKE_STRING(q);
         }
 
@@ -101,7 +101,7 @@ static void append_unreferenced_data(JournalFile *f, const sd_id128_t *boot_id)
         ts.monotonic = usec_sub_unsigned(previous_ts.monotonic, 10);
         ts.realtime = usec_sub_unsigned(previous_ts.realtime, 10);
 
-        ASSERT_NOT_NULL(q = strjoin("_BOOT_ID=", SD_ID128_TO_STRING(*boot_id)));
+        ASSERT_NOT_NULL((q = strjoin("_BOOT_ID=", SD_ID128_TO_STRING(*boot_id))));
         iovec = IOVEC_MAKE_STRING(q);
 
         ASSERT_ERROR(journal_file_append_entry(f, &ts, boot_id, &iovec, 1, NULL, NULL, NULL, NULL), EREMCHG);
@@ -116,7 +116,7 @@ static void test_check_number(sd_journal *j, unsigned expected) {
         ASSERT_OK(sd_journal_get_data(j, "NUMBER", &d, &l));
 
         _cleanup_free_ char *k = NULL;
-        ASSERT_NOT_NULL(k = strndup(d, l));
+        ASSERT_NOT_NULL((k = strndup(d, l)));
         printf("%s %s (expected=%u)\n", SD_ID128_TO_STRING(boot_id), k, expected);
 
         unsigned x;
@@ -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;
 
@@ -508,7 +508,7 @@ static void test_sequence_numbers_one(void) {
         uint64_t seqnum = 0;
         sd_id128_t seqnum_id;
 
-        ASSERT_NOT_NULL(m = mmap_cache_new());
+        ASSERT_NOT_NULL((m = mmap_cache_new()));
 
         mkdtemp_chdir_chattr("/var/tmp/journal-seq-XXXXXX", &t);
 
@@ -831,15 +831,15 @@ static void test_generic_array_bisect_one(size_t n, size_t num_corrupted) {
 
         log_info("/* %s(%zu, %zu) */", __func__, n, num_corrupted);
 
-        ASSERT_NOT_NULL(m = mmap_cache_new());
+        ASSERT_NOT_NULL((m = mmap_cache_new()));
 
         mkdtemp_chdir_chattr("/var/tmp/journal-seq-XXXXXX", &t);
 
         ASSERT_OK(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0644,
                                     UINT64_MAX, NULL, m, NULL, &f));
 
-        ASSERT_NOT_NULL(seqnum = new0(uint64_t, n));
-        ASSERT_NOT_NULL(offset = new0(uint64_t, n));
+        ASSERT_NOT_NULL((seqnum = new0(uint64_t, n)));
+        ASSERT_NOT_NULL((offset = new0(uint64_t, n)));
 
         for (size_t i = 0; i < n; i++) {
                 append_number(f, i, NULL, seqnum + i, offset + i);
@@ -847,7 +847,7 @@ static void test_generic_array_bisect_one(size_t n, size_t num_corrupted) {
                 ASSERT_GT(offset[i], i == 0 ? 0 : offset[i-1]);
         }
 
-        ASSERT_NOT_NULL(offset_candidates = newdup(uint64_t, offset, n));
+        ASSERT_NOT_NULL((offset_candidates = newdup(uint64_t, offset, n)));
 
         verify(f, seqnum, offset_candidates, offset, n);
 
@@ -1003,7 +1003,7 @@ static void verify_entry(sd_journal *j, const TestEntry *entry) {
         ASSERT_EQ(t, entry->ts.realtime);
 
         ASSERT_OK(sd_journal_get_data(j, "NUMBER", &d, &l));
-        ASSERT_NOT_NULL(s = strndup(d, l));
+        ASSERT_NOT_NULL((s = strndup(d, l)));
         ASSERT_OK(asprintf(&e, "NUMBER=%u", entry->number));
         ASSERT_STREQ(s, e);
 
@@ -1011,7 +1011,7 @@ static void verify_entry(sd_journal *j, const TestEntry *entry) {
         e = mfree(e);
 
         ASSERT_OK(sd_journal_get_data(j, "DATA", &d, &l));
-        ASSERT_NOT_NULL(s = strndup(d, l));
+        ASSERT_NOT_NULL((s = strndup(d, l)));
         ASSERT_OK(asprintf(&e, "DATA=%u", entry->data));
         ASSERT_STREQ(s, e);
 }
@@ -1188,7 +1188,7 @@ TEST(seek_time) {
 
         mkdtemp_chdir_chattr("/var/tmp/journal-seek-time-XXXXXX", &t);
 
-        ASSERT_NOT_NULL(m = mmap_cache_new());
+        ASSERT_NOT_NULL((m = mmap_cache_new()));
 
         ASSERT_OK(journal_file_open(
                                   -EBADF,

diff --git a/src/network/generator/test-network-generator.c b/src/network/generator/test-network-generator.c
index 92118907b7e02c3cae3fc3ac5a2577d0d8461ae8..dec84abc8f12ee6eeb420f4ac1c9eb0c9cef3135 100644 (file)
--- a/src/network/generator/test-network-generator.c
+++ b/src/network/generator/test-network-generator.c
@@ -13,7 +13,7 @@ static void test_network_one(const char *ifname, const char *key, const char *va
         log_debug("/* %s(%s=%s) */", __func__, key, value);
 
         ASSERT_OK(parse_cmdline_item(key, value, &context));
-        ASSERT_NOT_NULL(network = network_get(&context, ifname));
+        ASSERT_NOT_NULL((network = network_get(&context, ifname)));
         ASSERT_OK(network_format(network, &output));
         ASSERT_STREQ(output, expected);
 }
@@ -31,7 +31,7 @@ static void test_network_two(const char *ifname,
         ASSERT_OK(parse_cmdline_item(key1, value1, &context));
         ASSERT_OK(parse_cmdline_item(key2, value2, &context));
         ASSERT_OK(context_merge_networks(&context));
-        ASSERT_NOT_NULL(network = network_get(&context, ifname));
+        ASSERT_NOT_NULL((network = network_get(&context, ifname)));
         ASSERT_OK(network_format(network, &output));
         ASSERT_STREQ(output, expected);
 }
@@ -44,7 +44,7 @@ static void test_netdev_one(const char *ifname, const char *key, const char *val
         log_debug("/* %s(%s=%s) */", __func__, key, value);
 
         ASSERT_OK(parse_cmdline_item(key, value, &context));
-        ASSERT_NOT_NULL(netdev = netdev_get(&context, ifname));
+        ASSERT_NOT_NULL((netdev = netdev_get(&context, ifname)));
         ASSERT_OK(netdev_format(netdev, &output));
         ASSERT_STREQ(output, expected);
 }
@@ -57,7 +57,7 @@ static void test_link_one(const char *filename, const char *key, const char *val
         log_debug("/* %s(%s=%s) */", __func__, key, value);
 
         ASSERT_OK(parse_cmdline_item(key, value, &context));
-        ASSERT_NOT_NULL(link = link_get(&context, filename));
+        ASSERT_NOT_NULL((link = link_get(&context, filename)));
         ASSERT_OK(link_format(link, &output));
         ASSERT_STREQ(output, expected);
 }

diff --git a/src/network/test-networkd-conf.c b/src/network/test-networkd-conf.c
index f44383d03ab4fa48509ca9ca902b22f0795a0e96..032c2e75dc749077fb89493e6449048337a97793 100644 (file)
--- a/src/network/test-networkd-conf.c
+++ b/src/network/test-networkd-conf.c
@@ -66,7 +66,7 @@ static void test_config_parse_ether_addrs_one(const char *rvalue, const struct e
         for (size_t m = 0; m < n; m++) {
                 _cleanup_free_ struct ether_addr *q = NULL;
 
-                ASSERT_NOT_NULL(q = set_remove(s, &list[m]));
+                ASSERT_NOT_NULL((q = set_remove(s, &list[m])));
         }
 
         ASSERT_TRUE(set_isempty(s));

diff --git a/src/shutdown/test-umount.c b/src/shutdown/test-umount.c
index fe30d9a2fe84abba626599927055bb3d36cdd665..1de1fe8e1112a97121550da71b724e4655e118d0 100644 (file)
--- a/src/shutdown/test-umount.c
+++ b/src/shutdown/test-umount.c
@@ -19,7 +19,7 @@ static void test_mount_points_list_one(const char *fname) {
         if (fname) {
                 _cleanup_free_ char *testdata_fname = NULL;
                 assert_se(get_testdata_dir(fname, &testdata_fname) >= 0);
-                ASSERT_NOT_NULL(f = fopen(testdata_fname, "re"));
+                ASSERT_NOT_NULL((f = fopen(testdata_fname, "re")));
         }
 
         LIST_HEAD_INIT(mp_list_head);

diff --git a/src/test/test-acl-util.c b/src/test/test-acl-util.c
index bd68f58baeb8d68a281f73d563b5a6d19ee3cec7..f7e0f5ca4d41b77376a44a879f3799516e7f256a 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-bpf-restrict-fs.c b/src/test/test-bpf-restrict-fs.c
index 349c5a6894b3a5f01180d25f10b7c254da337fb1..31fdd7f0e2b2a9fa55ff6b2536803a2db26cb6dd 100644 (file)
--- a/src/test/test-bpf-restrict-fs.c
+++ b/src/test/test-bpf-restrict-fs.c
@@ -18,9 +18,9 @@ static int test_restrict_filesystems(Manager *m, const char *unit_name, const ch
         ExecContext *ec = NULL;
         int cld_code, r;
 
-        ASSERT_NOT_NULL(u = unit_new(m, sizeof(Service)));
+        ASSERT_NOT_NULL((u = unit_new(m, sizeof(Service))));
         ASSERT_OK_ZERO(unit_add_name(u, unit_name));
-        ASSERT_NOT_NULL(ec = unit_get_exec_context(u));
+        ASSERT_NOT_NULL((ec = unit_get_exec_context(u)));
 
         STRV_FOREACH(allow_filesystem, allowed_filesystems) {
                 r = config_parse_restrict_filesystems(
@@ -30,7 +30,7 @@ static int test_restrict_filesystems(Manager *m, const char *unit_name, const ch
                         return log_unit_error_errno(u, r, "Failed to parse RestrictFileSystems: %m");
         }
 
-        ASSERT_NOT_NULL(exec_start = strjoin("cat ", file_path));
+        ASSERT_NOT_NULL((exec_start = strjoin("cat ", file_path)));
         r = config_parse_exec(u->id, "filename", 1, "Service", 1, "ExecStart",
                         SERVICE_EXEC_START, exec_start, SERVICE(u)->exec_command, u);
         if (r < 0)
@@ -84,7 +84,7 @@ int main(int argc, char *argv[]) {
 
         ASSERT_OK(get_testdata_dir("units", &unit_dir));
         ASSERT_OK(setenv_unit_path(unit_dir));
-        ASSERT_NOT_NULL(runtime_dir = setup_fake_runtime_dir());
+        ASSERT_NOT_NULL((runtime_dir = setup_fake_runtime_dir()));
 
         ASSERT_OK(manager_new(RUNTIME_SCOPE_SYSTEM, MANAGER_TEST_RUN_BASIC, &m));
         ASSERT_OK(manager_startup(m, NULL, NULL, NULL));

diff --git a/src/test/test-chase.c b/src/test/test-chase.c
index 510264c547e461517b86ffad18acdb208c06b01c..16f470a08ea70c44ebe1c375f51c7abba5995ba3 100644 (file)
--- a/src/test/test-chase.c
+++ b/src/test/test-chase.c
@@ -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));

diff --git a/src/test/test-condition.c b/src/test/test-condition.c
index ef0a98a29fb847ab7d5d4c44d0f5ffa7af725358..be5fe67879e879342240905b29f5c4eb8fe06639 100644 (file)
--- a/src/test/test-condition.c
+++ b/src/test/test-condition.c
@@ -49,71 +49,71 @@
 TEST(condition_test_path) {
         Condition *condition;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_EXISTS, "/bin/s?", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/bin/s?", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, true)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, true)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_DIRECTORY, "/bin", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_DIRECTORY, "/bin", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_DIRECTORY_NOT_EMPTY, "/bin", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_DIRECTORY_NOT_EMPTY, "/bin", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FILE_NOT_EMPTY, "/bin/sh", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FILE_NOT_EMPTY, "/bin/sh", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/bin/sh", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/bin/sh", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/etc/passwd", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/etc/passwd", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/proc", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/proc", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/bin", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/bin", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_READ_WRITE, "/tmp", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_READ_WRITE, "/tmp", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_ENCRYPTED, "/sys", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_ENCRYPTED, "/sys", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_PATH_IS_SYMBOLIC_LINK, "/dev/stdout", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_SYMBOLIC_LINK, "/dev/stdout", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -127,11 +127,11 @@ TEST(condition_test_control_group_hierarchy) {
                 return (void) log_tests_skipped("cgroupfs is not mounted");
         ASSERT_OK(r);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "v1", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "v1", false, false)));
         ASSERT_OK_EQ(condition_test(condition, environ),  r < CGROUP_UNIFIED_ALL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "v2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "v2", false, false)));
         ASSERT_OK_EQ(condition_test(condition, environ), r >= CGROUP_UNIFIED_ALL);
         condition_free(condition);
 }
@@ -148,11 +148,11 @@ TEST(condition_test_control_group_controller) {
         ASSERT_OK(r);
 
         /* Invalid controllers are ignored */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "thisisnotarealcontroller", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "thisisnotarealcontroller", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "thisisnotarealcontroller", false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "thisisnotarealcontroller", false, true)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
@@ -164,20 +164,20 @@ TEST(condition_test_control_group_controller) {
                 log_info("chosen controller is '%s'", local_controller_name);
                 if (system_mask & CGROUP_CONTROLLER_TO_MASK(controller)) {
                         log_info("this controller is available");
-                        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, false));
+                        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, false)));
                         ASSERT_OK_POSITIVE(condition_test(condition, environ));
                         condition_free(condition);
 
-                        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, true));
+                        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, true)));
                         ASSERT_OK_ZERO(condition_test(condition, environ));
                         condition_free(condition);
                 } else {
                         log_info("this controller is unavailable");
-                        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, false));
+                        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, false)));
                         ASSERT_OK_ZERO(condition_test(condition, environ));
                         condition_free(condition);
 
-                        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, true));
+                        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, true)));
                         ASSERT_OK_POSITIVE(condition_test(condition, environ));
                         condition_free(condition);
                 }
@@ -186,11 +186,11 @@ TEST(condition_test_control_group_controller) {
         /* Multiple valid controllers at the same time */
         ASSERT_OK(cg_mask_to_string(system_mask, &controller_name));
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, strempty(controller_name), false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, strempty(controller_name), false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, strempty(controller_name), false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, strempty(controller_name), false, true)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -198,15 +198,15 @@ TEST(condition_test_control_group_controller) {
 TEST(condition_test_ac_power) {
         Condition *condition;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_AC_POWER, "true", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_AC_POWER, "true", false, false)));
         assert_se(condition_test(condition, environ) == on_ac_power());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_AC_POWER, "false", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_AC_POWER, "false", false, false)));
         assert_se(condition_test(condition, environ) != on_ac_power());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_AC_POWER, "false", false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_AC_POWER, "false", false, true)));
         assert_se(condition_test(condition, environ) == on_ac_power());
         condition_free(condition);
 }
@@ -222,25 +222,25 @@ TEST(condition_test_host) {
                 return (void) log_tests_skipped("/etc/machine-id missing");
         ASSERT_OK(r);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_HOST, SD_ID128_TO_STRING(id), false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, SD_ID128_TO_STRING(id), false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_HOST, "garbage value jjjjjjjjjjjjjj", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, "garbage value jjjjjjjjjjjjjj", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_HOST, SD_ID128_TO_STRING(id), false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, SD_ID128_TO_STRING(id), false, true)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(hostname = gethostname_malloc());
+        ASSERT_NOT_NULL((hostname = gethostname_malloc()));
 
         /* if hostname looks like an id128 then skip testing it */
         if (id128_is_valid(hostname))
                 return (void) log_notice("hostname is an id128, skipping test");
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_HOST, hostname, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, hostname, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -250,18 +250,18 @@ TEST(condition_test_architecture) {
         const char *sa;
         Architecture a;
 
-        ASSERT_OK(a = uname_architecture());
-        ASSERT_NOT_NULL(sa = architecture_to_string(a));
+        ASSERT_OK((a = uname_architecture()));
+        ASSERT_NOT_NULL((sa = architecture_to_string(a)));
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_ARCHITECTURE, sa, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, sa, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_ARCHITECTURE, "garbage value", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, "garbage value", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_ARCHITECTURE, sa, false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, sa, false, true)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -270,12 +270,12 @@ TEST(condition_test_firmware) {
         Condition *condition;
 
         /* Empty parameter */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         /* uefi parameter */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "uefi", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "uefi", false, false)));
         ASSERT_OK_EQ(condition_test(condition, environ), is_efi_boot());
         condition_free(condition);
 }
@@ -287,13 +287,13 @@ TEST(condition_test_firmware_device_tree) {
         /* device-tree parameter */
         is_device_tree_system = access("/sys/firmware/devicetree/", F_OK) == 0;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "device-tree", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "device-tree", false, false)));
         ASSERT_OK_EQ(condition_test(condition, environ), is_device_tree_system);
         condition_free(condition);
 
         /* device-tree-compatible parameter */
         if (!is_device_tree_system) {
-                ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "device-tree-compatible()", false, false));
+                ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "device-tree-compatible()", false, false)));
                 ASSERT_OK_ZERO(condition_test(condition, environ));
                 condition_free(condition);
         } else {
@@ -304,7 +304,7 @@ TEST(condition_test_firmware_device_tree) {
 
                 r = read_full_virtual_file("/proc/device-tree/compatible", &dtcompat, &dtcompat_size);
                 if (r < 0) {
-                        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "device-tree-compatible()", false, false));
+                        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "device-tree-compatible()", false, false)));
                         if (r == -ENOENT)
                                 ASSERT_OK_ZERO(condition_test(condition, environ));
                         else
@@ -318,8 +318,8 @@ TEST(condition_test_firmware_device_tree) {
                 STRV_FOREACH(c, dtcompatlist) {
                         _cleanup_free_ char *expression = NULL;
 
-                        ASSERT_NOT_NULL(expression = strjoin("device-tree-compatible(", *c, ")"));
-                        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+                        ASSERT_NOT_NULL((expression = strjoin("device-tree-compatible(", *c, ")")));
+                        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
                         ASSERT_OK_POSITIVE(condition_test(condition, environ));
                         condition_free(condition);
                 }
@@ -333,32 +333,32 @@ TEST(condition_test_firmware_smbios) {
 
         /* smbios-field parameter */
         /* Test some malformed smbios-field arguments */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field()", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field()", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed=)", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed=)", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed=)", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed=)", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field(not_existing=nothing garbage)", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(not_existing=nothing garbage)", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
         /* Test not existing SMBIOS field */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, "smbios-field(not_existing=nothing)", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(not_existing=nothing)", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
@@ -374,27 +374,27 @@ TEST(condition_test_firmware_smbios) {
 
         /* Test equality / inequality using fnmatch() */
         expression = strjoina("smbios-field(bios_vendor $= ", quote,  bios_vendor, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_vendor$=", quote, bios_vendor, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_vendor !$= ", quote, bios_vendor, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_vendor!$=", quote, bios_vendor, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_vendor $= ", quote,  bios_vendor, "*", quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
@@ -409,32 +409,32 @@ TEST(condition_test_firmware_smbios) {
         quote = strchr(bios_version, ' ') ? "\"" : "";
 
         expression = strjoina("smbios-field(bios_version = ", quote, bios_version, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_version != ", quote, bios_version, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_version <= ", quote, bios_version, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_version >= ", quote, bios_version, quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_version < ", quote, bios_version, ".1", quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         expression = strjoina("smbios-field(bios_version > ", quote, bios_version, ".1", quote, ")");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_FIRMWARE, expression, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -443,14 +443,14 @@ TEST(condition_test_kernel_command_line) {
         Condition *condition;
         int r;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "thisreallyshouldntbeonthekernelcommandline", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "thisreallyshouldntbeonthekernelcommandline", false, false)));
         r = condition_test(condition, environ);
         if (ERRNO_IS_PRIVILEGE(r))
                 return;
         ASSERT_OK_ZERO(r);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "andthis=neither", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "andthis=neither", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -460,115 +460,115 @@ TEST(condition_test_kernel_version) {
         struct utsname u;
         const char *v;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "*thisreallyshouldntbeinthekernelversion*", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "*thisreallyshouldntbeinthekernelversion*", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "*", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "*", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         /* An artificially empty condition. It evaluates to true, but normally
          * such condition cannot be created, because the condition list is reset instead. */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         ASSERT_OK_ERRNO(uname(&u));
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, u.release, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, u.release, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         strshorten(u.release, 4);
         strcpy(strchr(u.release, 0), "*");
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, u.release, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, u.release, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         /* 0.1.2 would be a very very very old kernel */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "> 0.1.2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "> 0.1.2", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, ">0.1.2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, ">0.1.2", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "'>0.1.2' '<9.0.0'", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "'>0.1.2' '<9.0.0'", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "> 0.1.2 < 9.0.0", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "> 0.1.2 < 9.0.0", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, ">", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, ">", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, ">= 0.1.2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, ">= 0.1.2", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "< 0.1.2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "< 0.1.2", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "<= 0.1.2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "<= 0.1.2", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "= 0.1.2", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "= 0.1.2", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         /* 4711.8.15 is a very very very future kernel */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "< 4711.8.15", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "< 4711.8.15", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "<= 4711.8.15", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "<= 4711.8.15", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "= 4711.8.15", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "= 4711.8.15", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, "> 4711.8.15", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, "> 4711.8.15", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, " >= 4711.8.15", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, " >= 4711.8.15", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         ASSERT_OK_ERRNO(uname(&u));
 
         v = strjoina(">=", u.release);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         v = strjoina("=  ", u.release);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         v = strjoina("<=", u.release);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         v = strjoina("> ", u.release);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         v = strjoina("<   ", u.release);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_VERSION, v, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -584,12 +584,12 @@ TEST(condition_test_credential) {
         ASSERT_OK_ERRNO(unsetenv("CREDENTIALS_DIRECTORY"));
         ASSERT_OK_ERRNO(unsetenv("ENCRYPTED_CREDENTIALS_DIRECTORY"));
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CREDENTIAL, "definitelymissing", /* trigger= */ false, /* negate= */ false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "definitelymissing", /* trigger= */ false, /* negate= */ false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         /* invalid */
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CREDENTIAL, "..", /* trigger= */ false, /* negate= */ false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "..", /* trigger= */ false, /* negate= */ false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
@@ -599,20 +599,20 @@ TEST(condition_test_credential) {
         ASSERT_OK_ERRNO(setenv("CREDENTIALS_DIRECTORY", n1, /* overwrite= */ true));
         ASSERT_OK_ERRNO(setenv("ENCRYPTED_CREDENTIALS_DIRECTORY", n2, /* overwrite= */ true));
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CREDENTIAL, "stillmissing", /* trigger= */ false, /* negate= */ false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "stillmissing", /* trigger= */ false, /* negate= */ false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(j = path_join(n1, "existing"));
+        ASSERT_NOT_NULL((j = path_join(n1, "existing")));
         assert_se(touch(j) >= 0);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CREDENTIAL, "existing", /* trigger= */ false, /* negate= */ false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "existing", /* trigger= */ false, /* negate= */ false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
         free(j);
 
-        ASSERT_NOT_NULL(j = path_join(n2, "existing-encrypted"));
+        ASSERT_NOT_NULL((j = path_join(n2, "existing-encrypted")));
         assert_se(touch(j) >= 0);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CREDENTIAL, "existing-encrypted", /* trigger= */ false, /* negate= */ false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "existing-encrypted", /* trigger= */ false, /* negate= */ false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
@@ -624,15 +624,15 @@ TEST(condition_test_credential) {
 TEST(condition_test_cpufeature) {
         Condition *condition;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_FEATURE, "fpu", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "fpu", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_FEATURE, "somecpufeaturethatreallydoesntmakesense", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "somecpufeaturethatreallydoesntmakesense", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_FEATURE, "a", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "a", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -641,39 +641,39 @@ TEST(condition_test_cpufeature) {
 TEST(condition_test_security) {
         Condition *condition;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "garbage oifdsjfoidsjoj", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "garbage oifdsjfoidsjoj", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "selinux", false, true));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "selinux", false, true)));
         assert_se(condition_test(condition, environ) != mac_selinux_use());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "apparmor", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "apparmor", false, false)));
         assert_se(condition_test(condition, environ) == mac_apparmor_use());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "tomoyo", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "tomoyo", false, false)));
         assert_se(condition_test(condition, environ) == mac_tomoyo_use());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "ima", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "ima", false, false)));
         assert_se(condition_test(condition, environ) == use_ima());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "smack", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "smack", false, false)));
         assert_se(condition_test(condition, environ) == mac_smack_use());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "audit", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "audit", false, false)));
         assert_se(condition_test(condition, environ) == use_audit());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "uefi-secureboot", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "uefi-secureboot", false, false)));
         assert_se(condition_test(condition, environ) == is_efi_secure_boot());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_SECURITY, "cvm", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "cvm", false, false)));
         assert_se(condition_test(condition, environ) ==
                   (detect_confidential_virtualization() != CONFIDENTIAL_VIRTUALIZATION_NONE));
         condition_free(condition);
@@ -697,7 +697,7 @@ TEST(condition_test_virtualization) {
         Condition *condition;
         int r;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_VIRTUALIZATION, "garbage oifdsjfoidsjoj", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "garbage oifdsjfoidsjoj", false, false)));
         r = condition_test(condition, environ);
         if (ERRNO_IS_PRIVILEGE(r))
                 return;
@@ -705,19 +705,19 @@ TEST(condition_test_virtualization) {
         ASSERT_OK_ZERO(r);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_VIRTUALIZATION, "container", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "container", false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionVirtualization=container → %i", r);
         assert_se(r == !!detect_container());
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_VIRTUALIZATION, "vm", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "vm", false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionVirtualization=vm → %i", r);
         assert_se(r == (detect_vm() && !detect_container()));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_VIRTUALIZATION, "private-users", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "private-users", false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionVirtualization=private-users → %i", r);
         assert_se(r == !!running_in_userns());
@@ -738,7 +738,7 @@ TEST(condition_test_virtualization) {
                        "bhyve\0"
                        "vm_other\0") {
 
-                ASSERT_NOT_NULL(condition = condition_new(CONDITION_VIRTUALIZATION, virt, false, false));
+                ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, virt, false, false)));
                 r = condition_test(condition, environ);
                 log_info("ConditionVirtualization=%s → %i", virt, r);
                 ASSERT_OK(r);
@@ -752,14 +752,14 @@ TEST(condition_test_user) {
         char* username;
         int r;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, "garbage oifdsjfoidsjoj", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, "garbage oifdsjfoidsjoj", false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=garbage → %i", r);
         ASSERT_OK_ZERO(r);
         condition_free(condition);
 
         ASSERT_OK_POSITIVE(asprintf(&uid, "%"PRIu32, UINT32_C(0xFFFF)));
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, uid, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, uid, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=%s → %i", uid, r);
         ASSERT_OK_ZERO(r);
@@ -767,7 +767,7 @@ TEST(condition_test_user) {
         free(uid);
 
         ASSERT_OK_POSITIVE(asprintf(&uid, "%u", (unsigned)getuid()));
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, uid, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, uid, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=%s → %i", uid, r);
         ASSERT_OK_POSITIVE(r);
@@ -775,15 +775,15 @@ TEST(condition_test_user) {
         free(uid);
 
         ASSERT_OK_POSITIVE(asprintf(&uid, "%u", (unsigned)getuid()+1));
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, uid, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, uid, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=%s → %i", uid, r);
         ASSERT_OK_ZERO(r);
         condition_free(condition);
         free(uid);
 
-        ASSERT_NOT_NULL(username = getusername_malloc());
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, username, false, false));
+        ASSERT_NOT_NULL((username = getusername_malloc()));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, username, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=%s → %i", username, r);
         ASSERT_OK_POSITIVE(r);
@@ -791,13 +791,13 @@ TEST(condition_test_user) {
         free(username);
 
         username = (char*)(geteuid() == 0 ? NOBODY_USER_NAME : "root");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, username, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, username, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=%s → %i", username, r);
         ASSERT_OK_ZERO(r);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_USER, "@system", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, "@system", false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionUser=@system → %i", r);
         if (uid_is_system(getuid()) || uid_is_system(geteuid()))
@@ -814,14 +814,14 @@ TEST(condition_test_group) {
         int ngroups_max, ngroups, r, i;
 
         xsprintf(gid, "%u", UINT32_C(0xFFFF));
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_GROUP, gid, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionGroup=%s → %i", gid, r);
         ASSERT_OK_ZERO(r);
         condition_free(condition);
 
         xsprintf(gid, "%u", getgid());
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_GROUP, gid, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionGroup=%s → %i", gid, r);
         ASSERT_OK_POSITIVE(r);
@@ -840,18 +840,18 @@ TEST(condition_test_group) {
                 _cleanup_free_ char *name = NULL;
 
                 xsprintf(gid, "%u", gids[i]);
-                ASSERT_NOT_NULL(condition = condition_new(CONDITION_GROUP, gid, false, false));
+                ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
                 r = condition_test(condition, environ);
                 log_info("ConditionGroup=%s → %i", gid, r);
                 ASSERT_OK_POSITIVE(r);
                 condition_free(condition);
                 max_gid = gids[i] > max_gid ? gids[i] : max_gid;
 
-                ASSERT_NOT_NULL(name = gid_to_name(gids[i]));
+                ASSERT_NOT_NULL((name = gid_to_name(gids[i])));
                 if (STR_IN_SET(name, "sbuild", "buildd"))
                         return; /* Debian package build in chroot, groupnames won't match, skip */
 
-                ASSERT_NOT_NULL(condition = condition_new(CONDITION_GROUP, name, false, false));
+                ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, name, false, false)));
                 r = condition_test(condition, environ);
                 log_info("ConditionGroup=%s → %i", name, r);
                 ASSERT_OK_POSITIVE(r);
@@ -860,7 +860,7 @@ TEST(condition_test_group) {
         }
 
         xsprintf(gid, "%u", max_gid + 1);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_GROUP, gid, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionGroup=%s → %i", gid, r);
         ASSERT_OK_ZERO(r);
@@ -874,7 +874,7 @@ TEST(condition_test_group) {
                 return (void) log_tests_skipped("user is in both root and nobody group");
 
         const char *groupname = getegid() == 0 ? NOBODY_GROUP_NAME : "root";
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_GROUP, groupname, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, groupname, false, false)));
         r = condition_test(condition, environ);
         log_info("ConditionGroup=%s → %i", groupname, r);
         ASSERT_OK_ZERO(r);
@@ -887,7 +887,7 @@ static void test_condition_test_cpus_one(const char *s, bool result) {
 
         log_debug("%s=%s", condition_type_to_string(CONDITION_CPUS), s);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPUS, s, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPUS, s, false, false)));
 
         r = condition_test(condition, environ);
         assert_se(r >= 0);
@@ -947,7 +947,7 @@ static void test_condition_test_memory_one(const char *s, bool result) {
 
         log_debug("%s=%s", condition_type_to_string(CONDITION_MEMORY), s);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY, s, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY, s, false, false)));
 
         r = condition_test(condition, environ);
         assert_se(r >= 0);
@@ -1027,7 +1027,7 @@ static void test_condition_test_environment_one(const char *s, bool result) {
 
         log_debug("%s=%s", condition_type_to_string(CONDITION_ENVIRONMENT), s);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_ENVIRONMENT, s, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_ENVIRONMENT, s, false, false)));
 
         r = condition_test(condition, environ);
         assert_se(r >= 0);
@@ -1060,57 +1060,57 @@ TEST(condition_test_os_release) {
         if (strv_length(os_release_pairs) < 2)
                 return;
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "_THISHOPEFULLYWONTEXIST=01234 56789", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "_THISHOPEFULLYWONTEXIST=01234 56789", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRONG FORMAT", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG FORMAT", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRONG!<>=FORMAT", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG!<>=FORMAT", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRONG FORMAT=", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG FORMAT=", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRONG =FORMAT", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG =FORMAT", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRONG = FORMAT", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG = FORMAT", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRONGFORMAT=   ", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONGFORMAT=   ", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "WRO NG=FORMAT", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRO NG=FORMAT", false, false)));
         ASSERT_ERROR(condition_test(condition, environ), EINVAL);
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         /* Test shell style globs */
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "ID_LIKE$=*THISHOPEFULLYWONTEXIST*", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_LIKE$=*THISHOPEFULLYWONTEXIST*", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "ID_THISHOPEFULLYWONTEXIST$=*rhel*", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_THISHOPEFULLYWONTEXIST$=*rhel*", false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "ID_LIKE!$=*THISHOPEFULLYWONTEXIST*", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_LIKE!$=*THISHOPEFULLYWONTEXIST*", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, "ID_THISHOPEFULLYWONTEXIST!$=*rhel*", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_THISHOPEFULLYWONTEXIST!$=*rhel*", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
@@ -1119,23 +1119,23 @@ TEST(condition_test_os_release) {
          * which is wrong, as the value is not quoted anymore. */
         const char *quote = strchr(os_release_pairs[1], ' ') ? "\"" : "";
         key_value_pair = strjoina(os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina(os_release_pairs[0], "!=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         /* Test fnmatch() operators */
         key_value_pair = strjoina(os_release_pairs[0], "$=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina(os_release_pairs[0], "!$=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
@@ -1144,57 +1144,57 @@ TEST(condition_test_os_release) {
                 return;
 
         key_value_pair = strjoina("VERSION_ID", "=", version_id);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "!=", version_id);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "<=", version_id);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", ">=", version_id);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "<", version_id, ".1");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", ">", version_id, ".1");
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "=", version_id, " ", os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "!=", version_id, " ", os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "=", version_id, " ", os_release_pairs[0], "!=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "!=", version_id, " ", os_release_pairs[0], "!=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_ZERO(condition_test(condition, environ));
         condition_free(condition);
 
         key_value_pair = strjoina("VERSION_ID", "<", version_id, ".1", " ", os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 }
@@ -1207,83 +1207,83 @@ TEST(condition_test_psi) {
         if (!is_pressure_supported())
                 return (void) log_notice("Pressure Stall Information (PSI) is not supported, skipping %s", __func__);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "sbarabau", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "sbarabau", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "10%sbarabau", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "10%sbarabau", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "10% sbarabau", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10% sbarabau", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "-10", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "-10", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "10%/10min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10%/10min", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "10min/10%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10min/10%", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "10% 5min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10% 5min", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "/5min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "/5min", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_IO_PRESSURE, "10s /   ", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_IO_PRESSURE, "10s /   ", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "100%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "100%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "0%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "0%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "0.0%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "0.0%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "100%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "100%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "0%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "0.0%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0.0%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "0.01%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0.01%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "0.0%/10sec", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0.0%/10sec", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "100.0% / 1min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "100.0% / 1min", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_IO_PRESSURE, "50.0% / 1min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_IO_PRESSURE, "50.0% / 1min", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
@@ -1302,27 +1302,27 @@ TEST(condition_test_psi) {
         if (!FLAGS_SET(mask, CGROUP_MASK_CPU))
                 return (void) log_notice("Requires the cgroup CPU controller, skipping %s", __func__);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, " : / ", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, " : / ", false, false)));
         ASSERT_FAIL(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "hopefullythisisnotarealone.slice:100% / 10sec", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "hopefullythisisnotarealone.slice:100% / 10sec", false, false)));
         ASSERT_OK_POSITIVE(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_CPU_PRESSURE, "-.slice:100.0% / 1min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "-.slice:100.0% / 1min", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "-.slice:0.0%/5min", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "-.slice:0.0%/5min", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_MEMORY_PRESSURE, "-.slice:100.0%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "-.slice:100.0%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 
-        ASSERT_NOT_NULL(condition = condition_new(CONDITION_IO_PRESSURE, "-.slice:0.0%", false, false));
+        ASSERT_NOT_NULL((condition = condition_new(CONDITION_IO_PRESSURE, "-.slice:0.0%", false, false)));
         ASSERT_OK(condition_test(condition, environ));
         condition_free(condition);
 }

diff --git a/src/test/test-conf-parser.c b/src/test/test-conf-parser.c
index a4309c0134f2f4af7aec28b3dcefeb17cb8cae2a..233f58b90e196521fb25d1c905740122d0d7a726 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-creds.c b/src/test/test-creds.c
index e82c8fd755de333b8b51a02ab6ba21c3da4caeef..070b02fa90afe36aea7018324e151898c56f57d5 100644 (file)
--- a/src/test/test-creds.c
+++ b/src/test/test-creds.c
@@ -20,7 +20,7 @@ TEST(read_credential_strings) {
 
         const char *e = getenv("CREDENTIALS_DIRECTORY");
         if (e)
-                ASSERT_NOT_NULL(saved = strdup(e));
+                ASSERT_NOT_NULL((saved = strdup(e)));
 
         ASSERT_OK_ZERO(read_credential_strings_many("foo", &x, "bar", &y));
         ASSERT_NULL(x);
@@ -34,7 +34,7 @@ TEST(read_credential_strings) {
         ASSERT_NULL(x);
         ASSERT_NULL(y);
 
-        ASSERT_NOT_NULL(p = path_join(tmp, "bar"));
+        ASSERT_NOT_NULL((p = path_join(tmp, "bar")));
         ASSERT_OK(write_string_file(p, "piff", WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_AVOID_NEWLINE));
 
         ASSERT_OK_ZERO(read_credential_strings_many("foo", &x, "bar", &y));
@@ -48,7 +48,7 @@ TEST(read_credential_strings) {
         ASSERT_STREQ(y, "paff");
 
         p = mfree(p);
-        ASSERT_NOT_NULL(p = path_join(tmp, "foo"));
+        ASSERT_NOT_NULL((p = path_join(tmp, "foo")));
         ASSERT_OK(write_string_file(p, "knurz", WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_AVOID_NEWLINE));
 
         ASSERT_OK(read_credential_strings_many("foo", &x, "bar", &y));
@@ -56,8 +56,8 @@ TEST(read_credential_strings) {
         ASSERT_STREQ(y, "paff");
 
         p = mfree(p);
-        ASSERT_NOT_NULL(p = path_join(tmp, "bazz"));
-        ASSERT_NOT_NULL(f = fopen(p, "w"));
+        ASSERT_NOT_NULL((p = path_join(tmp, "bazz")));
+        ASSERT_NOT_NULL((f = fopen(p, "w")));
         ASSERT_EQ(fwrite("x\0y", 1, 3, f), 3UL); /* embedded NUL byte should result in EBADMSG when reading back with read_credential_strings_many() */
         f = safe_fclose(f);
 
@@ -211,7 +211,7 @@ TEST(credential_encrypt_decrypt) {
         _cleanup_free_ char *ec = NULL;
 
         if (e)
-                ASSERT_NOT_NULL(ec = strdup(e));
+                ASSERT_NOT_NULL((ec = strdup(e)));
 
         ASSERT_OK_ERRNO(setenv("SYSTEMD_CREDENTIAL_SECRET", j, true));
 

diff --git a/src/test/test-execute.c b/src/test/test-execute.c
index f2224910b0a8d83bf0709ec8c4cb5ad6e8fc9ff4..c5d0707e136d88af78b57d7e67046ea3e166620e 100644 (file)
--- a/src/test/test-execute.c
+++ b/src/test/test-execute.c
@@ -788,13 +788,13 @@ static void test_exec_mount_apivfs(Manager *m) {
         ASSERT_OK(strv_extend_strv(&libraries, libraries_test, true));
 
         ASSERT_NOT_NULL(strextend(&data, "[Service]\n"));
-        ASSERT_NOT_NULL(strextend(&data, "ExecStart=", fullpath_touch, " /aaa\n"));
-        ASSERT_NOT_NULL(strextend(&data, "ExecStart=", fullpath_test, " -f /aaa\n"));
-        ASSERT_NOT_NULL(strextend(&data, "BindReadOnlyPaths=", fullpath_touch, "\n"));
-        ASSERT_NOT_NULL(strextend(&data, "BindReadOnlyPaths=", fullpath_test, "\n"));
+        ASSERT_NOT_NULL((strextend(&data, "ExecStart=", fullpath_touch, " /aaa\n")));
+        ASSERT_NOT_NULL((strextend(&data, "ExecStart=", fullpath_test, " -f /aaa\n")));
+        ASSERT_NOT_NULL((strextend(&data, "BindReadOnlyPaths=", fullpath_touch, "\n")));
+        ASSERT_NOT_NULL((strextend(&data, "BindReadOnlyPaths=", fullpath_test, "\n")));
 
         STRV_FOREACH(p, libraries)
-                ASSERT_NOT_NULL(strextend(&data, "BindReadOnlyPaths=", *p, "\n"));
+                ASSERT_NOT_NULL((strextend(&data, "BindReadOnlyPaths=", *p, "\n")));
 
         ASSERT_OK(write_drop_in(user_runtime_unit_dir, "exec-mount-apivfs-no.service", 10, "bind-mount", data));
 
@@ -981,7 +981,7 @@ static char* private_directory_bad(Manager *m) {
                 _cleanup_free_ char *p = NULL;
                 struct stat st;
 
-                ASSERT_NOT_NULL(p = path_join(m->prefix[dt], "private"));
+                ASSERT_NOT_NULL((p = path_join(m->prefix[dt], "private")));
 
                 if (stat(p, &st) >= 0 &&
                     (st.st_mode & (S_IRWXG|S_IRWXO)))
@@ -1393,9 +1393,9 @@ static void run_tests(RuntimeScope scope, char **patterns) {
         ASSERT_OK_ERRNO(unsetenv("VAR4"));
         ASSERT_OK_ERRNO(unsetenv("VAR5"));
 
-        ASSERT_NOT_NULL(runtime_dir = setup_fake_runtime_dir());
-        ASSERT_NOT_NULL(user_runtime_unit_dir = path_join(runtime_dir, "systemd/user"));
-        ASSERT_NOT_NULL(unit_paths = strjoin(PRIVATE_UNIT_DIR, ":", user_runtime_unit_dir));
+        ASSERT_NOT_NULL((runtime_dir = setup_fake_runtime_dir()));
+        ASSERT_NOT_NULL((user_runtime_unit_dir = path_join(runtime_dir, "systemd/user")));
+        ASSERT_NOT_NULL((unit_paths = strjoin(PRIVATE_UNIT_DIR, ":", user_runtime_unit_dir)));
         ASSERT_OK(setenv_unit_path(unit_paths));
 
         /* Write credential for test-execute-load-credential to the fake runtime dir, too */
@@ -1481,7 +1481,7 @@ static int prepare_ns(const char *process_name) {
                          * overmount it with an empty tmpfs, manager_new() will pin the wrong systemd-executor binary,
                          * which can then lead to unexpected (and painful to debug) test fails. */
                         ASSERT_OK_ERRNO(access(build_dir, F_OK));
-                        ASSERT_NOT_NULL(build_dir_mount = path_join(PRIVATE_UNIT_DIR, "build_dir"));
+                        ASSERT_NOT_NULL((build_dir_mount = path_join(PRIVATE_UNIT_DIR, "build_dir")));
                         ASSERT_OK(mkdir_p(build_dir_mount, 0755));
                         ASSERT_OK(mount_nofollow_verbose(LOG_DEBUG, build_dir, build_dir_mount, NULL, MS_BIND, NULL));
                 }
@@ -1521,7 +1521,7 @@ TEST(run_tests_root) {
                 return (void) log_tests_skipped("unshare() is disabled");
 
         /* safe_fork() clears saved_argv in the child process. Let's copy it. */
-        ASSERT_NOT_NULL(filters = strv_copy(strv_skip(saved_argv, 1)));
+        ASSERT_NOT_NULL((filters = strv_copy(strv_skip(saved_argv, 1))));
 
         if (prepare_ns("(test-execute-root)") == 0) {
                 can_unshare = true;
@@ -1547,7 +1547,7 @@ TEST(run_tests_without_unshare) {
                 return (void) log_tests_skipped("Seccomp not available, cannot run unshare() filtered tests");
 
         /* safe_fork() clears saved_argv in the child process. Let's copy it. */
-        ASSERT_NOT_NULL(filters = strv_copy(strv_skip(saved_argv, 1)));
+        ASSERT_NOT_NULL((filters = strv_copy(strv_skip(saved_argv, 1))));
 
         if (prepare_ns("(test-execute-without-unshare)") == 0) {
                 _cleanup_hashmap_free_ Hashmap *s = NULL;
@@ -1576,7 +1576,7 @@ TEST(run_tests_unprivileged) {
                 return (void) log_tests_skipped("unshare() is disabled");
 
         /* safe_fork() clears saved_argv in the child process. Let's copy it. */
-        ASSERT_NOT_NULL(filters = strv_copy(strv_skip(saved_argv, 1)));
+        ASSERT_NOT_NULL((filters = strv_copy(strv_skip(saved_argv, 1))));
 
         if (prepare_ns("(test-execute-unprivileged)") == 0) {
                 ASSERT_OK(capability_bounding_set_drop(0, /* right_now = */ true));

diff --git a/src/test/test-format-table.c b/src/test/test-format-table.c
index 3bfbf1fc467c872e0c7810db05efd246bd1ce8d5..0c80770c4dd06c68b683f559e01980b73c7f3bb4 100644 (file)
--- a/src/test/test-format-table.c
+++ b/src/test/test-format-table.c
@@ -15,7 +15,7 @@ TEST(issue_9549) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(table = table_new("name", "type", "ro", "usage", "created", "modified"));
+        ASSERT_NOT_NULL((table = table_new("name", "type", "ro", "usage", "created", "modified")));
         ASSERT_OK(table_set_align_percent(table, TABLE_HEADER_CELL(3), 100));
         ASSERT_OK(table_add_many(table,
                                  TABLE_STRING, "foooo",
@@ -38,7 +38,7 @@ TEST(multiline) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(table = table_new("foo", "bar"));
+        ASSERT_NOT_NULL((table = table_new("foo", "bar")));
 
         ASSERT_OK(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100));
 
@@ -150,7 +150,7 @@ TEST(strv) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(table = table_new("foo", "bar"));
+        ASSERT_NOT_NULL((table = table_new("foo", "bar")));
 
         ASSERT_OK(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100));
 
@@ -262,7 +262,7 @@ TEST(strv_wrapped) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(table = table_new("foo", "bar"));
+        ASSERT_NOT_NULL((table = table_new("foo", "bar")));
 
         ASSERT_OK(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100));
 
@@ -364,7 +364,7 @@ TEST(json) {
         _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
         _cleanup_(table_unrefp) Table *t = NULL;
 
-        ASSERT_NOT_NULL(t = table_new_raw(4));
+        ASSERT_NOT_NULL((t = table_new_raw(4)));
 
         ASSERT_OK(table_add_many(t,
                                  TABLE_HEADER, "foo bar",
@@ -432,7 +432,7 @@ TEST(json_mangling) {
 
         FOREACH_ELEMENT(i, cases) {
                 _cleanup_free_ char *ret = NULL;
-                ASSERT_NOT_NULL(ret = table_mangle_to_json_field_name(i->arg));
+                ASSERT_NOT_NULL((ret = table_mangle_to_json_field_name(i->arg)));
                 printf("\"%s\" -> \"%s\"\n", i->arg, ret);
                 ASSERT_STREQ(ret, i->exp);
         }
@@ -442,7 +442,7 @@ TEST(table) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(t = table_new("one", "two", "three", "four"));
+        ASSERT_NOT_NULL((t = table_new("one", "two", "three", "four")));
 
         ASSERT_OK(table_set_align_percent(t, TABLE_HEADER_CELL(3), 100));
 
@@ -584,7 +584,7 @@ TEST(signed_integers) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(t = table_new("int", "int8", "int16", "int32", "int64"));
+        ASSERT_NOT_NULL((t = table_new("int", "int8", "int16", "int32", "int64")));
         table_set_width(t, 0);
 
         ASSERT_OK(table_add_many(t,
@@ -649,7 +649,7 @@ TEST(unsigned_integers) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(t = table_new("uint", "uint8", "uint16", "uint32", "uhex32", "uint64", "uhex64"));
+        ASSERT_NOT_NULL((t = table_new("uint", "uint8", "uint16", "uint32", "uhex32", "uint64", "uhex64")));
         table_set_width(t, 0);
 
         ASSERT_OK(table_add_many(t,
@@ -709,7 +709,7 @@ TEST(vertical) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(t = table_new_vertical());
+        ASSERT_NOT_NULL((t = table_new_vertical()));
 
         ASSERT_OK(table_add_many(t,
                                  TABLE_FIELD, "pfft aa", TABLE_STRING, "foo",
@@ -745,7 +745,7 @@ TEST(path_basename) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(t = table_new("x"));
+        ASSERT_NOT_NULL((t = table_new("x")));
 
         table_set_header(t, false);
 
@@ -763,7 +763,7 @@ TEST(dup_cell) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(t = table_new("foo", "bar", "x", "baz", ".", "%", "!", "~", "+"));
+        ASSERT_NOT_NULL((t = table_new("foo", "bar", "x", "baz", ".", "%", "!", "~", "+")));
         table_set_width(t, 75);
 
         ASSERT_OK(table_add_many(t,
@@ -806,7 +806,7 @@ TEST(table_bps) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        ASSERT_NOT_NULL(table = table_new("uint64", "size", "bps"));
+        ASSERT_NOT_NULL((table = table_new("uint64", "size", "bps")));
         uint64_t v;
         FOREACH_ARGUMENT(v,
                          2500,

diff --git a/src/test/test-hashmap-plain.c b/src/test/test-hashmap-plain.c
index 6bcf353887fcee2e3c2782f459ba2d41795f3c52..3c75be30e57faa7474e9f192aa3ef9ef32089f97 100644 (file)
--- a/src/test/test-hashmap-plain.c
+++ b/src/test/test-hashmap-plain.c
@@ -76,14 +76,14 @@ TEST(hashmap_ensure_replace) {
 TEST(hashmap_copy) {
         _cleanup_hashmap_free_ Hashmap *m = NULL, *copy = NULL;
 
-        ASSERT_NOT_NULL(m = hashmap_new(&string_hash_ops));
+        ASSERT_NOT_NULL((m = hashmap_new(&string_hash_ops)));
 
         ASSERT_OK_POSITIVE(hashmap_put(m, "key 1", (void*) "val1"));
         ASSERT_OK_POSITIVE(hashmap_put(m, "key 2", (void*) "val2"));
         ASSERT_OK_POSITIVE(hashmap_put(m, "key 3", (void*) "val3"));
         ASSERT_OK_POSITIVE(hashmap_put(m, "key 4", (void*) "val4"));
 
-        ASSERT_NOT_NULL(copy = hashmap_copy(m));
+        ASSERT_NOT_NULL((copy = hashmap_copy(m)));
 
         ASSERT_STREQ(hashmap_get(copy, "key 1"), "val1");
         ASSERT_STREQ(hashmap_get(copy, "key 2"), "val2");
@@ -975,14 +975,14 @@ TEST(string_strv_hashmap) {
         assert_se(strv_equal(s, STRV_MAKE("bar", "BAR")));
 
         string_strv_hashmap_remove(m, "foo", "bar");
-        ASSERT_NOT_NULL(s = hashmap_get(m, "foo"));
+        ASSERT_NOT_NULL((s = hashmap_get(m, "foo")));
         ASSERT_TRUE(strv_equal(s, STRV_MAKE("BAR")));
 
         string_strv_hashmap_remove(m, "foo", "BAR");
         ASSERT_NULL(hashmap_get(m, "foo"));
 
         string_strv_hashmap_remove(m, "xxx", "BAR");
-        ASSERT_NOT_NULL(s = hashmap_get(m, "xxx"));
+        ASSERT_NOT_NULL((s = hashmap_get(m, "xxx")));
         ASSERT_TRUE(strv_equal(s, STRV_MAKE("bar")));
 
         string_strv_hashmap_remove(m, "xxx", "bar");

diff --git a/src/test/test-id128.c b/src/test/test-id128.c
index eb3bfec2bb3294032d2631128f6206416d86d3cb..4ff95deaea7f2a71642fb8f0bf74bcdea49e6459 100644 (file)
--- a/src/test/test-id128.c
+++ b/src/test/test-id128.c
@@ -307,28 +307,28 @@ TEST(id128_at) {
         ASSERT_EQ_ID128(id, i);
 
         /* id128_read() */
-        ASSERT_NOT_NULL(p = path_join(t, "/etc/machine-id"));
+        ASSERT_NOT_NULL((p = path_join(t, "/etc/machine-id")));
 
         i = SD_ID128_NULL;
         ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
         ASSERT_EQ_ID128(id, i);
 
         free(p);
-        ASSERT_NOT_NULL(p = path_join(t, "/etc2/machine-id"));
+        ASSERT_NOT_NULL((p = path_join(t, "/etc2/machine-id")));
 
         i = SD_ID128_NULL;
         ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
         ASSERT_EQ_ID128(id, i);
 
         free(p);
-        ASSERT_NOT_NULL(p = path_join(t, "/etc/hoge-id"));
+        ASSERT_NOT_NULL((p = path_join(t, "/etc/hoge-id")));
 
         i = SD_ID128_NULL;
         ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
         ASSERT_EQ_ID128(id, i);
 
         free(p);
-        ASSERT_NOT_NULL(p = path_join(t, "/etc2/hoge-id"));
+        ASSERT_NOT_NULL((p = path_join(t, "/etc2/hoge-id")));
 
         i = SD_ID128_NULL;
         ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));

diff --git a/src/test/test-json.c b/src/test/test-json.c
index 8dd5746495ee64a5801fd1418408032f1f6a4116..5cbcf9f68f1efabbc4572d1e5d90b28303ee1c75 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-mkdir.c b/src/test/test-mkdir.c
index b2cc910dd1382115128d0001ab338ff44eb38e4f..bd4698f0832eae8bb8d038746c0731d59145150c 100644 (file)
--- a/src/test/test-mkdir.c
+++ b/src/test/test-mkdir.c
@@ -145,7 +145,7 @@ TEST(mkdir_p_root_full) {
 
         ASSERT_OK(mkdtemp_malloc("/tmp/test-mkdir-XXXXXX", &tmp));
 
-        ASSERT_NOT_NULL(p = path_join(tmp, "foo"));
+        ASSERT_NOT_NULL((p = path_join(tmp, "foo")));
         ASSERT_OK(mkdir_p_root_full(tmp, "/foo", UID_INVALID, GID_INVALID, 0755, 2 * USEC_PER_SEC, NULL));
         ASSERT_GT(is_dir(p, false), 0);
         ASSERT_GT(is_dir(p, true), 0);
@@ -154,12 +154,12 @@ TEST(mkdir_p_root_full) {
         ASSERT_EQ(st.st_atim.tv_sec, 2);
 
         p = mfree(p);
-        ASSERT_NOT_NULL(p = path_join(tmp, "dir-not-exists/foo"));
+        ASSERT_NOT_NULL((p = path_join(tmp, "dir-not-exists/foo")));
         ASSERT_OK(mkdir_p_root_full(NULL, p, UID_INVALID, GID_INVALID, 0755, 90 * USEC_PER_HOUR, NULL));
         ASSERT_GT(is_dir(p, false), 0);
         ASSERT_GT(is_dir(p, true), 0);
         p = mfree(p);
-        ASSERT_NOT_NULL(p = path_join(tmp, "dir-not-exists"));
+        ASSERT_NOT_NULL((p = path_join(tmp, "dir-not-exists")));
         ASSERT_OK_ERRNO(stat(p, &st));
         ASSERT_EQ(st.st_mtim.tv_sec, 90 * 60 * 60);
         ASSERT_EQ(st.st_atim.tv_sec, 90 * 60 * 60);

diff --git a/src/test/test-mount-util.c b/src/test/test-mount-util.c
index ce6a43101e540acf93c2157b1d3633d1d138e1f2..ccaaacc812d7d6f14ded94180835746313c74a4f 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 cae65a14b107c7319c72c2084d3902a081a11999..25393baf73f1f60816bcdf5e5305d3015dd91dc9 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-process-util.c b/src/test/test-process-util.c
index e9a461b141b473cdbdbb4293f3f36551d1cd9e81..d24bcb768f12a99bf35edeb6b9ffe5c5dec8bd1d 100644 (file)
--- a/src/test/test-process-util.c
+++ b/src/test/test-process-util.c
@@ -143,14 +143,14 @@ static void test_pid_get_cmdline_one(pid_t pid) {
 
         r = pid_get_cmdline_strv(pid, 0, &strv_a);
         if (r >= 0)
-                ASSERT_NOT_NULL(joined = strv_join(strv_a, "\", \""));
+                ASSERT_NOT_NULL((joined = strv_join(strv_a, "\", \"")));
         log_info("      \"%s\"", r >= 0 ? joined : errno_to_name(r));
 
         joined = mfree(joined);
 
         r = pid_get_cmdline_strv(pid, PROCESS_CMDLINE_COMM_FALLBACK, &strv_b);
         if (r >= 0)
-                ASSERT_NOT_NULL(joined = strv_join(strv_b, "\", \""));
+                ASSERT_NOT_NULL((joined = strv_join(strv_b, "\", \"")));
         log_info("      \"%s\"", r >= 0 ? joined : errno_to_name(r));
 }
 

diff --git a/src/test/test-strv.c b/src/test/test-strv.c
index f0e9031b9a1695397a8cc6deaf0a430f72d88060..d64cc55c5b63a1b62d8d9894f6e1a9e7ecb4556d 100644 (file)
--- a/src/test/test-strv.c
+++ b/src/test/test-strv.c
@@ -551,41 +551,41 @@ TEST(strv_sort_uniq) {
 
         ASSERT_NULL(strv_sort_uniq(a));
 
-        ASSERT_NOT_NULL(a = strv_new(NULL));
+        ASSERT_NOT_NULL((a = strv_new(NULL)));
         assert_se(strv_sort_uniq(a) == a);
         ASSERT_NULL(a[0]);
         a = strv_free(a);
 
-        ASSERT_NOT_NULL(a = strv_new("a", "a", "a", "a", "a"));
+        ASSERT_NOT_NULL((a = strv_new("a", "a", "a", "a", "a")));
         assert_se(strv_sort_uniq(a) == a);
         ASSERT_STREQ(a[0], "a");
         ASSERT_NULL(a[1]);
         a = strv_free(a);
 
-        ASSERT_NOT_NULL(a = strv_new("a", "a", "a", "a", "b"));
+        ASSERT_NOT_NULL((a = strv_new("a", "a", "a", "a", "b")));
         assert_se(strv_sort_uniq(a) == a);
         ASSERT_STREQ(a[0], "a");
         ASSERT_STREQ(a[1], "b");
         ASSERT_NULL(a[2]);
         a = strv_free(a);
 
-        ASSERT_NOT_NULL(a = strv_new("b", "a", "a", "a", "a"));
+        ASSERT_NOT_NULL((a = strv_new("b", "a", "a", "a", "a")));
         assert_se(strv_sort_uniq(a) == a);
         ASSERT_STREQ(a[0], "a");
         ASSERT_STREQ(a[1], "b");
         ASSERT_NULL(a[2]);
         a = strv_free(a);
 
-        ASSERT_NOT_NULL(a = strv_new("a", "a", "b", "a", "b"));
+        ASSERT_NOT_NULL((a = strv_new("a", "a", "b", "a", "b")));
         assert_se(strv_sort_uniq(a) == a);
         ASSERT_STREQ(a[0], "a");
         ASSERT_STREQ(a[1], "b");
         ASSERT_NULL(a[2]);
         a = strv_free(a);
 
-        ASSERT_NOT_NULL(a = strv_copy((char**) input_table));
-        ASSERT_NOT_NULL(b = strv_copy((char**) input_table));
-        ASSERT_NOT_NULL(c = strv_copy((char**) input_table));
+        ASSERT_NOT_NULL((a = strv_copy((char**) input_table)));
+        ASSERT_NOT_NULL((b = strv_copy((char**) input_table)));
+        ASSERT_NOT_NULL((c = strv_copy((char**) input_table)));
 
         assert_se(strv_sort_uniq(a) == a);
         assert_se(strv_sort(strv_uniq(b)) == b);
@@ -664,8 +664,8 @@ TEST(strv_extend_strv_consume) {
         _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **n = NULL;
         const char *s1, *s2, *s3;
 
-        ASSERT_NOT_NULL(a = strv_new("abc", "def", "ghi"));
-        ASSERT_NOT_NULL(b = strv_new("jkl", "mno", "abc", "pqr"));
+        ASSERT_NOT_NULL((a = strv_new("abc", "def", "ghi")));
+        ASSERT_NOT_NULL((b = strv_new("jkl", "mno", "abc", "pqr")));
 
         s1 = b[0];
         s2 = b[1];
@@ -685,7 +685,7 @@ TEST(strv_extend_strv_consume) {
         ASSERT_STREQ(a[5], "pqr");
         ASSERT_EQ(strv_length(a), (size_t) 6);
 
-        ASSERT_NOT_NULL(c = strv_new("jkl", "mno"));
+        ASSERT_NOT_NULL((c = strv_new("jkl", "mno")));
 
         s1 = c[0];
         s2 = c[1];

diff --git a/src/test/test-terminal-util.c b/src/test/test-terminal-util.c
index a5616c81212f5ff70c7949d39bd9d06123b55e83..f454d3ea60ad668ae8bb85f2e1770f4f8f00d415 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-time-util.c b/src/test/test-time-util.c
index d717ca94d2fbaed66dd2224f293f88d9a0427458..f0daa500eb6a3381aa851a1192da0408e9f41db8 100644 (file)
--- a/src/test/test-time-util.c
+++ b/src/test/test-time-util.c
@@ -966,7 +966,7 @@ static void test_parse_timestamp_impl(const char *tz) {
         if (tz) {
                 _cleanup_free_ char *s = NULL;
 
-                ASSERT_NOT_NULL(s = strjoin("Fri 2012-11-23 23:02:15 ", tz));
+                ASSERT_NOT_NULL((s = strjoin("Fri 2012-11-23 23:02:15 ", tz)));
                 ASSERT_OK(parse_timestamp(s, NULL));
         }
 

diff --git a/src/test/test-unit-file.c b/src/test/test-unit-file.c
index a84e6aaf9756d8a2f85f3f9d6987049ddba3a537..1561265a3e4568e4de52760628cacd15ccb16fee 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. */
 
@@ -158,7 +158,7 @@ TEST(unit_file_remove_from_name_map) {
 
         _cleanup_(lookup_paths_done) LookupPaths lp = {};
         ASSERT_OK(lookup_paths_init(&lp, RUNTIME_SCOPE_SYSTEM, LOOKUP_PATHS_TEMPORARY_GENERATED, NULL));
-        ASSERT_NOT_NULL(d = strdup(lp.temporary_dir));
+        ASSERT_NOT_NULL((d = strdup(lp.temporary_dir)));
 
         for (size_t i = 0; i < 10; i++)
                 if (test_unit_file_remove_from_name_map_trail(&lp, i))

diff --git a/src/test/test-user-util.c b/src/test/test-user-util.c
index bf8dd16d5ba66f5b64534093841bb26c59af074c..0255c5775a958f95016ac549afac02430cd0504f 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);
 }
 

diff --git a/src/test/test-xattr-util.c b/src/test/test-xattr-util.c
index 89915188546e29e4ee1f1055eaacd550ea1fbaa0..169be82e596d8cdfdbd7a31b83268dd77ef6f789 100644 (file)
--- a/src/test/test-xattr-util.c
+++ b/src/test/test-xattr-util.c
@@ -102,7 +102,7 @@ static void xattr_symlink_test_one(int fd, const char *path) {
         r = listxattr_at_malloc(fd, path, 0, &list);
         ASSERT_OK(r);
         ASSERT_GE(r, (int) sizeof("trusted.test\0trusted.bar"));
-        ASSERT_NOT_NULL(list_split = strv_parse_nulstr(list, r));
+        ASSERT_NOT_NULL((list_split = strv_parse_nulstr(list, r)));
         ASSERT_TRUE(strv_contains(list_split, "trusted.bar"));
         ASSERT_TRUE(strv_contains(list_split, "trusted.test"));
 

diff --git a/src/udev/test-udev-spawn.c b/src/udev/test-udev-spawn.c
index b4e020cea6cefef08a19828da2cce15dad19bc0a..e4c8f0c70d12b34438ab014a21eb6bb83fc078d8 100644 (file)
--- a/src/udev/test-udev-spawn.c
+++ b/src/udev/test-udev-spawn.c
@@ -17,7 +17,7 @@ static void test_event_spawn_core(bool with_pidfd, const char *cmd, char *result
         ASSERT_OK_ERRNO(setenv("SYSTEMD_PIDFD", yes_no(with_pidfd), 1));
 
         ASSERT_OK(sd_device_new_from_syspath(&dev, "/sys/class/net/lo"));
-        ASSERT_NOT_NULL(event = udev_event_new(dev, NULL, EVENT_TEST_SPAWN));
+        ASSERT_NOT_NULL((event = udev_event_new(dev, NULL, EVENT_TEST_SPAWN)));
         ASSERT_OK_ZERO(udev_event_spawn(event, false, cmd, result_buf, buf_size, NULL));
 
         ASSERT_OK_ERRNO(unsetenv("SYSTEMD_PIDFD"));
@@ -36,7 +36,7 @@ static void test_event_spawn_cat(bool with_pidfd, size_t buf_size) {
         test_event_spawn_core(with_pidfd, cmd, result_buf,
                               buf_size >= BUF_SIZE ? BUF_SIZE : buf_size);
 
-        ASSERT_NOT_NULL(lines = strv_split_newlines(result_buf));
+        ASSERT_NOT_NULL((lines = strv_split_newlines(result_buf)));
         strv_print(lines);
 
         if (buf_size >= BUF_SIZE) {
@@ -53,11 +53,11 @@ static void test_event_spawn_self(const char *self, const char *arg, bool with_p
         log_debug("/* %s(%s, %s) */", __func__, arg, yes_no(with_pidfd));
 
         /* 'self' may contain spaces, hence needs to be quoted. */
-        ASSERT_NOT_NULL(cmd = strjoin("'", self, "' ", arg));
+        ASSERT_NOT_NULL((cmd = strjoin("'", self, "' ", arg)));
 
         test_event_spawn_core(with_pidfd, cmd, result_buf, BUF_SIZE);
 
-        ASSERT_NOT_NULL(lines = strv_split_newlines(result_buf));
+        ASSERT_NOT_NULL((lines = strv_split_newlines(result_buf)));
         strv_print(lines);
 
         ASSERT_TRUE(strv_contains(lines, "aaa"));