diff --git a/src/home/homectl.c b/src/home/homectl.c index 291ce8eaf17..65243e4a6fe 100644 --- a/src/home/homectl.c +++ b/src/home/homectl.c @@ -2548,7 +2548,7 @@ static int create_or_register_from_credentials(void) { const char *e; if ((e = startswith(de->d_name, "home.create."))) op = OPERATION_CREATE; - if ((e = startswith(de->d_name, "home.register."))) + else if ((e = startswith(de->d_name, "home.register."))) op = OPERATION_REGISTER; else continue; diff --git a/src/home/homed-manager-bus.c b/src/home/homed-manager-bus.c index a3fe2b6a69a..bf252ce835c 100644 --- a/src/home/homed-manager-bus.c +++ b/src/home/homed-manager-bus.c @@ -993,7 +993,7 @@ static int method_add_signing_key(sd_bus_message *message, void *userdata, sd_bu return log_error_errno(r, "Failed to convert public key to PEM: %m"); _cleanup_free_ char *fn_copy = strdup(fn); - if (!fn) + if (!fn_copy) return log_oom(); _cleanup_free_ char *p = path_join("/var/lib/systemd/home/", fn); diff --git a/src/libsystemd/sd-device/test-sd-device-monitor.c b/src/libsystemd/sd-device/test-sd-device-monitor.c index 1cdeabbf21e..01681792ca3 100644 --- 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 6394507994f..79a3d30356f 100644 --- 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 f9b755a8ce3..80bb436ea57 100644 --- 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/libsystemd/sd-netlink/test-netlink.c b/src/libsystemd/sd-netlink/test-netlink.c index 7c1bd0d9df4..9862904e306 100644 --- a/src/libsystemd/sd-netlink/test-netlink.c +++ b/src/libsystemd/sd-netlink/test-netlink.c @@ -94,11 +94,11 @@ TEST(message_address) { const char *label; int r; - ASSERT_OK(sd_netlink_open(&rtnl) >= 0); + ASSERT_OK(sd_netlink_open(&rtnl)); ifindex = (int) if_nametoindex("lo"); - ASSERT_OK(sd_rtnl_message_new_addr(rtnl, &message, RTM_GETADDR, ifindex, AF_INET) >= 0); - ASSERT_OK(sd_netlink_message_set_request_dump(message, true) >= 0); + ASSERT_OK(sd_rtnl_message_new_addr(rtnl, &message, RTM_GETADDR, ifindex, AF_INET)); + ASSERT_OK(sd_netlink_message_set_request_dump(message, true)); ASSERT_OK((r = sd_netlink_call(rtnl, message, 0, &reply))); @@ -117,21 +117,21 @@ TEST(message_route) { struct in_addr addr, addr_data; uint32_t index = 2, u32_data; - ASSERT_OK(sd_netlink_open(&rtnl) >= 0); + ASSERT_OK(sd_netlink_open(&rtnl)); - ASSERT_OK(sd_rtnl_message_new_route(rtnl, &req, RTM_NEWROUTE, AF_INET, RTPROT_STATIC) >= 0); + ASSERT_OK(sd_rtnl_message_new_route(rtnl, &req, RTM_NEWROUTE, AF_INET, RTPROT_STATIC)); addr.s_addr = htobe32(INADDR_LOOPBACK); - ASSERT_OK(sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &addr) >= 0); - ASSERT_OK(sd_netlink_message_append_u32(req, RTA_OIF, index) >= 0); + ASSERT_OK(sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &addr)); + ASSERT_OK(sd_netlink_message_append_u32(req, RTA_OIF, index)); - ASSERT_OK(sd_netlink_message_rewind(req, rtnl) >= 0); + ASSERT_OK(sd_netlink_message_rewind(req, rtnl)); - ASSERT_OK(sd_netlink_message_read_in_addr(req, RTA_GATEWAY, &addr_data) >= 0); + ASSERT_OK(sd_netlink_message_read_in_addr(req, RTA_GATEWAY, &addr_data)); ASSERT_EQ(addr_data.s_addr, addr.s_addr); - ASSERT_OK(sd_netlink_message_read_u32(req, RTA_OIF, &u32_data) >= 0); + ASSERT_OK(sd_netlink_message_read_u32(req, RTA_OIF, &u32_data)); ASSERT_EQ(u32_data, index); ASSERT_NULL((req = sd_netlink_message_unref(req))); diff --git a/src/network/generator/test-network-generator.c b/src/network/generator/test-network-generator.c index 92118907b7e..dec84abc8f1 100644 --- 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 f44383d03ab..032c2e75dc7 100644 --- 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 fe30d9a2fe8..1de1fe8e111 100644 --- 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 bd68f58baeb..f7e0f5ca4d4 100644 --- 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 349c5a6894b..31fdd7f0e2b 100644 --- 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 510264c547e..16f470a08ea 100644 --- 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 ef0a98a29fb..be5fe67879e 100644 --- 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 a4309c0134f..233f58b90e1 100644 --- 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 e82c8fd755d..070b02fa90a 100644 --- 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 f2224910b0a..c5d0707e136 100644 --- 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 3bfbf1fc467..0c80770c4dd 100644 --- 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 6bcf353887f..3c75be30e57 100644 --- 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 eb3bfec2bb3..4ff95deaea7 100644 --- 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 8dd5746495e..5cbcf9f68f1 100644 --- 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 b2cc910dd13..bd4698f0832 100644 --- 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 ce6a43101e5..ccaaacc812d 100644 --- 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 cae65a14b10..25393baf73f 100644 --- 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 e9a461b141b..d24bcb768f1 100644 --- 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 f0e9031b9a1..d64cc55c5b6 100644 --- 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 a5616c81212..f454d3ea60a 100644 --- 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 d717ca94d2f..f0daa500eb6 100644 --- 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 a84e6aaf975..1561265a3e4 100644 --- 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 bf8dd16d5ba..0255c5775a9 100644 --- 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 89915188546..169be82e596 100644 --- 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 b4e020cea6c..e4c8f0c70d1 100644 --- 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"));