test-id128: Use new assertion macros

diff --git a/src/test/test-id128.c b/src/test/test-id128.c
index 48fdbba6c7de971a1919217610d315f6d450ff0f..a6ed640bd6e53401c0f46e5da67497cbc008394e 100644 (file)
--- a/src/test/test-id128.c
+++ b/src/test/test-id128.c
@@ -28,31 +28,31 @@ TEST(id128) {
         _cleanup_free_ char *b = NULL;
         _cleanup_close_ int fd = -EBADF;
 
-        assert_se(sd_id128_randomize(&id) == 0);
+        ASSERT_OK(sd_id128_randomize(&id));
         printf("random: %s\n", sd_id128_to_string(id, t));
 
-        assert_se(sd_id128_from_string(t, &id2) == 0);
-        assert_se(sd_id128_equal(id, id2));
-        assert_se(sd_id128_in_set(id, id));
-        assert_se(sd_id128_in_set(id, id2));
-        assert_se(sd_id128_in_set(id, id2, id));
-        assert_se(sd_id128_in_set(id, ID128_WALDI, id));
-        assert_se(!sd_id128_in_set(id));
-        assert_se(!sd_id128_in_set(id, ID128_WALDI));
-        assert_se(!sd_id128_in_set(id, ID128_WALDI, ID128_WALDI));
+        ASSERT_OK(sd_id128_from_string(t, &id2) == 0);
+        ASSERT_EQ_ID128(id, id2);
+        ASSERT_TRUE(sd_id128_in_set(id, id));
+        ASSERT_TRUE(sd_id128_in_set(id, id2));
+        ASSERT_TRUE(sd_id128_in_set(id, id2, id));
+        ASSERT_TRUE(sd_id128_in_set(id, ID128_WALDI, id));
+        ASSERT_FALSE(sd_id128_in_set(id));
+        ASSERT_FALSE(sd_id128_in_set(id, ID128_WALDI));
+        ASSERT_FALSE(sd_id128_in_set(id, ID128_WALDI, ID128_WALDI));
 
         if (sd_booted() > 0 && sd_id128_get_machine(NULL) >= 0) {
-                assert_se(sd_id128_get_machine(&id) == 0);
+                ASSERT_OK(sd_id128_get_machine(&id));
                 printf("machine: %s\n", sd_id128_to_string(id, t));
 
-                assert_se(sd_id128_get_boot(&id) == 0);
+                ASSERT_OK(sd_id128_get_boot(&id));
                 printf("boot: %s\n", sd_id128_to_string(id, t));
         }
 
         printf("waldi: %s\n", sd_id128_to_string(ID128_WALDI, t));
         ASSERT_STREQ(t, STR_WALDI);
 
-        assert_se(asprintf(&b, SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 32);
+        ASSERT_EQ(asprintf(&b, SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)), 32);
         printf("waldi2: %s\n", b);
         ASSERT_STREQ(t, b);
 
@@ -60,137 +60,137 @@ TEST(id128) {
         ASSERT_STREQ(q, UUID_WALDI);
 
         b = mfree(b);
-        assert_se(asprintf(&b, SD_ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 36);
+        ASSERT_EQ(asprintf(&b, SD_ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)), 36);
         printf("waldi4: %s\n", b);
         ASSERT_STREQ(q, b);
 
-        assert_se(sd_id128_from_string(STR_WALDI, &id) >= 0);
-        assert_se(sd_id128_equal(id, ID128_WALDI));
-
-        assert_se(sd_id128_from_string(UUID_WALDI, &id) >= 0);
-        assert_se(sd_id128_equal(id, ID128_WALDI));
-
-        assert_se(sd_id128_from_string("", &id) < 0);
-        assert_se(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f101", &id) < 0);
-        assert_se(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f10-", &id) < 0);
-        assert_se(sd_id128_from_string("01020304-0506-0708-090a0b0c0d0e0f10", &id) < 0);
-        assert_se(sd_id128_from_string("010203040506-0708-090a-0b0c0d0e0f10", &id) < 0);
-
-        assert_se(id128_from_string_nonzero(STR_WALDI, &id) == 0);
-        assert_se(id128_from_string_nonzero(STR_NULL, &id) == -ENXIO);
-        assert_se(id128_from_string_nonzero("01020304-0506-0708-090a-0b0c0d0e0f101", &id) < 0);
-        assert_se(id128_from_string_nonzero("01020304-0506-0708-090a-0b0c0d0e0f10-", &id) < 0);
-        assert_se(id128_from_string_nonzero("01020304-0506-0708-090a0b0c0d0e0f10", &id) < 0);
-        assert_se(id128_from_string_nonzero("010203040506-0708-090a-0b0c0d0e0f10", &id) < 0);
-
-        assert_se(id128_is_valid(STR_WALDI));
-        assert_se(id128_is_valid(UUID_WALDI));
-        assert_se(!id128_is_valid(""));
-        assert_se(!id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f101"));
-        assert_se(!id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f10-"));
-        assert_se(!id128_is_valid("01020304-0506-0708-090a0b0c0d0e0f10"));
-        assert_se(!id128_is_valid("010203040506-0708-090a-0b0c0d0e0f10"));
+        ASSERT_OK(sd_id128_from_string(STR_WALDI, &id));
+        ASSERT_EQ_ID128(id, ID128_WALDI);
+
+        ASSERT_OK(sd_id128_from_string(UUID_WALDI, &id));
+        ASSERT_EQ_ID128(id, ID128_WALDI);
+
+        ASSERT_FAIL(sd_id128_from_string("", &id));
+        ASSERT_FAIL(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f101", &id));
+        ASSERT_FAIL(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f10-", &id));
+        ASSERT_FAIL(sd_id128_from_string("01020304-0506-0708-090a0b0c0d0e0f10", &id));
+        ASSERT_FAIL(sd_id128_from_string("010203040506-0708-090a-0b0c0d0e0f10", &id));
+
+        ASSERT_OK(id128_from_string_nonzero(STR_WALDI, &id));
+        ASSERT_ERROR(id128_from_string_nonzero(STR_NULL, &id), ENXIO);
+        ASSERT_FAIL(id128_from_string_nonzero("01020304-0506-0708-090a-0b0c0d0e0f101", &id));
+        ASSERT_FAIL(id128_from_string_nonzero("01020304-0506-0708-090a-0b0c0d0e0f10-", &id));
+        ASSERT_FAIL(id128_from_string_nonzero("01020304-0506-0708-090a0b0c0d0e0f10", &id));
+        ASSERT_FAIL(id128_from_string_nonzero("010203040506-0708-090a-0b0c0d0e0f10", &id));
+
+        ASSERT_TRUE(id128_is_valid(STR_WALDI));
+        ASSERT_TRUE(id128_is_valid(UUID_WALDI));
+        ASSERT_FALSE(id128_is_valid(""));
+        ASSERT_FALSE(id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f101"));
+        ASSERT_FALSE(id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f10-"));
+        ASSERT_FALSE(id128_is_valid("01020304-0506-0708-090a0b0c0d0e0f10"));
+        ASSERT_FALSE(id128_is_valid("010203040506-0708-090a-0b0c0d0e0f10"));
 
         fd = open_tmpfile_unlinkable(NULL, O_RDWR|O_CLOEXEC);
-        assert_se(fd >= 0);
+        ASSERT_OK(fd);
 
         /* First, write as UUID */
-        assert_se(sd_id128_randomize(&id) >= 0);
-        assert_se(id128_write_fd(fd, ID128_FORMAT_UUID, id) >= 0);
+        ASSERT_OK(sd_id128_randomize(&id));
+        ASSERT_OK(id128_write_fd(fd, ID128_FORMAT_UUID, id));
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2) == -EUCLEAN);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2), EUCLEAN);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_UUID, &id2) >= 0);
-        assert_se(sd_id128_equal(id, id2));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_UUID, &id2));
+        ASSERT_EQ_ID128(id, id2);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_ANY, &id2) >= 0);
-        assert_se(sd_id128_equal(id, id2));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_ANY, &id2));
+        ASSERT_EQ_ID128(id, id2);
 
         /* Second, write as plain */
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
 
-        assert_se(sd_id128_randomize(&id) >= 0);
-        assert_se(id128_write_fd(fd, ID128_FORMAT_PLAIN, id) >= 0);
+        ASSERT_OK(sd_id128_randomize(&id));
+        ASSERT_OK(id128_write_fd(fd, ID128_FORMAT_PLAIN, id));
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_UUID, &id2) == -EUCLEAN);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET) == 0);
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_UUID, &id2), EUCLEAN);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2) >= 0);
-        assert_se(sd_id128_equal(id, id2));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2));
+        ASSERT_EQ_ID128(id, id2);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_ANY, &id2) >= 0);
-        assert_se(sd_id128_equal(id, id2));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_ANY, &id2));
+        ASSERT_EQ_ID128(id, id2);
 
         /* Third, write plain without trailing newline */
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
 
-        assert_se(sd_id128_randomize(&id) >= 0);
-        assert_se(write(fd, sd_id128_to_string(id, t), 32) == 32);
+        ASSERT_OK(sd_id128_randomize(&id));
+        ASSERT_EQ(write(fd, sd_id128_to_string(id, t), 32), 32);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_UUID, &id2) == -EUCLEAN);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_UUID, &id2), EUCLEAN);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2) >= 0);
-        assert_se(sd_id128_equal(id, id2));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2));
+        ASSERT_EQ_ID128(id, id2);
 
         /* Fourth, write UUID without trailing newline */
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
 
-        assert_se(sd_id128_randomize(&id) >= 0);
-        assert_se(write(fd, sd_id128_to_uuid_string(id, q), 36) == 36);
+        ASSERT_OK(sd_id128_randomize(&id));
+        ASSERT_EQ(write(fd, sd_id128_to_uuid_string(id, q), 36), 36);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2) == -EUCLEAN);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_PLAIN, &id2), EUCLEAN);
 
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_UUID, &id2) >= 0);
-        assert_se(sd_id128_equal(id, id2));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_UUID, &id2));
+        ASSERT_EQ_ID128(id, id2);
 
         /* Fifth, tests for "uninitialized" */
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
-        assert_se(write(fd, "uninitialized", STRLEN("uninitialized")) == STRLEN("uninitialized"));
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_ANY, NULL) == -ENOPKG);
-
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
-        assert_se(write(fd, "uninitialized\n", STRLEN("uninitialized\n")) == STRLEN("uninitialized\n"));
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_ANY, NULL) == -ENOPKG);
-
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
-        assert_se(write(fd, "uninitialized\nfoo", STRLEN("uninitialized\nfoo")) == STRLEN("uninitialized\nfoo"));
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_ANY, NULL) == -EUCLEAN);
-
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(ftruncate(fd, 0) >= 0);
-        assert_se(write(fd, "uninit", STRLEN("uninit")) == STRLEN("uninit"));
-        assert_se(lseek(fd, 0, SEEK_SET) == 0);
-        assert_se(id128_read_fd(fd, ID128_FORMAT_ANY, NULL) == -EUCLEAN);
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
+        ASSERT_EQ(write(fd, "uninitialized", STRLEN("uninitialized")), (ssize_t) STRLEN("uninitialized"));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_ANY, NULL), ENOPKG);
+
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
+        ASSERT_EQ(write(fd, "uninitialized\n", STRLEN("uninitialized\n")), (ssize_t) STRLEN("uninitialized\n"));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_ANY, NULL), ENOPKG);
+
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
+        ASSERT_EQ(write(fd, "uninitialized\nfoo", STRLEN("uninitialized\nfoo")), (ssize_t) STRLEN("uninitialized\nfoo"));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_ANY, NULL), EUCLEAN);
+
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_OK_ERRNO(ftruncate(fd, 0));
+        ASSERT_EQ(write(fd, "uninit", STRLEN("uninit")), (ssize_t) STRLEN("uninit"));
+        ASSERT_OK_ERRNO(lseek(fd, 0, SEEK_SET));
+        ASSERT_ERROR(id128_read_fd(fd, ID128_FORMAT_ANY, NULL), EUCLEAN);
 
         /* build/systemd-id128 -a f03daaeb1c334b43a732172944bf772e show 51df0b4bc3b04c9780e299b98ca373b8 */
-        assert_se(sd_id128_get_app_specific(SD_ID128_MAKE(51,df,0b,4b,c3,b0,4c,97,80,e2,99,b9,8c,a3,73,b8),
-                                            SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id) >= 0);
-        assert_se(sd_id128_equal(id, SD_ID128_MAKE(1d,ee,59,54,e7,5c,4d,6f,b9,6c,c6,c0,4c,a1,8a,86)));
+        ASSERT_OK(sd_id128_get_app_specific(SD_ID128_MAKE(51,df,0b,4b,c3,b0,4c,97,80,e2,99,b9,8c,a3,73,b8),
+                                            SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id));
+        ASSERT_EQ_ID128(id, SD_ID128_MAKE(1d,ee,59,54,e7,5c,4d,6f,b9,6c,c6,c0,4c,a1,8a,86));
 
         if (sd_booted() > 0 && sd_id128_get_machine(NULL) >= 0) {
-                assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id) >= 0);
-                assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id2) >= 0);
-                assert_se(sd_id128_equal(id, id2));
-                assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(51,df,0b,4b,c3,b0,4c,97,80,e2,99,b9,8c,a3,73,b8), &id2) >= 0);
-                assert_se(!sd_id128_equal(id, id2));
+                ASSERT_OK(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id));
+                ASSERT_OK(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id2));
+                ASSERT_EQ_ID128(id, id2);
+                ASSERT_OK(sd_id128_get_machine_app_specific(SD_ID128_MAKE(51,df,0b,4b,c3,b0,4c,97,80,e2,99,b9,8c,a3,73,b8), &id2));
+                ASSERT_NE_ID128(id, id2);
         }
 
         /* Check return values */
@@ -214,7 +214,7 @@ TEST(sd_id128_get_invocation) {
         if (r < 0)
                 log_warning_errno(r, "Failed to get invocation ID, ignoring: %m");
         else {
-                assert(!sd_id128_equal(id, appid));
+                ASSERT_NE_ID128(id, appid);
                 log_info("Per-App Invocation ID: " SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(appid));
         }
 
@@ -223,8 +223,8 @@ TEST(sd_id128_get_invocation) {
         if (r < 0)
                 log_warning_errno(r, "Failed to get invocation ID, ignoring: %m");
         else {
-                assert(!sd_id128_equal(id, appid2));
-                assert(!sd_id128_equal(appid, appid2));
+                ASSERT_NE_ID128(id, appid2);
+                ASSERT_NE_ID128(appid, appid2);
                 log_info("Per-App Invocation ID 2: " SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(appid2));
         }
 
@@ -233,9 +233,9 @@ TEST(sd_id128_get_invocation) {
         if (r < 0)
                 log_warning_errno(r, "Failed to get invocation ID, ignoring: %m");
         else {
-                assert(!sd_id128_equal(id, appid3));
-                assert(sd_id128_equal(appid, appid3));
-                assert(!sd_id128_equal(appid2, appid3));
+                ASSERT_NE_ID128(id, appid3);
+                ASSERT_EQ_ID128(appid, appid3);
+                ASSERT_NE_ID128(appid2, appid3);
                 log_info("Per-App Invocation ID 3: " SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(appid3));
         }
 }
@@ -256,7 +256,7 @@ TEST(benchmark_sd_id128_get_machine_app_specific) {
         for (unsigned i = 0; i < iterations; i++) {
                 id.qwords[1] = i;
 
-                assert_se(sd_id128_get_machine_app_specific(id, &id2) >= 0);
+                ASSERT_OK(sd_id128_get_machine_app_specific(id, &id2));
         }
 
         q = now(CLOCK_MONOTONIC) - t;
@@ -271,79 +271,79 @@ TEST(id128_at) {
         sd_id128_t id, i;
 
         tfd = mkdtemp_open(NULL, O_PATH, &t);
-        assert_se(tfd >= 0);
-        assert_se(mkdirat(tfd, "etc", 0755) >= 0);
-        assert_se(symlinkat("etc", tfd, "etc2") >= 0);
-        assert_se(symlinkat("machine-id", tfd, "etc/hoge-id") >= 0);
+        ASSERT_OK(tfd);
+        ASSERT_OK_ERRNO(mkdirat(tfd, "etc", 0755));
+        ASSERT_OK_ERRNO(symlinkat("etc", tfd, "etc2"));
+        ASSERT_OK_ERRNO(symlinkat("machine-id", tfd, "etc/hoge-id"));
 
-        assert_se(sd_id128_randomize(&id) == 0);
+        ASSERT_OK(sd_id128_randomize(&id));
 
-        assert_se(id128_write_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, id) >= 0);
+        ASSERT_OK(id128_write_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, id));
         if (geteuid() == 0)
-                assert_se(id128_write_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, id) >= 0);
+                ASSERT_OK(id128_write_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, id));
         else
-                assert_se(id128_write_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, id) == -EACCES);
-        assert_se(unlinkat(tfd, "etc/machine-id", 0) >= 0);
-        assert_se(id128_write_at(tfd, "etc2/machine-id", ID128_FORMAT_PLAIN, id) >= 0);
-        assert_se(unlinkat(tfd, "etc/machine-id", 0) >= 0);
-        assert_se(id128_write_at(tfd, "etc/hoge-id", ID128_FORMAT_PLAIN, id) >= 0);
-        assert_se(unlinkat(tfd, "etc/machine-id", 0) >= 0);
-        assert_se(id128_write_at(tfd, "etc2/hoge-id", ID128_FORMAT_PLAIN, id) >= 0);
+                ASSERT_ERROR(id128_write_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, id), EACCES);
+        ASSERT_OK_ERRNO(unlinkat(tfd, "etc/machine-id", 0));
+        ASSERT_OK(id128_write_at(tfd, "etc2/machine-id", ID128_FORMAT_PLAIN, id));
+        ASSERT_OK_ERRNO(unlinkat(tfd, "etc/machine-id", 0));
+        ASSERT_OK(id128_write_at(tfd, "etc/hoge-id", ID128_FORMAT_PLAIN, id));
+        ASSERT_OK_ERRNO(unlinkat(tfd, "etc/machine-id", 0));
+        ASSERT_OK(id128_write_at(tfd, "etc2/hoge-id", ID128_FORMAT_PLAIN, id));
 
         /* id128_read_at() */
         i = SD_ID128_NULL; /* Not necessary in real code, but for testing that the id is really assigned. */
-        assert_se(id128_read_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read_at(tfd, "etc/machine-id", ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         i = SD_ID128_NULL;
-        assert_se(id128_read_at(tfd, "etc2/machine-id", ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read_at(tfd, "etc2/machine-id", ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         i = SD_ID128_NULL;
-        assert_se(id128_read_at(tfd, "etc/hoge-id", ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read_at(tfd, "etc/hoge-id", ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         i = SD_ID128_NULL;
-        assert_se(id128_read_at(tfd, "etc2/hoge-id", ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read_at(tfd, "etc2/hoge-id", ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         /* id128_read() */
-        assert_se(p = path_join(t, "/etc/machine-id"));
+        ASSERT_NOT_NULL(p = path_join(t, "/etc/machine-id"));
 
         i = SD_ID128_NULL;
-        assert_se(id128_read(p, ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         free(p);
-        assert_se(p = path_join(t, "/etc2/machine-id"));
+        ASSERT_NOT_NULL(p = path_join(t, "/etc2/machine-id"));
 
         i = SD_ID128_NULL;
-        assert_se(id128_read(p, ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         free(p);
-        assert_se(p = path_join(t, "/etc/hoge-id"));
+        ASSERT_NOT_NULL(p = path_join(t, "/etc/hoge-id"));
 
         i = SD_ID128_NULL;
-        assert_se(id128_read(p, ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         free(p);
-        assert_se(p = path_join(t, "/etc2/hoge-id"));
+        ASSERT_NOT_NULL(p = path_join(t, "/etc2/hoge-id"));
 
         i = SD_ID128_NULL;
-        assert_se(id128_read(p, ID128_FORMAT_PLAIN, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_read(p, ID128_FORMAT_PLAIN, &i));
+        ASSERT_EQ_ID128(id, i);
 
         /* id128_get_machine_at() */
         i = SD_ID128_NULL;
-        assert_se(id128_get_machine_at(tfd, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_get_machine_at(tfd, &i));
+        ASSERT_EQ_ID128(id, i);
 
         /* id128_get_machine() */
         i = SD_ID128_NULL;
-        assert_se(id128_get_machine(t, &i) >= 0);
-        assert_se(sd_id128_equal(id, i));
+        ASSERT_OK(id128_get_machine(t, &i));
+        ASSERT_EQ_ID128(id, i);
 }
 
 TEST(ID128_REFUSE_NULL) {
@@ -352,18 +352,18 @@ TEST(ID128_REFUSE_NULL) {
         sd_id128_t id;
 
         tfd = mkdtemp_open(NULL, O_PATH, &t);
-        assert_se(tfd >= 0);
+        ASSERT_OK(tfd);
 
-        assert_se(id128_write_at(tfd, "zero-id", ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, (sd_id128_t) {}) == -ENOMEDIUM);
-        assert_se(unlinkat(tfd, "zero-id", 0) >= 0);
-        assert_se(id128_write_at(tfd, "zero-id", ID128_FORMAT_PLAIN, (sd_id128_t) {}) >= 0);
+        ASSERT_ERROR(id128_write_at(tfd, "zero-id", ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, (sd_id128_t) {}), ENOMEDIUM);
+        ASSERT_OK_ERRNO(unlinkat(tfd, "zero-id", 0));
+        ASSERT_OK(id128_write_at(tfd, "zero-id", ID128_FORMAT_PLAIN, (sd_id128_t) {}));
 
-        assert_se(sd_id128_randomize(&id) == 0);
-        assert_se(!sd_id128_equal(id, SD_ID128_NULL));
-        assert_se(id128_read_at(tfd, "zero-id", ID128_FORMAT_PLAIN, &id) >= 0);
-        assert_se(sd_id128_equal(id, SD_ID128_NULL));
+        ASSERT_OK(sd_id128_randomize(&id));
+        ASSERT_NE_ID128(id, SD_ID128_NULL);
+        ASSERT_OK(id128_read_at(tfd, "zero-id", ID128_FORMAT_PLAIN, &id));
+        ASSERT_EQ_ID128(id, SD_ID128_NULL);
 
-        assert_se(id128_read_at(tfd, "zero-id", ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, &id) == -ENOMEDIUM);
+        ASSERT_ERROR(id128_read_at(tfd, "zero-id", ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, &id), ENOMEDIUM);
 }
 
 DEFINE_TEST_MAIN(LOG_INFO);