[systemd.git] / src / test / test-path-util.c

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  This file is part of systemd.

  Copyright 2013 Zbigniew Jędrzejewski-Szmek

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdio.h>
#include <unistd.h>

#include "alloc-util.h"
#include "fd-util.h"
#include "macro.h"
#include "mount-util.h"
#include "path-util.h"
#include "rm-rf.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
#include "util.h"

#define test_path_compare(a, b, result) {                 \
                assert_se(path_compare(a, b) == result);  \
                assert_se(path_compare(b, a) == -result); \
                assert_se(path_equal(a, b) == !result);   \
                assert_se(path_equal(b, a) == !result);   \
        }

static void test_path(void) {
        _cleanup_close_ int fd = -1;

        test_path_compare("/goo", "/goo", 0);
        test_path_compare("/goo", "/goo", 0);
        test_path_compare("//goo", "/goo", 0);
        test_path_compare("//goo/////", "/goo", 0);
        test_path_compare("goo/////", "goo", 0);

        test_path_compare("/goo/boo", "/goo//boo", 0);
        test_path_compare("//goo/boo", "/goo/boo//", 0);

        test_path_compare("/", "///", 0);

        test_path_compare("/x", "x/", 1);
        test_path_compare("x/", "/", -1);

        test_path_compare("/x/./y", "x/y", 1);
        test_path_compare("x/.y", "x/y", -1);

        test_path_compare("foo", "/foo", -1);
        test_path_compare("/foo", "/foo/bar", -1);
        test_path_compare("/foo/aaa", "/foo/b", -1);
        test_path_compare("/foo/aaa", "/foo/b/a", -1);
        test_path_compare("/foo/a", "/foo/aaa", -1);
        test_path_compare("/foo/a/b", "/foo/aaa", -1);

        assert_se(path_is_absolute("/"));
        assert_se(!path_is_absolute("./"));

        assert_se(is_path("/dir"));
        assert_se(is_path("a/b"));
        assert_se(!is_path("."));

        assert_se(streq(basename("./aa/bb/../file.da."), "file.da."));
        assert_se(streq(basename("/aa///.file"), ".file"));
        assert_se(streq(basename("/aa///file..."), "file..."));
        assert_se(streq(basename("file.../"), ""));

        fd = open("/", O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOCTTY);
        assert_se(fd >= 0);
        assert_se(fd_is_mount_point(fd, "/", 0) > 0);

        {
                char p1[] = "aaa/bbb////ccc";
                char p2[] = "//aaa/.////ccc";
                char p3[] = "/./";

                assert_se(path_equal(path_kill_slashes(p1), "aaa/bbb/ccc"));
                assert_se(path_equal(path_kill_slashes(p2), "/aaa/./ccc"));
                assert_se(path_equal(path_kill_slashes(p3), "/./"));
        }

        assert_se(PATH_IN_SET("/bin", "/", "/bin", "/foo"));
        assert_se(PATH_IN_SET("/bin", "/bin"));
        assert_se(PATH_IN_SET("/bin", "/foo/bar", "/bin"));
        assert_se(PATH_IN_SET("/", "/", "/", "/foo/bar"));
        assert_se(!PATH_IN_SET("/", "/abc", "/def"));

        assert_se(path_equal_ptr(NULL, NULL));
        assert_se(path_equal_ptr("/a", "/a"));
        assert_se(!path_equal_ptr("/a", "/b"));
        assert_se(!path_equal_ptr("/a", NULL));
        assert_se(!path_equal_ptr(NULL, "/a"));
}

static void test_path_equal_root(void) {
        /* Nail down the details of how path_equal("/", ...) works. */

        assert_se(path_equal("/", "/"));
        assert_se(path_equal("/", "//"));

        assert_se(!path_equal("/", "/./"));
        assert_se(!path_equal("/", "/../"));

        assert_se(!path_equal("/", "/.../"));

        /* Make sure that files_same works as expected. */

        assert_se(files_same("/", "/", 0) > 0);
        assert_se(files_same("/", "/", AT_SYMLINK_NOFOLLOW) > 0);
        assert_se(files_same("/", "//", 0) > 0);
        assert_se(files_same("/", "//", AT_SYMLINK_NOFOLLOW) > 0);

        assert_se(files_same("/", "/./", 0) > 0);
        assert_se(files_same("/", "/./", AT_SYMLINK_NOFOLLOW) > 0);
        assert_se(files_same("/", "/../", 0) > 0);
        assert_se(files_same("/", "/../", AT_SYMLINK_NOFOLLOW) > 0);

        assert_se(files_same("/", "/.../", 0) == -ENOENT);
        assert_se(files_same("/", "/.../", AT_SYMLINK_NOFOLLOW) == -ENOENT);

        /* The same for path_equal_or_files_same. */

        assert_se(path_equal_or_files_same("/", "/", 0));
        assert_se(path_equal_or_files_same("/", "/", AT_SYMLINK_NOFOLLOW));
        assert_se(path_equal_or_files_same("/", "//", 0));
        assert_se(path_equal_or_files_same("/", "//", AT_SYMLINK_NOFOLLOW));

        assert_se(path_equal_or_files_same("/", "/./", 0));
        assert_se(path_equal_or_files_same("/", "/./", AT_SYMLINK_NOFOLLOW));
        assert_se(path_equal_or_files_same("/", "/../", 0));
        assert_se(path_equal_or_files_same("/", "/../", AT_SYMLINK_NOFOLLOW));

        assert_se(!path_equal_or_files_same("/", "/.../", 0));
        assert_se(!path_equal_or_files_same("/", "/.../", AT_SYMLINK_NOFOLLOW));
}

static void test_find_binary(const char *self) {
        char *p;

        assert_se(find_binary("/bin/sh", &p) == 0);
        puts(p);
        assert_se(path_equal(p, "/bin/sh"));
        free(p);

        assert_se(find_binary(self, &p) == 0);
        puts(p);
        /* libtool might prefix the binary name with "lt-" */
        assert_se(endswith(p, "/lt-test-path-util") || endswith(p, "/test-path-util"));
        assert_se(path_is_absolute(p));
        free(p);

        assert_se(find_binary("sh", &p) == 0);
        puts(p);
        assert_se(endswith(p, "/sh"));
        assert_se(path_is_absolute(p));
        free(p);

        assert_se(find_binary("xxxx-xxxx", &p) == -ENOENT);
        assert_se(find_binary("/some/dir/xxxx-xxxx", &p) == -ENOENT);
}

static void test_prefixes(void) {
        static const char* values[] = { "/a/b/c/d", "/a/b/c", "/a/b", "/a", "", NULL};
        unsigned i;
        char s[PATH_MAX];
        bool b;

        i = 0;
        PATH_FOREACH_PREFIX_MORE(s, "/a/b/c/d") {
                log_error("---%s---", s);
                assert_se(streq(s, values[i++]));
        }
        assert_se(values[i] == NULL);

        i = 1;
        PATH_FOREACH_PREFIX(s, "/a/b/c/d") {
                log_error("---%s---", s);
                assert_se(streq(s, values[i++]));
        }
        assert_se(values[i] == NULL);

        i = 0;
        PATH_FOREACH_PREFIX_MORE(s, "////a////b////c///d///////")
                assert_se(streq(s, values[i++]));
        assert_se(values[i] == NULL);

        i = 1;
        PATH_FOREACH_PREFIX(s, "////a////b////c///d///////")
                assert_se(streq(s, values[i++]));
        assert_se(values[i] == NULL);

        PATH_FOREACH_PREFIX(s, "////")
                assert_not_reached("Wut?");

        b = false;
        PATH_FOREACH_PREFIX_MORE(s, "////") {
                assert_se(!b);
                assert_se(streq(s, ""));
                b = true;
        }
        assert_se(b);

        PATH_FOREACH_PREFIX(s, "")
                assert_not_reached("wut?");

        b = false;
        PATH_FOREACH_PREFIX_MORE(s, "") {
                assert_se(!b);
                assert_se(streq(s, ""));
                b = true;
        }
}

static void test_path_join(void) {

#define test_join(root, path, rest, expected) {  \
                _cleanup_free_ char *z = NULL;   \
                z = path_join(root, path, rest); \
                assert_se(streq(z, expected));   \
        }

        test_join("/root", "/a/b", "/c", "/root/a/b/c");
        test_join("/root", "a/b", "c", "/root/a/b/c");
        test_join("/root", "/a/b", "c", "/root/a/b/c");
        test_join("/root", "/", "c", "/root/c");
        test_join("/root", "/", NULL, "/root/");

        test_join(NULL, "/a/b", "/c", "/a/b/c");
        test_join(NULL, "a/b", "c", "a/b/c");
        test_join(NULL, "/a/b", "c", "/a/b/c");
        test_join(NULL, "/", "c", "/c");
        test_join(NULL, "/", NULL, "/");
}

static void test_fsck_exists(void) {
        /* Ensure we use a sane default for PATH. */
        unsetenv("PATH");

        /* fsck.minix is provided by util-linux and will probably exist. */
        assert_se(fsck_exists("minix") == 1);

        assert_se(fsck_exists("AbCdE") == 0);
        assert_se(fsck_exists("/../bin/") == 0);
}

static void test_make_relative(void) {
        char *result;

        assert_se(path_make_relative("some/relative/path", "/some/path", &result) < 0);
        assert_se(path_make_relative("/some/path", "some/relative/path", &result) < 0);
        assert_se(path_make_relative("/some/dotdot/../path", "/some/path", &result) < 0);

#define test(from_dir, to_path, expected) {                \
                _cleanup_free_ char *z = NULL;             \
                path_make_relative(from_dir, to_path, &z); \
                assert_se(streq(z, expected));             \
        }

        test("/", "/", ".");
        test("/", "/some/path", "some/path");
        test("/some/path", "/some/path", ".");
        test("/some/path", "/some/path/in/subdir", "in/subdir");
        test("/some/path", "/", "../..");
        test("/some/path", "/some/other/path", "../other/path");
        test("/some/path/./dot", "/some/further/path", "../../further/path");
        test("//extra/////slashes///won't////fool///anybody//", "////extra///slashes////are/just///fine///", "../../../are/just/fine");
}

static void test_strv_resolve(void) {
        char tmp_dir[] = "/tmp/test-path-util-XXXXXX";
        _cleanup_strv_free_ char **search_dirs = NULL;
        _cleanup_strv_free_ char **absolute_dirs = NULL;
        char **d;

        assert_se(mkdtemp(tmp_dir) != NULL);

        search_dirs = strv_new("/dir1", "/dir2", "/dir3", NULL);
        assert_se(search_dirs);
        STRV_FOREACH(d, search_dirs) {
                char *p = strappend(tmp_dir, *d);
                assert_se(p);
                assert_se(strv_push(&absolute_dirs, p) == 0);
        }

        assert_se(mkdir(absolute_dirs[0], 0700) == 0);
        assert_se(mkdir(absolute_dirs[1], 0700) == 0);
        assert_se(symlink("dir2", absolute_dirs[2]) == 0);

        path_strv_resolve(search_dirs, tmp_dir);
        assert_se(streq(search_dirs[0], "/dir1"));
        assert_se(streq(search_dirs[1], "/dir2"));
        assert_se(streq(search_dirs[2], "/dir2"));

        assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0);
}

static void test_path_startswith(void) {
        const char *p;

        p = path_startswith("/foo/bar/barfoo/", "/foo");
        assert_se(streq_ptr(p, "bar/barfoo/"));

        p = path_startswith("/foo/bar/barfoo/", "/foo/");
        assert_se(streq_ptr(p, "bar/barfoo/"));

        p = path_startswith("/foo/bar/barfoo/", "/");
        assert_se(streq_ptr(p, "foo/bar/barfoo/"));

        p = path_startswith("/foo/bar/barfoo/", "////");
        assert_se(streq_ptr(p, "foo/bar/barfoo/"));

        p = path_startswith("/foo/bar/barfoo/", "/foo//bar/////barfoo///");
        assert_se(streq_ptr(p, ""));

        p = path_startswith("/foo/bar/barfoo/", "/foo/bar/barfoo////");
        assert_se(streq_ptr(p, ""));

        p = path_startswith("/foo/bar/barfoo/", "/foo/bar///barfoo/");
        assert_se(streq_ptr(p, ""));

        p = path_startswith("/foo/bar/barfoo/", "/foo////bar/barfoo/");
        assert_se(streq_ptr(p, ""));

        p = path_startswith("/foo/bar/barfoo/", "////foo/bar/barfoo/");
        assert_se(streq_ptr(p, ""));

        p = path_startswith("/foo/bar/barfoo/", "/foo/bar/barfoo");
        assert_se(streq_ptr(p, ""));

        assert_se(!path_startswith("/foo/bar/barfoo/", "/foo/bar/barfooa/"));
        assert_se(!path_startswith("/foo/bar/barfoo/", "/foo/bar/barfooa"));
        assert_se(!path_startswith("/foo/bar/barfoo/", ""));
        assert_se(!path_startswith("/foo/bar/barfoo/", "/bar/foo"));
        assert_se(!path_startswith("/foo/bar/barfoo/", "/f/b/b/"));
}

static void test_prefix_root_one(const char *r, const char *p, const char *expected) {
        _cleanup_free_ char *s = NULL;
        const char *t;

        assert_se(s = prefix_root(r, p));
        assert_se(streq_ptr(s, expected));

        t = prefix_roota(r, p);
        assert_se(t);
        assert_se(streq_ptr(t, expected));
}

static void test_prefix_root(void) {
        test_prefix_root_one("/", "/foo", "/foo");
        test_prefix_root_one(NULL, "/foo", "/foo");
        test_prefix_root_one("", "/foo", "/foo");
        test_prefix_root_one("///", "/foo", "/foo");
        test_prefix_root_one("/", "////foo", "/foo");
        test_prefix_root_one(NULL, "////foo", "/foo");

        test_prefix_root_one("/foo", "/bar", "/foo/bar");
        test_prefix_root_one("/foo", "bar", "/foo/bar");
        test_prefix_root_one("foo", "bar", "foo/bar");
        test_prefix_root_one("/foo/", "/bar", "/foo/bar");
        test_prefix_root_one("/foo/", "//bar", "/foo/bar");
        test_prefix_root_one("/foo///", "//bar", "/foo/bar");
}

static void test_file_in_same_dir(void) {
        char *t;

        t = file_in_same_dir("/", "a");
        assert_se(streq(t, "/a"));
        free(t);

        t = file_in_same_dir("/", "/a");
        assert_se(streq(t, "/a"));
        free(t);

        t = file_in_same_dir("", "a");
        assert_se(streq(t, "a"));
        free(t);

        t = file_in_same_dir("a/", "a");
        assert_se(streq(t, "a/a"));
        free(t);

        t = file_in_same_dir("bar/foo", "bar");
        assert_se(streq(t, "bar/bar"));
        free(t);
}

static void test_last_path_component(void) {
        assert_se(streq(last_path_component("a/b/c"), "c"));
        assert_se(streq(last_path_component("a/b/c/"), "c/"));
        assert_se(streq(last_path_component("/"), "/"));
        assert_se(streq(last_path_component("//"), "/"));
        assert_se(streq(last_path_component("///"), "/"));
        assert_se(streq(last_path_component("."), "."));
        assert_se(streq(last_path_component("./."), "."));
        assert_se(streq(last_path_component("././"), "./"));
        assert_se(streq(last_path_component("././/"), ".//"));
        assert_se(streq(last_path_component("/foo/a"), "a"));
        assert_se(streq(last_path_component("/foo/a/"), "a/"));
        assert_se(streq(last_path_component(""), ""));
}

static void test_filename_is_valid(void) {
        char foo[FILENAME_MAX+2];
        int i;

        assert_se(!filename_is_valid(""));
        assert_se(!filename_is_valid("/bar/foo"));
        assert_se(!filename_is_valid("/"));
        assert_se(!filename_is_valid("."));
        assert_se(!filename_is_valid(".."));

        for (i=0; i<FILENAME_MAX+1; i++)
                foo[i] = 'a';
        foo[FILENAME_MAX+1] = '\0';

        assert_se(!filename_is_valid(foo));

        assert_se(filename_is_valid("foo_bar-333"));
        assert_se(filename_is_valid("o.o"));
}

static void test_hidden_or_backup_file(void) {
        assert_se(hidden_or_backup_file(".hidden"));
        assert_se(hidden_or_backup_file("..hidden"));
        assert_se(!hidden_or_backup_file("hidden."));

        assert_se(hidden_or_backup_file("backup~"));
        assert_se(hidden_or_backup_file(".backup~"));

        assert_se(hidden_or_backup_file("lost+found"));
        assert_se(hidden_or_backup_file("aquota.user"));
        assert_se(hidden_or_backup_file("aquota.group"));

        assert_se(hidden_or_backup_file("test.rpmnew"));
        assert_se(hidden_or_backup_file("test.dpkg-old"));
        assert_se(hidden_or_backup_file("test.dpkg-remove"));
        assert_se(hidden_or_backup_file("test.swp"));

        assert_se(!hidden_or_backup_file("test.rpmnew."));
        assert_se(!hidden_or_backup_file("test.dpkg-old.foo"));
}

static void test_systemd_installation_has_version(const char *path) {
        int r;
        const unsigned versions[] = {0, 231, atoi(PACKAGE_VERSION), 999};
        unsigned i;

        for (i = 0; i < ELEMENTSOF(versions); i++) {
                r = systemd_installation_has_version(path, versions[i]);
                assert_se(r >= 0);
                log_info("%s has systemd >= %u: %s",
                         path ?: "Current installation", versions[i], yes_no(r));
        }
}

static void test_skip_dev_prefix(void) {

        assert_se(streq(skip_dev_prefix("/"), "/"));
        assert_se(streq(skip_dev_prefix("/dev"), ""));
        assert_se(streq(skip_dev_prefix("/dev/"), ""));
        assert_se(streq(skip_dev_prefix("/dev/foo"), "foo"));
        assert_se(streq(skip_dev_prefix("/dev/foo/bar"), "foo/bar"));
        assert_se(streq(skip_dev_prefix("//dev"), ""));
        assert_se(streq(skip_dev_prefix("//dev//"), ""));
        assert_se(streq(skip_dev_prefix("/dev///foo"), "foo"));
        assert_se(streq(skip_dev_prefix("///dev///foo///bar"), "foo///bar"));
        assert_se(streq(skip_dev_prefix("//foo"), "//foo"));
        assert_se(streq(skip_dev_prefix("foo"), "foo"));
}

int main(int argc, char **argv) {
        log_set_max_level(LOG_DEBUG);
        log_parse_environment();
        log_open();

        test_path();
        test_path_equal_root();
        test_find_binary(argv[0]);
        test_prefixes();
        test_path_join();
        test_fsck_exists();
        test_make_relative();
        test_strv_resolve();
        test_path_startswith();
        test_prefix_root();
        test_file_in_same_dir();
        test_last_path_component();
        test_filename_is_valid();
        test_hidden_or_backup_file();
        test_skip_dev_prefix();

        test_systemd_installation_has_version(argv[1]); /* NULL is OK */

        return 0;
}
Commit	Line	Data
52ad194e	1	/* SPDX-License-Identifier: LGPL-2.1+ */
663996b3 MS	2	/***
	3	This file is part of systemd.
	4
	5	Copyright 2013 Zbigniew Jędrzejewski-Szmek
	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
	21	#include <stdio.h>
db2df898	22	#include <unistd.h>
663996b3	23
db2df898 MP	24	#include "alloc-util.h"
db2df898 MP	25	#include "fd-util.h"
663996b3	26	#include "macro.h"
db2df898 MP	27	#include "mount-util.h"
db2df898 MP	28	#include "path-util.h"
e3bff60a	29	#include "rm-rf.h"
81c58355	30	#include "stat-util.h"
db2df898 MP	31	#include "string-util.h"
	32	#include "strv.h"
	33	#include "util.h"
663996b3	34
e3bff60a MP	35	#define test_path_compare(a, b, result) { \
	36	assert_se(path_compare(a, b) == result); \
	37	assert_se(path_compare(b, a) == -result); \
	38	assert_se(path_equal(a, b) == !result); \
	39	assert_se(path_equal(b, a) == !result); \
	40	}
663996b3 MS	41
663996b3 MS	42	static void test_path(void) {
e3bff60a MP	43	_cleanup_close_ int fd = -1;
	44
	45	test_path_compare("/goo", "/goo", 0);
	46	test_path_compare("/goo", "/goo", 0);
	47	test_path_compare("//goo", "/goo", 0);
	48	test_path_compare("//goo/////", "/goo", 0);
	49	test_path_compare("goo/////", "goo", 0);
663996b3	50
e3bff60a MP	51	test_path_compare("/goo/boo", "/goo//boo", 0);
e3bff60a MP	52	test_path_compare("//goo/boo", "/goo/boo//", 0);
663996b3	53
e3bff60a	54	test_path_compare("/", "///", 0);
663996b3	55
e3bff60a MP	56	test_path_compare("/x", "x/", 1);
e3bff60a MP	57	test_path_compare("x/", "/", -1);
663996b3	58
e3bff60a MP	59	test_path_compare("/x/./y", "x/y", 1);
	60	test_path_compare("x/.y", "x/y", -1);
	61
	62	test_path_compare("foo", "/foo", -1);
	63	test_path_compare("/foo", "/foo/bar", -1);
	64	test_path_compare("/foo/aaa", "/foo/b", -1);
	65	test_path_compare("/foo/aaa", "/foo/b/a", -1);
	66	test_path_compare("/foo/a", "/foo/aaa", -1);
	67	test_path_compare("/foo/a/b", "/foo/aaa", -1);
663996b3 MS	68
	69	assert_se(path_is_absolute("/"));
	70	assert_se(!path_is_absolute("./"));
	71
	72	assert_se(is_path("/dir"));
	73	assert_se(is_path("a/b"));
	74	assert_se(!is_path("."));
	75
60f067b4 JS	76	assert_se(streq(basename("./aa/bb/../file.da."), "file.da."));
	77	assert_se(streq(basename("/aa///.file"), ".file"));
	78	assert_se(streq(basename("/aa///file..."), "file..."));
	79	assert_se(streq(basename("file.../"), ""));
663996b3	80
e3bff60a MP	81	fd = open("/", O_RDONLY\|O_CLOEXEC\|O_DIRECTORY\|O_NOCTTY);
e3bff60a MP	82	assert_se(fd >= 0);
86f210e9	83	assert_se(fd_is_mount_point(fd, "/", 0) > 0);
663996b3 MS	84
	85	{
	86	char p1[] = "aaa/bbb////ccc";
	87	char p2[] = "//aaa/.////ccc";
	88	char p3[] = "/./";
	89
5eef597e MP	90	assert_se(path_equal(path_kill_slashes(p1), "aaa/bbb/ccc"));
	91	assert_se(path_equal(path_kill_slashes(p2), "/aaa/./ccc"));
	92	assert_se(path_equal(path_kill_slashes(p3), "/./"));
663996b3	93	}
aa27b158 MP	94
	95	assert_se(PATH_IN_SET("/bin", "/", "/bin", "/foo"));
	96	assert_se(PATH_IN_SET("/bin", "/bin"));
	97	assert_se(PATH_IN_SET("/bin", "/foo/bar", "/bin"));
	98	assert_se(PATH_IN_SET("/", "/", "/", "/foo/bar"));
	99	assert_se(!PATH_IN_SET("/", "/abc", "/def"));
	100
	101	assert_se(path_equal_ptr(NULL, NULL));
	102	assert_se(path_equal_ptr("/a", "/a"));
	103	assert_se(!path_equal_ptr("/a", "/b"));
	104	assert_se(!path_equal_ptr("/a", NULL));
	105	assert_se(!path_equal_ptr(NULL, "/a"));
663996b3 MS	106	}
663996b3 MS	107
81c58355 MB	108	static void test_path_equal_root(void) {
	109	/* Nail down the details of how path_equal("/", ...) works. */
	110
	111	assert_se(path_equal("/", "/"));
	112	assert_se(path_equal("/", "//"));
	113
	114	assert_se(!path_equal("/", "/./"));
	115	assert_se(!path_equal("/", "/../"));
	116
	117	assert_se(!path_equal("/", "/.../"));
	118
	119	/* Make sure that files_same works as expected. */
	120
	121	assert_se(files_same("/", "/", 0) > 0);
	122	assert_se(files_same("/", "/", AT_SYMLINK_NOFOLLOW) > 0);
	123	assert_se(files_same("/", "//", 0) > 0);
	124	assert_se(files_same("/", "//", AT_SYMLINK_NOFOLLOW) > 0);
	125
	126	assert_se(files_same("/", "/./", 0) > 0);
	127	assert_se(files_same("/", "/./", AT_SYMLINK_NOFOLLOW) > 0);
	128	assert_se(files_same("/", "/../", 0) > 0);
	129	assert_se(files_same("/", "/../", AT_SYMLINK_NOFOLLOW) > 0);
	130
	131	assert_se(files_same("/", "/.../", 0) == -ENOENT);
	132	assert_se(files_same("/", "/.../", AT_SYMLINK_NOFOLLOW) == -ENOENT);
	133
	134	/* The same for path_equal_or_files_same. */
	135
	136	assert_se(path_equal_or_files_same("/", "/", 0));
	137	assert_se(path_equal_or_files_same("/", "/", AT_SYMLINK_NOFOLLOW));
	138	assert_se(path_equal_or_files_same("/", "//", 0));
	139	assert_se(path_equal_or_files_same("/", "//", AT_SYMLINK_NOFOLLOW));
	140
	141	assert_se(path_equal_or_files_same("/", "/./", 0));
	142	assert_se(path_equal_or_files_same("/", "/./", AT_SYMLINK_NOFOLLOW));
	143	assert_se(path_equal_or_files_same("/", "/../", 0));
	144	assert_se(path_equal_or_files_same("/", "/../", AT_SYMLINK_NOFOLLOW));
	145
	146	assert_se(!path_equal_or_files_same("/", "/.../", 0));
	147	assert_se(!path_equal_or_files_same("/", "/.../", AT_SYMLINK_NOFOLLOW));
	148	}
	149
db2df898	150	static void test_find_binary(const char *self) {
14228c0d MB	151	char *p;
14228c0d MB	152
db2df898	153	assert_se(find_binary("/bin/sh", &p) == 0);
14228c0d	154	puts(p);
db2df898	155	assert_se(path_equal(p, "/bin/sh"));
14228c0d MB	156	free(p);
14228c0d MB	157
db2df898	158	assert_se(find_binary(self, &p) == 0);
14228c0d	159	puts(p);
8a584da2 MP	160	/* libtool might prefix the binary name with "lt-" */
8a584da2 MP	161	assert_se(endswith(p, "/lt-test-path-util") \|\| endswith(p, "/test-path-util"));
5eef597e	162	assert_se(path_is_absolute(p));
14228c0d MB	163	free(p);
14228c0d MB	164
db2df898	165	assert_se(find_binary("sh", &p) == 0);
14228c0d	166	puts(p);
5eef597e MP	167	assert_se(endswith(p, "/sh"));
5eef597e MP	168	assert_se(path_is_absolute(p));
14228c0d MB	169	free(p);
14228c0d MB	170
db2df898 MP	171	assert_se(find_binary("xxxx-xxxx", &p) == -ENOENT);
db2df898 MP	172	assert_se(find_binary("/some/dir/xxxx-xxxx", &p) == -ENOENT);
14228c0d MB	173	}
	174
	175	static void test_prefixes(void) {
	176	static const char* values[] = { "/a/b/c/d", "/a/b/c", "/a/b", "/a", "", NULL};
	177	unsigned i;
	178	char s[PATH_MAX];
	179	bool b;
	180
	181	i = 0;
	182	PATH_FOREACH_PREFIX_MORE(s, "/a/b/c/d") {
	183	log_error("---%s---", s);
	184	assert_se(streq(s, values[i++]));
	185	}
	186	assert_se(values[i] == NULL);
	187
	188	i = 1;
	189	PATH_FOREACH_PREFIX(s, "/a/b/c/d") {
	190	log_error("---%s---", s);
	191	assert_se(streq(s, values[i++]));
	192	}
	193	assert_se(values[i] == NULL);
	194
	195	i = 0;
	196	PATH_FOREACH_PREFIX_MORE(s, "////a////b////c///d///////")
	197	assert_se(streq(s, values[i++]));
	198	assert_se(values[i] == NULL);
	199
	200	i = 1;
	201	PATH_FOREACH_PREFIX(s, "////a////b////c///d///////")
	202	assert_se(streq(s, values[i++]));
	203	assert_se(values[i] == NULL);
	204
	205	PATH_FOREACH_PREFIX(s, "////")
	206	assert_not_reached("Wut?");
	207
	208	b = false;
	209	PATH_FOREACH_PREFIX_MORE(s, "////") {
	210	assert_se(!b);
	211	assert_se(streq(s, ""));
	212	b = true;
	213	}
	214	assert_se(b);
	215
	216	PATH_FOREACH_PREFIX(s, "")
	217	assert_not_reached("wut?");
	218
	219	b = false;
	220	PATH_FOREACH_PREFIX_MORE(s, "") {
5eef597e MP	221	assert_se(!b);
5eef597e MP	222	assert_se(streq(s, ""));
14228c0d MB	223	b = true;
	224	}
	225	}
	226
5eef597e MP	227	static void test_path_join(void) {
	228
	229	#define test_join(root, path, rest, expected) { \
	230	_cleanup_free_ char *z = NULL; \
	231	z = path_join(root, path, rest); \
	232	assert_se(streq(z, expected)); \
	233	}
	234
	235	test_join("/root", "/a/b", "/c", "/root/a/b/c");
	236	test_join("/root", "a/b", "c", "/root/a/b/c");
	237	test_join("/root", "/a/b", "c", "/root/a/b/c");
e735f4d4	238	test_join("/root", "/", "c", "/root/c");
5eef597e MP	239	test_join("/root", "/", NULL, "/root/");
	240
	241	test_join(NULL, "/a/b", "/c", "/a/b/c");
	242	test_join(NULL, "a/b", "c", "a/b/c");
	243	test_join(NULL, "/a/b", "c", "/a/b/c");
e735f4d4	244	test_join(NULL, "/", "c", "/c");
5eef597e MP	245	test_join(NULL, "/", NULL, "/");
	246	}
	247
60f067b4 JS	248	static void test_fsck_exists(void) {
	249	/* Ensure we use a sane default for PATH. */
	250	unsetenv("PATH");
	251
	252	/* fsck.minix is provided by util-linux and will probably exist. */
db2df898	253	assert_se(fsck_exists("minix") == 1);
60f067b4	254
db2df898 MP	255	assert_se(fsck_exists("AbCdE") == 0);
db2df898 MP	256	assert_se(fsck_exists("/../bin/") == 0);
60f067b4 JS	257	}
	258
	259	static void test_make_relative(void) {
	260	char *result;
	261
	262	assert_se(path_make_relative("some/relative/path", "/some/path", &result) < 0);
	263	assert_se(path_make_relative("/some/path", "some/relative/path", &result) < 0);
f5e65279	264	assert_se(path_make_relative("/some/dotdot/../path", "/some/path", &result) < 0);
60f067b4	265
5eef597e MP	266	#define test(from_dir, to_path, expected) { \
	267	_cleanup_free_ char *z = NULL; \
	268	path_make_relative(from_dir, to_path, &z); \
	269	assert_se(streq(z, expected)); \
60f067b4 JS	270	}
	271
	272	test("/", "/", ".");
	273	test("/", "/some/path", "some/path");
	274	test("/some/path", "/some/path", ".");
	275	test("/some/path", "/some/path/in/subdir", "in/subdir");
	276	test("/some/path", "/", "../..");
	277	test("/some/path", "/some/other/path", "../other/path");
f5e65279	278	test("/some/path/./dot", "/some/further/path", "../../further/path");
60f067b4 JS	279	test("//extra/////slashes///won't////fool///anybody//", "////extra///slashes////are/just///fine///", "../../../are/just/fine");
	280	}
	281
e842803a MB	282	static void test_strv_resolve(void) {
	283	char tmp_dir[] = "/tmp/test-path-util-XXXXXX";
	284	_cleanup_strv_free_ char **search_dirs = NULL;
	285	_cleanup_strv_free_ char **absolute_dirs = NULL;
	286	char **d;
	287
	288	assert_se(mkdtemp(tmp_dir) != NULL);
	289
	290	search_dirs = strv_new("/dir1", "/dir2", "/dir3", NULL);
	291	assert_se(search_dirs);
	292	STRV_FOREACH(d, search_dirs) {
	293	char p = strappend(tmp_dir, d);
	294	assert_se(p);
	295	assert_se(strv_push(&absolute_dirs, p) == 0);
	296	}
	297
	298	assert_se(mkdir(absolute_dirs[0], 0700) == 0);
	299	assert_se(mkdir(absolute_dirs[1], 0700) == 0);
	300	assert_se(symlink("dir2", absolute_dirs[2]) == 0);
	301
	302	path_strv_resolve(search_dirs, tmp_dir);
	303	assert_se(streq(search_dirs[0], "/dir1"));
	304	assert_se(streq(search_dirs[1], "/dir2"));
	305	assert_se(streq(search_dirs[2], "/dir2"));
	306
e3bff60a	307	assert_se(rm_rf(tmp_dir, REMOVE_ROOT\|REMOVE_PHYSICAL) == 0);
e842803a MB	308	}
e842803a MB	309
f47781d8	310	static void test_path_startswith(void) {
8a584da2 MP	311	const char *p;
	312
	313	p = path_startswith("/foo/bar/barfoo/", "/foo");
	314	assert_se(streq_ptr(p, "bar/barfoo/"));
	315
	316	p = path_startswith("/foo/bar/barfoo/", "/foo/");
	317	assert_se(streq_ptr(p, "bar/barfoo/"));
	318
	319	p = path_startswith("/foo/bar/barfoo/", "/");
	320	assert_se(streq_ptr(p, "foo/bar/barfoo/"));
	321
	322	p = path_startswith("/foo/bar/barfoo/", "////");
	323	assert_se(streq_ptr(p, "foo/bar/barfoo/"));
	324
	325	p = path_startswith("/foo/bar/barfoo/", "/foo//bar/////barfoo///");
	326	assert_se(streq_ptr(p, ""));
	327
	328	p = path_startswith("/foo/bar/barfoo/", "/foo/bar/barfoo////");
	329	assert_se(streq_ptr(p, ""));
	330
	331	p = path_startswith("/foo/bar/barfoo/", "/foo/bar///barfoo/");
	332	assert_se(streq_ptr(p, ""));
	333
	334	p = path_startswith("/foo/bar/barfoo/", "/foo////bar/barfoo/");
	335	assert_se(streq_ptr(p, ""));
	336
	337	p = path_startswith("/foo/bar/barfoo/", "////foo/bar/barfoo/");
	338	assert_se(streq_ptr(p, ""));
	339
	340	p = path_startswith("/foo/bar/barfoo/", "/foo/bar/barfoo");
	341	assert_se(streq_ptr(p, ""));
f47781d8 MP	342
	343	assert_se(!path_startswith("/foo/bar/barfoo/", "/foo/bar/barfooa/"));
	344	assert_se(!path_startswith("/foo/bar/barfoo/", "/foo/bar/barfooa"));
	345	assert_se(!path_startswith("/foo/bar/barfoo/", ""));
	346	assert_se(!path_startswith("/foo/bar/barfoo/", "/bar/foo"));
	347	assert_se(!path_startswith("/foo/bar/barfoo/", "/f/b/b/"));
	348	}
	349
e3bff60a MP	350	static void test_prefix_root_one(const char r, const char p, const char *expected) {
	351	_cleanup_free_ char *s = NULL;
	352	const char *t;
	353
	354	assert_se(s = prefix_root(r, p));
	355	assert_se(streq_ptr(s, expected));
	356
	357	t = prefix_roota(r, p);
	358	assert_se(t);
	359	assert_se(streq_ptr(t, expected));
	360	}
	361
	362	static void test_prefix_root(void) {
	363	test_prefix_root_one("/", "/foo", "/foo");
	364	test_prefix_root_one(NULL, "/foo", "/foo");
	365	test_prefix_root_one("", "/foo", "/foo");
	366	test_prefix_root_one("///", "/foo", "/foo");
	367	test_prefix_root_one("/", "////foo", "/foo");
	368	test_prefix_root_one(NULL, "////foo", "/foo");
	369
	370	test_prefix_root_one("/foo", "/bar", "/foo/bar");
	371	test_prefix_root_one("/foo", "bar", "/foo/bar");
	372	test_prefix_root_one("foo", "bar", "foo/bar");
	373	test_prefix_root_one("/foo/", "/bar", "/foo/bar");
	374	test_prefix_root_one("/foo/", "//bar", "/foo/bar");
	375	test_prefix_root_one("/foo///", "//bar", "/foo/bar");
	376	}
	377
aa27b158 MP	378	static void test_file_in_same_dir(void) {
	379	char *t;
	380
	381	t = file_in_same_dir("/", "a");
	382	assert_se(streq(t, "/a"));
	383	free(t);
	384
	385	t = file_in_same_dir("/", "/a");
	386	assert_se(streq(t, "/a"));
	387	free(t);
	388
	389	t = file_in_same_dir("", "a");
	390	assert_se(streq(t, "a"));
	391	free(t);
	392
	393	t = file_in_same_dir("a/", "a");
	394	assert_se(streq(t, "a/a"));
	395	free(t);
	396
	397	t = file_in_same_dir("bar/foo", "bar");
	398	assert_se(streq(t, "bar/bar"));
	399	free(t);
	400	}
	401
52ad194e MB	402	static void test_last_path_component(void) {
	403	assert_se(streq(last_path_component("a/b/c"), "c"));
	404	assert_se(streq(last_path_component("a/b/c/"), "c/"));
	405	assert_se(streq(last_path_component("/"), "/"));
	406	assert_se(streq(last_path_component("//"), "/"));
	407	assert_se(streq(last_path_component("///"), "/"));
	408	assert_se(streq(last_path_component("."), "."));
	409	assert_se(streq(last_path_component("./."), "."));
	410	assert_se(streq(last_path_component("././"), "./"));
	411	assert_se(streq(last_path_component("././/"), ".//"));
	412	assert_se(streq(last_path_component("/foo/a"), "a"));
	413	assert_se(streq(last_path_component("/foo/a/"), "a/"));
	414	assert_se(streq(last_path_component(""), ""));
	415	}
	416
aa27b158 MP	417	static void test_filename_is_valid(void) {
	418	char foo[FILENAME_MAX+2];
	419	int i;
	420
	421	assert_se(!filename_is_valid(""));
	422	assert_se(!filename_is_valid("/bar/foo"));
	423	assert_se(!filename_is_valid("/"));
	424	assert_se(!filename_is_valid("."));
	425	assert_se(!filename_is_valid(".."));
	426
	427	for (i=0; i<FILENAME_MAX+1; i++)
	428	foo[i] = 'a';
	429	foo[FILENAME_MAX+1] = '\0';
	430
	431	assert_se(!filename_is_valid(foo));
	432
	433	assert_se(filename_is_valid("foo_bar-333"));
	434	assert_se(filename_is_valid("o.o"));
	435	}
	436
	437	static void test_hidden_or_backup_file(void) {
	438	assert_se(hidden_or_backup_file(".hidden"));
	439	assert_se(hidden_or_backup_file("..hidden"));
	440	assert_se(!hidden_or_backup_file("hidden."));
	441
	442	assert_se(hidden_or_backup_file("backup~"));
	443	assert_se(hidden_or_backup_file(".backup~"));
	444
	445	assert_se(hidden_or_backup_file("lost+found"));
	446	assert_se(hidden_or_backup_file("aquota.user"));
	447	assert_se(hidden_or_backup_file("aquota.group"));
	448
	449	assert_se(hidden_or_backup_file("test.rpmnew"));
	450	assert_se(hidden_or_backup_file("test.dpkg-old"));
	451	assert_se(hidden_or_backup_file("test.dpkg-remove"));
	452	assert_se(hidden_or_backup_file("test.swp"));
	453
	454	assert_se(!hidden_or_backup_file("test.rpmnew."));
	455	assert_se(!hidden_or_backup_file("test.dpkg-old.foo"));
	456	}
	457
8a584da2 MP	458	static void test_systemd_installation_has_version(const char *path) {
	459	int r;
	460	const unsigned versions[] = {0, 231, atoi(PACKAGE_VERSION), 999};
	461	unsigned i;
	462
	463	for (i = 0; i < ELEMENTSOF(versions); i++) {
	464	r = systemd_installation_has_version(path, versions[i]);
	465	assert_se(r >= 0);
	466	log_info("%s has systemd >= %u: %s",
	467	path ?: "Current installation", versions[i], yes_no(r));
	468	}
	469	}
	470
f5e65279 MB	471	static void test_skip_dev_prefix(void) {
	472
	473	assert_se(streq(skip_dev_prefix("/"), "/"));
	474	assert_se(streq(skip_dev_prefix("/dev"), ""));
	475	assert_se(streq(skip_dev_prefix("/dev/"), ""));
	476	assert_se(streq(skip_dev_prefix("/dev/foo"), "foo"));
	477	assert_se(streq(skip_dev_prefix("/dev/foo/bar"), "foo/bar"));
	478	assert_se(streq(skip_dev_prefix("//dev"), ""));
	479	assert_se(streq(skip_dev_prefix("//dev//"), ""));
	480	assert_se(streq(skip_dev_prefix("/dev///foo"), "foo"));
	481	assert_se(streq(skip_dev_prefix("///dev///foo///bar"), "foo///bar"));
	482	assert_se(streq(skip_dev_prefix("//foo"), "//foo"));
	483	assert_se(streq(skip_dev_prefix("foo"), "foo"));
	484	}
	485
60f067b4	486	int main(int argc, char **argv) {
8a584da2 MP	487	log_set_max_level(LOG_DEBUG);
	488	log_parse_environment();
	489	log_open();
	490
663996b3	491	test_path();
81c58355	492	test_path_equal_root();
db2df898	493	test_find_binary(argv[0]);
14228c0d	494	test_prefixes();
5eef597e	495	test_path_join();
60f067b4 JS	496	test_fsck_exists();
60f067b4 JS	497	test_make_relative();
e842803a	498	test_strv_resolve();
f47781d8	499	test_path_startswith();
e3bff60a	500	test_prefix_root();
aa27b158	501	test_file_in_same_dir();
52ad194e	502	test_last_path_component();
aa27b158 MP	503	test_filename_is_valid();
aa27b158 MP	504	test_hidden_or_backup_file();
f5e65279	505	test_skip_dev_prefix();
f47781d8	506
8a584da2 MP	507	test_systemd_installation_has_version(argv[1]); /* NULL is OK */
8a584da2 MP	508
663996b3 MS	509	return 0;
663996b3 MS	510	}