test: use assert_se() instead of assert()

diff --git a/src/libsystemd-network/test-dhcp-option.c b/src/libsystemd-network/test-dhcp-option.c
index d152e7925d75b4da59148987249eab0d3fda2291..c4a0d4ccb2696c68eb416bb2847cd5ae46cb4596 100644 (file)
--- a/src/libsystemd-network/test-dhcp-option.c
+++ b/src/libsystemd-network/test-dhcp-option.c
@@ -121,7 +121,7 @@ static DHCPMessage *create_message(uint8_t *options, uint16_t optlen,
 }
 
 static void test_ignore_opts(uint8_t *descoption, int *descpos, int *desclen) {
-        assert(*descpos >= 0);
+        assert_se(*descpos >= 0);
 
         while (*descpos < *desclen) {
                 switch(descoption[*descpos]) {

diff --git a/src/libsystemd/sd-bus/test-bus-address.c b/src/libsystemd/sd-bus/test-bus-address.c
index b92558fea9d43ad5dbfac4e5fe85f3e007ea6642..59421094c566c3739e753ae4e914a81d5373c9b6 100644 (file)
--- a/src/libsystemd/sd-bus/test-bus-address.c
+++ b/src/libsystemd/sd-bus/test-bus-address.c
@@ -16,7 +16,7 @@ static void test_one_address(sd_bus *b,
         r = bus_set_address_system_remote(b, host);
         log_info("\"%s\" → %d, \"%s\"", host, r, strna(r >= 0 ? b->address : NULL));
         if (result < 0 || expected) {
-                assert(r == result);
+                assert_se(r == result);
                 if (r >= 0)
                         assert_se(streq(b->address, expected));
         }

diff --git a/src/libsystemd/sd-event/test-event.c b/src/libsystemd/sd-event/test-event.c
index e28885b5e06c6931ef899b73f1e2dd9da380fc9a..406d10d92b43bf0d2db94d7657a3453c6b05e6db 100644 (file)
--- a/src/libsystemd/sd-event/test-event.c
+++ b/src/libsystemd/sd-event/test-event.c
@@ -404,8 +404,8 @@ struct inotify_context {
 static void maybe_exit(sd_event_source *s, struct inotify_context *c) {
         unsigned n;
 
-        assert(s);
-        assert(c);
+        assert_se(s);
+        assert_se(c);
 
         if (!c->delete_self_handler_called)
                 return;

diff --git a/src/libsystemd/sd-journal/test-compress.c b/src/libsystemd/sd-journal/test-compress.c
index 54e0e738b3b645e0f13b3ab1496996de0767a4ca..615bbb2934604c603dbe42ce0aa2b625560409a8 100644 (file)
--- a/src/libsystemd/sd-journal/test-compress.c
+++ b/src/libsystemd/sd-journal/test-compress.c
@@ -118,7 +118,7 @@ _unused_ static void test_decompress_startswith(const char *compression,
                 compressed = compressed2 = malloc(BUFSIZE_2);
                 assert_se(compressed2);
                 r = compress(data, data_len, compressed, BUFSIZE_2, &csize);
-                assert(r == 0);
+                assert_se(r == 0);
         }
         assert_se(r == 0);
 

diff --git a/src/libsystemd/sd-netlink/test-netlink.c b/src/libsystemd/sd-netlink/test-netlink.c
index c5a5e512a203f1c2d2f2254a5d517d06ea9aeb2f..fbc3ef06094fb342198d3b0462add1ff2654e364 100644 (file)
--- a/src/libsystemd/sd-netlink/test-netlink.c
+++ b/src/libsystemd/sd-netlink/test-netlink.c
@@ -287,7 +287,7 @@ struct test_async_object {
 };
 
 static struct test_async_object *test_async_object_free(struct test_async_object *t) {
-        assert(t);
+        assert_se(t);
 
         free(t->ifname);
         return mfree(t);
@@ -315,7 +315,7 @@ static int link_handler2(sd_netlink *rtnl, sd_netlink_message *m, void *userdata
 static void test_async_object_destroy(void *userdata) {
         struct test_async_object *t = userdata;
 
-        assert(userdata);
+        assert_se(userdata);
 
         log_info("%s: n_ref=%u", __func__, t->n_ref);
         test_async_object_unref(t);
@@ -593,8 +593,8 @@ static int genl_ctrl_match_callback(sd_netlink *genl, sd_netlink_message *m, voi
         uint16_t id;
         uint8_t cmd;
 
-        assert(genl);
-        assert(m);
+        assert_se(genl);
+        assert_se(m);
 
         assert_se(sd_genl_message_get_family_name(genl, m, &name) >= 0);
         assert_se(streq(name, CTRL_GENL_NAME));

diff --git a/src/oom/test-oomd-util.c b/src/oom/test-oomd-util.c
index 29f2c54ab13aa046961073ffeb33a9345b52c6c7..265e77c0a2468f9bbe1095946beaff4cc537fe4d 100644 (file)
--- a/src/oom/test-oomd-util.c
+++ b/src/oom/test-oomd-util.c
@@ -52,7 +52,7 @@ static void test_oomd_cgroup_kill(void) {
         /* Create another cgroup below this one for the pids we forked off. We need this to be managed
          * by the test so that pid1 doesn't delete it before we can read the xattrs. */
         cgroup = path_join(cgroup_root, "oomdkilltest");
-        assert(cgroup);
+        assert_se(cgroup);
         assert_se(cg_create(SYSTEMD_CGROUP_CONTROLLER, cgroup) >= 0);
 
         /* If we don't have permissions to set xattrs we're likely in a userns or missing capabilities */

diff --git a/src/resolve/test-resolved-etc-hosts.c b/src/resolve/test-resolved-etc-hosts.c
index 6706885ebd0e63b1f74521c0c8d8b1566157746f..cc55a980ad2e605f41956c2da511ade784eefb06 100644 (file)
--- a/src/resolve/test-resolved-etc-hosts.c
+++ b/src/resolve/test-resolved-etc-hosts.c
@@ -105,14 +105,14 @@ static void test_parse_etc_hosts(void) {
         assert_se(address_equal_4(bn->addresses[2], inet_addr("1.2.3.11")));
         assert_se(address_equal_4(bn->addresses[3], inet_addr("1.2.3.12")));
 
-        assert(!hashmap_get(hosts.by_name, "within.comment"));
-        assert(!hashmap_get(hosts.by_name, "within.comment2"));
-        assert(!hashmap_get(hosts.by_name, "within.comment3"));
-        assert(!hashmap_get(hosts.by_name, "#"));
-
-        assert(!hashmap_get(hosts.by_name, "short.address"));
-        assert(!hashmap_get(hosts.by_name, "long.address"));
-        assert(!hashmap_get(hosts.by_name, "multi.colon"));
+        assert_se(!hashmap_get(hosts.by_name, "within.comment"));
+        assert_se(!hashmap_get(hosts.by_name, "within.comment2"));
+        assert_se(!hashmap_get(hosts.by_name, "within.comment3"));
+        assert_se(!hashmap_get(hosts.by_name, "#"));
+
+        assert_se(!hashmap_get(hosts.by_name, "short.address"));
+        assert_se(!hashmap_get(hosts.by_name, "long.address"));
+        assert_se(!hashmap_get(hosts.by_name, "multi.colon"));
         assert_se(!set_contains(hosts.no_address, "short.address"));
         assert_se(!set_contains(hosts.no_address, "long.address"));
         assert_se(!set_contains(hosts.no_address, "multi.colon"));

diff --git a/src/test/test-boot-timestamps.c b/src/test/test-boot-timestamps.c
index 23155b2d98b61580bf2a3208d97c90214a1cea8b..2bee2d5c1d6fc2c278d0ac60b6ab881da693b106 100644 (file)
--- a/src/test/test-boot-timestamps.c
+++ b/src/test/test-boot-timestamps.c
@@ -76,11 +76,11 @@ int main(int argc, char* argv[]) {
         test_setup_logging(LOG_DEBUG);
 
         p = test_acpi_fpdt();
-        assert(p >= 0);
+        assert_se(p >= 0);
         q = test_efi_loader();
-        assert(q >= 0);
+        assert_se(q >= 0);
         r = test_boot_timestamps();
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         if (p == 0 && q == 0 && r == 0)
                 return log_tests_skipped("access to firmware variables not possible");

diff --git a/src/test/test-bpf-firewall.c b/src/test/test-bpf-firewall.c
index 1e0ad177b9956616fa9e49b2677bb19e6860e4db..732350fae43306d242e3706075978bbb797d1d13 100644 (file)
--- a/src/test/test-bpf-firewall.c
+++ b/src/test/test-bpf-firewall.c
@@ -56,10 +56,10 @@ int main(int argc, char *argv[]) {
         assert_se(runtime_dir = setup_fake_runtime_dir());
 
         r = bpf_program_new(BPF_PROG_TYPE_CGROUP_SKB, &p);
-        assert(r == 0);
+        assert_se(r == 0);
 
         r = bpf_program_add_instructions(p, exit_insn, ELEMENTSOF(exit_insn));
-        assert(r == 0);
+        assert_se(r == 0);
 
         if (getuid() != 0)
                 return log_tests_skipped("not running as root");
@@ -76,7 +76,7 @@ int main(int argc, char *argv[]) {
                 log_notice("BPF firewalling (though without BPF_F_ALLOW_MULTI) supported. Good.");
 
         r = bpf_program_load_kernel(p, log_buf, ELEMENTSOF(log_buf));
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         if (test_custom_filter) {
                 zero(attr);
@@ -158,8 +158,8 @@ int main(int argc, char *argv[]) {
                 return log_tests_skipped("Kernel doesn't support the necessary bpf bits (masked out via seccomp?)");
         assert_se(r >= 0);
 
-        assert(u->ip_bpf_ingress);
-        assert(u->ip_bpf_egress);
+        assert_se(u->ip_bpf_ingress);
+        assert_se(u->ip_bpf_egress);
 
         r = bpf_program_load_kernel(u->ip_bpf_ingress, log_buf, ELEMENTSOF(log_buf));
 
@@ -168,7 +168,7 @@ int main(int argc, char *argv[]) {
         log_notice("%s", log_buf);
         log_notice("-------");
 
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         r = bpf_program_load_kernel(u->ip_bpf_egress, log_buf, ELEMENTSOF(log_buf));
 
@@ -177,7 +177,7 @@ int main(int argc, char *argv[]) {
         log_notice("%s", log_buf);
         log_notice("-------");
 
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         assert_se(unit_start(u) >= 0);
 

diff --git a/src/test/test-bus-util.c b/src/test/test-bus-util.c
index 0381ba1ee4feb24e47df3341a1d4c1e373556dc7..5aa1bfac0e5db003f5243d9433911b57045af2b7 100644 (file)
--- a/src/test/test-bus-util.c
+++ b/src/test/test-bus-util.c
@@ -30,7 +30,7 @@ static void test_destroy_callback(void) {
         }
 
         r = sd_bus_request_name_async(bus, &slot, "org.freedesktop.systemd.test-bus-util", 0, callback, &n_called);
-        assert(r == 1);
+        assert_se(r == 1);
 
         assert_se(sd_bus_slot_get_destroy_callback(slot, NULL) == 0);
         assert_se(sd_bus_slot_get_destroy_callback(slot, &t) == 0);
@@ -41,9 +41,9 @@ static void test_destroy_callback(void) {
         assert_se(t == destroy_callback);
 
         /* Force cleanup so we can look at n_called */
-        assert(n_called == 0);
+        assert_se(n_called == 0);
         sd_bus_slot_unref(slot);
-        assert(n_called == 1);
+        assert_se(n_called == 1);
 }
 
 int main(int argc, char **argv) {

diff --git a/src/test/test-calendarspec.c b/src/test/test-calendarspec.c
index 5d680f9b9a469e9d2b250daebc2f73442789fc10..fe76d27752e6d57a9f7eedc214455bff8084c232 100644 (file)
--- a/src/test/test-calendarspec.c
+++ b/src/test/test-calendarspec.c
@@ -58,7 +58,7 @@ static void _test_next(int line, const char *input, const char *new_tz, usec_t a
         if (expect != USEC_INFINITY)
                 assert_se(r >= 0 && u == expect);
         else
-                assert(r == -ENOENT);
+                assert_se(r == -ENOENT);
 
         calendar_spec_free(c);
 

diff --git a/src/test/test-capability.c b/src/test/test-capability.c
index 94f15bfb213a9798754d84d3aa5e33e3e917901d..c5596bb6c3c2765324630ee4db8bf6a4dbebc6d3 100644 (file)
--- a/src/test/test-capability.c
+++ b/src/test/test-capability.c
@@ -194,7 +194,7 @@ static void test_update_inherited_set(void) {
 
         assert_se(!capability_update_inherited_set(caps, set));
         assert_se(!cap_get_flag(caps, CAP_CHOWN, CAP_INHERITABLE, &fv));
-        assert(fv == CAP_SET);
+        assert_se(fv == CAP_SET);
 
         cap_free(caps);
 }

diff --git a/src/test/test-cgroup-util.c b/src/test/test-cgroup-util.c
index c2adfa07ce02cc6eab869e36e254d014605ca15e..bc5eda61f8e8e9ed98498fb0e0610ac96011024b 100644 (file)
--- a/src/test/test-cgroup-util.c
+++ b/src/test/test-cgroup-util.c
@@ -395,12 +395,12 @@ static void test_cg_get_keyed_attribute(void) {
 
         assert_se(cg_get_keyed_attribute("cpu", "/init.scope", "cpu.stat", STRV_MAKE("usage_usec", "no_such_attr"), vals3) == -ENXIO);
         assert_se(cg_get_keyed_attribute_graceful("cpu", "/init.scope", "cpu.stat", STRV_MAKE("usage_usec", "no_such_attr"), vals3) == 1);
-        assert(vals3[0] && !vals3[1]);
+        assert_se(vals3[0] && !vals3[1]);
         free(vals3[0]);
 
         assert_se(cg_get_keyed_attribute("cpu", "/init.scope", "cpu.stat", STRV_MAKE("usage_usec", "usage_usec"), vals3) == -ENXIO);
         assert_se(cg_get_keyed_attribute_graceful("cpu", "/init.scope", "cpu.stat", STRV_MAKE("usage_usec", "usage_usec"), vals3) == 1);
-        assert(vals3[0] && !vals3[1]);
+        assert_se(vals3[0] && !vals3[1]);
         free(vals3[0]);
 
         assert_se(cg_get_keyed_attribute("cpu", "/init.scope", "cpu.stat",

diff --git a/src/test/test-chase-symlinks.c b/src/test/test-chase-symlinks.c
index 5f53eba101a15019b1d4cc696ec7a16b8b19d9dd..9e50c5c7490875345c8392e6912de93abe91a160 100644 (file)
--- a/src/test/test-chase-symlinks.c
+++ b/src/test/test-chase-symlinks.c
@@ -34,8 +34,8 @@ static int parse_argv(int argc, char *argv[]) {
 
         int c;
 
-        assert(argc >= 0);
-        assert(argv);
+        assert_se(argc >= 0);
+        assert_se(argv);
 
         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0)
                 switch (c) {
@@ -103,9 +103,9 @@ static int run(int argc, char **argv) {
                 else {
                         log_info("→ %s", p);
                         if (arg_open)
-                                assert(fd >= 0);
+                                assert_se(fd >= 0);
                         else
-                                assert(fd == -1);
+                                assert_se(fd == -1);
                 }
         }
 

diff --git a/src/test/test-condition.c b/src/test/test-condition.c
index 62776086c287b187bf60294c35d75d1ef00da699..d7cd63da815f0fdea7e40be79a50d03304397077 100644 (file)
--- a/src/test/test-condition.c
+++ b/src/test/test-condition.c
@@ -689,12 +689,12 @@ static void test_condition_test_group(void) {
         free(gid);
 
         ngroups_max = sysconf(_SC_NGROUPS_MAX);
-        assert(ngroups_max > 0);
+        assert_se(ngroups_max > 0);
 
         gids = newa(gid_t, ngroups_max);
 
         ngroups = getgroups(ngroups_max, gids);
-        assert(ngroups >= 0);
+        assert_se(ngroups >= 0);
 
         max_gid = getgid();
         for (i = 0; i < ngroups; i++) {

diff --git a/src/test/test-cpu-set-util.c b/src/test/test-cpu-set-util.c
index 0cfc883d66885d2c951e4ba99089f7c710fbb0bf..c07b93950620e83330d28a0898c1d58b0e46fa42 100644 (file)
--- a/src/test/test-cpu-set-util.c
+++ b/src/test/test-cpu-set-util.c
@@ -256,7 +256,7 @@ static void test_cpu_set_to_from_dbus(void) {
 
         assert_se(allocated <= sizeof expected);
         assert_se(allocated >= DIV_ROUND_UP(201u, 8u)); /* We need at least 201 bits for our mask */
-        assert(memcmp(array, expected, allocated) == 0);
+        assert_se(memcmp(array, expected, allocated) == 0);
 
         assert_se(cpu_set_from_dbus(array, allocated, &c2) == 0);
         assert_se(c2.set);
@@ -268,7 +268,7 @@ static void test_cpus_in_affinity_mask(void) {
         int r;
 
         r = cpus_in_affinity_mask();
-        assert(r > 0);
+        assert_se(r > 0);
         log_info("cpus_in_affinity_mask: %d", r);
 }
 

diff --git a/src/test/test-escape.c b/src/test/test-escape.c
index 413e8cd860e734972a56923710789f369e895cfd..3fd318653c2291cf64508c0d0c7befdc30ee5565 100644 (file)
--- a/src/test/test-escape.c
+++ b/src/test/test-escape.c
@@ -58,8 +58,8 @@ static void test_xescape_full(bool eight_bits) {
                 log_info("%02d: <%s>", i, q);
                 if (i > 0)
                         assert_se(endswith(q, "."));
-                assert(strlen(q) <= i);
-                assert(strlen(q) + 3 >= strlen(t));
+                assert_se(strlen(q) <= i);
+                assert_se(strlen(q) + 3 >= strlen(t));
         }
 }
 

diff --git a/src/test/test-exec-util.c b/src/test/test-exec-util.c
index 4c11f54cef5e8ca714716b37d07889e964179b04..ae740218b2dbb6617d646cb3ce9c0e63d7322f1d 100644 (file)
--- a/src/test/test-exec-util.c
+++ b/src/test/test-exec-util.c
@@ -26,22 +26,22 @@ static void *ignore_stdout_args[] = { &here, &here2, &here3 };
 
 /* noop handlers, just check that arguments are passed correctly */
 static int ignore_stdout_func(int fd, void *arg) {
-        assert(fd >= 0);
-        assert(arg == &here);
+        assert_se(fd >= 0);
+        assert_se(arg == &here);
         safe_close(fd);
 
         return 0;
 }
 static int ignore_stdout_func2(int fd, void *arg) {
-        assert(fd >= 0);
-        assert(arg == &here2);
+        assert_se(fd >= 0);
+        assert_se(arg == &here2);
         safe_close(fd);
 
         return 0;
 }
 static int ignore_stdout_func3(int fd, void *arg) {
-        assert(fd >= 0);
-        assert(arg == &here3);
+        assert_se(fd >= 0);
+        assert_se(arg == &here3);
         safe_close(fd);
 
         return 0;

diff --git a/src/test/test-execute.c b/src/test/test-execute.c
index 98989f405a8dd2f0704f8ef3c891f289280d671c..b9c1dc72c2393c1298f56b9c597f769dd306769f 100644 (file)
--- a/src/test/test-execute.c
+++ b/src/test/test-execute.c
@@ -174,7 +174,7 @@ static bool check_user_has_group_with_same_name(const char *name) {
         struct passwd *p;
         struct group *g;
 
-        assert(name);
+        assert_se(name);
 
         p = getpwnam(name);
         if (!p ||
@@ -510,8 +510,8 @@ static int on_spawn_io(sd_event_source *s, int fd, uint32_t revents, void *userd
         char buf[4096];
         ssize_t l;
 
-        assert(s);
-        assert(fd >= 0);
+        assert_se(s);
+        assert_se(fd >= 0);
 
         l = read(fd, buf, sizeof(buf) - 1);
         if (l < 0) {
@@ -538,7 +538,7 @@ reenable:
 static int on_spawn_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
         pid_t *pid = userdata;
 
-        assert(pid);
+        assert_se(pid);
 
         (void) kill(*pid, SIGKILL);
 
@@ -548,7 +548,7 @@ static int on_spawn_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
 static int on_spawn_sigchld(sd_event_source *s, const siginfo_t *si, void *userdata) {
         int ret = -EIO;
 
-        assert(si);
+        assert_se(si);
 
         if (si->si_code == CLD_EXITED)
                 ret = si->si_status;
@@ -568,8 +568,8 @@ static int find_libraries(const char *exec, char ***ret) {
         pid_t pid;
         int r;
 
-        assert(exec);
-        assert(ret);
+        assert_se(exec);
+        assert_se(ret);
 
         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0);
 
@@ -653,7 +653,7 @@ static void test_exec_mount_apivfs(Manager *m) {
         _cleanup_strv_free_ char **libraries = NULL, **libraries_test = NULL;
         int r;
 
-        assert(user_runtime_unit_dir);
+        assert_se(user_runtime_unit_dir);
 
         r = find_executable("touch", &fullpath_touch);
         if (r < 0) {

diff --git a/src/test/test-fileio.c b/src/test/test-fileio.c
index fa8a66df042bcbff72849c6a1f2b58c89162bcfb..5c266c0c9adaf52082ca896a7efb3fc45a620779 100644 (file)
--- a/src/test/test-fileio.c
+++ b/src/test/test-fileio.c
@@ -241,7 +241,7 @@ static void test_merge_env_file(void) {
                                 "zzzz=${foobar:-${nothing}}\n"
                                 "zzzzz=${nothing:+${nothing}}\n"
                                 , WRITE_STRING_FILE_AVOID_NEWLINE);
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         r = merge_env_file(&a, NULL, t);
         assert_se(r >= 0);
@@ -305,7 +305,7 @@ static void test_merge_env_file_invalid(void) {
                                 "#\n"
                                 "\n\n"                  /* empty line */
                                 , WRITE_STRING_FILE_AVOID_NEWLINE);
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         r = merge_env_file(&a, NULL, t);
         assert_se(r >= 0);

diff --git a/src/test/test-firewall-util.c b/src/test/test-firewall-util.c
index d2843cfab73da20a52234a7f98f53e327f9efad8..f22bc3c5bcce903877ef187e125334a551190861 100644 (file)
--- a/src/test/test-firewall-util.c
+++ b/src/test/test-firewall-util.c
@@ -47,8 +47,8 @@ static void test_v6(FirewallContext *ctx) {
 }
 
 static union in_addr_union *parse_addr(const char *str, union in_addr_union *u) {
-        assert(str);
-        assert(u);
+        assert_se(str);
+        assert_se(u);
         assert_se(in_addr_from_string(AF_INET, str, u) >= 0);
         return u;
 }
@@ -82,7 +82,7 @@ static bool test_v4(FirewallContext *ctx) {
                 if (ignore)
                         return false;
         }
-        assert(r >= 0);
+        assert_se(r >= 0);
 
         assert_se(fw_add_masquerade(&ctx, true, AF_INET, parse_addr("10.0.2.0", &u), 28) >= 0);
         assert_se(fw_add_masquerade(&ctx, false, AF_INET, parse_addr("10.0.2.0", &u), 28) >= 0);

diff --git a/src/test/test-hashmap-plain.c b/src/test/test-hashmap-plain.c
index f7bc8a7b2b3e6b6e75db74ab1b542acbc656f0b1..45a475539950d49553124cd110b3d7af9e37f8a0 100644 (file)
--- a/src/test/test-hashmap-plain.c
+++ b/src/test/test-hashmap-plain.c
@@ -486,7 +486,7 @@ static void test_hashmap_foreach_key(void) {
                 hashmap_put(m, key, (void*) (const char*) "my dummy val");
 
         HASHMAP_FOREACH_KEY(s, key, m) {
-                assert(s);
+                assert_se(s);
                 if (!key_found[0] && streq(key, "key 1"))
                         key_found[0] = true;
                 else if (!key_found[1] && streq(key, "key 2"))

diff --git a/src/test/test-hostname-setup.c b/src/test/test-hostname-setup.c
index 55996500f3b264a436d800f135f97917386aa85f..dcd61b295fe9fe834eba2d81cb7ffd721338ce4e 100644 (file)
--- a/src/test/test-hostname-setup.c
+++ b/src/test/test-hostname-setup.c
@@ -15,7 +15,7 @@ static void test_read_etc_hostname(void) {
         int fd;
 
         fd = mkostemp_safe(path);
-        assert(fd > 0);
+        assert_se(fd > 0);
         close(fd);
 
         /* simple hostname */

diff --git a/src/test/test-install-root.c b/src/test/test-install-root.c
index 30494f7fa1fe443396a7a8fab234e2a9d226992b..ddba5e4dfffca8a5a87ad129aa59dd7ed2c0fc3b 100644 (file)
--- a/src/test/test-install-root.c
+++ b/src/test/test-install-root.c
@@ -286,7 +286,7 @@ static void test_linked_units(const char *root) {
                 else
                         assert_not_reached();
         }
-        assert(!p && !q);
+        assert_se(!p && !q);
         unit_file_changes_free(changes, n_changes);
         changes = NULL; n_changes = 0;
 
@@ -307,7 +307,7 @@ static void test_linked_units(const char *root) {
                 else
                         assert_not_reached();
         }
-        assert(!p && !q);
+        assert_se(!p && !q);
         unit_file_changes_free(changes, n_changes);
         changes = NULL; n_changes = 0;
 
@@ -328,7 +328,7 @@ static void test_linked_units(const char *root) {
                 else
                         assert_not_reached();
         }
-        assert(!p && !q);
+        assert_se(!p && !q);
         unit_file_changes_free(changes, n_changes);
         changes = NULL; n_changes = 0;
 
@@ -681,7 +681,7 @@ static void test_revert(const char *root) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
 
-        assert(root);
+        assert_se(root);
 
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "xx.service", NULL) == -ENOENT);
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "yy.service", NULL) == -ENOENT);
@@ -1103,13 +1103,13 @@ static void verify_one(
                        i->name, alias, r, expected,
                        alias2 ? " [" : "", strempty(alias2),
                        alias2 ? "]" : "");
-        assert(r == expected);
+        assert_se(r == expected);
 
         /* This is test for "instance propagation". This propagation matters mostly for WantedBy= and
          * RequiredBy= settings, and less so for Alias=. The only case where it should happen is when we have
          * an Alias=alias@.service an instantiated template template@instance. In that case the instance name
          * should be propagated into the alias as alias@instance. */
-        assert(streq_ptr(alias2, updated_name));
+        assert_se(streq_ptr(alias2, updated_name));
 }
 
 static void test_verify_alias(void) {

diff --git a/src/test/test-log.c b/src/test/test-log.c
index de8399dea8a1714d47f6ce66b969f4b5c58f91ae..cf438e6869fbfe34551b598d707009b90757e81f 100644 (file)
--- a/src/test/test-log.c
+++ b/src/test/test-log.c
@@ -23,7 +23,7 @@ static void test_file(void) {
         log_info("RELATIVE_SOURCE_PATH: %s", RELATIVE_SOURCE_PATH);
         log_info("PROJECT_FILE: %s", PROJECT_FILE);
 
-        assert(startswith(__FILE__, RELATIVE_SOURCE_PATH "/"));
+        assert_se(startswith(__FILE__, RELATIVE_SOURCE_PATH "/"));
 }
 
 static void test_log_struct(void) {

diff --git a/src/test/test-macro.c b/src/test/test-macro.c
index 428f3b952ae54fbfdb21cb4312e4cc02afc683ba..4acbbfb7afe64ae34871d74574bfcaec388a1981 100644 (file)
--- a/src/test/test-macro.c
+++ b/src/test/test-macro.c
@@ -243,15 +243,15 @@ static void test_foreach_pointer(void) {
                 k++;
         }
 
-        assert(k == 3);
+        assert_se(k == 3);
 
         FOREACH_POINTER(i, &b) {
-                assert(k == 3);
-                assert(i == &b);
+                assert_se(k == 3);
+                assert_se(i == &b);
                 k = 4;
         }
 
-        assert(k == 4);
+        assert_se(k == 4);
 
         FOREACH_POINTER(i, NULL, &c, NULL, &b, NULL, &a, NULL) {
                 switch (k) {
@@ -292,7 +292,7 @@ static void test_foreach_pointer(void) {
                 k++;
         }
 
-        assert(k == 11);
+        assert_se(k == 11);
 }
 
 static void test_align_to(void) {

diff --git a/src/test/test-modhex.c b/src/test/test-modhex.c
index 836460cec49bf44b967100d32c0ae6b0e81e01d5..314be9987926ecf220b20f6072f5103c0209c9e6 100644 (file)
--- a/src/test/test-modhex.c
+++ b/src/test/test-modhex.c
@@ -8,7 +8,7 @@ static void test_normalize_recovery_key(const char *t, const char *expected) {
         _cleanup_free_ char *z = NULL;
         int r;
 
-        assert(t);
+        assert_se(t);
 
         r = normalize_recovery_key(t, &z);
         assert_se(expected ?

diff --git a/src/test/test-path-lookup.c b/src/test/test-path-lookup.c
index da146aac2a0cb5ce45a7e5dabd7b679e99ca10a8..f0b716a4c5fd810c782062e1298f4aa967e69487 100644 (file)
--- a/src/test/test-path-lookup.c
+++ b/src/test/test-path-lookup.c
@@ -60,7 +60,7 @@ static void test_user_and_global_paths(void) {
                         k++;
                 }
                 log_info("  %s", *p);
-                assert(u[k]); /* If NULL, we didn't find a matching entry */
+                assert_se(u[k]); /* If NULL, we didn't find a matching entry */
                 k++;
         }
         STRV_FOREACH(p, u + k)

diff --git a/src/test/test-psi-util.c b/src/test/test-psi-util.c
index 857ecb59a460b1e865aed32b236ec822e3613863..d8d09118a6419034e25b6360aba50f18cecee283 100644 (file)
--- a/src/test/test-psi-util.c
+++ b/src/test/test-psi-util.c
@@ -42,7 +42,7 @@ static void test_read_mem_pressure(void) {
         assert_se(LOADAVG_INT_SIDE(rp.avg300) == 1);
         assert_se(LOADAVG_DECIMAL_SIDE(rp.avg300) == 11);
         assert_se(rp.total == 58761459);
-        assert(read_resource_pressure(path, PRESSURE_TYPE_FULL, &rp) == 0);
+        assert_se(read_resource_pressure(path, PRESSURE_TYPE_FULL, &rp) == 0);
         assert_se(LOADAVG_INT_SIDE(rp.avg10) == 0);
         assert_se(LOADAVG_DECIMAL_SIDE(rp.avg10) == 23);
         assert_se(LOADAVG_INT_SIDE(rp.avg60) == 0);
@@ -62,7 +62,7 @@ static void test_read_mem_pressure(void) {
         assert_se(LOADAVG_INT_SIDE(rp.avg300) == 1);
         assert_se(LOADAVG_DECIMAL_SIDE(rp.avg300) == 11);
         assert_se(rp.total == 58761459);
-        assert(read_resource_pressure(path, PRESSURE_TYPE_FULL, &rp) == 0);
+        assert_se(read_resource_pressure(path, PRESSURE_TYPE_FULL, &rp) == 0);
         assert_se(LOADAVG_INT_SIDE(rp.avg10) == 0);
         assert_se(LOADAVG_DECIMAL_SIDE(rp.avg10) == 23);
         assert_se(LOADAVG_INT_SIDE(rp.avg60) == 0);

diff --git a/src/test/test-recurse-dir.c b/src/test/test-recurse-dir.c
index c3961191c4665ef6e34f1e580579e4d17ad6f7d7..2c2120b136fda51fb84a4d94e37e53213f22871b 100644 (file)
--- a/src/test/test-recurse-dir.c
+++ b/src/test/test-recurse-dir.c
@@ -63,8 +63,8 @@ static int recurse_dir_callback(
 
         char ***l = userdata;
 
-        assert(path);
-        assert(de);
+        assert_se(path);
+        assert_se(de);
 
         switch (event) {
 

diff --git a/src/test/test-sd-hwdb.c b/src/test/test-sd-hwdb.c
index 7e1512a97dc6b0c6a313e5ad1c33108d45d1d94a..7ed6907cbd0af2d7fd2538bbfb4a3f8ccea04de2 100644 (file)
--- a/src/test/test-sd-hwdb.c
+++ b/src/test/test-sd-hwdb.c
@@ -45,11 +45,11 @@ static void test_basic_enumerate(void) {
 
         for (;;) {
                 r = sd_hwdb_enumerate(hwdb, &key, &value);
-                assert(IN_SET(r, 0, 1));
+                assert_se(IN_SET(r, 0, 1));
                 if (r == 0)
                         break;
-                assert(key);
-                assert(value);
+                assert_se(key);
+                assert_se(value);
                 log_debug("A: \"%s\" → \"%s\"", key, value);
                 len1 += strlen(key) + strlen(value);
         }

diff --git a/src/test/test-set.c b/src/test/test-set.c
index fd12021cfa7e4fa8aa17eabe58bb08009c269ab5..e63137192cbc82b4d5aa27f04b4f8de43bf3b2f6 100644 (file)
--- a/src/test/test-set.c
+++ b/src/test/test-set.c
@@ -143,7 +143,7 @@ static void test_set_copy(void) {
         copy = set_copy(s);
         assert_se(copy);
 
-        assert(set_equal(s, copy));
+        assert_se(set_equal(s, copy));
 
         set_free(s);
         set_free_free(copy);

diff --git a/src/test/test-signal-util.c b/src/test/test-signal-util.c
index 058677590255bb02a2ddaa9abff7d73fd20626ea..1e08b7a0624efd9c98c221c757a9f5b319386c05 100644 (file)
--- a/src/test/test-signal-util.c
+++ b/src/test/test-signal-util.c
@@ -16,7 +16,7 @@ static void test_rt_signals(void) {
         info(SIGRTMAX);
 
         /* We use signals SIGRTMIN+0 to SIGRTMIN+24 unconditionally */
-        assert(SIGRTMAX - SIGRTMIN >= 24);
+        assert_se(SIGRTMAX - SIGRTMIN >= 24);
 }
 
 static void test_signal_to_string_one(int val) {

diff --git a/src/test/test-socket-netlink.c b/src/test/test-socket-netlink.c
index da484a40032d07a443d370f5caa47f75a0493ebe..c7d039af5500af82bb7e5c76200f80476fbbadb8 100644 (file)
--- a/src/test/test-socket-netlink.c
+++ b/src/test/test-socket-netlink.c
@@ -16,7 +16,7 @@ static void test_socket_address_parse_one(const char *in, int ret, int family, c
                 r = socket_address_print(&a, &out);
                 if (r < 0)
                         log_error_errno(r, "Printing failed for \"%s\": %m", in);
-                assert(r >= 0);
+                assert_se(r >= 0);
                 assert_se(a.type == 0);
         }
 

diff --git a/src/test/test-socket-util.c b/src/test/test-socket-util.c
index 584253c2fcb60c9a70b91c6774756ab815f81700..f9b22c7e11c47ba1c089658e56cbb3fc9c435e8c 100644 (file)
--- a/src/test/test-socket-util.c
+++ b/src/test/test-socket-util.c
@@ -26,37 +26,37 @@ assert_cc(SUN_PATH_LEN == 108);
 static void test_ifname_valid(void) {
         log_info("/* %s */", __func__);
 
-        assert( ifname_valid("foo"));
-        assert( ifname_valid("eth0"));
-
-        assert(!ifname_valid("0"));
-        assert(!ifname_valid("99"));
-        assert( ifname_valid("a99"));
-        assert( ifname_valid("99a"));
-
-        assert(!ifname_valid(NULL));
-        assert(!ifname_valid(""));
-        assert(!ifname_valid(" "));
-        assert(!ifname_valid(" foo"));
-        assert(!ifname_valid("bar\n"));
-        assert(!ifname_valid("."));
-        assert(!ifname_valid(".."));
-        assert(ifname_valid("foo.bar"));
-        assert(!ifname_valid("x:y"));
-
-        assert( ifname_valid_full("xxxxxxxxxxxxxxx", 0));
-        assert(!ifname_valid_full("xxxxxxxxxxxxxxxx", 0));
-        assert( ifname_valid_full("xxxxxxxxxxxxxxxx", IFNAME_VALID_ALTERNATIVE));
-        assert( ifname_valid_full("xxxxxxxxxxxxxxxx", IFNAME_VALID_ALTERNATIVE));
-        assert(!ifname_valid_full("999", IFNAME_VALID_ALTERNATIVE));
-        assert( ifname_valid_full("999", IFNAME_VALID_ALTERNATIVE | IFNAME_VALID_NUMERIC));
-        assert(!ifname_valid_full("0", IFNAME_VALID_ALTERNATIVE | IFNAME_VALID_NUMERIC));
+        assert_se( ifname_valid("foo"));
+        assert_se( ifname_valid("eth0"));
+
+        assert_se(!ifname_valid("0"));
+        assert_se(!ifname_valid("99"));
+        assert_se( ifname_valid("a99"));
+        assert_se( ifname_valid("99a"));
+
+        assert_se(!ifname_valid(NULL));
+        assert_se(!ifname_valid(""));
+        assert_se(!ifname_valid(" "));
+        assert_se(!ifname_valid(" foo"));
+        assert_se(!ifname_valid("bar\n"));
+        assert_se(!ifname_valid("."));
+        assert_se(!ifname_valid(".."));
+        assert_se(ifname_valid("foo.bar"));
+        assert_se(!ifname_valid("x:y"));
+
+        assert_se( ifname_valid_full("xxxxxxxxxxxxxxx", 0));
+        assert_se(!ifname_valid_full("xxxxxxxxxxxxxxxx", 0));
+        assert_se( ifname_valid_full("xxxxxxxxxxxxxxxx", IFNAME_VALID_ALTERNATIVE));
+        assert_se( ifname_valid_full("xxxxxxxxxxxxxxxx", IFNAME_VALID_ALTERNATIVE));
+        assert_se(!ifname_valid_full("999", IFNAME_VALID_ALTERNATIVE));
+        assert_se( ifname_valid_full("999", IFNAME_VALID_ALTERNATIVE | IFNAME_VALID_NUMERIC));
+        assert_se(!ifname_valid_full("0", IFNAME_VALID_ALTERNATIVE | IFNAME_VALID_NUMERIC));
 }
 
 static void test_socket_print_unix_one(const char *in, size_t len_in, const char *expected) {
         _cleanup_free_ char *out = NULL, *c = NULL;
 
-        assert(len_in <= SUN_PATH_LEN);
+        assert_se(len_in <= SUN_PATH_LEN);
         SocketAddress a = { .sockaddr = { .un = { .sun_family = AF_UNIX } },
                             .size = offsetof(struct sockaddr_un, sun_path) + len_in,
                             .type = SOCK_STREAM,
@@ -194,7 +194,7 @@ static void test_getpeercred_getpeergroups(void) {
                         test_gid = getgid();
 
                         ngroups_max = sysconf(_SC_NGROUPS_MAX);
-                        assert(ngroups_max > 0);
+                        assert_se(ngroups_max > 0);
 
                         test_gids = newa(gid_t, ngroups_max);
 

diff --git a/src/test/test-stat-util.c b/src/test/test-stat-util.c
index fa167fb263b57a9c24624c673c566bac42b3d42e..b27d26c81ace86d53b30e487e90441d620291433 100644 (file)
--- a/src/test/test-stat-util.c
+++ b/src/test/test-stat-util.c
@@ -184,7 +184,7 @@ static void test_device_path_make_canonical_one(const char *path) {
         log_debug("> %s", path);
 
         if (stat(path, &st) < 0) {
-                assert(errno == ENOENT);
+                assert_se(errno == ENOENT);
                 log_notice("Path %s not found, skipping test", path);
                 return;
         }

diff --git a/src/test/test-strv.c b/src/test/test-strv.c
index 51ad45b5ac381e2932643016cd38367a35941f93..34f438cf9cc2aa462d8ae10ad77262a4966f87b8 100644 (file)
--- a/src/test/test-strv.c
+++ b/src/test/test-strv.c
@@ -1007,7 +1007,7 @@ static void test_strv_fnmatch(void) {
         v = strv_new("xxx", "*\\*", "yyy");
         assert_se(!strv_fnmatch_full(v, "\\", 0, NULL));
         assert_se(strv_fnmatch_full(v, "\\", FNM_NOESCAPE, &pos));
-        assert(pos == 1);
+        assert_se(pos == 1);
 }
 
 int main(int argc, char *argv[]) {

diff --git a/src/test/test-time-util.c b/src/test/test-time-util.c
index 7079bffa7fe4aa33a5606977040153290a852924..53f811450170d1347390cfe171a109cdcac3af6a 100644 (file)
--- a/src/test/test-time-util.c
+++ b/src/test/test-time-util.c
@@ -656,7 +656,7 @@ int main(int argc, char *argv[]) {
         /* Ensure TIME_T_MAX works correctly */
         uintmax_t x = TIME_T_MAX;
         x++;
-        assert((time_t) x < 0);
+        assert_se((time_t) x < 0);
 
         return 0;
 }

diff --git a/src/test/test-tmpfile-util.c b/src/test/test-tmpfile-util.c
index 9f2e6158674e2510612b5d4421b8f5dbe5165443..39d524e2b6b86d240fb4f8badbcf1cfcb748b60d 100644 (file)
--- a/src/test/test-tmpfile-util.c
+++ b/src/test/test-tmpfile-util.c
@@ -14,7 +14,7 @@ static void test_tempfn_random_one(const char *p, const char *extra, const char
         r = tempfn_random(p, extra, &s);
         log_info_errno(r, "%s+%s → %s vs. %s (%i/%m vs. %i/%s)", p, strna(extra), strna(s), strna(expect), r, ret, strerror_safe(ret));
 
-        assert(!s == !expect);
+        assert_se(!s == !expect);
         if (s) {
                 const char *suffix;
 
@@ -22,7 +22,7 @@ static void test_tempfn_random_one(const char *p, const char *extra, const char
                 assert_se(in_charset(suffix, HEXDIGITS));
                 assert_se(strlen(suffix) == 16);
         }
-        assert(ret == r);
+        assert_se(ret == r);
 }
 
 static void test_tempfn_random(void) {
@@ -59,14 +59,14 @@ static void test_tempfn_xxxxxx_one(const char *p, const char *extra, const char
         r = tempfn_xxxxxx(p, extra, &s);
         log_info_errno(r, "%s+%s → %s vs. %s (%i/%m vs. %i/%s)", p, strna(extra), strna(s), strna(expect), r, ret, strerror_safe(ret));
 
-        assert(!s == !expect);
+        assert_se(!s == !expect);
         if (s) {
                 const char *suffix;
 
                 assert_se(suffix = startswith(s, expect));
                 assert_se(streq(suffix, "XXXXXX"));
         }
-        assert(ret == r);
+        assert_se(ret == r);
 }
 
 static void test_tempfn_xxxxxx(void) {

diff --git a/src/test/test-unit-file.c b/src/test/test-unit-file.c
index 477ae03a0231fe8a62c432267c342a189d813a96..4fcd2e0efd0fbd7b0f0519d6717cddffc493af21 100644 (file)
--- a/src/test/test-unit-file.c
+++ b/src/test/test-unit-file.c
@@ -65,7 +65,7 @@ static void test_unit_file_build_name_map(char **ids) {
                                              *id,
                                              &fragment,
                                              &names);
-                 assert(r == 0);
+                 assert_se(r == 0);
                  log_info("fragment: %s", fragment);
                  log_info("names:");
                  SET_FOREACH(name, names)

diff --git a/src/test/test-unit-serialize.c b/src/test/test-unit-serialize.c
index 58a0d9dfd4de1162915540f10240da0295200d96..9bd634fcbd172acce305fc6b6be4939387cd76d9 100644 (file)
--- a/src/test/test-unit-serialize.c
+++ b/src/test/test-unit-serialize.c
@@ -17,7 +17,7 @@ static void test_deserialize_exec_command_one(Manager *m, const char *key, const
 
         r = service_deserialize_exec_command(u, key, line);
         log_debug("[%s] → %d (expected: %d)", line, r, expected);
-        assert(r == expected);
+        assert_se(r == expected);
 
         /* Note that the command doesn't match any command in the empty list of commands in 's', so it is
          * always rejected with "Current command vanished from the unit file", and we don't leak anything. */

diff --git a/src/test/test-user-util.c b/src/test/test-user-util.c
index 94ca3f04bae7f872b8dfe0dc90b7123c156c4f27..af9537a3abcee9b047bc27b25fbea8303f5f0080 100644 (file)
--- a/src/test/test-user-util.c
+++ b/src/test/test-user-util.c
@@ -374,14 +374,14 @@ static void test_make_salt(void) {
         assert_se(make_salt(&t) == 0);
         log_info("got %s", t);
 
-        assert(!streq(s, t));
+        assert_se(!streq(s, t));
 }
 
 static void test_in_gid(void) {
-        assert(in_gid(getgid()) >= 0);
-        assert(in_gid(getegid()) >= 0);
-        assert(in_gid(GID_INVALID) < 0);
-        assert(in_gid(TTY_GID) == 0); /* The TTY gid is for owning ttys, it would be really really weird if we were in it. */
+        assert_se(in_gid(getgid()) >= 0);
+        assert_se(in_gid(getegid()) >= 0);
+        assert_se(in_gid(GID_INVALID) < 0);
+        assert_se(in_gid(TTY_GID) == 0); /* The TTY gid is for owning ttys, it would be really really weird if we were in it. */
 }
 
 static void test_gid_lists_ops(void) {

diff --git a/src/test/test-varlink.c b/src/test/test-varlink.c
index 9a5fbc6c8e280f8ba449f019660c059de6f933d8..a2708ecd086c7dbcc462c05989fbacc5f61013f7 100644 (file)
--- a/src/test/test-varlink.c
+++ b/src/test/test-varlink.c
@@ -72,8 +72,8 @@ static int reply(Varlink *link, JsonVariant *parameters, const char *error_id, V
 static int on_connect(VarlinkServer *s, Varlink *link, void *userdata) {
         uid_t uid = UID_INVALID;
 
-        assert(s);
-        assert(link);
+        assert_se(s);
+        assert_se(link);
 
         assert_se(varlink_get_peer_uid(link, &uid) >= 0);
         assert_se(getuid() == uid);

diff --git a/src/tmpfiles/test-offline-passwd.c b/src/tmpfiles/test-offline-passwd.c
index e509c63961ea13ec70fccfd014440ba24b3c9b30..5978e69b864decd3c5f365b645793b81562633e7 100644 (file)
--- a/src/tmpfiles/test-offline-passwd.c
+++ b/src/tmpfiles/test-offline-passwd.c
@@ -47,8 +47,8 @@ static int parse_argv(int argc, char *argv[]) {
 
         int c;
 
-        assert(argc >= 0);
-        assert(argv);
+        assert_se(argc >= 0);
+        assert_se(argv);
 
         while ((c = getopt_long(argc, argv, "r:", options, NULL)) >= 0)
                 switch(c) {