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_SYSTEM, &m) == 0);
 126
 127 #define expect(unit, pattern, expected)                                 \
 128         {                                                               \
 129                 char _cleanup_free_ *t =                                \
 130                         unit_full_printf(unit, pattern);                \
 131                 printf("result: %s\n", t);                              \
 132                 assert(streq(t, expected));                             \
 133         }
 134
 135         assert_se(setenv("USER", "root", 1) == 0);
 136         assert_se(setenv("HOME", "/root", 1) == 0);
 137
 138         assert_se(u = unit_new(m, sizeof(Service)));
 139         assert_se(unit_add_name(u, "blah.service") == 0);
 140         assert_se(unit_add_name(u, "blah.service") == 0);
 141
 142         /* general tests */
 143         expect(u, "%%", "%");
 144         expect(u, "%%s", "%s");
 145         expect(u, "%", "");    // REALLY?
 146
 147         /* normal unit */
 148         expect(u, "%n", "blah.service");
 149         expect(u, "%N", "blah");
 150         expect(u, "%p", "blah");
 151         expect(u, "%P", "blah");
 152         expect(u, "%i", "");
 153         expect(u, "%I", "");
 154         expect(u, "%u", root->pw_name);
 155         expect(u, "%U", root_uid);
 156         expect(u, "%h", root->pw_dir);
 157         expect(u, "%s", root->pw_shell);
 158         expect(u, "%m", mid);
 159         expect(u, "%b", bid);
 160         expect(u, "%H", host);
 161         expect(u, "%t", "/run");
 162
 163         /* templated */
 164         assert_se(u2 = unit_new(m, sizeof(Service)));
 165         assert_se(unit_add_name(u2, "blah@foo-foo.service") == 0);
 166         assert_se(unit_add_name(u2, "blah@foo-foo.service") == 0);
 167
 168         expect(u2, "%n", "blah@foo-foo.service");
 169         expect(u2, "%N", "blah@foo-foo");
 170         expect(u2, "%p", "blah");
 171         expect(u2, "%P", "blah");
 172         expect(u2, "%i", "foo-foo");
 173         expect(u2, "%I", "foo/foo");
 174         expect(u2, "%u", root->pw_name);
 175         expect(u2, "%U", root_uid);
 176         expect(u2, "%h", root->pw_dir);
 177         expect(u2, "%s", root->pw_shell);
 178         expect(u2, "%m", mid);
 179         expect(u2, "%b", bid);
 180         expect(u2, "%H", host);
 181         expect(u2, "%t", "/run");
 182 }
 183
 184 int main(int argc, char* argv[]) {
 185         test_replacements();
 186         test_unit_printf();
 187
 188         return 0;
 189 }