src/shared/tests.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <sched.h>
   4 #include <signal.h>
   5 #include <stdlib.h>
   6 #include <sys/mount.h>
   7 #include <sys/wait.h>
   8 #include <util.h>
   9
  10 /* When we include libgen.h because we need dirname() we immediately
  11  * undefine basename() since libgen.h defines it as a macro to the POSIX
  12  * version which is really broken. We prefer GNU basename(). */
  13 #include <libgen.h>
  14 #undef basename
  15
  16 #include "alloc-util.h"
  17 #include "env-file.h"
  18 #include "env-util.h"
  19 #include "fs-util.h"
  20 #include "log.h"
  21 #include "path-util.h"
  22 #include "strv.h"
  23 #include "tests.h"
  24
  25 char* setup_fake_runtime_dir(void) {
  26         char t[] = "/tmp/fake-xdg-runtime-XXXXXX", *p;
  27
  28         assert_se(mkdtemp(t));
  29         assert_se(setenv("XDG_RUNTIME_DIR", t, 1) >= 0);
  30         assert_se(p = strdup(t));
  31
  32         return p;
  33 }
  34
  35 static void load_testdata_env(void) {
  36         static bool called = false;
  37         _cleanup_free_ char *s = NULL;
  38         _cleanup_free_ char *envpath = NULL;
  39         _cleanup_strv_free_ char **pairs = NULL;
  40         char **k, **v;
  41
  42         if (called)
  43                 return;
  44         called = true;
  45
  46         assert_se(readlink_and_make_absolute("/proc/self/exe", &s) >= 0);
  47         dirname(s);
  48
  49         envpath = path_join(s, "systemd-runtest.env");
  50         if (load_env_file_pairs(NULL, envpath, &pairs) < 0)
  51                 return;
  52
  53         STRV_FOREACH_PAIR(k, v, pairs)
  54                 setenv(*k, *v, 0);
  55 }
  56
  57 const char* get_testdata_dir(void) {
  58         const char *env;
  59
  60         load_testdata_env();
  61
  62         /* if the env var is set, use that */
  63         env = getenv("SYSTEMD_TEST_DATA");
  64         if (!env)
  65                 env = SYSTEMD_TEST_DATA;
  66         if (access(env, F_OK) < 0) {
  67                 fprintf(stderr, "ERROR: $SYSTEMD_TEST_DATA directory [%s] does not exist\n", env);
  68                 exit(EXIT_FAILURE);
  69         }
  70
  71         return env;
  72 }
  73
  74 const char* get_catalog_dir(void) {
  75         const char *env;
  76
  77         load_testdata_env();
  78
  79         /* if the env var is set, use that */
  80         env = getenv("SYSTEMD_CATALOG_DIR");
  81         if (!env)
  82                 env = SYSTEMD_CATALOG_DIR;
  83         if (access(env, F_OK) < 0) {
  84                 fprintf(stderr, "ERROR: $SYSTEMD_CATALOG_DIR directory [%s] does not exist\n", env);
  85                 exit(EXIT_FAILURE);
  86         }
  87         return env;
  88 }
  89
  90 bool slow_tests_enabled(void) {
  91         int r;
  92
  93         r = getenv_bool("SYSTEMD_SLOW_TESTS");
  94         if (r >= 0)
  95                 return r;
  96
  97         if (r != -ENXIO)
  98                 log_warning_errno(r, "Cannot parse $SYSTEMD_SLOW_TESTS, ignoring.");
  99         return SYSTEMD_SLOW_TESTS_DEFAULT;
 100 }
 101
 102 void test_setup_logging(int level) {
 103         log_set_max_level(level);
 104         log_parse_environment();
 105         log_open();
 106 }
 107
 108 int log_tests_skipped(const char *message) {
 109         log_notice("%s: %s, skipping tests.",
 110                    program_invocation_short_name, message);
 111         return EXIT_TEST_SKIP;
 112 }
 113
 114 int log_tests_skipped_errno(int r, const char *message) {
 115         log_notice_errno(r, "%s: %s, skipping tests: %m",
 116                          program_invocation_short_name, message);
 117         return EXIT_TEST_SKIP;
 118 }
 119
 120 bool have_namespaces(void) {
 121         siginfo_t si = {};
 122         pid_t pid;
 123
 124         /* Checks whether namespaces are available. In some cases they aren't. We do this by calling unshare(), and we
 125          * do so in a child process in order not to affect our own process. */
 126
 127         pid = fork();
 128         assert_se(pid >= 0);
 129
 130         if (pid == 0) {
 131                 /* child */
 132                 if (unshare(CLONE_NEWNS) < 0)
 133                         _exit(EXIT_FAILURE);
 134
 135                 if (mount(NULL, "/", NULL, MS_SLAVE|MS_REC, NULL) < 0)
 136                         _exit(EXIT_FAILURE);
 137
 138                 _exit(EXIT_SUCCESS);
 139         }
 140
 141         assert_se(waitid(P_PID, pid, &si, WEXITED) >= 0);
 142         assert_se(si.si_code == CLD_EXITED);
 143
 144         if (si.si_status == EXIT_SUCCESS)
 145                 return true;
 146
 147         if (si.si_status == EXIT_FAILURE)
 148                 return false;
 149
 150         assert_not_reached("unexpected exit code");
 151 }