src/test/test-unit-name.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2012 Lennart Poettering
   7   Copyright 2013 Zbigniew Jędrzejewski-Szmek
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/types.h>
  27 #include <pwd.h>
  28
  29 #include "manager.h"
  30 #include "unit.h"
  31 #include "unit-name.h"
  32 #include "unit-printf.h"
  33 #include "install.h"
  34 #include "specifier.h"
  35 #include "util.h"
  36 #include "macro.h"
  37
  38 static void test_replacements(void) {
  39 #define expect(pattern, repl, expected)                            \
  40         {                                                          \
  41                 char _cleanup_free_ *t =                           \
  42                         unit_name_replace_instance(pattern, repl); \
  43                 puts(t);                                           \
  44                 assert(streq(t, expected));                        \
  45         }
  46
  47         expect("foo@.service", "waldo", "foo@waldo.service");
  48         expect("foo@xyz.service", "waldo", "foo@waldo.service");
  49         expect("xyz", "waldo", "xyz");
  50         expect("", "waldo", "");
  51         expect("foo.service", "waldo", "foo.service");
  52         expect(".service", "waldo", ".service");
  53         expect("foo@", "waldo", "foo@waldo");
  54         expect("@bar", "waldo", "@waldo");
  55
  56         puts("-------------------------------------------------");
  57 #undef expect
  58 #define expect(path, suffix, expected)                             \
  59         {                                                          \
  60                 char _cleanup_free_ *k, *t =                       \
  61                         unit_name_from_path(path, suffix);         \
  62                 puts(t);                                           \
  63                 k = unit_name_to_path(t);                          \
  64                 puts(k);                                           \
  65                 assert(streq(k, expected ? expected : path));     \
  66         }
  67
  68         expect("/waldo", ".mount", NULL);
  69         expect("/waldo/quuix", ".mount", NULL);
  70         expect("/waldo/quuix/", ".mount", "/waldo/quuix");
  71         expect("/", ".mount", NULL);
  72         expect("///", ".mount", "/");
  73
  74         puts("-------------------------------------------------");
  75 #undef expect
  76 #define expect(pattern, path, suffix, expected)                         \
  77         {                                                               \
  78                 char _cleanup_free_ *t =                                \
  79                         unit_name_from_path_instance(pattern, path, suffix); \
  80                 puts(t);                                                \
  81                 assert(streq(t, expected));                             \
  82         }
  83
  84         expect("waldo", "/waldo", ".mount", "waldo@waldo.mount");
  85         expect("waldo", "/waldo////quuix////", ".mount", "waldo@waldo-quuix.mount");
  86         expect("waldo", "/", ".mount", "waldo@-.mount");
  87         expect("wa--ldo", "/--", ".mount", "wa--ldo@\\x2d\\x2d.mount");
  88
  89         puts("-------------------------------------------------");
  90 #undef expect
  91 #define expect(pattern)                                                 \
  92         {                                                               \
  93                 char _cleanup_free_ *k, *t;                             \
  94                 assert_se(t = unit_name_mangle(pattern));               \
  95                 assert_se(k = unit_name_mangle(t));                     \
  96                 puts(t);                                                \
  97                 assert_se(streq(t, k));                                 \
  98         }
  99
 100         expect("/home");
 101         expect("/dev/sda");
 102         expect("üxknürz.service");
 103         expect("foobar-meh...waldi.service");
 104         expect("_____####----.....service");
 105         expect("_____##@;;;,,,##----.....service");
 106         expect("xxx@@@@/////\\\\\\\\\\yyy.service");
 107
 108 #undef expect
 109 }
 110
 111 static void test_unit_printf(void) {
 112         Manager *m;
 113         Unit *u, *u2;
 114
 115         char _cleanup_free_ *mid, *bid, *host, *root_uid;
 116         struct passwd *root;
 117
 118         assert_se((mid = specifier_machine_id('m', NULL, NULL)));
 119         assert_se((bid = specifier_boot_id('b', NULL, NULL)));
 120         assert_se((host = gethostname_malloc()));
 121
 122         assert_se((root = getpwnam("root")));
 123         assert_se(asprintf(&root_uid, "%d", (int) root->pw_uid) > 0);
 124
 125         assert_se(manager_new(SYSTEMD_USER, &m) == 0);
 126
 127 #define expect(unit, pattern, expected)                                 \
 128         {                                                               \
 129                 char *e;                                                \
 130                 char _cleanup_free_ *t =                                \
 131                         unit_full_printf(unit, pattern);                \
 132                 printf("result: %s\n", t);                              \
 133                 if ((e = endswith(expected, "*")))                      \
 134                         assert(strncmp(t, e, e-expected));              \
 135                 else                                                    \
 136                         assert(streq(t, expected));                     \
 137         }
 138
 139         assert_se(setenv("USER", "root", 1) == 0);
 140         assert_se(setenv("HOME", "/root", 1) == 0);
 141
 142         assert_se(u = unit_new(m, sizeof(Service)));
 143         assert_se(unit_add_name(u, "blah.service") == 0);
 144         assert_se(unit_add_name(u, "blah.service") == 0);
 145
 146         /* general tests */
 147         expect(u, "%%", "%");
 148         expect(u, "%%s", "%s");
 149         expect(u, "%", "");    // REALLY?
 150
 151         /* normal unit */
 152         expect(u, "%n", "blah.service");
 153         expect(u, "%N", "blah");
 154         expect(u, "%p", "blah");
 155         expect(u, "%P", "blah");
 156         expect(u, "%i", "");
 157         expect(u, "%I", "");
 158         expect(u, "%u", root->pw_name);
 159         expect(u, "%U", root_uid);
 160         expect(u, "%h", root->pw_dir);
 161         expect(u, "%s", root->pw_shell);
 162         expect(u, "%m", mid);
 163         expect(u, "%b", bid);
 164         expect(u, "%H", host);
 165         expect(u, "%t", "/run/user/*");
 166
 167         /* templated */
 168         assert_se(u2 = unit_new(m, sizeof(Service)));
 169         assert_se(unit_add_name(u2, "blah@foo-foo.service") == 0);
 170         assert_se(unit_add_name(u2, "blah@foo-foo.service") == 0);
 171
 172         expect(u2, "%n", "blah@foo-foo.service");
 173         expect(u2, "%N", "blah@foo-foo");
 174         expect(u2, "%p", "blah");
 175         expect(u2, "%P", "blah");
 176         expect(u2, "%i", "foo-foo");
 177         expect(u2, "%I", "foo/foo");
 178         expect(u2, "%u", root->pw_name);
 179         expect(u2, "%U", root_uid);
 180         expect(u2, "%h", root->pw_dir);
 181         expect(u2, "%s", root->pw_shell);
 182         expect(u2, "%m", mid);
 183         expect(u2, "%b", bid);
 184         expect(u2, "%H", host);
 185         expect(u2, "%t", "/run/user/*");
 186 }
 187
 188 int main(int argc, char* argv[]) {
 189         test_replacements();
 190         test_unit_printf();
 191
 192         return 0;
 193 }