test-pidref: Migrate to new assertion macros

diff --git a/src/test/test-pidref.c b/src/test/test-pidref.c
index 0f6126c5b4f047ef9fa299b03825b438c9c52dab..3a5f44053ba219ea970476fec1a2129b06dcea16 100644 (file)
--- a/src/test/test-pidref.c
+++ b/src/test/test-pidref.c
@@ -8,23 +8,23 @@
 #include "tests.h"
 
 TEST(pidref_is_set) {
-        assert_se(!pidref_is_set(NULL));
-        assert_se(!pidref_is_set(&PIDREF_NULL));
-        assert_se(pidref_is_set(&PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_is_set(NULL));
+        ASSERT_FALSE(pidref_is_set(&PIDREF_NULL));
+        ASSERT_TRUE(pidref_is_set(&PIDREF_MAKE_FROM_PID(1)));
 }
 
 TEST(pidref_equal) {
-        assert_se(pidref_equal(NULL, NULL));
-        assert_se(pidref_equal(NULL, &PIDREF_NULL));
-        assert_se(pidref_equal(&PIDREF_NULL, NULL));
-        assert_se(pidref_equal(&PIDREF_NULL, &PIDREF_NULL));
+        ASSERT_TRUE(pidref_equal(NULL, NULL));
+        ASSERT_TRUE(pidref_equal(NULL, &PIDREF_NULL));
+        ASSERT_TRUE(pidref_equal(&PIDREF_NULL, NULL));
+        ASSERT_TRUE(pidref_equal(&PIDREF_NULL, &PIDREF_NULL));
 
-        assert_se(!pidref_equal(NULL, &PIDREF_MAKE_FROM_PID(1)));
-        assert_se(!pidref_equal(&PIDREF_MAKE_FROM_PID(1), NULL));
-        assert_se(!pidref_equal(&PIDREF_NULL, &PIDREF_MAKE_FROM_PID(1)));
-        assert_se(!pidref_equal(&PIDREF_MAKE_FROM_PID(1), &PIDREF_NULL));
-        assert_se(pidref_equal(&PIDREF_MAKE_FROM_PID(1), &PIDREF_MAKE_FROM_PID(1)));
-        assert_se(!pidref_equal(&PIDREF_MAKE_FROM_PID(1), &PIDREF_MAKE_FROM_PID(2)));
+        ASSERT_FALSE(pidref_equal(NULL, &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_equal(&PIDREF_MAKE_FROM_PID(1), NULL));
+        ASSERT_FALSE(pidref_equal(&PIDREF_NULL, &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_equal(&PIDREF_MAKE_FROM_PID(1), &PIDREF_NULL));
+        ASSERT_TRUE(pidref_equal(&PIDREF_MAKE_FROM_PID(1), &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_equal(&PIDREF_MAKE_FROM_PID(1), &PIDREF_MAKE_FROM_PID(2)));
 }
 
 TEST(pidref_set_pid) {
@@ -34,18 +34,18 @@ TEST(pidref_set_pid) {
         r = pidref_set_pid(&pidref, 1);
         if (r == -ESRCH)
                 return (void) log_tests_skipped_errno(r, "PID1 does not exist");
-        assert_se(r >= 0);
+        ASSERT_OK(r);
 
-        assert_se(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(1)));
-        assert_se(!pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(2)));
+        ASSERT_TRUE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(2)));
 }
 
 TEST(pidref_set_self) {
         _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 
-        assert_se(pidref_set_self(&pidref) >= 0);
-        assert_se(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached())));
-        assert_se(!pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached()+1)));
+        ASSERT_OK(pidref_set_self(&pidref));
+        ASSERT_TRUE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached())));
+        ASSERT_FALSE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached()+1)));
 }
 
 TEST(pidref_set_pidstr) {
@@ -53,105 +53,105 @@ TEST(pidref_set_pidstr) {
         char buf[DECIMAL_STR_MAX(pid_t)];
 
         xsprintf(buf, PID_FMT, getpid_cached());
-        assert_se(pidref_set_pidstr(&pidref, buf) >= 0);
-        assert_se(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached())));
-        assert_se(!pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached()+1)));
+        ASSERT_OK(pidref_set_pidstr(&pidref, buf));
+        ASSERT_TRUE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached())));
+        ASSERT_FALSE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(getpid_cached()+1)));
 }
 
 TEST(pidref_set_pidfd) {
         _cleanup_(pidref_done) PidRef a = PIDREF_NULL, b = PIDREF_NULL, c = PIDREF_NULL, d = PIDREF_NULL;
 
-        assert_se(pidref_set_self(&a) >= 0);
+        ASSERT_OK(pidref_set_self(&a));
         if (a.fd < 0)
                 return (void) log_tests_skipped("PIDFD not supported");
 
-        assert_se(pidref_set_pidfd(&b, a.fd) >= 0);
-        assert_se(pidref_equal(&a, &b));
-        assert_se(pidref_set_pidfd_take(&c, b.fd) >= 0);
+        ASSERT_OK(pidref_set_pidfd(&b, a.fd));
+        ASSERT_TRUE(pidref_equal(&a, &b));
+        ASSERT_OK(pidref_set_pidfd_take(&c, b.fd));
         b.fd = -EBADF;
-        assert_se(pidref_equal(&a, &c));
-        assert_se(pidref_set_pidfd_consume(&d, TAKE_FD(c.fd)) >= 0);
-        assert_se(pidref_equal(&a, &d));
+        ASSERT_TRUE(pidref_equal(&a, &c));
+        ASSERT_OK(pidref_set_pidfd_consume(&d, TAKE_FD(c.fd)));
+        ASSERT_TRUE(pidref_equal(&a, &d));
 }
 
 TEST(pidref_is_self) {
         _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 
-        assert_se(pidref_set_self(&pidref) >= 0);
-        assert_se(pidref_is_self(&pidref));
+        ASSERT_OK(pidref_set_self(&pidref));
+        ASSERT_TRUE(pidref_is_self(&pidref));
 
-        assert_se(!pidref_is_self(NULL));
-        assert_se(!pidref_is_self(&PIDREF_NULL));
-        assert_se(pidref_is_self(&PIDREF_MAKE_FROM_PID(getpid_cached())));
-        assert_se(!pidref_is_self(&PIDREF_MAKE_FROM_PID(getpid_cached()+1)));
+        ASSERT_FALSE(pidref_is_self(NULL));
+        ASSERT_FALSE(pidref_is_self(&PIDREF_NULL));
+        ASSERT_TRUE(pidref_is_self(&PIDREF_MAKE_FROM_PID(getpid_cached())));
+        ASSERT_FALSE(pidref_is_self(&PIDREF_MAKE_FROM_PID(getpid_cached()+1)));
 }
 
 TEST(pidref_copy) {
         _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
         int r;
 
-        assert_se(pidref_copy(NULL, &pidref) >= 0);
-        assert_se(!pidref_is_set(&pidref));
+        ASSERT_OK(pidref_copy(NULL, &pidref));
+        ASSERT_FALSE(pidref_is_set(&pidref));
 
-        assert_se(pidref_copy(&PIDREF_NULL, &pidref) >= 0);
-        assert_se(!pidref_is_set(&pidref));
+        ASSERT_OK(pidref_copy(&PIDREF_NULL, &pidref));
+        ASSERT_FALSE(pidref_is_set(&pidref));
 
-        assert_se(pidref_copy(&PIDREF_MAKE_FROM_PID(getpid_cached()), &pidref) >= 0);
-        assert_se(pidref_is_self(&pidref));
+        ASSERT_OK(pidref_copy(&PIDREF_MAKE_FROM_PID(getpid_cached()), &pidref));
+        ASSERT_TRUE(pidref_is_self(&pidref));
         pidref_done(&pidref);
 
         r = pidref_copy(&PIDREF_MAKE_FROM_PID(1), &pidref);
         if (r == -ESRCH)
                 return (void) log_tests_skipped_errno(r, "PID1 does not exist");
-        assert_se(r >= 0);
-        assert_se(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_OK(r);
+        ASSERT_TRUE(pidref_equal(&pidref, &PIDREF_MAKE_FROM_PID(1)));
 }
 
 TEST(pidref_dup) {
         _cleanup_(pidref_freep) PidRef *pidref = NULL;
         int r;
 
-        assert_se(pidref_dup(NULL, &pidref) >= 0);
-        assert_se(pidref);
-        assert_se(!pidref_is_set(pidref));
+        ASSERT_OK(pidref_dup(NULL, &pidref));
+        ASSERT_NOT_NULL(pidref);
+        ASSERT_FALSE(pidref_is_set(pidref));
         pidref = pidref_free(pidref);
 
-        assert_se(pidref_dup(&PIDREF_NULL, &pidref) >= 0);
-        assert_se(pidref);
-        assert_se(!pidref_is_set(pidref));
+        ASSERT_OK(pidref_dup(&PIDREF_NULL, &pidref));
+        ASSERT_NOT_NULL(pidref);
+        ASSERT_FALSE(pidref_is_set(pidref));
         pidref = pidref_free(pidref);
 
-        assert_se(pidref_dup(&PIDREF_MAKE_FROM_PID(getpid_cached()), &pidref) >= 0);
-        assert_se(pidref_is_self(pidref));
+        ASSERT_OK(pidref_dup(&PIDREF_MAKE_FROM_PID(getpid_cached()), &pidref));
+        ASSERT_TRUE(pidref_is_self(pidref));
         pidref = pidref_free(pidref);
 
         r = pidref_dup(&PIDREF_MAKE_FROM_PID(1), &pidref);
         if (r == -ESRCH)
                 return (void) log_tests_skipped_errno(r, "PID1 does not exist");
-        assert_se(r >= 0);
-        assert_se(pidref_equal(pidref, &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_OK(r);
+        ASSERT_TRUE(pidref_equal(pidref, &PIDREF_MAKE_FROM_PID(1)));
 }
 
 TEST(pidref_new_from_pid) {
         _cleanup_(pidref_freep) PidRef *pidref = NULL;
         int r;
 
-        assert_se(pidref_new_from_pid(-1, &pidref) == -ESRCH);
-        assert_se(!pidref);
+        ASSERT_ERROR(pidref_new_from_pid(-1, &pidref), ESRCH);
+        ASSERT_NULL(pidref);
 
-        assert_se(pidref_new_from_pid(0, &pidref) >= 0);
-        assert_se(pidref_is_self(pidref));
+        ASSERT_OK(pidref_new_from_pid(0, &pidref));
+        ASSERT_TRUE(pidref_is_self(pidref));
         pidref = pidref_free(pidref);
 
-        assert_se(pidref_new_from_pid(getpid_cached(), &pidref) >= 0);
-        assert_se(pidref_is_self(pidref));
+        ASSERT_OK(pidref_new_from_pid(getpid_cached(), &pidref));
+        ASSERT_TRUE(pidref_is_self(pidref));
         pidref = pidref_free(pidref);
 
         r = pidref_new_from_pid(1, &pidref);
         if (r == -ESRCH)
                 return (void) log_tests_skipped_errno(r, "PID1 does not exist");
-        assert_se(r >= 0);
-        assert_se(pidref_equal(pidref, &PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_OK(r);
+        ASSERT_TRUE(pidref_equal(pidref, &PIDREF_MAKE_FROM_PID(1)));
 }
 
 TEST(pidref_kill) {
@@ -160,9 +160,9 @@ TEST(pidref_kill) {
 
         ASSERT_OK_POSITIVE(pidref_safe_fork("(test-pidref-kill)", FORK_DEATHSIG_SIGKILL|FORK_FREEZE, &pidref));
 
-        assert_se(pidref_kill(&pidref, SIGKILL) >= 0);
-        assert_se(pidref_wait_for_terminate(&pidref, &si) >= 0);
-        assert_se(si.si_signo == SIGCHLD);
+        ASSERT_OK(pidref_kill(&pidref, SIGKILL));
+        ASSERT_OK(pidref_wait_for_terminate(&pidref, &si));
+        ASSERT_EQ(si.si_signo, SIGCHLD);
 }
 
 TEST(pidref_kill_and_sigcont) {
@@ -171,9 +171,9 @@ TEST(pidref_kill_and_sigcont) {
 
         ASSERT_OK_POSITIVE(pidref_safe_fork("(test-pidref-kill-and-sigcont)", FORK_DEATHSIG_SIGTERM|FORK_FREEZE, &pidref));
 
-        assert_se(pidref_kill_and_sigcont(&pidref, SIGTERM) >= 0);
-        assert_se(pidref_wait_for_terminate(&pidref, &si) >= 0);
-        assert_se(si.si_signo == SIGCHLD);
+        ASSERT_OK(pidref_kill_and_sigcont(&pidref, SIGTERM));
+        ASSERT_OK(pidref_wait_for_terminate(&pidref, &si));
+        ASSERT_EQ(si.si_signo, SIGCHLD);
 }
 
 TEST(pidref_sigqueue) {
@@ -182,9 +182,9 @@ TEST(pidref_sigqueue) {
 
         ASSERT_OK_POSITIVE(pidref_safe_fork("(test-pidref-sigqueue)", FORK_DEATHSIG_SIGTERM|FORK_FREEZE, &pidref));
 
-        assert_se(pidref_sigqueue(&pidref, SIGTERM, 42) >= 0);
-        assert_se(pidref_wait_for_terminate(&pidref, &si) >= 0);
-        assert_se(si.si_signo == SIGCHLD);
+        ASSERT_OK(pidref_sigqueue(&pidref, SIGTERM, 42));
+        ASSERT_OK(pidref_wait_for_terminate(&pidref, &si));
+        ASSERT_EQ(si.si_signo, SIGCHLD);
 }
 
 TEST(pidref_done_sigkill_wait) {
@@ -195,39 +195,41 @@ TEST(pidref_done_sigkill_wait) {
 
 TEST(pidref_verify) {
         _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
+        int r;
 
-        assert_se(pidref_verify(NULL) == -ESRCH);
-        assert_se(pidref_verify(&PIDREF_NULL) == -ESRCH);
+        ASSERT_ERROR(pidref_verify(NULL), ESRCH);
+        ASSERT_ERROR(pidref_verify(&PIDREF_NULL), ESRCH);
 
-        assert_se(pidref_verify(&PIDREF_MAKE_FROM_PID(1)) == 1);
-        assert_se(pidref_verify(&PIDREF_MAKE_FROM_PID(getpid_cached())) == 0);
+        ASSERT_OK_POSITIVE(pidref_verify(&PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_OK_ZERO(pidref_verify(&PIDREF_MAKE_FROM_PID(getpid_cached())));
 
-        assert_se(pidref_set_self(&pidref) >= 0);
-        assert_se(pidref_verify(&pidref) == (pidref.fd >= 0));
+        ASSERT_OK(pidref_set_self(&pidref));
+        ASSERT_OK(r = pidref_verify(&pidref));
+        ASSERT_EQ(r, (pidref.fd >= 0));
 }
 
 TEST(pidref_is_automatic) {
-        assert_se(!pidref_is_automatic(NULL));
-        assert_se(!pidref_is_automatic(&PIDREF_NULL));
-        assert_se(!pidref_is_automatic(&PIDREF_MAKE_FROM_PID(1)));
-        assert_se(!pidref_is_automatic(&PIDREF_MAKE_FROM_PID(getpid_cached())));
-        assert_se(pidref_is_automatic(&PIDREF_AUTOMATIC));
+        ASSERT_FALSE(pidref_is_automatic(NULL));
+        ASSERT_FALSE(pidref_is_automatic(&PIDREF_NULL));
+        ASSERT_FALSE(pidref_is_automatic(&PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_is_automatic(&PIDREF_MAKE_FROM_PID(getpid_cached())));
+        ASSERT_TRUE(pidref_is_automatic(&PIDREF_AUTOMATIC));
 
-        assert_se(!pid_is_automatic(0));
-        assert_se(!pid_is_automatic(1));
-        assert_se(!pid_is_automatic(getpid_cached()));
-        assert_se(pid_is_automatic(PID_AUTOMATIC));
+        ASSERT_FALSE(pid_is_automatic(0));
+        ASSERT_FALSE(pid_is_automatic(1));
+        ASSERT_FALSE(pid_is_automatic(getpid_cached()));
+        ASSERT_TRUE(pid_is_automatic(PID_AUTOMATIC));
 
-        assert_se(!pidref_is_set(&PIDREF_AUTOMATIC));
-        assert_se(!pid_is_valid(PID_AUTOMATIC));
+        ASSERT_FALSE(pidref_is_set(&PIDREF_AUTOMATIC));
+        ASSERT_FALSE(pid_is_valid(PID_AUTOMATIC));
 }
 
 TEST(pidref_is_remote) {
-        assert_se(!pidref_is_remote(NULL));
-        assert_se(!pidref_is_remote(&PIDREF_NULL));
-        assert_se(!pidref_is_remote(&PIDREF_MAKE_FROM_PID(1)));
-        assert_se(!pidref_is_remote(&PIDREF_MAKE_FROM_PID(getpid_cached())));
-        assert_se(!pidref_is_remote(&PIDREF_AUTOMATIC));
+        ASSERT_FALSE(pidref_is_remote(NULL));
+        ASSERT_FALSE(pidref_is_remote(&PIDREF_NULL));
+        ASSERT_FALSE(pidref_is_remote(&PIDREF_MAKE_FROM_PID(1)));
+        ASSERT_FALSE(pidref_is_remote(&PIDREF_MAKE_FROM_PID(getpid_cached())));
+        ASSERT_FALSE(pidref_is_remote(&PIDREF_AUTOMATIC));
 
         PidRef p = {
                 .pid = 1,
@@ -235,13 +237,13 @@ TEST(pidref_is_remote) {
                 .fd_id = 4711,
         };
 
-        assert_se(pidref_is_set(&p));
-        assert_se(pidref_is_remote(&p));
-        assert_se(!pidref_is_automatic(&p));
-        assert_se(pidref_kill(&p, SIGTERM) == -EREMOTE);
-        assert_se(pidref_kill_and_sigcont(&p, SIGTERM) == -EREMOTE);
-        assert_se(pidref_wait_for_terminate(&p, /* ret= */ NULL) == -EREMOTE);
-        assert_se(pidref_verify(&p) == -EREMOTE);
+        ASSERT_TRUE(pidref_is_set(&p));
+        ASSERT_TRUE(pidref_is_remote(&p));
+        ASSERT_FALSE(pidref_is_automatic(&p));
+        ASSERT_ERROR(pidref_kill(&p, SIGTERM), EREMOTE);
+        ASSERT_ERROR(pidref_kill_and_sigcont(&p, SIGTERM), EREMOTE);
+        ASSERT_ERROR(pidref_wait_for_terminate(&p, /* ret= */ NULL), EREMOTE);
+        ASSERT_ERROR(pidref_verify(&p), EREMOTE);
 }
 
 DEFINE_TEST_MAIN(LOG_DEBUG);