test-namespace: Migrate to new assertion macros

diff --git a/src/test/test-namespace.c b/src/test/test-namespace.c
index 83d47d62b0c476cd9d2825892ff79933871d6f72..7b66fb472d68d6df23fd883f1e6eb645a5b838d0 100644 (file)
--- a/src/test/test-namespace.c
+++ b/src/test/test-namespace.c
@@ -21,20 +21,20 @@
 #include "process-util.h"
 #include "string-util.h"
 #include "tests.h"
+#include "tmpfile-util.h"
 #include "uid-range.h"
 #include "user-util.h"
 #include "virt.h"
 
 TEST(namespace_cleanup_tmpdir) {
         {
-                _cleanup_(namespace_cleanup_tmpdirp) char *dir;
-                assert_se(dir = strdup(RUN_SYSTEMD_EMPTY));
+                _cleanup_(namespace_cleanup_tmpdirp) char *dir = NULL;
+                ASSERT_NOT_NULL(dir = strdup(RUN_SYSTEMD_EMPTY));
         }
 
         {
-                _cleanup_(namespace_cleanup_tmpdirp) char *dir;
-                assert_se(dir = strdup("/tmp/systemd-test-namespace.XXXXXX"));
-                assert_se(mkdtemp(dir));
+                _cleanup_(namespace_cleanup_tmpdirp) char *dir = NULL;
+                ASSERT_OK(mkdtemp_malloc("/tmp/systemd-test-namespace.XXXXXX", &dir));
         }
 }
 
@@ -43,34 +43,34 @@ static void test_tmpdir_one(const char *id, const char *A, const char *B) {
         struct stat x, y;
         char *c, *d;
 
-        assert_se(setup_tmp_dirs(id, &a, &b) == 0);
+        ASSERT_OK_ZERO(setup_tmp_dirs(id, &a, &b));
 
-        assert_se(stat(a, &x) >= 0);
-        assert_se(stat(b, &y) >= 0);
+        ASSERT_OK_ERRNO(stat(a, &x));
+        ASSERT_OK_ERRNO(stat(b, &y));
 
-        assert_se(S_ISDIR(x.st_mode));
-        assert_se(S_ISDIR(y.st_mode));
+        ASSERT_TRUE(S_ISDIR(x.st_mode));
+        ASSERT_TRUE(S_ISDIR(y.st_mode));
 
         if (!streq(a, RUN_SYSTEMD_EMPTY)) {
-                assert_se(startswith(a, A));
-                assert_se((x.st_mode & 01777) == 0700);
-                c = strjoina(a, "/tmp");
-                assert_se(stat(c, &x) >= 0);
-                assert_se(S_ISDIR(x.st_mode));
-                assert_se(FLAGS_SET(x.st_mode, 01777));
-                assert_se(rmdir(c) >= 0);
-                assert_se(rmdir(a) >= 0);
+                ASSERT_TRUE(startswith(a, A));
+                ASSERT_EQ((x.st_mode & 01777), 0700U);
+                ASSERT_NOT_NULL(c = strjoina(a, "/tmp"));
+                ASSERT_OK_ERRNO(stat(c, &x));
+                ASSERT_TRUE(S_ISDIR(x.st_mode));
+                ASSERT_TRUE(FLAGS_SET(x.st_mode, 01777));
+                ASSERT_OK_ERRNO(rmdir(c));
+                ASSERT_OK_ERRNO(rmdir(a));
         }
 
         if (!streq(b, RUN_SYSTEMD_EMPTY)) {
-                assert_se(startswith(b, B));
-                assert_se((y.st_mode & 01777) == 0700);
-                d = strjoina(b, "/tmp");
-                assert_se(stat(d, &y) >= 0);
-                assert_se(S_ISDIR(y.st_mode));
-                assert_se(FLAGS_SET(y.st_mode, 01777));
-                assert_se(rmdir(d) >= 0);
-                assert_se(rmdir(b) >= 0);
+                ASSERT_TRUE(startswith(b, B));
+                ASSERT_EQ((y.st_mode & 01777), 0700U);
+                ASSERT_NOT_NULL(d = strjoina(b, "/tmp"));
+                ASSERT_OK_ERRNO(stat(d, &y));
+                ASSERT_TRUE(S_ISDIR(y.st_mode));
+                ASSERT_TRUE(FLAGS_SET(y.st_mode, 01777));
+                ASSERT_OK_ERRNO(rmdir(d));
+                ASSERT_OK_ERRNO(rmdir(b));
         }
 }
 
@@ -78,18 +78,15 @@ TEST(tmpdir) {
         _cleanup_free_ char *x = NULL, *y = NULL, *z = NULL, *zz = NULL;
         sd_id128_t bid;
 
-        assert_se(sd_id128_get_boot(&bid) >= 0);
+        ASSERT_OK(sd_id128_get_boot(&bid));
 
-        x = strjoin("/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-abcd.service-");
-        y = strjoin("/var/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-abcd.service-");
-        assert_se(x && y);
+        ASSERT_NOT_NULL(x = strjoin("/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-abcd.service-"));
+        ASSERT_NOT_NULL(y = strjoin("/var/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-abcd.service-"));
 
         test_tmpdir_one("abcd.service", x, y);
 
-        z = strjoin("/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-");
-        zz = strjoin("/var/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-");
-
-        assert_se(z && zz);
+        ASSERT_NOT_NULL(z = strjoin("/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-"));
+        ASSERT_NOT_NULL(zz = strjoin("/var/tmp/systemd-private-", SD_ID128_TO_STRING(bid), "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-"));
 
         test_tmpdir_one("sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device", z, zz);
 }
@@ -106,54 +103,54 @@ static void test_shareable_ns(unsigned long nsflag) {
                 return;
         }
 
-        assert_se(socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, s) >= 0);
+        ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, s));
 
         pid1 = fork();
-        assert_se(pid1 >= 0);
+        ASSERT_OK_ERRNO(pid1);
 
         if (pid1 == 0) {
                 r = setup_shareable_ns(s, nsflag);
-                assert_se(r >= 0 || ERRNO_IS_NEG_PRIVILEGE(r));
+                if (!ERRNO_IS_PRIVILEGE(r))
+                        ASSERT_OK(r);
                 _exit(r >= 0 ? r : EX_NOPERM);
         }
 
         pid2 = fork();
-        assert_se(pid2 >= 0);
+        ASSERT_OK_ERRNO(pid2);
 
         if (pid2 == 0) {
                 r = setup_shareable_ns(s, nsflag);
-                assert_se(r >= 0 || ERRNO_IS_NEG_PRIVILEGE(r));
+                if (!ERRNO_IS_PRIVILEGE(r))
+                        ASSERT_OK(r);
                 _exit(r >= 0 ? r : EX_NOPERM);
         }
 
         pid3 = fork();
-        assert_se(pid3 >= 0);
+        ASSERT_OK_ERRNO(pid3);
 
         if (pid3 == 0) {
                 r = setup_shareable_ns(s, nsflag);
-                assert_se(r >= 0 || ERRNO_IS_NEG_PRIVILEGE(r));
+                if (!ERRNO_IS_PRIVILEGE(r))
+                        ASSERT_OK(r);
                 _exit(r >= 0 ? r : EX_NOPERM);
         }
 
-        r = wait_for_terminate(pid1, &si);
-        assert_se(r >= 0);
-        assert_se(si.si_code == CLD_EXITED);
+        ASSERT_OK(wait_for_terminate(pid1, &si));
+        ASSERT_EQ(si.si_code, CLD_EXITED);
         if (si.si_status == EX_NOPERM)
                 permission_denied = true;
         else
                 n += si.si_status;
 
-        r = wait_for_terminate(pid2, &si);
-        assert_se(r >= 0);
-        assert_se(si.si_code == CLD_EXITED);
+        ASSERT_OK(wait_for_terminate(pid2, &si));
+        ASSERT_EQ(si.si_code, CLD_EXITED);
         if (si.si_status == EX_NOPERM)
                 permission_denied = true;
         else
                 n += si.si_status;
 
-        r = wait_for_terminate(pid3, &si);
-        assert_se(r >= 0);
-        assert_se(si.si_code == CLD_EXITED);
+        ASSERT_OK(wait_for_terminate(pid3, &si));
+        ASSERT_EQ(si.si_code, CLD_EXITED);
         if (si.si_status == EX_NOPERM)
                 permission_denied = true;
         else
@@ -164,7 +161,7 @@ static void test_shareable_ns(unsigned long nsflag) {
         if (permission_denied)
                 return (void) log_tests_skipped("insufficient privileges");
 
-        assert_se(n == 1);
+        ASSERT_EQ(n, 1);
 }
 
 TEST(netns) {
@@ -206,7 +203,6 @@ TEST(protect_kernel_logs) {
                 .protect_kernel_logs = true,
         };
         pid_t pid;
-        int r;
 
         if (geteuid() > 0) {
                 (void) log_tests_skipped("not root");
@@ -220,33 +216,30 @@ TEST(protect_kernel_logs) {
         }
 
         pid = fork();
-        assert_se(pid >= 0);
+        ASSERT_OK_ERRNO(pid);
 
         if (pid == 0) {
                 _cleanup_close_ int fd = -EBADF;
 
-                fd = open("/dev/kmsg", O_RDONLY | O_CLOEXEC);
-                assert_se(fd > 0);
+                ASSERT_OK_ERRNO(fd = open("/dev/kmsg", O_RDONLY | O_CLOEXEC));
 
-                r = setup_namespace(&p, NULL);
-                assert_se(r == 0);
+                ASSERT_OK_ZERO(setup_namespace(&p, NULL));
 
-                assert_se(setresuid(UID_NOBODY, UID_NOBODY, UID_NOBODY) >= 0);
-                assert_se(open("/dev/kmsg", O_RDONLY | O_CLOEXEC) < 0);
-                assert_se(errno == EACCES);
+                ASSERT_OK_ERRNO(setresuid(UID_NOBODY, UID_NOBODY, UID_NOBODY));
+                ASSERT_ERROR_ERRNO(open("/dev/kmsg", O_RDONLY | O_CLOEXEC), EACCES);
 
                 _exit(EXIT_SUCCESS);
         }
 
-        assert_se(wait_for_terminate_and_check("ns-kernellogs", pid, WAIT_LOG) == EXIT_SUCCESS);
+        ASSERT_OK_EQ(wait_for_terminate_and_check("ns-kernellogs", pid, WAIT_LOG), EXIT_SUCCESS);
 }
 
 TEST(idmapping_supported) {
-        assert_se(is_idmapping_supported("/run") >= 0);
-        assert_se(is_idmapping_supported("/var/lib") >= 0);
-        assert_se(is_idmapping_supported("/var/cache") >= 0);
-        assert_se(is_idmapping_supported("/var/log") >= 0);
-        assert_se(is_idmapping_supported("/etc") >= 0);
+        ASSERT_OK(is_idmapping_supported("/run"));
+        ASSERT_OK(is_idmapping_supported("/var/lib"));
+        ASSERT_OK(is_idmapping_supported("/var/cache"));
+        ASSERT_OK(is_idmapping_supported("/var/log"));
+        ASSERT_OK(is_idmapping_supported("/etc"));
 }
 
 TEST(namespace_is_init) {