test: Use TEST macro in more cases

This converts to TEST macro in less trivial cases. This is mostly
due to having an intro or outro before/after the actual tests.

Some notable changes:
 - add a "test" to make sure the hashmap and ordered_hashmap tests
   from different compilation units are actually run in test-hashmap.c
 - make root arg a global var in test-install-root.c
 - slightly rework an EFI specific test in test-proc-cmdline.c
 - usage of saved_argv/saved_argc in test-process-util.c
 - splitting test-rlimit-util.c into several tests
 - moving the hwdb open check into intro in test-sd-hwdb.c
 - condense several "tests" into one in test-udev-util.c

13 files changed, 299 insertions, 668 deletions

diff --git a/src/test/test-cgroup-setup.c b/src/test/test-cgroup-setup.c
index 37ef66b0fd..018992f96d 100644
--- a/src/test/test-cgroup-setup.c
+++ b/src/test/test-cgroup-setup.c
@@ -11,7 +11,7 @@
 #include "tests.h"
 #include "version.h"
 
-static void test_is_wanted_print(bool header) {
+static void test_is_wanted_print_one(bool header) {
         _cleanup_free_ char *cmdline = NULL;
 
         log_info("-- %s --", __func__);
@@ -28,46 +28,46 @@ static void test_is_wanted_print(bool header) {
         log_info(" ");
 }
 
-static void test_is_wanted(void) {
+TEST(is_wanted_print) {
+        test_is_wanted_print_one(true);
+        test_is_wanted_print_one(false); /* run twice to test caching */
+}
+
+TEST(is_wanted) {
         assert_se(setenv("SYSTEMD_PROC_CMDLINE",
                          "systemd.unified_cgroup_hierarchy", 1) >= 0);
-        test_is_wanted_print(false);
+        test_is_wanted_print_one(false);
 
         assert_se(setenv("SYSTEMD_PROC_CMDLINE",
                          "systemd.unified_cgroup_hierarchy=0", 1) >= 0);
-        test_is_wanted_print(false);
+        test_is_wanted_print_one(false);
 
         assert_se(setenv("SYSTEMD_PROC_CMDLINE",
                          "systemd.unified_cgroup_hierarchy=0 "
                          "systemd.legacy_systemd_cgroup_controller", 1) >= 0);
-        test_is_wanted_print(false);
+        test_is_wanted_print_one(false);
 
         assert_se(setenv("SYSTEMD_PROC_CMDLINE",
                          "systemd.unified_cgroup_hierarchy=0 "
                          "systemd.legacy_systemd_cgroup_controller=0", 1) >= 0);
-        test_is_wanted_print(false);
+        test_is_wanted_print_one(false);
 
         /* cgroup_no_v1=all implies unified cgroup hierarchy, unless otherwise
          * explicitly specified. */
         assert_se(setenv("SYSTEMD_PROC_CMDLINE",
                          "cgroup_no_v1=all", 1) >= 0);
-        test_is_wanted_print(false);
+        test_is_wanted_print_one(false);
 
         assert_se(setenv("SYSTEMD_PROC_CMDLINE",
                          "cgroup_no_v1=all "
                          "systemd.unified_cgroup_hierarchy=0", 1) >= 0);
-        test_is_wanted_print(false);
+        test_is_wanted_print_one(false);
 }
 
-int main(void) {
-        test_setup_logging(LOG_DEBUG);
-
-        if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
-                return log_tests_skipped("can't read /proc/cmdline");
-
-        test_is_wanted_print(true);
-        test_is_wanted_print(false); /* run twice to test caching */
-        test_is_wanted();
-
-        return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_DEBUG,
+        ({
+                if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
+                        return log_tests_skipped("can't read /proc/cmdline");
+        }),
+        /* no outro */);
diff --git a/src/test/test-chown-rec.c b/src/test/test-chown-rec.c
index 66c6fd97d1..53d44566d5 100644
--- a/src/test/test-chown-rec.c
+++ b/src/test/test-chown-rec.c
@@ -40,7 +40,7 @@ static bool has_xattr(const char *p) {
         return true;
 }
 
-static void test_chown_recursive(void) {
+TEST(chown_recursive) {
         _cleanup_(rm_rf_physical_and_freep) char *t = NULL;
         struct stat st;
         const char *p;
@@ -149,13 +149,10 @@ static void test_chown_recursive(void) {
         assert_se(!has_xattr(p));
 }
 
-int main(int argc, char *argv[]) {
-        test_setup_logging(LOG_DEBUG);
-
-        if (geteuid() != 0)
-                return log_tests_skipped("not running as root");
-
-        test_chown_recursive();
-
-        return EXIT_SUCCESS;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_DEBUG,
+        ({
+                if (geteuid() != 0)
+                        return log_tests_skipped("not running as root");
+        }),
+        /* no outro */);
diff --git a/src/test/test-format-table.c b/src/test/test-format-table.c
index 7a4c98eba6..a3b29ca337 100644
--- a/src/test/test-format-table.c
+++ b/src/test/test-format-table.c
@@ -6,14 +6,13 @@
 #include "format-table.h"
 #include "string-util.h"
 #include "strv.h"
+#include "tests.h"
 #include "time-util.h"
 
-static void test_issue_9549(void) {
+TEST(issue_9549) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(table = table_new("name", "type", "ro", "usage", "created", "modified"));
         assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(3), 100) >= 0);
         assert_se(table_add_many(table,
@@ -34,12 +33,10 @@ static void test_issue_9549(void) {
                         ));
 }
 
-static void test_multiline(void) {
+TEST(multiline) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(table = table_new("foo", "bar"));
 
         assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100) >= 0);
@@ -148,12 +145,10 @@ static void test_multiline(void) {
         formatted = mfree(formatted);
 }
 
-static void test_strv(void) {
+TEST(strv) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(table = table_new("foo", "bar"));
 
         assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100) >= 0);
@@ -262,12 +257,10 @@ static void test_strv(void) {
         formatted = mfree(formatted);
 }
 
-static void test_strv_wrapped(void) {
+TEST(strv_wrapped) {
         _cleanup_(table_unrefp) Table *table = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(table = table_new("foo", "bar"));
 
         assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100) >= 0);
@@ -366,12 +359,10 @@ static void test_strv_wrapped(void) {
         formatted = mfree(formatted);
 }
 
-static void test_json(void) {
+TEST(json) {
         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
         _cleanup_(table_unrefp) Table *t = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(t = table_new("foo bar", "quux", "piep miau"));
         assert_se(table_set_json_field_name(t, 2, "zzz") >= 0);
 
@@ -401,13 +392,10 @@ static void test_json(void) {
         assert_se(json_variant_equal(v, w));
 }
 
-int main(int argc, char *argv[]) {
+TEST(table) {
         _cleanup_(table_unrefp) Table *t = NULL;
         _cleanup_free_ char *formatted = NULL;
 
-        assert_se(setenv("SYSTEMD_COLORS", "0", 1) >= 0);
-        assert_se(setenv("COLUMNS", "40", 1) >= 0);
-
         assert_se(t = table_new("one", "two", "three"));
 
         assert_se(table_set_align_percent(t, TABLE_HEADER_CELL(2), 100) >= 0);
@@ -539,12 +527,12 @@ int main(int argc, char *argv[]) {
                                 " yes fäää          yes fäää         fäää\n"
                                 " yes xxx           yes xxx          xxx\n"
                                 "5min              5min              \n"));
-
-        test_issue_9549();
-        test_multiline();
-        test_strv();
-        test_strv_wrapped();
-        test_json();
-
-        return 0;
 }
+
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_INFO,
+        ({
+                assert_se(setenv("SYSTEMD_COLORS", "0", 1) >= 0);
+                assert_se(setenv("COLUMNS", "40", 1) >= 0);
+        }),
+        /* no outro */);
diff --git a/src/test/test-hashmap-plain.c b/src/test/test-hashmap-plain.c
index 45a4755399..36a775012b 100644
--- a/src/test/test-hashmap-plain.c
+++ b/src/test/test-hashmap-plain.c
@@ -10,14 +10,10 @@
 #include "time-util.h"
 #include "tests.h"
 
-void test_hashmap_funcs(void);
-
-static void test_hashmap_replace(void) {
+TEST(hashmap_replace) {
         Hashmap *m;
         char *val1, *val2, *val3, *val4, *val5, *r;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
 
         val1 = strdup("val1");
@@ -52,12 +48,10 @@ static void test_hashmap_replace(void) {
         hashmap_free(m);
 }
 
-static void test_hashmap_copy(void) {
+TEST(hashmap_copy) {
         Hashmap *m, *copy;
         char *val1, *val2, *val3, *val4, *r;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -89,13 +83,11 @@ static void test_hashmap_copy(void) {
         hashmap_free(m);
 }
 
-static void test_hashmap_get_strv(void) {
+TEST(hashmap_get_strv) {
         Hashmap *m;
         char **strv;
         char *val1, *val2, *val3, *val4;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -128,12 +120,10 @@ static void test_hashmap_get_strv(void) {
         hashmap_free(m);
 }
 
-static void test_hashmap_move_one(void) {
+TEST(hashmap_move_one) {
         Hashmap *m, *n;
         char *val1, *val2, *val3, *val4, *r;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -169,12 +159,10 @@ static void test_hashmap_move_one(void) {
         hashmap_free_free(n);
 }
 
-static void test_hashmap_move(void) {
+TEST(hashmap_move) {
         Hashmap *m, *n;
         char *val1, *val2, *val3, *val4, *r;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -213,12 +201,10 @@ static void test_hashmap_move(void) {
         hashmap_free_free(n);
 }
 
-static void test_hashmap_update(void) {
+TEST(hashmap_update) {
         Hashmap *m;
         char *val1, *val2, *r;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         val1 = strdup("old_value");
         assert_se(val1);
@@ -242,15 +228,13 @@ static void test_hashmap_update(void) {
         hashmap_free(m);
 }
 
-static void test_hashmap_put(void) {
+TEST(hashmap_put) {
         Hashmap *m = NULL;
         int valid_hashmap_put;
         void *val1 = (void*) "val 1";
         void *val2 = (void*) "val 2";
         _cleanup_free_ char* key1 = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(hashmap_ensure_allocated(&m, &string_hash_ops) == 1);
         assert_se(m);
 
@@ -265,12 +249,10 @@ static void test_hashmap_put(void) {
         hashmap_free(m);
 }
 
-static void test_hashmap_remove(void) {
+TEST(hashmap_remove1) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char *r;
 
-        log_info("/* %s */", __func__);
-
         r = hashmap_remove(NULL, "key 1");
         assert_se(r == NULL);
 
@@ -291,7 +273,7 @@ static void test_hashmap_remove(void) {
         assert_se(!hashmap_get(m, "key 1"));
 }
 
-static void test_hashmap_remove2(void) {
+TEST(hashmap_remove2) {
         _cleanup_hashmap_free_free_free_ Hashmap *m = NULL;
         char key1[] = "key 1";
         char key2[] = "key 2";
@@ -299,8 +281,6 @@ static void test_hashmap_remove2(void) {
         char val2[] = "val 2";
         void *r, *r2;
 
-        log_info("/* %s */", __func__);
-
         r = hashmap_remove2(NULL, "key 1", &r2);
         assert_se(r == NULL);
 
@@ -324,15 +304,13 @@ static void test_hashmap_remove2(void) {
         assert_se(!hashmap_get(m, key1));
 }
 
-static void test_hashmap_remove_value(void) {
+TEST(hashmap_remove_value) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char *r;
 
         char val1[] = "val 1";
         char val2[] = "val 2";
 
-        log_info("/* %s */", __func__);
-
         r = hashmap_remove_value(NULL, "key 1", val1);
         assert_se(r == NULL);
 
@@ -360,13 +338,11 @@ static void test_hashmap_remove_value(void) {
         assert_se(!hashmap_get(m, "key 1"));
 }
 
-static void test_hashmap_remove_and_put(void) {
+TEST(hashmap_remove_and_put) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         int valid;
         char *r;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -392,7 +368,7 @@ static void test_hashmap_remove_and_put(void) {
         assert_se(valid == -EEXIST);
 }
 
-static void test_hashmap_remove_and_replace(void) {
+TEST(hashmap_remove_and_replace) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         int valid;
         void *key1 = UINT_TO_PTR(1);
@@ -401,8 +377,6 @@ static void test_hashmap_remove_and_replace(void) {
         void *r;
         int i, j;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&trivial_hash_ops);
         assert_se(m);
 
@@ -450,12 +424,10 @@ static void test_hashmap_remove_and_replace(void) {
         }
 }
 
-static void test_hashmap_ensure_allocated(void) {
+TEST(hashmap_ensure_allocated) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         int r;
 
-        log_info("/* %s */", __func__);
-
         r = hashmap_ensure_allocated(&m, &string_hash_ops);
         assert_se(r == 1);
 
@@ -467,7 +439,7 @@ static void test_hashmap_ensure_allocated(void) {
         assert_se(r == 0);
 }
 
-static void test_hashmap_foreach_key(void) {
+TEST(hashmap_foreach_key) {
         Hashmap *m;
         bool key_found[] = { false, false, false, false };
         const char *s;
@@ -478,8 +450,6 @@ static void test_hashmap_foreach_key(void) {
                 "key 3\0"
                 "key 4\0";
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
 
         NULSTR_FOREACH(key, key_table)
@@ -503,14 +473,12 @@ static void test_hashmap_foreach_key(void) {
         hashmap_free(m);
 }
 
-static void test_hashmap_foreach(void) {
+TEST(hashmap_foreach) {
         Hashmap *m;
         bool value_found[] = { false, false, false, false };
         char *val1, *val2, *val3, *val4, *s;
         unsigned count;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("my val1");
         assert_se(val1);
         val2 = strdup("my val2");
@@ -556,12 +524,10 @@ static void test_hashmap_foreach(void) {
         hashmap_free_free(m);
 }
 
-static void test_hashmap_merge(void) {
+TEST(hashmap_merge) {
         Hashmap *m, *n;
         char *val1, *val2, *val3, *val4, *r;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("my val1");
         assert_se(val1);
         val2 = strdup("my val2");
@@ -591,12 +557,10 @@ static void test_hashmap_merge(void) {
         hashmap_free_free(m);
 }
 
-static void test_hashmap_contains(void) {
+TEST(hashmap_contains) {
         Hashmap *m;
         char *val1;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("my val");
         assert_se(val1);
 
@@ -613,12 +577,10 @@ static void test_hashmap_contains(void) {
         hashmap_free_free(m);
 }
 
-static void test_hashmap_isempty(void) {
+TEST(hashmap_isempty) {
         Hashmap *m;
         char *val1;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("my val");
         assert_se(val1);
 
@@ -632,12 +594,10 @@ static void test_hashmap_isempty(void) {
         hashmap_free_free(m);
 }
 
-static void test_hashmap_size(void) {
+TEST(hashmap_size) {
         Hashmap *m;
         char *val1, *val2, *val3, *val4;
 
-        log_info("/* %s */", __func__);
-
         val1 = strdup("my val");
         assert_se(val1);
         val2 = strdup("my val");
@@ -663,13 +623,11 @@ static void test_hashmap_size(void) {
         hashmap_free_free(m);
 }
 
-static void test_hashmap_get(void) {
+TEST(hashmap_get) {
         Hashmap *m;
         char *r;
         char *val;
 
-        log_info("/* %s */", __func__);
-
         val = strdup("my val");
         assert_se(val);
 
@@ -690,15 +648,13 @@ static void test_hashmap_get(void) {
         hashmap_free_free(m);
 }
 
-static void test_hashmap_get2(void) {
+TEST(hashmap_get2) {
         Hashmap *m;
         char *r;
         char *val;
         char key_orig[] = "Key 1";
         void *key_copy;
 
-        log_info("/* %s */", __func__);
-
         val = strdup("my val");
         assert_se(val);
 
@@ -734,7 +690,7 @@ static const struct hash_ops crippled_hashmap_ops = {
         .compare = trivial_compare_func,
 };
 
-static void test_hashmap_many(void) {
+TEST(hashmap_many) {
         Hashmap *h;
         unsigned i, j;
         void *v, *k;
@@ -785,7 +741,7 @@ static void test_hashmap_many(void) {
 extern unsigned custom_counter;
 extern const struct hash_ops boring_hash_ops, custom_hash_ops;
 
-static void test_hashmap_free(void) {
+TEST(hashmap_free) {
         Hashmap *h;
         bool slow = slow_tests_enabled();
         usec_t ts, n;
@@ -835,13 +791,11 @@ static void item_seen(Item *item) {
         item->seen++;
 }
 
-static void test_hashmap_free_with_destructor(void) {
+TEST(hashmap_free_with_destructor) {
         Hashmap *m;
         struct Item items[4] = {};
         unsigned i;
 
-        log_info("/* %s */", __func__);
-
         assert_se(m = hashmap_new(NULL));
         for (i = 0; i < ELEMENTSOF(items) - 1; i++)
                 assert_se(hashmap_put(m, INT_TO_PTR(i), items + i) == 1);
@@ -853,11 +807,9 @@ static void test_hashmap_free_with_destructor(void) {
         assert_se(items[3].seen == 0);
 }
 
-static void test_hashmap_first(void) {
+TEST(hashmap_first) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -872,11 +824,9 @@ static void test_hashmap_first(void) {
 #endif
 }
 
-static void test_hashmap_first_key(void) {
+TEST(hashmap_first_key) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -891,11 +841,9 @@ static void test_hashmap_first_key(void) {
 #endif
 }
 
-static void test_hashmap_steal_first_key(void) {
+TEST(hashmap_steal_first_key) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -906,13 +854,11 @@ static void test_hashmap_steal_first_key(void) {
         assert_se(hashmap_isempty(m));
 }
 
-static void test_hashmap_steal_first(void) {
+TEST(hashmap_steal_first) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         int seen[3] = {};
         char *val;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -928,11 +874,9 @@ static void test_hashmap_steal_first(void) {
         assert_se(hashmap_isempty(m));
 }
 
-static void test_hashmap_clear_free_free(void) {
+TEST(hashmap_clear_free_free) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -954,11 +898,9 @@ static void test_hashmap_clear_free_free(void) {
 DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(test_hash_ops_key, char, string_hash_func, string_compare_func, free);
 DEFINE_PRIVATE_HASH_OPS_FULL(test_hash_ops_full, char, string_hash_func, string_compare_func, free, char, free);
 
-static void test_hashmap_clear_free_with_destructor(void) {
+TEST(hashmap_clear_free_with_destructor) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&test_hash_ops_key);
         assert_se(m);
 
@@ -981,11 +923,9 @@ static void test_hashmap_clear_free_with_destructor(void) {
         assert_se(hashmap_isempty(m));
 }
 
-static void test_hashmap_reserve(void) {
+TEST(hashmap_reserve) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
-        log_info("/* %s */", __func__);
-
         m = hashmap_new(&string_hash_ops);
 
         assert_se(hashmap_reserve(m, 1) == 0);
@@ -1000,11 +940,9 @@ static void test_hashmap_reserve(void) {
         assert_se(hashmap_reserve(m, UINT_MAX - 1) == -ENOMEM);
 }
 
-static void test_path_hashmap(void) {
+TEST(path_hashmap) {
         _cleanup_hashmap_free_ Hashmap *h = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(h = hashmap_new(&path_hash_ops));
 
         assert_se(hashmap_put(h, "foo", INT_TO_PTR(1)) >= 0);
@@ -1035,12 +973,10 @@ static void test_path_hashmap(void) {
         assert_se(hashmap_get(h, "foo././//ba.r////.quux///.//.") == INT_TO_PTR(9));
 }
 
-static void test_string_strv_hashmap(void) {
+TEST(string_strv_hashmap) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char **s;
 
-        log_info("/* %s */", __func__);
-
         assert_se(string_strv_hashmap_put(&m, "foo", "bar") == 1);
         assert_se(string_strv_hashmap_put(&m, "foo", "bar") == 0);
         assert_se(string_strv_hashmap_put(&m, "foo", "BAR") == 1);
@@ -1062,40 +998,8 @@ static void test_string_strv_hashmap(void) {
         assert_se(strv_equal(s, STRV_MAKE("bar", "BAR")));
 }
 
-void test_hashmap_funcs(void) {
-        log_info("/************ %s ************/", __func__);
-
-        test_hashmap_copy();
-        test_hashmap_get_strv();
-        test_hashmap_move_one();
-        test_hashmap_move();
-        test_hashmap_replace();
-        test_hashmap_update();
-        test_hashmap_put();
-        test_hashmap_remove();
-        test_hashmap_remove2();
-        test_hashmap_remove_value();
-        test_hashmap_remove_and_put();
-        test_hashmap_remove_and_replace();
-        test_hashmap_ensure_allocated();
-        test_hashmap_foreach();
-        test_hashmap_foreach_key();
-        test_hashmap_contains();
-        test_hashmap_merge();
-        test_hashmap_isempty();
-        test_hashmap_get();
-        test_hashmap_get2();
-        test_hashmap_size();
-        test_hashmap_many();
-        test_hashmap_free();
-        test_hashmap_free_with_destructor();
-        test_hashmap_first();
-        test_hashmap_first_key();
-        test_hashmap_steal_first_key();
-        test_hashmap_steal_first();
-        test_hashmap_clear_free_free();
-        test_hashmap_clear_free_with_destructor();
-        test_hashmap_reserve();
-        test_path_hashmap();
-        test_string_strv_hashmap();
+/* Signal to test-hashmap.c that tests from this compilation unit were run. */
+extern int n_extern_tests_run;
+TEST(ensure_extern_hashmap_tests) {
+        n_extern_tests_run++;
 }
diff --git a/src/test/test-hashmap.c b/src/test/test-hashmap.c
index 20bc97ce58..cba0c33a8a 100644
--- a/src/test/test-hashmap.c
+++ b/src/test/test-hashmap.c
@@ -2,6 +2,7 @@
 
 #include "hashmap.h"
 #include "string-util.h"
+#include "tests.h"
 #include "util.h"
 
 unsigned custom_counter = 0;
@@ -13,15 +14,10 @@ static void custom_destruct(void* p) {
 DEFINE_HASH_OPS_FULL(boring_hash_ops, char, string_hash_func, string_compare_func, free, char, free);
 DEFINE_HASH_OPS_FULL(custom_hash_ops, char, string_hash_func, string_compare_func, custom_destruct, char, custom_destruct);
 
-void test_hashmap_funcs(void);
-void test_ordered_hashmap_funcs(void);
-
-static void test_ordered_hashmap_next(void) {
+TEST(ordered_hashmap_next) {
         _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
         int i;
 
-        log_info("/* %s */", __func__);
-
         assert_se(m = ordered_hashmap_new(NULL));
         for (i = -2; i <= 2; i++)
                 assert_se(ordered_hashmap_put(m, INT_TO_PTR(i), INT_TO_PTR(i+10)) == 1);
@@ -32,7 +28,7 @@ static void test_ordered_hashmap_next(void) {
         assert_se(!ordered_hashmap_next(m, INT_TO_PTR(3)));
 }
 
-static void test_uint64_compare_func(void) {
+TEST(uint64_compare_func) {
         const uint64_t a = 0x100, b = 0x101;
 
         assert_se(uint64_compare_func(&a, &a) == 0);
@@ -40,13 +36,13 @@ static void test_uint64_compare_func(void) {
         assert_se(uint64_compare_func(&b, &a) == 1);
 }
 
-static void test_trivial_compare_func(void) {
+TEST(trivial_compare_func) {
         assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('a')) == 0);
         assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('b')) == -1);
         assert_se(trivial_compare_func(INT_TO_PTR('b'), INT_TO_PTR('a')) == 1);
 }
 
-static void test_string_compare_func(void) {
+TEST(string_compare_func) {
         assert_se(string_compare_func("fred", "wilma") != 0);
         assert_se(string_compare_func("fred", "fred") == 0);
 }
@@ -71,12 +67,10 @@ static void compare_cache(Hashmap *map, IteratedCache *cache) {
         assert_se(idx == num);
 }
 
-static void test_iterated_cache(void) {
+TEST(iterated_cache) {
         Hashmap *m;
         IteratedCache *c;
 
-        log_info("/* %s */", __func__);
-
         assert_se(m = hashmap_new(NULL));
         assert_se(c = hashmap_iterated_cache_new(m));
         compare_cache(m, c);
@@ -109,15 +103,13 @@ static void test_iterated_cache(void) {
         assert_se(iterated_cache_free(c) == NULL);
 }
 
-static void test_hashmap_put_strdup(void) {
+TEST(hashmap_put_strdup) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char *s;
 
         /* We don't have ordered_hashmap_put_strdup() yet. If it is added,
          * these tests should be moved to test-hashmap-plain.c. */
 
-        log_info("/* %s */", __func__);
-
         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 1);
         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
         assert_se(hashmap_put_strdup(&m, "foo", "BAR") == -EEXIST);
@@ -137,12 +129,10 @@ static void test_hashmap_put_strdup(void) {
         assert_se(streq(s, "bar"));
 }
 
-static void test_hashmap_put_strdup_null(void) {
+TEST(hashmap_put_strdup_null) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char *s;
 
-        log_info("/* %s */", __func__);
-
         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 1);
         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
         assert_se(hashmap_put_strdup(&m, "foo", NULL) == -EEXIST);
@@ -161,26 +151,14 @@ static void test_hashmap_put_strdup_null(void) {
         assert_se(s == NULL);
 }
 
-int main(int argc, const char *argv[]) {
-        /* This file tests in test-hashmap-plain.c, and tests in test-hashmap-ordered.c, which is generated
-         * from test-hashmap-plain.c. Hashmap tests should be added to test-hashmap-plain.c, and here only if
-         * they don't apply to ordered hashmaps. */
+/* This file tests in test-hashmap-plain.c, and tests in test-hashmap-ordered.c, which is generated
+ * from test-hashmap-plain.c. Hashmap tests should be added to test-hashmap-plain.c, and here only if
+ * they don't apply to ordered hashmaps. */
 
-        log_parse_environment();
-        log_open();
+/* This variable allows us to assert that the tests from different compilation units were actually run. */
+int n_extern_tests_run = 0;
 
-        test_hashmap_funcs();
-        test_ordered_hashmap_funcs();
-
-        log_info("/************ non-shared tests ************/");
-
-        test_ordered_hashmap_next();
-        test_uint64_compare_func();
-        test_trivial_compare_func();
-        test_string_compare_func();
-        test_iterated_cache();
-        test_hashmap_put_strdup();
-        test_hashmap_put_strdup_null();
-
-        return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_INFO,
+        assert_se(n_extern_tests_run == 0),
+        assert_se(n_extern_tests_run == 2)); /* Ensure hashmap and ordered_hashmap were tested. */
diff --git a/src/test/test-install-root.c b/src/test/test-install-root.c
index d0bd6917a8..ba715e6d7e 100644
--- a/src/test/test-install-root.c
+++ b/src/test/test-install-root.c
@@ -12,14 +12,14 @@
 #include "string-util.h"
 #include "tests.h"
 
-static void test_basic_mask_and_enable(const char *root) {
+static char root[] = "/tmp/rootXXXXXX";
+
+TEST(basic_mask_and_enable) {
         const char *p;
         UnitFileState state;
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
 
-        test_setup_logging(LOG_DEBUG);
-
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "a.service", NULL) == -ENOENT);
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "b.service", NULL) == -ENOENT);
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "c.service", NULL) == -ENOENT);
@@ -196,7 +196,7 @@ static void test_basic_mask_and_enable(const char *root) {
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "f.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
 }
 
-static void test_linked_units(const char *root) {
+TEST(linked_units) {
         const char *p, *q;
         UnitFileState state;
         UnitFileChange *changes = NULL;
@@ -342,7 +342,7 @@ static void test_linked_units(const char *root) {
         changes = NULL; n_changes = 0;
 }
 
-static void test_default(const char *root) {
+TEST(default) {
         _cleanup_free_ char *def = NULL;
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
@@ -378,7 +378,7 @@ static void test_default(const char *root) {
         assert_se(streq_ptr(def, "test-default-real.target"));
 }
 
-static void test_add_dependency(const char *root) {
+TEST(add_dependency) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
         const char *p;
@@ -405,7 +405,7 @@ static void test_add_dependency(const char *root) {
         changes = NULL; n_changes = 0;
 }
 
-static void test_template_enable(const char *root) {
+TEST(template_enable) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
         UnitFileState state;
@@ -519,7 +519,7 @@ static void test_template_enable(const char *root) {
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "template-symlink@quux.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
 }
 
-static void test_indirect(const char *root) {
+TEST(indirect) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
         UnitFileState state;
@@ -568,7 +568,7 @@ static void test_indirect(const char *root) {
         changes = NULL; n_changes = 0;
 }
 
-static void test_preset_and_list(const char *root) {
+TEST(preset_and_list) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0, i;
         const char *p, *q;
@@ -675,14 +675,12 @@ static void test_preset_and_list(const char *root) {
         assert_se(got_yes && got_no);
 }
 
-static void test_revert(const char *root) {
+TEST(revert) {
         const char *p;
         UnitFileState state;
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
 
-        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);
 
@@ -725,7 +723,7 @@ static void test_revert(const char *root) {
         changes = NULL; n_changes = 0;
 }
 
-static void test_preset_order(const char *root) {
+TEST(preset_order) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
         const char *p;
@@ -772,7 +770,7 @@ static void test_preset_order(const char *root) {
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "prefix-2.service", &state) >= 0 && state == UNIT_FILE_DISABLED);
 }
 
-static void test_static_instance(const char *root) {
+TEST(static_instance) {
         UnitFileState state;
         const char *p;
 
@@ -794,7 +792,7 @@ static void test_static_instance(const char *root) {
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "static-instance@foo.service", &state) >= 0 && state == UNIT_FILE_STATIC);
 }
 
-static void test_with_dropin(const char *root) {
+TEST(with_dropin) {
         const char *p;
         UnitFileState state;
         UnitFileChange *changes = NULL;
@@ -923,7 +921,7 @@ static void test_with_dropin(const char *root) {
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "with-dropin-4b.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
 }
 
-static void test_with_dropin_template(const char *root) {
+TEST(with_dropin_template) {
         const char *p;
         UnitFileState state;
         UnitFileChange *changes = NULL;
@@ -1021,7 +1019,7 @@ static void test_with_dropin_template(const char *root) {
         assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "with-dropin-3@instance-2.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
 }
 
-static void test_preset_multiple_instances(const char *root) {
+TEST(preset_multiple_instances) {
         UnitFileChange *changes = NULL;
         size_t n_changes = 0;
         const char *p;
@@ -1104,7 +1102,7 @@ static void verify_one(
         assert_se(streq_ptr(alias2, updated_name));
 }
 
-static void test_verify_alias(void) {
+TEST(verify_alias) {
         const UnitFileInstallInfo
                 plain_service    = { .name = (char*) "plain.service" },
                 bare_template    = { .name = (char*) "template1@.service" },
@@ -1241,8 +1239,7 @@ static void test_verify_alias(void) {
         verify_one(&di_inst_template, "goo.target.conf/plain.service", -EXDEV, NULL);
 }
 
-int main(int argc, char *argv[]) {
-        char root[] = "/tmp/rootXXXXXX";
+static void setup_root(void) {
         const char *p;
 
         assert_se(mkdtemp(root));
@@ -1267,24 +1264,6 @@ int main(int argc, char *argv[]) {
 
         p = strjoina(root, "/usr/lib/systemd/system/graphical.target");
         assert_se(write_string_file(p, "# pretty much empty", WRITE_STRING_FILE_CREATE) >= 0);
-
-        test_basic_mask_and_enable(root);
-        test_linked_units(root);
-        test_default(root);
-        test_add_dependency(root);
-        test_template_enable(root);
-        test_indirect(root);
-        test_preset_and_list(root);
-        test_preset_order(root);
-        test_preset_multiple_instances(root);
-        test_revert(root);
-        test_static_instance(root);
-        test_with_dropin(root);
-        test_with_dropin_template(root);
-
-        assert_se(rm_rf(root, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
-
-        test_verify_alias();
-
-        return 0;
 }
+
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, setup_root(), assert_se(rm_rf(root, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0));
diff --git a/src/test/test-mountpoint-util.c b/src/test/test-mountpoint-util.c
index 983e1842d6..d11edf502a 100644
--- a/src/test/test-mountpoint-util.c
+++ b/src/test/test-mountpoint-util.c
@@ -17,7 +17,7 @@
 #include "tests.h"
 #include "tmpfile-util.h"
 
-static void test_mount_propagation_flags(const char *name, int ret, unsigned long expected) {
+static void test_mount_propagation_flags_one(const char *name, int ret, unsigned long expected) {
         long unsigned flags;
 
         log_info("/* %s(%s) */", __func__, name);
@@ -37,7 +37,17 @@ static void test_mount_propagation_flags(const char *name, int ret, unsigned lon
         }
 }
 
-static void test_mnt_id(void) {
+TEST(mount_propagation_flags) {
+        test_mount_propagation_flags_one("shared", 0, MS_SHARED);
+        test_mount_propagation_flags_one("slave", 0, MS_SLAVE);
+        test_mount_propagation_flags_one("private", 0, MS_PRIVATE);
+        test_mount_propagation_flags_one(NULL, 0, 0);
+        test_mount_propagation_flags_one("", 0, 0);
+        test_mount_propagation_flags_one("xxxx", -EINVAL, 0);
+        test_mount_propagation_flags_one(" ", -EINVAL, 0);
+}
+
+TEST(mnt_id) {
         _cleanup_fclose_ FILE *f = NULL;
         _cleanup_hashmap_free_free_ Hashmap *h = NULL;
         char *p;
@@ -96,15 +106,13 @@ static void test_mnt_id(void) {
         }
 }
 
-static void test_path_is_mount_point(void) {
+TEST(path_is_mount_point) {
         int fd;
         char tmp_dir[] = "/tmp/test-path-is-mount-point-XXXXXX";
         _cleanup_free_ char *file1 = NULL, *file2 = NULL, *link1 = NULL, *link2 = NULL;
         _cleanup_free_ char *dir1 = NULL, *dir1file = NULL, *dirlink1 = NULL, *dirlink1file = NULL;
         _cleanup_free_ char *dir2 = NULL, *dir2file = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(path_is_mount_point("/", NULL, AT_SYMLINK_FOLLOW) > 0);
         assert_se(path_is_mount_point("/", NULL, 0) > 0);
         assert_se(path_is_mount_point("//", NULL, AT_SYMLINK_FOLLOW) > 0);
@@ -257,11 +265,9 @@ static void test_path_is_mount_point(void) {
         assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0);
 }
 
-static void test_fd_is_mount_point(void) {
+TEST(fd_is_mount_point) {
         _cleanup_close_ int fd = -1;
 
-        log_info("/* %s */", __func__);
-
         fd = open("/", O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOCTTY);
         assert_se(fd >= 0);
 
@@ -288,30 +294,17 @@ static void test_fd_is_mount_point(void) {
         assert_se(IN_SET(fd_is_mount_point(fd, "root/", 0), -ENOENT, 0));
 }
 
-int main(int argc, char *argv[]) {
-        test_setup_logging(LOG_DEBUG);
-
-        /* let's move into our own mount namespace with all propagation from the host turned off, so that
-         * /proc/self/mountinfo is static and constant for the whole time our test runs. */
-        if (unshare(CLONE_NEWNS) < 0) {
-                if (!ERRNO_IS_PRIVILEGE(errno))
-                        return log_error_errno(errno, "Failed to detach mount namespace: %m");
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_DEBUG,
+        ({
+                /* let's move into our own mount namespace with all propagation from the host turned off, so
+                 * that /proc/self/mountinfo is static and constant for the whole time our test runs. */
+                if (unshare(CLONE_NEWNS) < 0) {
+                        if (!ERRNO_IS_PRIVILEGE(errno))
+                                return log_error_errno(errno, "Failed to detach mount namespace: %m");
 
-                log_notice("Lacking privilege to create separate mount namespace, proceeding in originating mount namespace.");
-        } else
-                assert_se(mount(NULL, "/", NULL, MS_PRIVATE | MS_REC, NULL) >= 0);
-
-        test_mount_propagation_flags("shared", 0, MS_SHARED);
-        test_mount_propagation_flags("slave", 0, MS_SLAVE);
-        test_mount_propagation_flags("private", 0, MS_PRIVATE);
-        test_mount_propagation_flags(NULL, 0, 0);
-        test_mount_propagation_flags("", 0, 0);
-        test_mount_propagation_flags("xxxx", -EINVAL, 0);
-        test_mount_propagation_flags(" ", -EINVAL, 0);
-
-        test_mnt_id();
-        test_path_is_mount_point();
-        test_fd_is_mount_point();
-
-        return 0;
-}
+                        log_notice("Lacking privilege to create separate mount namespace, proceeding in originating mount namespace.");
+                } else
+                        assert_se(mount(NULL, "/", NULL, MS_PRIVATE | MS_REC, NULL) >= 0);
+        }),
+        /* no outro */);
diff --git a/src/test/test-proc-cmdline.c b/src/test/test-proc-cmdline.c
index a72523bd02..1c8c9b80b7 100644
--- a/src/test/test-proc-cmdline.c
+++ b/src/test/test-proc-cmdline.c
@@ -21,15 +21,11 @@ static int parse_item(const char *key, const char *value, void *data) {
         return 0;
 }
 
-static void test_proc_cmdline_parse(void) {
-        log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_parse) {
         assert_se(proc_cmdline_parse(parse_item, &obj, PROC_CMDLINE_STRIP_RD_PREFIX) >= 0);
 }
 
-static void test_proc_cmdline_override(void) {
-        log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_override) {
         assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"") == 0);
         assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=different") == 0);
 
@@ -87,7 +83,7 @@ static int parse_item_given(const char *key, const char *value, void *data) {
         return 0;
 }
 
-static void test_proc_cmdline_given(bool flip_initrd) {
+static void test_proc_cmdline_given_one(bool flip_initrd) {
         log_info("/* %s (flip: %s) */", __func__, yes_no(flip_initrd));
 
         if (flip_initrd)
@@ -104,10 +100,15 @@ static void test_proc_cmdline_given(bool flip_initrd) {
                 in_initrd_force(!in_initrd());
 }
 
-static void test_proc_cmdline_get_key(void) {
+TEST(test_proc_cmdline_given) {
+        test_proc_cmdline_given_one(false);
+        /* Repeat the same thing, but now flip our ininitrdness */
+        test_proc_cmdline_given_one(true);
+}
+
+TEST(proc_cmdline_get_key) {
         _cleanup_free_ char *value = NULL;
 
-        log_info("/* %s */", __func__);
         assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm spaaace='ö ü ß' ticks=\"''\"\n\nkkk=uuu\n\n\n") == 0);
 
         assert_se(proc_cmdline_get_key("", 0, &value) == -EINVAL);
@@ -150,10 +151,9 @@ static void test_proc_cmdline_get_key(void) {
         assert_se(proc_cmdline_get_key("kkk", 0, &value) > 0 && streq_ptr(value, "uuu"));
 }
 
-static void test_proc_cmdline_get_bool(void) {
+TEST(proc_cmdline_get_bool) {
         bool value = false;
 
-        log_info("/* %s */", __func__);
         assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar bar-waldo=1 x_y-z=0 quux=miep\nda=yes\nthe=1") == 0);
         assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=") == 0);
 
@@ -170,11 +170,15 @@ static void test_proc_cmdline_get_bool(void) {
         assert_se(proc_cmdline_get_bool("quux", &value) == -EINVAL && value == false);
         assert_se(proc_cmdline_get_bool("da", &value) > 0 && value == true);
         assert_se(proc_cmdline_get_bool("the", &value) > 0 && value == true);
+}
+
+#if ENABLE_EFI
+TEST(proc_cmdline_get_bool_efi) {
+        bool value = false;
 
         assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=") == 0);
         assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=foo_bar bar-waldo=1 x_y-z=0 quux=miep\nda=yes\nthe=1") == 0);
 
-#if ENABLE_EFI
         assert_se(proc_cmdline_get_bool("", &value) == -EINVAL);
         assert_se(proc_cmdline_get_bool("abc", &value) == 0 && value == false);
         assert_se(proc_cmdline_get_bool("foo_bar", &value) > 0 && value == true);
@@ -188,13 +192,12 @@ static void test_proc_cmdline_get_bool(void) {
         assert_se(proc_cmdline_get_bool("quux", &value) == -EINVAL && value == false);
         assert_se(proc_cmdline_get_bool("da", &value) > 0 && value == true);
         assert_se(proc_cmdline_get_bool("the", &value) > 0 && value == true);
-#endif
 }
+#endif
 
-static void test_proc_cmdline_get_key_many(void) {
+TEST(proc_cmdline_get_key_many) {
         _cleanup_free_ char *value1 = NULL, *value2 = NULL, *value3 = NULL, *value4 = NULL, *value5 = NULL, *value6 = NULL, *value7 = NULL;
 
-        log_info("/* %s */", __func__);
         assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm SPACE='one two' doubleticks=\" aaa aaa \"\n\nzummm='\n'\n") == 0);
 
         assert_se(proc_cmdline_get_key_many(0,
@@ -215,9 +218,7 @@ static void test_proc_cmdline_get_key_many(void) {
         assert_se(streq_ptr(value7, "\n"));
 }
 
-static void test_proc_cmdline_key_streq(void) {
-        log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_key_streq) {
         assert_se(proc_cmdline_key_streq("", ""));
         assert_se(proc_cmdline_key_streq("a", "a"));
         assert_se(!proc_cmdline_key_streq("", "a"));
@@ -232,9 +233,7 @@ static void test_proc_cmdline_key_streq(void) {
         assert_se(!proc_cmdline_key_streq("x_y-z", "x-z_z"));
 }
 
-static void test_proc_cmdline_key_startswith(void) {
-        log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_key_startswith) {
         assert_se(proc_cmdline_key_startswith("", ""));
         assert_se(proc_cmdline_key_startswith("x", ""));
         assert_se(!proc_cmdline_key_startswith("", "x"));
@@ -248,22 +247,10 @@ static void test_proc_cmdline_key_startswith(void) {
         assert_se(!proc_cmdline_key_startswith("foo-bar", "foo_xx"));
 }
 
-int main(void) {
-        test_setup_logging(LOG_INFO);
-
-        if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
-                return log_tests_skipped("can't read /proc/cmdline");
-
-        test_proc_cmdline_parse();
-        test_proc_cmdline_override();
-        test_proc_cmdline_given(false);
-        /* Repeat the same thing, but now flip our ininitrdness */
-        test_proc_cmdline_given(true);
-        test_proc_cmdline_key_streq();
-        test_proc_cmdline_key_startswith();
-        test_proc_cmdline_get_key();
-        test_proc_cmdline_get_bool();
-        test_proc_cmdline_get_key_many();
-
-        return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_INFO,
+        ({
+                if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
+                        return log_tests_skipped("can't read /proc/cmdline");
+        }),
+        /* no outro */);
diff --git a/src/test/test-process-util.c b/src/test/test-process-util.c
index cc0f870e57..a180f3f9b4 100644
--- a/src/test/test-process-util.c
+++ b/src/test/test-process-util.c
@@ -37,7 +37,7 @@
 #include "util.h"
 #include "virt.h"
 
-static void test_get_process_comm(pid_t pid) {
+static void test_get_process_comm_one(pid_t pid) {
         struct stat st;
         _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
         _cleanup_free_ char *env = NULL;
@@ -98,6 +98,18 @@ static void test_get_process_comm(pid_t pid) {
         log_info("PID"PID_FMT" $PATH: '%s'", pid, strna(i));
 }
 
+TEST(get_process_comm) {
+        if (saved_argc > 1) {
+                pid_t pid = 0;
+
+                (void) parse_pid(saved_argv[1], &pid);
+                test_get_process_comm_one(pid);
+        } else {
+                TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm_one(1));
+                test_get_process_comm_one(getpid());
+        }
+}
+
 static void test_get_process_cmdline_one(pid_t pid) {
         _cleanup_free_ char *c = NULL, *d = NULL, *e = NULL, *f = NULL, *g = NULL, *h = NULL;
         int r;
@@ -121,12 +133,10 @@ static void test_get_process_cmdline_one(pid_t pid) {
         log_info("      %s", r >= 0 ? h : errno_to_name(r));
 }
 
-static void test_get_process_cmdline(void) {
+TEST(get_process_cmdline) {
         _cleanup_closedir_ DIR *d = NULL;
         struct dirent *de;
 
-        log_info("/* %s */", __func__);
-
         assert_se(d = opendir("/proc"));
 
         FOREACH_DIRENT(de, d, return) {
@@ -155,11 +165,9 @@ static void test_get_process_comm_escape_one(const char *input, const char *outp
         assert_se(streq_ptr(n, output));
 }
 
-static void test_get_process_comm_escape(void) {
+TEST(get_process_comm_escape) {
         _cleanup_free_ char *saved = NULL;
 
-        log_info("/* %s */", __func__);
-
         assert_se(get_process_comm(0, &saved) >= 0);
 
         test_get_process_comm_escape_one("", "");
@@ -176,7 +184,7 @@ static void test_get_process_comm_escape(void) {
         assert_se(prctl(PR_SET_NAME, saved) >= 0);
 }
 
-static void test_pid_is_unwaited(void) {
+TEST(pid_is_unwaited) {
         pid_t pid;
 
         pid = fork();
@@ -193,11 +201,9 @@ static void test_pid_is_unwaited(void) {
         assert_se(!pid_is_unwaited(-1));
 }
 
-static void test_pid_is_alive(void) {
+TEST(pid_is_alive) {
         pid_t pid;
 
-        log_info("/* %s */", __func__);
-
         pid = fork();
         assert_se(pid >= 0);
         if (pid == 0) {
@@ -212,9 +218,7 @@ static void test_pid_is_alive(void) {
         assert_se(!pid_is_alive(-1));
 }
 
-static void test_personality(void) {
-        log_info("/* %s */", __func__);
-
+TEST(personality) {
         assert_se(personality_to_string(PER_LINUX));
         assert_se(!personality_to_string(PERSONALITY_INVALID));
 
@@ -236,14 +240,12 @@ static void test_personality(void) {
 #endif
 }
 
-static void test_get_process_cmdline_harder(void) {
+TEST(get_process_cmdline_harder) {
         char path[] = "/tmp/test-cmdlineXXXXXX";
         _cleanup_close_ int fd = -1;
         _cleanup_free_ char *line = NULL;
         pid_t pid;
 
-        log_info("/* %s */", __func__);
-
         if (geteuid() != 0) {
                 log_info("Skipping %s: not root", __func__);
                 return;
@@ -589,7 +591,7 @@ static void test_rename_process_one(const char *p, int ret) {
         assert_se(si.si_status == EXIT_SUCCESS);
 }
 
-static void test_rename_process_multi(void) {
+TEST(rename_process_multi) {
         pid_t pid;
 
         pid = fork();
@@ -616,21 +618,18 @@ static void test_rename_process_multi(void) {
         _exit(EXIT_SUCCESS);
 }
 
-static void test_rename_process(void) {
+TEST(rename_process) {
         test_rename_process_one(NULL, -EINVAL);
         test_rename_process_one("", -EINVAL);
         test_rename_process_one("foo", 1); /* should always fit */
         test_rename_process_one("this is a really really long process name, followed by some more words", 0); /* unlikely to fit */
         test_rename_process_one("1234567", 1); /* should always fit */
-        test_rename_process_multi(); /* multiple invocations and dropped privileges */
 }
 
-static void test_getpid_cached(void) {
+TEST(getpid_cached) {
         siginfo_t si;
         pid_t a, b, c, d, e, f, child;
 
-        log_info("/* %s */", __func__);
-
         a = raw_getpid();
         b = getpid_cached();
         c = getpid();
@@ -661,7 +660,7 @@ static void test_getpid_cached(void) {
         assert_se(si.si_code == CLD_EXITED);
 }
 
-static void test_getpid_measure(void) {
+TEST(getpid_measure) {
         usec_t t, q;
 
         unsigned long long iterations = slow_tests_enabled() ? 1000000 : 1000;
@@ -685,13 +684,11 @@ static void test_getpid_measure(void) {
         log_info("getpid_cached(): %lf µs each\n", (double) q / iterations);
 }
 
-static void test_safe_fork(void) {
+TEST(safe_fork) {
         siginfo_t status;
         pid_t pid;
         int r;
 
-        log_info("/* %s */", __func__);
-
         BLOCK_SIGNALS(SIGCHLD);
 
         r = safe_fork("(test-child)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_NULL_STDIO|FORK_REOPEN_LOG, &pid);
@@ -709,8 +706,7 @@ static void test_safe_fork(void) {
         assert_se(status.si_status == 88);
 }
 
-static void test_pid_to_ptr(void) {
-
+TEST(pid_to_ptr) {
         assert_se(PTR_TO_PID(NULL) == 0);
         assert_se(PID_TO_PTR(0) == NULL);
 
@@ -745,9 +741,7 @@ static void test_ioprio_class_from_to_string_one(const char *val, int expected,
         }
 }
 
-static void test_ioprio_class_from_to_string(void) {
-        log_info("/* %s */", __func__);
-
+TEST(ioprio_class_from_to_string) {
         test_ioprio_class_from_to_string_one("none", IOPRIO_CLASS_NONE, IOPRIO_CLASS_BE);
         test_ioprio_class_from_to_string_one("realtime", IOPRIO_CLASS_RT, IOPRIO_CLASS_RT);
         test_ioprio_class_from_to_string_one("best-effort", IOPRIO_CLASS_BE, IOPRIO_CLASS_BE);
@@ -760,11 +754,9 @@ static void test_ioprio_class_from_to_string(void) {
         test_ioprio_class_from_to_string_one("-1", -EINVAL, -EINVAL);
 }
 
-static void test_setpriority_closest(void) {
+TEST(setpriority_closest) {
         int r;
 
-        log_info("/* %s */", __func__);
-
         r = safe_fork("(test-setprio)",
                       FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_WAIT|FORK_LOG, NULL);
         assert_se(r >= 0);
@@ -849,12 +841,10 @@ static void test_setpriority_closest(void) {
         }
 }
 
-static void test_get_process_ppid(void) {
+TEST(get_process_ppid) {
         uint64_t limit;
         int r;
 
-        log_info("/* %s */", __func__);
-
         assert_se(get_process_ppid(1, NULL) == -EADDRNOTAVAIL);
 
         /* the process with the PID above the global limit definitely doesn't exist. Verify that */
@@ -888,7 +878,7 @@ static void test_get_process_ppid(void) {
         }
 }
 
-static void test_set_oom_score_adjust(void) {
+TEST(set_oom_score_adjust) {
         int a, b, r;
 
         assert_se(get_oom_score_adjust(&a) >= 0);
@@ -906,37 +896,4 @@ static void test_set_oom_score_adjust(void) {
         assert_se(b == a);
 }
 
-int main(int argc, char *argv[]) {
-        log_show_color(true);
-        test_setup_logging(LOG_INFO);
-
-        save_argc_argv(argc, argv);
-
-        if (argc > 1) {
-                pid_t pid = 0;
-
-                (void) parse_pid(argv[1], &pid);
-                test_get_process_comm(pid);
-        } else {
-                TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm(1));
-                test_get_process_comm(getpid());
-        }
-
-        test_get_process_comm_escape();
-        test_get_process_cmdline();
-        test_pid_is_unwaited();
-        test_pid_is_alive();
-        test_personality();
-        test_get_process_cmdline_harder();
-        test_rename_process();
-        test_getpid_cached();
-        test_getpid_measure();
-        test_safe_fork();
-        test_pid_to_ptr();
-        test_ioprio_class_from_to_string();
-        test_setpriority_closest();
-        test_get_process_ppid();
-        test_set_oom_score_adjust();
-
-        return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, log_show_color(true), /* no outro */);
diff --git a/src/test/test-rlimit-util.c b/src/test/test-rlimit-util.c
index 2ebe81df41..86d0c04555 100644
--- a/src/test/test-rlimit-util.c
+++ b/src/test/test-rlimit-util.c
@@ -8,9 +8,10 @@
 #include "missing_resource.h"
 #include "rlimit-util.h"
 #include "string-util.h"
+#include "tests.h"
 #include "time-util.h"
 
-static void test_rlimit_parse_format(int resource, const char *string, rlim_t soft, rlim_t hard, int ret, const char *formatted) {
+static void test_rlimit_parse_format_one(int resource, const char *string, rlim_t soft, rlim_t hard, int ret, const char *formatted) {
         _cleanup_free_ char *f = NULL;
         struct rlimit rl = {
                 .rlim_cur = 4711,
@@ -34,37 +35,48 @@ static void test_rlimit_parse_format(int resource, const char *string, rlim_t so
         assert_se(memcmp(&rl, &rl2, sizeof(struct rlimit)) == 0);
 }
 
-int main(int argc, char *argv[]) {
-        struct rlimit old, new, high;
-        struct rlimit err = {
-                .rlim_cur = 10,
-                .rlim_max = 5,
-        };
-        int i;
-
-        log_parse_environment();
-        log_open();
-
-        assert_se(drop_capability(CAP_SYS_RESOURCE) == 0);
-
-        assert_se(getrlimit(RLIMIT_NOFILE, &old) == 0);
-        new.rlim_cur = MIN(5U, old.rlim_max);
-        new.rlim_max = old.rlim_max;
-        assert_se(setrlimit(RLIMIT_NOFILE, &new) >= 0);
+TEST(rlimit_parse_format) {
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "4:5", 4, 5, 0, "4:5");
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "6", 6, 6, 0, "6");
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "infinity:infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "8:infinity", 8, RLIM_INFINITY, 0, "8:infinity");
+        test_rlimit_parse_format_one(RLIMIT_CPU, "25min:13h", (25*USEC_PER_MINUTE) / USEC_PER_SEC, (13*USEC_PER_HOUR) / USEC_PER_SEC, 0, "1500:46800");
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "", 0, 0, -EINVAL, NULL);
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "5:4", 0, 0, -EILSEQ, NULL);
+        test_rlimit_parse_format_one(RLIMIT_NOFILE, "5:4:3", 0, 0, -EINVAL, NULL);
+        test_rlimit_parse_format_one(RLIMIT_NICE, "20", 20, 20, 0, "20");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "40", 40, 40, 0, "40");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "41", 41, 41, -ERANGE, "41");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "0", 0, 0, 0, "0");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "-7", 27, 27, 0, "27");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "-20", 40, 40, 0, "40");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "-21", 41, 41, -ERANGE, "41");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "-0", 20, 20, 0, "20");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "+7", 13, 13, 0, "13");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "+19", 1, 1, 0, "1");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "+20", 0, 0, -ERANGE, "0");
+        test_rlimit_parse_format_one(RLIMIT_NICE, "+0", 20, 20, 0, "20");
+}
 
+TEST(rlimit_from_string) {
         assert_se(rlimit_from_string("NOFILE") == RLIMIT_NOFILE);
         assert_se(rlimit_from_string("LimitNOFILE") == -EINVAL);
         assert_se(rlimit_from_string("RLIMIT_NOFILE") == -EINVAL);
         assert_se(rlimit_from_string("xxxNOFILE") == -EINVAL);
         assert_se(rlimit_from_string("DefaultLimitNOFILE") == -EINVAL);
+}
 
+TEST(rlimit_from_string_harder) {
         assert_se(rlimit_from_string_harder("NOFILE") == RLIMIT_NOFILE);
         assert_se(rlimit_from_string_harder("LimitNOFILE") == RLIMIT_NOFILE);
         assert_se(rlimit_from_string_harder("RLIMIT_NOFILE") == RLIMIT_NOFILE);
         assert_se(rlimit_from_string_harder("xxxNOFILE") == -EINVAL);
         assert_se(rlimit_from_string_harder("DefaultLimitNOFILE") == -EINVAL);
+}
 
-        for (i = 0; i < _RLIMIT_MAX; i++) {
+TEST(rlimit_to_string_all) {
+        for (int i = 0; i < _RLIMIT_MAX; i++) {
                 _cleanup_free_ char *prefixed = NULL;
                 const char *p;
 
@@ -85,6 +97,21 @@ int main(int argc, char *argv[]) {
                 assert_se(rlimit_from_string(prefixed) < 0);
                 assert_se(rlimit_from_string_harder(prefixed) == i);
         }
+}
+
+TEST(setrlimit) {
+        struct rlimit old, new, high;
+        struct rlimit err = {
+                .rlim_cur = 10,
+                .rlim_max = 5,
+        };
+
+        assert_se(drop_capability(CAP_SYS_RESOURCE) == 0);
+
+        assert_se(getrlimit(RLIMIT_NOFILE, &old) == 0);
+        new.rlim_cur = MIN(5U, old.rlim_max);
+        new.rlim_max = old.rlim_max;
+        assert_se(setrlimit(RLIMIT_NOFILE, &new) >= 0);
 
         assert_se(streq_ptr(rlimit_to_string(RLIMIT_NOFILE), "NOFILE"));
         assert_se(rlimit_to_string(-1) == NULL);
@@ -107,28 +134,6 @@ int main(int argc, char *argv[]) {
         assert_se(getrlimit(RLIMIT_NOFILE, &new) == 0);
         assert_se(old.rlim_cur == new.rlim_cur);
         assert_se(old.rlim_max == new.rlim_max);
-
-        test_rlimit_parse_format(RLIMIT_NOFILE, "4:5", 4, 5, 0, "4:5");
-        test_rlimit_parse_format(RLIMIT_NOFILE, "6", 6, 6, 0, "6");
-        test_rlimit_parse_format(RLIMIT_NOFILE, "infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
-        test_rlimit_parse_format(RLIMIT_NOFILE, "infinity:infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
-        test_rlimit_parse_format(RLIMIT_NOFILE, "8:infinity", 8, RLIM_INFINITY, 0, "8:infinity");
-        test_rlimit_parse_format(RLIMIT_CPU, "25min:13h", (25*USEC_PER_MINUTE) / USEC_PER_SEC, (13*USEC_PER_HOUR) / USEC_PER_SEC, 0, "1500:46800");
-        test_rlimit_parse_format(RLIMIT_NOFILE, "", 0, 0, -EINVAL, NULL);
-        test_rlimit_parse_format(RLIMIT_NOFILE, "5:4", 0, 0, -EILSEQ, NULL);
-        test_rlimit_parse_format(RLIMIT_NOFILE, "5:4:3", 0, 0, -EINVAL, NULL);
-        test_rlimit_parse_format(RLIMIT_NICE, "20", 20, 20, 0, "20");
-        test_rlimit_parse_format(RLIMIT_NICE, "40", 40, 40, 0, "40");
-        test_rlimit_parse_format(RLIMIT_NICE, "41", 41, 41, -ERANGE, "41");
-        test_rlimit_parse_format(RLIMIT_NICE, "0", 0, 0, 0, "0");
-        test_rlimit_parse_format(RLIMIT_NICE, "-7", 27, 27, 0, "27");
-        test_rlimit_parse_format(RLIMIT_NICE, "-20", 40, 40, 0, "40");
-        test_rlimit_parse_format(RLIMIT_NICE, "-21", 41, 41, -ERANGE, "41");
-        test_rlimit_parse_format(RLIMIT_NICE, "-0", 20, 20, 0, "20");
-        test_rlimit_parse_format(RLIMIT_NICE, "+7", 13, 13, 0, "13");
-        test_rlimit_parse_format(RLIMIT_NICE, "+19", 1, 1, 0, "1");
-        test_rlimit_parse_format(RLIMIT_NICE, "+20", 0, 0, -ERANGE, "0");
-        test_rlimit_parse_format(RLIMIT_NICE, "+0", 20, 20, 0, "20");
-
-        return 0;
 }
+
+DEFINE_TEST_MAIN(LOG_INFO);
diff --git a/src/test/test-sd-hwdb.c b/src/test/test-sd-hwdb.c
index 7ed6907cbd..7961c17c4a 100644
--- a/src/test/test-sd-hwdb.c
+++ b/src/test/test-sd-hwdb.c
@@ -7,38 +7,28 @@
 #include "errno.h"
 #include "tests.h"
 
-static int test_failed_enumerate(void) {
+TEST(failed_enumerate) {
         _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
         const char *key, *value;
-        int r;
-
-        log_info("/* %s */", __func__);
 
-        r = sd_hwdb_new(&hwdb);
-        if (r == -ENOENT || ERRNO_IS_PRIVILEGE(r))
-                return r;
-        assert_se(r == 0);
+        assert_se(sd_hwdb_new(&hwdb) == 0);
 
         assert_se(sd_hwdb_seek(hwdb, "no-such-modalias-should-exist") == 0);
 
         assert_se(sd_hwdb_enumerate(hwdb, &key, &value) == 0);
         assert_se(sd_hwdb_enumerate(hwdb, &key, NULL) == -EINVAL);
         assert_se(sd_hwdb_enumerate(hwdb, NULL, &value) == -EINVAL);
-
-        return 0;
 }
 
 #define DELL_MODALIAS \
         "evdev:atkbd:dmi:bvnXXX:bvrYYY:bdZZZ:svnDellXXX:pnYYY"
 
-static void test_basic_enumerate(void) {
+TEST(basic_enumerate) {
         _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
         const char *key, *value;
         size_t len1 = 0, len2 = 0;
         int r;
 
-        log_info("/* %s */", __func__);
-
         assert_se(sd_hwdb_new(&hwdb) == 0);
 
         assert_se(sd_hwdb_seek(hwdb, DELL_MODALIAS) == 0);
@@ -62,16 +52,12 @@ static void test_basic_enumerate(void) {
         assert_se(len1 == len2);
 }
 
-int main(int argc, char *argv[]) {
-        int r;
-
-        test_setup_logging(LOG_DEBUG);
-
-        r = test_failed_enumerate();
-        if (r < 0)
-                return log_tests_skipped_errno(r, "cannot open hwdb");
-
-        test_basic_enumerate();
-
-        return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_DEBUG,
+        ({
+                _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
+                int r = sd_hwdb_new(&hwdb);
+                if (r == -ENOENT || ERRNO_IS_PRIVILEGE(r))
+                        return log_tests_skipped_errno(r, "cannot open hwdb");
+        }),
+        /* no outro */);
diff --git a/src/test/test-serialize.c b/src/test/test-serialize.c
index 7bd53a861d..fb04b3e7fa 100644
--- a/src/test/test-serialize.c
+++ b/src/test/test-serialize.c
@@ -12,7 +12,7 @@
 
 char long_string[LONG_LINE_MAX+1];
 
-static void test_serialize_item(void) {
+TEST(serialize_item) {
         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
         _cleanup_fclose_ FILE *f = NULL;
 
@@ -37,7 +37,7 @@ static void test_serialize_item(void) {
         assert_se(streq(line3, ""));
 }
 
-static void test_serialize_item_escaped(void) {
+TEST(serialize_item_escaped) {
         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
         _cleanup_fclose_ FILE *f = NULL;
 
@@ -62,7 +62,7 @@ static void test_serialize_item_escaped(void) {
         assert_se(streq(line3, ""));
 }
 
-static void test_serialize_usec(void) {
+TEST(serialize_usec) {
         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
         _cleanup_fclose_ FILE *f = NULL;
 
@@ -89,7 +89,7 @@ static void test_serialize_usec(void) {
         assert_se(x == USEC_INFINITY-1);
 }
 
-static void test_serialize_strv(void) {
+TEST(serialize_strv) {
         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
         _cleanup_fclose_ FILE *f = NULL;
 
@@ -133,11 +133,9 @@ static void test_serialize_strv(void) {
         assert_se(strv_equal(strv, strv2));
 }
 
-static void test_deserialize_environment(void) {
+TEST(deserialize_environment) {
         _cleanup_strv_free_ char **env;
 
-        log_info("/* %s */", __func__);
-
         assert_se(env = strv_new("A=1"));
 
         assert_se(deserialize_environment("B=2", &env) >= 0);
@@ -149,7 +147,7 @@ static void test_deserialize_environment(void) {
         assert_se(deserialize_environment("bar\\_baz", &env) < 0);
 }
 
-static void test_serialize_environment(void) {
+TEST(serialize_environment) {
         _cleanup_strv_free_ char **env = NULL, **env2 = NULL;
         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-env-util.XXXXXXX";
         _cleanup_fclose_ FILE *f = NULL;
@@ -191,18 +189,10 @@ static void test_serialize_environment(void) {
         assert_se(strv_equal(env, env2));
 }
 
-int main(int argc, char *argv[]) {
-        test_setup_logging(LOG_INFO);
-
-        memset(long_string, 'x', sizeof(long_string)-1);
-        char_array_0(long_string);
-
-        test_serialize_item();
-        test_serialize_item_escaped();
-        test_serialize_usec();
-        test_serialize_strv();
-        test_deserialize_environment();
-        test_serialize_environment();
-
-        return EXIT_SUCCESS;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+        LOG_INFO,
+        ({
+                memset(long_string, 'x', sizeof(long_string)-1);
+                char_array_0(long_string);
+        }),
+        /* no outro */);
diff --git a/src/test/test-udev-util.c b/src/test/test-udev-util.c
index b87a90f766..d413997189 100644
--- a/src/test/test-udev-util.c
+++ b/src/test/test-udev-util.c
@@ -5,6 +5,7 @@
 
 #include "macro.h"
 #include "string-util.h"
+#include "tests.h"
 #include "udev-util.h"
 
 static void test_udev_rule_parse_value_one(const char *in, const char *expected_value, int expected_retval) {
@@ -12,6 +13,8 @@ static void test_udev_rule_parse_value_one(const char *in, const char *expected_
         char *value = UINT_TO_PTR(0x12345678U);
         char *endpos = UINT_TO_PTR(0x87654321U);
 
+        log_info("/* %s (%s, %s, %d) */", __func__, in, expected_value, expected_retval);
+
         assert_se(str = strdup(in));
         assert_se(udev_rule_parse_value(str, &value, &endpos) == expected_retval);
         if (expected_retval < 0) {
@@ -24,161 +27,50 @@ static void test_udev_rule_parse_value_one(const char *in, const char *expected_
         }
 }
 
-static void test_parse_value(void) {
+TEST(udev_rule_parse_value) {
         /* input: "valid operand"
          * parsed: valid operand
          * use the following command to help generate textual C strings:
          * python3 -c 'import json; print(json.dumps(input()))' */
-        test_udev_rule_parse_value_one(
-                "\"valid operand\"",
-                "valid operand",
-                0
-        );
-}
-
-static void test_parse_value_with_backslashes(void) {
+        test_udev_rule_parse_value_one("\"valid operand\"", "valid operand", 0);
         /* input: "va'l\'id\"op\"erand"
          * parsed: va'l\'id"op"erand */
-        test_udev_rule_parse_value_one(
-                "\"va'l\\'id\\\"op\\\"erand\"",
-                "va'l\\'id\"op\"erand",
-                0
-        );
-}
-
-static void test_parse_value_no_quotes(void) {
-        test_udev_rule_parse_value_one(
-                "no quotes",
-                0,
-                -EINVAL
-        );
-}
-
-static void test_parse_value_noescape(void) {
-        test_udev_rule_parse_value_one(
-                "\"\\\\a\\b\\x\\y\"",
-                "\\\\a\\b\\x\\y",
-                0
-        );
-}
-
-static void test_parse_value_nul(void) {
-        test_udev_rule_parse_value_one(
-                "\"reject\0nul\"",
-                0,
-                -EINVAL
-        );
-}
-
-static void test_parse_value_escape_nothing(void) {
+        test_udev_rule_parse_value_one("\"va'l\\'id\\\"op\\\"erand\"", "va'l\\'id\"op\"erand", 0);
+        test_udev_rule_parse_value_one("no quotes", 0, -EINVAL);
+        test_udev_rule_parse_value_one("\"\\\\a\\b\\x\\y\"", "\\\\a\\b\\x\\y", 0);
+        test_udev_rule_parse_value_one("\"reject\0nul\"", 0, -EINVAL);
         /* input: e"" */
-        test_udev_rule_parse_value_one(
-                "e\"\"",
-                "",
-                0
-        );
-}
-
-static void test_parse_value_escape_nothing2(void) {
+        test_udev_rule_parse_value_one("e\"\"", "", 0);
         /* input: e"1234" */
-        test_udev_rule_parse_value_one(
-                "e\"1234\"",
-                "1234",
-                0
-        );
-}
-
-static void test_parse_value_escape_double_quote(void) {
+        test_udev_rule_parse_value_one("e\"1234\"", "1234", 0);
         /* input: e"\"" */
-        test_udev_rule_parse_value_one(
-                "e\"\\\"\"",
-                "\"",
-                0
-        );
-}
-
-static void test_parse_value_escape_backslash(void) {
+        test_udev_rule_parse_value_one("e\"\\\"\"", "\"", 0);
         /* input: e"\ */
-        test_udev_rule_parse_value_one(
-                "e\"\\",
-                0,
-                -EINVAL
-        );
+        test_udev_rule_parse_value_one("e\"\\", 0, -EINVAL);
         /* input: e"\" */
-        test_udev_rule_parse_value_one(
-                "e\"\\\"",
-                0,
-                -EINVAL
-        );
+        test_udev_rule_parse_value_one("e\"\\\"", 0, -EINVAL);
         /* input: e"\\" */
-        test_udev_rule_parse_value_one(
-                "e\"\\\\\"",
-                "\\",
-                0
-        );
+        test_udev_rule_parse_value_one("e\"\\\\\"", "\\", 0);
         /* input: e"\\\" */
-        test_udev_rule_parse_value_one(
-                "e\"\\\\\\\"",
-                0,
-                -EINVAL
-        );
+        test_udev_rule_parse_value_one("e\"\\\\\\\"", 0, -EINVAL);
         /* input: e"\\\"" */
-        test_udev_rule_parse_value_one(
-                "e\"\\\\\\\"\"",
-                "\\\"",
-                0
-        );
+        test_udev_rule_parse_value_one("e\"\\\\\\\"\"", "\\\"", 0);
         /* input: e"\\\\" */
-        test_udev_rule_parse_value_one(
-                "e\"\\\\\\\\\"",
-                "\\\\",
-                0
-        );
-}
-
-static void test_parse_value_newline(void) {
+        test_udev_rule_parse_value_one("e\"\\\\\\\\\"", "\\\\", 0);
         /* input: e"operand with newline\n" */
-        test_udev_rule_parse_value_one(
-                "e\"operand with newline\\n\"",
-                "operand with newline\n",
-                0
-        );
-}
-
-static void test_parse_value_escaped(void) {
+        test_udev_rule_parse_value_one("e\"operand with newline\\n\"", "operand with newline\n", 0);
         /* input: e"single\rcharacter\t\aescape\bsequence" */
         test_udev_rule_parse_value_one(
-                "e\"single\\rcharacter\\t\\aescape\\bsequence\"",
-                "single\rcharacter\t\aescape\bsequence",
-                0
-        );
-}
-
-static void test_parse_value_invalid_escape(void) {
+                "e\"single\\rcharacter\\t\\aescape\\bsequence\"", "single\rcharacter\t\aescape\bsequence", 0);
         /* input: e"reject\invalid escape sequence" */
-        test_udev_rule_parse_value_one(
-                "e\"reject\\invalid escape sequence",
-                0,
-                -EINVAL
-        );
-}
-
-static void test_parse_value_invalid_termination(void) {
+        test_udev_rule_parse_value_one("e\"reject\\invalid escape sequence", 0, -EINVAL);
         /* input: e"\ */
-        test_udev_rule_parse_value_one(
-                "e\"\\",
-                0,
-                -EINVAL
-        );
-}
-
-static void test_parse_value_unicode(void) {
+        test_udev_rule_parse_value_one("e\"\\", 0, -EINVAL);
         /* input: "s\u1d1c\u1d04\u029c \u1d1c\u0274\u026a\u1d04\u1d0f\u1d05\u1d07 \U0001d568\U0001d560\U0001d568" */
         test_udev_rule_parse_value_one(
                 "e\"s\\u1d1c\\u1d04\\u029c \\u1d1c\\u0274\\u026a\\u1d04\\u1d0f\\u1d05\\u1d07 \\U0001d568\\U0001d560\\U0001d568\"",
                 "s\xe1\xb4\x9c\xe1\xb4\x84\xca\x9c \xe1\xb4\x9c\xc9\xb4\xc9\xaa\xe1\xb4\x84\xe1\xb4\x8f\xe1\xb4\x85\xe1\xb4\x87 \xf0\x9d\x95\xa8\xf0\x9d\x95\xa0\xf0\x9d\x95\xa8",
-                0
-        );
+                0);
 }
 
 static void test_udev_replace_whitespace_one_len(const char *str, size_t len, const char *expected) {
@@ -196,9 +88,7 @@ static void test_udev_replace_whitespace_one(const char *str, const char *expect
         test_udev_replace_whitespace_one_len(str, strlen(str), expected);
 }
 
-static void test_udev_replace_whitespace(void) {
-        log_info("/* %s */", __func__);
-
+TEST(udev_replace_whitespace) {
         test_udev_replace_whitespace_one("hogehoge", "hogehoge");
         test_udev_replace_whitespace_one("hoge  hoge", "hoge_hoge");
         test_udev_replace_whitespace_one("  hoge  hoge  ", "hoge_hoge");
@@ -246,9 +136,7 @@ static void test_udev_resolve_subsys_kernel_one(const char *str, bool read_value
                 assert_se(streq(result, expected));
 }
 
-static void test_udev_resolve_subsys_kernel(void) {
-        log_info("/* %s */", __func__);
-
+TEST(udev_resolve_subsys_kernel) {
         test_udev_resolve_subsys_kernel_one("hoge", false, -EINVAL, NULL);
         test_udev_resolve_subsys_kernel_one("[hoge", false, -EINVAL, NULL);
         test_udev_resolve_subsys_kernel_one("[hoge/foo", false, -EINVAL, NULL);
@@ -267,25 +155,4 @@ static void test_udev_resolve_subsys_kernel(void) {
         test_udev_resolve_subsys_kernel_one("[net/lo]/address", true, 0, "00:00:00:00:00:00");
 }
 
-int main(int argc, char **argv) {
-        test_parse_value();
-        test_parse_value_with_backslashes();
-        test_parse_value_no_quotes();
-        test_parse_value_nul();
-        test_parse_value_noescape();
-
-        test_parse_value_escape_nothing();
-        test_parse_value_escape_nothing2();
-        test_parse_value_escape_double_quote();
-        test_parse_value_escape_backslash();
-        test_parse_value_newline();
-        test_parse_value_escaped();
-        test_parse_value_invalid_escape();
-        test_parse_value_invalid_termination();
-        test_parse_value_unicode();
-
-        test_udev_replace_whitespace();
-        test_udev_resolve_subsys_kernel();
-
-        return EXIT_SUCCESS;
-}
+DEFINE_TEST_MAIN(LOG_INFO);