src/test/test-path-util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Zbigniew Jędrzejewski-Szmek
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdio.h>
  23 #include <unistd.h>
  24
  25 #include "path-util.h"
  26 #include "util.h"
  27 #include "macro.h"
  28 #include "strv.h"
  29
  30
  31 static void test_path(void) {
  32         assert_se(path_equal("/goo", "/goo"));
  33         assert_se(path_equal("//goo", "/goo"));
  34         assert_se(path_equal("//goo/////", "/goo"));
  35         assert_se(path_equal("goo/////", "goo"));
  36
  37         assert_se(path_equal("/goo/boo", "/goo//boo"));
  38         assert_se(path_equal("//goo/boo", "/goo/boo//"));
  39
  40         assert_se(path_equal("/", "///"));
  41
  42         assert_se(!path_equal("/x", "x/"));
  43         assert_se(!path_equal("x/", "/"));
  44
  45         assert_se(!path_equal("/x/./y", "x/y"));
  46         assert_se(!path_equal("x/.y", "x/y"));
  47
  48         assert_se(path_is_absolute("/"));
  49         assert_se(!path_is_absolute("./"));
  50
  51         assert_se(is_path("/dir"));
  52         assert_se(is_path("a/b"));
  53         assert_se(!is_path("."));
  54
  55         assert_se(streq(basename("./aa/bb/../file.da."), "file.da."));
  56         assert_se(streq(basename("/aa///.file"), ".file"));
  57         assert_se(streq(basename("/aa///file..."), "file..."));
  58         assert_se(streq(basename("file.../"), ""));
  59
  60 #define test_parent(x, y) {                                \
  61                 _cleanup_free_ char *z = NULL;             \
  62                 int r = path_get_parent(x, &z);            \
  63                 printf("expected: %s\n", y ? y : "error"); \
  64                 printf("actual: %s\n", r<0 ? "error" : z); \
  65                 assert_se((y==NULL) ^ (r==0));             \
  66                 assert_se(y==NULL || path_equal(z, y));    \
  67         }
  68
  69         test_parent("./aa/bb/../file.da.", "./aa/bb/..");
  70         test_parent("/aa///.file", "/aa///");
  71         test_parent("/aa///file...", "/aa///");
  72         test_parent("file.../", NULL);
  73
  74         assert_se(path_is_mount_point("/", true));
  75         assert_se(path_is_mount_point("/", false));
  76
  77         {
  78                 char p1[] = "aaa/bbb////ccc";
  79                 char p2[] = "//aaa/.////ccc";
  80                 char p3[] = "/./";
  81
  82                 assert(path_equal(path_kill_slashes(p1), "aaa/bbb/ccc"));
  83                 assert(path_equal(path_kill_slashes(p2), "/aaa/./ccc"));
  84                 assert(path_equal(path_kill_slashes(p3), "/./"));
  85         }
  86 }
  87
  88 static void test_find_binary(const char *self) {
  89         char *p;
  90
  91         assert(find_binary("/bin/sh", &p) == 0);
  92         puts(p);
  93         assert(streq(p, "/bin/sh"));
  94         free(p);
  95
  96         assert(find_binary(self, &p) == 0);
  97         puts(p);
  98         assert(endswith(p, "/test-path-util"));
  99         assert(path_is_absolute(p));
 100         free(p);
 101
 102         assert(find_binary("sh", &p) == 0);
 103         puts(p);
 104         assert(endswith(p, "/sh"));
 105         assert(path_is_absolute(p));
 106         free(p);
 107
 108         assert(find_binary("xxxx-xxxx", &p) == -ENOENT);
 109
 110         assert(find_binary("/some/dir/xxxx-xxxx", &p) == -ENOENT);
 111 }
 112
 113 static void test_prefixes(void) {
 114         static const char* values[] = { "/a/b/c/d", "/a/b/c", "/a/b", "/a", "", NULL};
 115         unsigned i;
 116         char s[PATH_MAX];
 117         bool b;
 118
 119         i = 0;
 120         PATH_FOREACH_PREFIX_MORE(s, "/a/b/c/d") {
 121                 log_error("---%s---", s);
 122                 assert_se(streq(s, values[i++]));
 123         }
 124         assert_se(values[i] == NULL);
 125
 126         i = 1;
 127         PATH_FOREACH_PREFIX(s, "/a/b/c/d") {
 128                 log_error("---%s---", s);
 129                 assert_se(streq(s, values[i++]));
 130         }
 131         assert_se(values[i] == NULL);
 132
 133         i = 0;
 134         PATH_FOREACH_PREFIX_MORE(s, "////a////b////c///d///////")
 135                 assert_se(streq(s, values[i++]));
 136         assert_se(values[i] == NULL);
 137
 138         i = 1;
 139         PATH_FOREACH_PREFIX(s, "////a////b////c///d///////")
 140                 assert_se(streq(s, values[i++]));
 141         assert_se(values[i] == NULL);
 142
 143         PATH_FOREACH_PREFIX(s, "////")
 144                 assert_not_reached("Wut?");
 145
 146         b = false;
 147         PATH_FOREACH_PREFIX_MORE(s, "////") {
 148                 assert_se(!b);
 149                 assert_se(streq(s, ""));
 150                 b = true;
 151         }
 152         assert_se(b);
 153
 154         PATH_FOREACH_PREFIX(s, "")
 155                 assert_not_reached("wut?");
 156
 157         b = false;
 158         PATH_FOREACH_PREFIX_MORE(s, "") {
 159                 assert(!b);
 160                 assert(streq(s, ""));
 161                 b = true;
 162         }
 163 }
 164
 165 static void test_path_join(void) {
 166         assert_se(streq(path_join("/root", "/a/b", "/c"), "/root/a/b/c"));
 167         assert_se(streq(path_join("/root", "a/b", "c"), "/root/a/b/c"));
 168         assert_se(streq(path_join("/root", "/a/b", "c"), "/root/a/b/c"));
 169         assert_se(streq(path_join("/root", "/", "c"), "/root//c"));
 170         assert_se(streq(path_join("/root", "/", NULL), "/root/"));
 171
 172         assert_se(streq(path_join(NULL, "/a/b", "/c"), "/a/b/c"));
 173         assert_se(streq(path_join(NULL, "a/b", "c"), "a/b/c"));
 174         assert_se(streq(path_join(NULL, "/a/b", "c"), "/a/b/c"));
 175         assert_se(streq(path_join(NULL, "/", "c"), "//c"));
 176         assert_se(streq(path_join(NULL, "/", NULL), "/"));
 177 }
 178
 179 static void test_fsck_exists(void) {
 180         /* Ensure we use a sane default for PATH. */
 181         unsetenv("PATH");
 182
 183         /* fsck.minix is provided by util-linux and will probably exist. */
 184         assert_se(fsck_exists("minix") == 0);
 185
 186         assert_se(fsck_exists("AbCdE") == -ENOENT);
 187 }
 188
 189 static void test_make_relative(void) {
 190         char *result;
 191
 192         assert_se(path_make_relative("some/relative/path", "/some/path", &result) < 0);
 193         assert_se(path_make_relative("/some/path", "some/relative/path", &result) < 0);
 194
 195 #define test(from_dir, to_path, expected) {                     \
 196                 path_make_relative(from_dir, to_path, &result); \
 197                 assert_se(streq(result, expected));             \
 198                 free(result);                                   \
 199         }
 200
 201         test("/", "/", ".");
 202         test("/", "/some/path", "some/path");
 203         test("/some/path", "/some/path", ".");
 204         test("/some/path", "/some/path/in/subdir", "in/subdir");
 205         test("/some/path", "/", "../..");
 206         test("/some/path", "/some/other/path", "../other/path");
 207         test("//extra/////slashes///won't////fool///anybody//", "////extra///slashes////are/just///fine///", "../../../are/just/fine");
 208 }
 209
 210 static void test_strv_resolve(void) {
 211         char tmp_dir[] = "/tmp/test-path-util-XXXXXX";
 212         _cleanup_strv_free_ char **search_dirs = NULL;
 213         _cleanup_strv_free_ char **absolute_dirs = NULL;
 214         char **d;
 215
 216         assert_se(mkdtemp(tmp_dir) != NULL);
 217
 218         search_dirs = strv_new("/dir1", "/dir2", "/dir3", NULL);
 219         assert_se(search_dirs);
 220         STRV_FOREACH(d, search_dirs) {
 221                 char *p = strappend(tmp_dir, *d);
 222                 assert_se(p);
 223                 assert_se(strv_push(&absolute_dirs, p) == 0);
 224         }
 225
 226         assert_se(mkdir(absolute_dirs[0], 0700) == 0);
 227         assert_se(mkdir(absolute_dirs[1], 0700) == 0);
 228         assert_se(symlink("dir2", absolute_dirs[2]) == 0);
 229
 230         path_strv_resolve(search_dirs, tmp_dir);
 231         assert_se(streq(search_dirs[0], "/dir1"));
 232         assert_se(streq(search_dirs[1], "/dir2"));
 233         assert_se(streq(search_dirs[2], "/dir2"));
 234
 235         assert_se(rm_rf_dangerous(tmp_dir, false, true, false) == 0);
 236 }
 237
 238 int main(int argc, char **argv) {
 239         test_path();
 240         test_find_binary(argv[0]);
 241         test_prefixes();
 242         test_path_join();
 243         test_fsck_exists();
 244         test_make_relative();
 245         test_strv_resolve();
 246         return 0;
 247 }