test-user-util: Migrate to new assertion macros

diff --git a/src/shared/tests.h b/src/shared/tests.h
index 52e26dc15bfc2ee828d460675054f173155ae8fe..855a28d5b320b6174316da6b77054f0dc4a905f0 100644 (file)
--- a/src/shared/tests.h
+++ b/src/shared/tests.h
@@ -455,6 +455,18 @@ _noreturn_ void log_test_failed_internal(const char *file, int line, const char
         })
 #endif
 
+#ifdef __COVERITY__
+#  define ASSERT_NOT_STREQ(expr1, expr2) __coverity_check__(!streq_ptr((expr1), (expr2)))
+#else
+#  define ASSERT_NOT_STREQ(expr1, expr2)                                                                        \
+        ({                                                                                                      \
+                const char *_expr1 = (expr1), *_expr2 = (expr2);                                                \
+                if (streq_ptr(_expr1, _expr2))                                                                  \
+                        log_test_failed("Expected \"%s != %s\", got \"%s == %s\"",                              \
+                                        #expr1, #expr2, strnull(_expr1), strnull(_expr2));                      \
+        })
+#endif
+
 #ifdef __COVERITY__
 #  define ASSERT_STRNEQ(expr1, expr2, n) __coverity_check__(strneq_ptr((expr1), (expr2), (n)))
 #else

diff --git a/src/test/test-tests.c b/src/test/test-tests.c
index 6f9fe048705ab87e614690b05344a094d9a43cb4..108f155ee75414822e3d5d7e1df3d5ef6c986e28 100644 (file)
--- a/src/test/test-tests.c
+++ b/src/test/test-tests.c
@@ -91,6 +91,11 @@ TEST(ASSERT) {
         ASSERT_SIGNAL(ASSERT_STREQ(null, "bar"), SIGABRT);
         ASSERT_SIGNAL(ASSERT_STREQ("foo", "bar"), SIGABRT);
 
+        ASSERT_NOT_STREQ("foo", "bar");
+        ASSERT_NOT_STREQ("foo", NULL);
+        ASSERT_SIGNAL(ASSERT_NOT_STREQ("foo", "foo"), SIGABRT);
+        ASSERT_SIGNAL(ASSERT_NOT_STREQ(NULL, NULL), SIGABRT);
+
         ASSERT_EQ(0, 0);
         ASSERT_EQ(-1, -1);
         ASSERT_SIGNAL(ASSERT_EQ(255, -1), SIGABRT);

diff --git a/src/test/test-user-util.c b/src/test/test-user-util.c
index 4fee2ba7c27ef9cc5bd195367f6809f8ddca7385..d822df61fb135c8b003f431bfda348f6f3b3e1f3 100644 (file)
--- a/src/test/test-user-util.c
+++ b/src/test/test-user-util.c
@@ -17,7 +17,7 @@ static void test_uid_to_name_one(uid_t uid, const char *name) {
 
         log_info("/* %s("UID_FMT", \"%s\") */", __func__, uid, name);
 
-        assert_se(t = uid_to_name(uid));
+        t = ASSERT_NOT_NULL(uid_to_name(uid));
         if (!synthesize_nobody() && streq(name, NOBODY_USER_NAME)) {
                 log_info("(skipping detailed tests because nobody is not synthesized)");
                 return;
@@ -37,7 +37,7 @@ static void test_gid_to_name_one(gid_t gid, const char *name) {
 
         log_info("/* %s("GID_FMT", \"%s\") */", __func__, gid, name);
 
-        assert_se(t = gid_to_name(gid));
+        t = ASSERT_NOT_NULL(gid_to_name(gid));
         if (!synthesize_nobody() && streq(name, NOBODY_GROUP_NAME)) {
                 log_info("(skipping detailed tests because nobody is not synthesized)");
                 return;
@@ -53,290 +53,238 @@ TEST(gid_to_name) {
 }
 
 TEST(parse_uid) {
-        int r;
         uid_t uid;
 
-        r = parse_uid("0", &uid);
-        assert_se(r == 0);
-        assert_se(uid == 0);
-
-        r = parse_uid("1", &uid);
-        assert_se(r == 0);
-        assert_se(uid == 1);
-
-        r = parse_uid("01", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 1);
-
-        r = parse_uid("001", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 1);
-
-        r = parse_uid("100", &uid);
-        assert_se(r == 0);
-        assert_se(uid == 100);
-
-        r = parse_uid("65535", &uid);
-        assert_se(r == -ENXIO);
-        assert_se(uid == 100);
-
-        r = parse_uid("0x1234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("0o1234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("0b1234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("+1234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("-1234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid(" 1234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("01234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("001234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("0001234", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("-0", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("+0", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("00", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("000", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
-
-        r = parse_uid("asdsdas", &uid);
-        assert_se(r == -EINVAL);
-        assert_se(uid == 100);
+        ASSERT_OK(parse_uid("0", &uid));
+        ASSERT_EQ(uid, 0u);
+
+        ASSERT_OK(parse_uid("1", &uid));
+        ASSERT_EQ(uid, 1u);
+
+        ASSERT_ERROR(parse_uid("01", &uid), EINVAL);
+        ASSERT_EQ(uid, 1u);
+        ASSERT_ERROR(parse_uid("001", &uid), EINVAL);
+
+        ASSERT_OK(parse_uid("100", &uid));
+        ASSERT_EQ(uid, 100u);
+
+        ASSERT_ERROR(parse_uid("65535", &uid), ENXIO);
+        ASSERT_ERROR(parse_uid("0x1234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("0o1234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("0b1234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("+1234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("-1234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid(" 1234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("01234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("001234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("0001234", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("-0", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("+0", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("00", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("000", &uid), EINVAL);
+        ASSERT_ERROR(parse_uid("asdsdas", &uid), EINVAL);
 }
 
 TEST(uid_ptr) {
         ASSERT_NOT_NULL(UID_TO_PTR(0));
         ASSERT_NOT_NULL(UID_TO_PTR(1000));
 
-        assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
-        assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
+        ASSERT_EQ(PTR_TO_UID(UID_TO_PTR(0)), 0u);
+        ASSERT_EQ(PTR_TO_UID(UID_TO_PTR(1000)), 1000u);
 }
 
 TEST(valid_user_group_name_relaxed) {
-        assert_se(!valid_user_group_name(NULL, VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("1", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("65535", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("-1", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("foo\nbar", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("0123456789012345678901234567890123456789", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("aaa:bbb", VALID_USER_RELAX|VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name(".aaa:bbb", VALID_USER_RELAX|VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name(".", VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("..", VALID_USER_RELAX));
-
-        assert_se(valid_user_group_name("root", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("lennart", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("LENNART", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("_kkk", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("kkk-", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("kk-k", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("eff.eff", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("eff.", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("-kkk", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("rööt", VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".eff", VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".1", VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".65535", VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".-1", VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".-kkk", VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".rööt", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("...", VALID_USER_RELAX));
-
-        assert_se(valid_user_group_name("some5", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("5some", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("INNER5NUMBER", VALID_USER_RELAX));
-
-        assert_se(valid_user_group_name("piff.paff@ad.domain.example", VALID_USER_RELAX));
-        assert_se(valid_user_group_name("Dāvis", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name(NULL, VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("1", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("65535", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("-1", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("foo\nbar", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("0123456789012345678901234567890123456789", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("aaa:bbb", VALID_USER_RELAX|VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name(".aaa:bbb", VALID_USER_RELAX|VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name(".", VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("..", VALID_USER_RELAX));
+
+        ASSERT_TRUE(valid_user_group_name("root", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("lennart", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("LENNART", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("_kkk", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("kkk-", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("kk-k", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("eff.eff", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("eff.", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("-kkk", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("rööt", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".eff", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".1", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".65535", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".-1", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".-kkk", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".rööt", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("...", VALID_USER_RELAX));
+
+        ASSERT_TRUE(valid_user_group_name("some5", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("5some", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("INNER5NUMBER", VALID_USER_RELAX));
+
+        ASSERT_TRUE(valid_user_group_name("piff.paff@ad.domain.example", VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("Dāvis", VALID_USER_RELAX));
 }
 
 TEST(valid_user_group_name) {
-        assert_se(!valid_user_group_name(NULL, 0));
-        assert_se(!valid_user_group_name("", 0));
-        assert_se(!valid_user_group_name("1", 0));
-        assert_se(!valid_user_group_name("65535", 0));
-        assert_se(!valid_user_group_name("-1", 0));
-        assert_se(!valid_user_group_name("-kkk", 0));
-        assert_se(!valid_user_group_name("rööt", 0));
-        assert_se(!valid_user_group_name(".", 0));
-        assert_se(!valid_user_group_name(".eff", 0));
-        assert_se(!valid_user_group_name("foo\nbar", 0));
-        assert_se(!valid_user_group_name("0123456789012345678901234567890123456789", 0));
-        assert_se(!valid_user_group_name("aaa:bbb", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name(".", 0));
-        assert_se(!valid_user_group_name("..", 0));
-        assert_se(!valid_user_group_name("...", 0));
-        assert_se(!valid_user_group_name(".1", 0));
-        assert_se(!valid_user_group_name(".65535", 0));
-        assert_se(!valid_user_group_name(".-1", 0));
-        assert_se(!valid_user_group_name(".-kkk", 0));
-        assert_se(!valid_user_group_name(".rööt", 0));
-        assert_se(!valid_user_group_name(".aaa:bbb", VALID_USER_ALLOW_NUMERIC));
-
-        assert_se(valid_user_group_name("root", 0));
-        assert_se(valid_user_group_name("lennart", 0));
-        assert_se(valid_user_group_name("LENNART", 0));
-        assert_se(valid_user_group_name("_kkk", 0));
-        assert_se(valid_user_group_name("kkk-", 0));
-        assert_se(valid_user_group_name("kk-k", 0));
-        assert_se(!valid_user_group_name("eff.eff", 0));
-        assert_se(!valid_user_group_name("eff.", 0));
-
-        assert_se(valid_user_group_name("some5", 0));
-        assert_se(!valid_user_group_name("5some", 0));
-        assert_se(valid_user_group_name("INNER5NUMBER", 0));
-
-        assert_se(!valid_user_group_name("piff.paff@ad.domain.example", 0));
-        assert_se(!valid_user_group_name("Dāvis", 0));
+        ASSERT_FALSE(valid_user_group_name(NULL, 0));
+        ASSERT_FALSE(valid_user_group_name("", 0));
+        ASSERT_FALSE(valid_user_group_name("1", 0));
+        ASSERT_FALSE(valid_user_group_name("65535", 0));
+        ASSERT_FALSE(valid_user_group_name("-1", 0));
+        ASSERT_FALSE(valid_user_group_name("-kkk", 0));
+        ASSERT_FALSE(valid_user_group_name("rööt", 0));
+        ASSERT_FALSE(valid_user_group_name(".", 0));
+        ASSERT_FALSE(valid_user_group_name(".eff", 0));
+        ASSERT_FALSE(valid_user_group_name("foo\nbar", 0));
+        ASSERT_FALSE(valid_user_group_name("0123456789012345678901234567890123456789", 0));
+        ASSERT_FALSE(valid_user_group_name("aaa:bbb", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name(".", 0));
+        ASSERT_FALSE(valid_user_group_name("..", 0));
+        ASSERT_FALSE(valid_user_group_name("...", 0));
+        ASSERT_FALSE(valid_user_group_name(".1", 0));
+        ASSERT_FALSE(valid_user_group_name(".65535", 0));
+        ASSERT_FALSE(valid_user_group_name(".-1", 0));
+        ASSERT_FALSE(valid_user_group_name(".-kkk", 0));
+        ASSERT_FALSE(valid_user_group_name(".rööt", 0));
+        ASSERT_FALSE(valid_user_group_name(".aaa:bbb", VALID_USER_ALLOW_NUMERIC));
+
+        ASSERT_TRUE(valid_user_group_name("root", 0));
+        ASSERT_TRUE(valid_user_group_name("lennart", 0));
+        ASSERT_TRUE(valid_user_group_name("LENNART", 0));
+        ASSERT_TRUE(valid_user_group_name("_kkk", 0));
+        ASSERT_TRUE(valid_user_group_name("kkk-", 0));
+        ASSERT_TRUE(valid_user_group_name("kk-k", 0));
+        ASSERT_FALSE(valid_user_group_name("eff.eff", 0));
+        ASSERT_FALSE(valid_user_group_name("eff.", 0));
+
+        ASSERT_TRUE(valid_user_group_name("some5", 0));
+        ASSERT_FALSE(valid_user_group_name("5some", 0));
+        ASSERT_TRUE(valid_user_group_name("INNER5NUMBER", 0));
+
+        ASSERT_FALSE(valid_user_group_name("piff.paff@ad.domain.example", 0));
+        ASSERT_FALSE(valid_user_group_name("Dāvis", 0));
 }
 
 TEST(valid_user_group_name_or_numeric_relaxed) {
-        assert_se(!valid_user_group_name(NULL, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("0", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("1", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("65534", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("65535", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("65536", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("-1", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("foo\nbar", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("0123456789012345678901234567890123456789", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("aaa:bbb", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name(".", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(!valid_user_group_name("..", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-
-        assert_se(valid_user_group_name("root", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("lennart", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("LENNART", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("_kkk", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("kkk-", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("kk-k", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("-kkk", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("rööt", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name(".eff", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("eff.eff", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("eff.", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("...", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-
-        assert_se(valid_user_group_name("some5", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("5some", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("INNER5NUMBER", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-
-        assert_se(valid_user_group_name("piff.paff@ad.domain.example", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
-        assert_se(valid_user_group_name("Dāvis", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name(NULL, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("0", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("1", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("65534", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("65535", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("65536", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("-1", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("foo\nbar", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("0123456789012345678901234567890123456789", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("aaa:bbb", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name(".", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_FALSE(valid_user_group_name("..", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+
+        ASSERT_TRUE(valid_user_group_name("root", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("lennart", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("LENNART", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("_kkk", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("kkk-", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("kk-k", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("-kkk", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("rööt", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name(".eff", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("eff.eff", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("eff.", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("...", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+
+        ASSERT_TRUE(valid_user_group_name("some5", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("5some", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("INNER5NUMBER", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+
+        ASSERT_TRUE(valid_user_group_name("piff.paff@ad.domain.example", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
+        ASSERT_TRUE(valid_user_group_name("Dāvis", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
 }
 
 TEST(valid_user_group_name_or_numeric) {
-        assert_se(!valid_user_group_name(NULL, VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("0", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("1", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("65534", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("65535", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("65536", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("-1", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("-kkk", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("rööt", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name(".", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("..", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("...", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name(".eff", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("eff.eff", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("eff.", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("foo\nbar", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("0123456789012345678901234567890123456789", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("aaa:bbb", VALID_USER_ALLOW_NUMERIC));
-
-        assert_se(valid_user_group_name("root", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("lennart", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("LENNART", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("_kkk", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("kkk-", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("kk-k", VALID_USER_ALLOW_NUMERIC));
-
-        assert_se(valid_user_group_name("some5", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("5some", VALID_USER_ALLOW_NUMERIC));
-        assert_se(valid_user_group_name("INNER5NUMBER", VALID_USER_ALLOW_NUMERIC));
-
-        assert_se(!valid_user_group_name("piff.paff@ad.domain.example", VALID_USER_ALLOW_NUMERIC));
-        assert_se(!valid_user_group_name("Dāvis", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name(NULL, VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("0", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("1", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("65534", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("65535", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("65536", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("-1", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("-kkk", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("rööt", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name(".", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("..", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("...", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name(".eff", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("eff.eff", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("eff.", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("foo\nbar", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("0123456789012345678901234567890123456789", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("aaa:bbb", VALID_USER_ALLOW_NUMERIC));
+
+        ASSERT_TRUE(valid_user_group_name("root", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("lennart", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("LENNART", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("_kkk", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("kkk-", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("kk-k", VALID_USER_ALLOW_NUMERIC));
+
+        ASSERT_TRUE(valid_user_group_name("some5", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("5some", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_TRUE(valid_user_group_name("INNER5NUMBER", VALID_USER_ALLOW_NUMERIC));
+
+        ASSERT_FALSE(valid_user_group_name("piff.paff@ad.domain.example", VALID_USER_ALLOW_NUMERIC));
+        ASSERT_FALSE(valid_user_group_name("Dāvis", VALID_USER_ALLOW_NUMERIC));
 }
 
 TEST(valid_gecos) {
-        assert_se(!valid_gecos(NULL));
-        assert_se(valid_gecos(""));
-        assert_se(valid_gecos("test"));
-        assert_se(valid_gecos("Ümläüt"));
-        assert_se(!valid_gecos("In\nvalid"));
-        assert_se(!valid_gecos("In:valid"));
+        ASSERT_FALSE(valid_gecos(NULL));
+        ASSERT_TRUE(valid_gecos(""));
+        ASSERT_TRUE(valid_gecos("test"));
+        ASSERT_TRUE(valid_gecos("Ümläüt"));
+        ASSERT_FALSE(valid_gecos("In\nvalid"));
+        ASSERT_FALSE(valid_gecos("In:valid"));
 }
 
 TEST(valid_home) {
-        assert_se(!valid_home(NULL));
-        assert_se(!valid_home(""));
-        assert_se(!valid_home("."));
-        assert_se(!valid_home("/home/.."));
-        assert_se(!valid_home("/home/../"));
-        assert_se(!valid_home("/home\n/foo"));
-        assert_se(!valid_home("./piep"));
-        assert_se(!valid_home("piep"));
-        assert_se(!valid_home("/home/user:lennart"));
-
-        assert_se(valid_home("/"));
-        assert_se(valid_home("/home"));
-        assert_se(valid_home("/home/foo"));
-        assert_se(valid_home("/home/foo/"));
+        ASSERT_FALSE(valid_home(NULL));
+        ASSERT_FALSE(valid_home(""));
+        ASSERT_FALSE(valid_home("."));
+        ASSERT_FALSE(valid_home("/home/.."));
+        ASSERT_FALSE(valid_home("/home/../"));
+        ASSERT_FALSE(valid_home("/home\n/foo"));
+        ASSERT_FALSE(valid_home("./piep"));
+        ASSERT_FALSE(valid_home("piep"));
+        ASSERT_FALSE(valid_home("/home/user:lennart"));
+
+        ASSERT_TRUE(valid_home("/"));
+        ASSERT_TRUE(valid_home("/home"));
+        ASSERT_TRUE(valid_home("/home/foo"));
+        ASSERT_TRUE(valid_home("/home/foo/"));
 }
 
 TEST(valid_shell) {
-        assert_se(!valid_shell(NULL));
-        assert_se(!valid_shell(""));
-        assert_se(!valid_shell("."));
-        assert_se(!valid_shell("/shell/.."));
-        assert_se(!valid_shell("/shell/../"));
-        assert_se(!valid_shell("/shell\n/foo"));
-        assert_se(!valid_shell("./piep"));
-        assert_se(!valid_shell("piep"));
-        assert_se(!valid_shell("/shell/user:lennart"));
-        assert_se(!valid_shell("/"));
-        assert_se(!valid_shell("/bin/sh/"));
-        assert_se(valid_shell("/shell"));
-        assert_se(valid_shell("/shell/foo"));
-        assert_se(valid_shell("/bin/sh"));
+        ASSERT_FALSE(valid_shell(NULL));
+        ASSERT_FALSE(valid_shell(""));
+        ASSERT_FALSE(valid_shell("."));
+        ASSERT_FALSE(valid_shell("/shell/.."));
+        ASSERT_FALSE(valid_shell("/shell/../"));
+        ASSERT_FALSE(valid_shell("/shell\n/foo"));
+        ASSERT_FALSE(valid_shell("./piep"));
+        ASSERT_FALSE(valid_shell("piep"));
+        ASSERT_FALSE(valid_shell("/shell/user:lennart"));
+        ASSERT_FALSE(valid_shell("/"));
+        ASSERT_FALSE(valid_shell("/bin/sh/"));
+        ASSERT_TRUE(valid_shell("/shell"));
+        ASSERT_TRUE(valid_shell("/shell/foo"));
+        ASSERT_TRUE(valid_shell("/bin/sh"));
 }
 
 static void test_get_user_creds_one(const char *id, const char *name, uid_t uid, gid_t gid, const char *home, const char *shell) {
@@ -356,11 +304,11 @@ static void test_get_user_creds_one(const char *id, const char *name, uid_t uid,
                 log_info("(skipping detailed tests because nobody is not synthesized)");
                 return;
         }
-        assert_se(r == 0);
+        ASSERT_OK(r);
         ASSERT_STREQ(id, name);
-        assert_se(ruid == uid);
-        assert_se(rgid == gid);
-        assert_se(path_equal(rhome, home));
+        ASSERT_EQ(ruid, uid);
+        ASSERT_EQ(rgid, gid);
+        ASSERT_TRUE(path_equal(rhome, home));
 }
 
 TEST(get_user_creds) {
@@ -382,9 +330,9 @@ static void test_get_group_creds_one(const char *id, const char *name, gid_t gid
                 log_info("(skipping detailed tests because nobody is not synthesized)");
                 return;
         }
-        assert_se(r == 0);
+        ASSERT_OK(r);
         ASSERT_STREQ(id, name);
-        assert_se(rgid == gid);
+        ASSERT_EQ(rgid, gid);
 }
 
 TEST(get_group_creds) {
@@ -397,20 +345,20 @@ TEST(get_group_creds) {
 TEST(make_salt) {
         _cleanup_free_ char *s, *t;
 
-        assert_se(make_salt(&s) == 0);
+        ASSERT_OK(make_salt(&s));
         log_info("got %s", s);
 
-        assert_se(make_salt(&t) == 0);
+        ASSERT_OK(make_salt(&t));
         log_info("got %s", t);
 
-        assert_se(!streq(s, t));
+        ASSERT_NOT_STREQ(s, t);
 }
 
 TEST(in_gid) {
-        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. */
+        ASSERT_OK(in_gid(getgid()));
+        ASSERT_OK(in_gid(getegid()));
+        ASSERT_FAIL(in_gid(GID_INVALID));
+        ASSERT_OK_ZERO(in_gid(TTY_GID)); /* The TTY gid is for owning ttys, it would be really really weird if we were in it. */
 }
 
 TEST(gid_lists_ops) {
@@ -429,63 +377,76 @@ TEST(gid_lists_ops) {
         _cleanup_free_ gid_t *res4 = NULL;
         int nresult;
 
-        nresult = merge_gid_lists(l2, ELEMENTSOF(l2), l3, ELEMENTSOF(l3), &res1);
-        assert_se(nresult >= 0);
-        assert_se(memcmp_nn(res1, nresult, result1, ELEMENTSOF(result1)) == 0);
+        nresult = ASSERT_OK(merge_gid_lists(l2, ELEMENTSOF(l2), l3, ELEMENTSOF(l3), &res1));
+        ASSERT_EQ(memcmp_nn(res1, nresult, result1, ELEMENTSOF(result1)), 0);
 
-        nresult = merge_gid_lists(NULL, 0, l2, ELEMENTSOF(l2), &res2);
-        assert_se(nresult >= 0);
-        assert_se(memcmp_nn(res2, nresult, l2, ELEMENTSOF(l2)) == 0);
+        nresult = ASSERT_OK(merge_gid_lists(NULL, 0, l2, ELEMENTSOF(l2), &res2));
+        ASSERT_EQ(memcmp_nn(res2, nresult, l2, ELEMENTSOF(l2)), 0);
 
-        nresult = merge_gid_lists(l1, ELEMENTSOF(l1), l1, ELEMENTSOF(l1), &res3);
-        assert_se(nresult >= 0);
-        assert_se(memcmp_nn(l1, ELEMENTSOF(l1), res3, nresult) == 0);
+        nresult = ASSERT_OK(merge_gid_lists(l1, ELEMENTSOF(l1), l1, ELEMENTSOF(l1), &res3));
+        ASSERT_EQ(memcmp_nn(l1, ELEMENTSOF(l1), res3, nresult), 0);
 
-        nresult = merge_gid_lists(l1, ELEMENTSOF(l1), l4, ELEMENTSOF(l4), &res4);
-        assert_se(nresult >= 0);
-        assert_se(memcmp_nn(result2, ELEMENTSOF(result2), res4, nresult) == 0);
+        nresult = ASSERT_OK(merge_gid_lists(l1, ELEMENTSOF(l1), l4, ELEMENTSOF(l4), &res4));
+        ASSERT_EQ(memcmp_nn(result2, ELEMENTSOF(result2), res4, nresult), 0);
 
-        ASSERT_OK(nresult = getgroups_alloc(&gids));
-        assert_se(gids || nresult == 0);
+        nresult = ASSERT_OK(getgroups_alloc(&gids));
+        if (nresult > 0)
+                ASSERT_TRUE(gids);
 }
 
 TEST(parse_uid_range) {
         uid_t a = 4711, b = 4711;
 
-        assert_se(parse_uid_range("", &a, &b) == -EINVAL && a == 4711 && b == 4711);
-        assert_se(parse_uid_range(" ", &a, &b) == -EINVAL && a == 4711 && b == 4711);
-        assert_se(parse_uid_range("x", &a, &b) == -EINVAL && a == 4711 && b == 4711);
-
-        assert_se(parse_uid_range("0", &a, &b) >= 0 && a == 0 && b == 0);
-        assert_se(parse_uid_range("1", &a, &b) >= 0 && a == 1 && b == 1);
-        assert_se(parse_uid_range("2-2", &a, &b) >= 0 && a == 2 && b == 2);
-        assert_se(parse_uid_range("3-3", &a, &b) >= 0 && a == 3 && b == 3);
-        assert_se(parse_uid_range("4-5", &a, &b) >= 0 && a == 4 && b == 5);
-
-        assert_se(parse_uid_range("7-6", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("-1", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("01", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("001", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("+1", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("1--1", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range(" 1", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range(" 1-2", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("1 -2", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("1- 2", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("1-2 ", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("01-2", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("1-02", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("001-2", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range("1-002", &a, &b) == -EINVAL && a == 4 && b == 5);
-        assert_se(parse_uid_range(" 01", &a, &b) == -EINVAL && a == 4 && b == 5);
+        ASSERT_ERROR(parse_uid_range("", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range(" ", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("x", &a, &b), EINVAL);
+        ASSERT_EQ(a, 4711u);
+        ASSERT_EQ(b, 4711u);
+
+        ASSERT_OK(parse_uid_range("0", &a, &b));
+        ASSERT_EQ(a, 0u);
+        ASSERT_EQ(b, 0u);
+
+        ASSERT_OK(parse_uid_range("1", &a, &b));
+        ASSERT_EQ(a, 1u);
+        ASSERT_EQ(b, 1u);
+
+        ASSERT_OK(parse_uid_range("2-2", &a, &b));
+        ASSERT_EQ(a, 2u);
+        ASSERT_EQ(b, 2u);
+
+        ASSERT_OK(parse_uid_range("3-3", &a, &b));
+        ASSERT_EQ(a, 3u);
+        ASSERT_EQ(b, 3u);
+
+        ASSERT_OK(parse_uid_range("4-5", &a, &b));
+        ASSERT_EQ(a, 4u);
+        ASSERT_EQ(b, 5u);
+
+        ASSERT_ERROR(parse_uid_range("7-6", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("-1", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("01", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("001", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("+1", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("1--1", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range(" 1", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range(" 1-2", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("1 -2", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("1- 2", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("1-2 ", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("01-2", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("1-02", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("001-2", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range("1-002", &a, &b), EINVAL);
+        ASSERT_ERROR(parse_uid_range(" 01", &a, &b), EINVAL);
 }
 
 static void test_mangle_gecos_one(const char *input, const char *expected) {
         _cleanup_free_ char *p = NULL;
 
-        assert_se(p = mangle_gecos(input));
+        p = ASSERT_NOT_NULL(mangle_gecos(input));
         ASSERT_STREQ(p, expected);
-        assert_se(valid_gecos(p));
+        ASSERT_TRUE(valid_gecos(p));
 }
 
 TEST(mangle_gecos) {