/* * Copyright (C) 2024 Linux Studio Plugins Project * (C) 2024 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 9 февр. 2019 г. * * lsp-runtime-lib 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 3 of the License, or * any later version. * * lsp-runtime-lib 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 lsp-runtime-lib. If not, see . */ #include #include #include #include #ifdef PLATFORM_WINDOWS #define TEST_PATH1 "C:\\Windows\\system32" #define TEST_PATH2 "C:\\Windows\\system\\lib" #define TEST_PATH2_FIRST "C:\\Windows\\system" #define TEST_PATH2_LAST "lib" #define TEST_PATH3 "C:\\Windows\\system\\bin" #define TEST_PATH3_FIRST "C:\\" #define TEST_PATH3_LAST "Windows\\system\\bin" #define TEST_PATH4 "C:\\Windows\\system" #define TEST_PATH4_LAST "system" #define TEST_PATH5 "C:\\Windows" #define TEST_ROOT "C:\\" #else #define TEST_PATH1 "/usr/local/bin" #define TEST_PATH2 "/usr/share/local/lib" #define TEST_PATH2_FIRST "/usr/share/local" #define TEST_PATH2_LAST "lib" #define TEST_PATH3 "/usr/share/local/bin" #define TEST_PATH3_FIRST "/" #define TEST_PATH3_LAST "usr/share/local/bin" #define TEST_PATH4 "/usr/share/local" #define TEST_PATH4_LAST "local" #define TEST_PATH5 "/usr" #define TEST_ROOT "/" #endif using namespace lsp; using namespace lsp::io; static char *cnull = NULL; static LSPString *snull = NULL; static Path *pnull = NULL; static const char *cpaths[] = { #if !defined(PLATFORM_WINDOWS) ".", "", "./", "", "..", "", "../", "", "./.././a", "a", "a/b/c/../../d/./", "a/d", "a///b/c/.//../../d/./", "a/d", "a/b/c/../../../d/e/./f/", "d/e/f", "//", "/", "/.", "/", "/..", "/", "/./", "/", "/../", "/", "/a/b/c/../../d/./", "/a/d", "/a///b/c/.//../../d/./", "/a/d", "/a/b/c/../../../d/e/./f/", "/d/e/f", "/../a/b/c/../../d/./", "/a/d", "/../a///b/c/.//../../d/./", "/a/d", "/./../a/b/c/../../../d/e/./f/", "/d/e/f", #else ".", "", ".\\", "", "..", "", "..\\", "", ".\\..\\.\\a", "a", "a\\b\\c\\..\\..\\d\\.\\", "a\\d", "a\\\\\\b\\c\\.\\\\..\\..\\d\\.\\", "a\\d", "a\\b\\c\\..\\..\\..\\d\\e\\.\\f\\", "d\\e\\f", "C:\\\\", "C:\\", "C:\\.", "C:\\", "C:\\..", "C:\\", "C:\\.\\", "C:\\", "C:\\..\\", "C:\\", "C:\\a\\b\\c\\..\\..\\d\\.\\", "C:\\a\\d", "C:\\a\\\\\\b\\c\\.\\\\..\\..\\d\\.\\", "C:\\a\\d", "C:\\a\\b\\c\\..\\..\\..\\d\\e\\.\\f\\", "C:\\d\\e\\f", "C:\\..\\a\\b\\c\\..\\..\\d\\.\\", "C:\\a\\d", "C:\\..\\a\\\\\\b\\c\\.\\\\..\\..\\d\\.\\", "C:\\a\\d", "C:\\.\\..\\a\\b\\c\\..\\..\\..\\d\\e\\.\\f\\", "C:\\d\\e\\f", #endif NULL, NULL }; UTEST_BEGIN("runtime.io", path) // status_t get_parent(char *path, size_t maxlen) const; // status_t set_parent(const char *path); // status_t get_parent(LSPString *path) const; // status_t get_parent(Path *path) const; // status_t set_parent(LSPString *path); // status_t set_parent(Path *path); void test_get_set_parent() { Path bp, dp; char path[PATH_MAX]; LSPString spath, dpath; printf("Testing get_parent and set_parent...\n"); UTEST_ASSERT(bp.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(bp.get_parent(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(bp.get_parent(path, 2) == STATUS_TOO_BIG); UTEST_ASSERT(bp.get_parent(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(strcmp(path, TEST_PATH4) == 0); UTEST_ASSERT(spath.set_utf8(TEST_PATH4)); UTEST_ASSERT(bp.get_parent(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(bp.get_parent(&dpath) == STATUS_OK); UTEST_ASSERT(dpath.equals(&spath)); UTEST_ASSERT(bp.get_parent(&dp) == STATUS_OK); UTEST_ASSERT(dp.equals(&spath)); UTEST_ASSERT(bp.set(TEST_ROOT) == STATUS_OK); UTEST_ASSERT(bp.get_parent(path, PATH_MAX) == STATUS_NOT_FOUND); UTEST_ASSERT(bp.get_parent(&dpath) == STATUS_NOT_FOUND); UTEST_ASSERT(bp.get_parent(&dp) == STATUS_NOT_FOUND); UTEST_ASSERT(bp.set("bin") == STATUS_OK); UTEST_ASSERT(bp.get_parent(path, PATH_MAX) == STATUS_NOT_FOUND); UTEST_ASSERT(bp.get_parent(&dpath) == STATUS_NOT_FOUND); UTEST_ASSERT(bp.get_parent(&dp) == STATUS_NOT_FOUND); } // status_t set_last(const char *path); // status_t get_last(char *path, size_t maxlen) const; // status_t set_last(const LSPString *path); // status_t get_last(LSPString *path) const; // status_t set_last(const Path *path); // status_t get_last(Path *path) const; void test_get_set_last() { Path bp, dp, p; char path[PATH_MAX]; LSPString spath, dpath, t1; printf("Testing get_last and set_last...\n"); UTEST_ASSERT(dp.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(dp.set_last("bin") == STATUS_OK); UTEST_ASSERT(dp.set_last(cnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(dp.equals(TEST_PATH3)); UTEST_ASSERT(dp.get_last(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(strcmp(path, "bin") == 0); UTEST_ASSERT(dp.set_last("") == STATUS_OK); UTEST_ASSERT(dp.equals(TEST_PATH4)); UTEST_ASSERT(bp.set_last("bin") == STATUS_OK); UTEST_ASSERT(bp.set_last(cnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(bp.equals("bin")); UTEST_ASSERT(bp.get_last(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(bp.get_last(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(strcmp(path, "bin") == 0); UTEST_ASSERT(bp.set_last("") == STATUS_OK); UTEST_ASSERT(bp.is_empty()); UTEST_ASSERT(dpath.set_utf8("bin")); dp.clear(); UTEST_ASSERT(spath.set_utf8(TEST_PATH2)); UTEST_ASSERT(bp.set(&spath) == STATUS_OK); UTEST_ASSERT(bp.set_last(&dpath) == STATUS_OK); UTEST_ASSERT(bp.equals(TEST_PATH3)); UTEST_ASSERT(bp.get_last(&t1) == STATUS_OK); UTEST_ASSERT(bp.get_last(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(t1.equals(&dpath)); UTEST_ASSERT(dp.set_last(&dpath) == STATUS_OK); UTEST_ASSERT(dp.equals("bin")); UTEST_ASSERT(dp.get_last(&spath) == STATUS_OK); UTEST_ASSERT(t1.equals(&spath)); UTEST_ASSERT(bp.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(dp.set("bin") == STATUS_OK); UTEST_ASSERT(bp.set_last(&dp) == STATUS_OK); UTEST_ASSERT(bp.set_last(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(bp.equals(TEST_PATH3)); UTEST_ASSERT(bp.get_last(&p) == STATUS_OK); UTEST_ASSERT(p.equals("bin")); UTEST_ASSERT(bp.set(TEST_ROOT) == STATUS_OK); UTEST_ASSERT(bp.get_last(&p) == STATUS_OK); UTEST_ASSERT(p.is_empty()); } // status_t set(const char *path); // status_t set(const LSPString *path); // status_t set(const Path *path); // status_t get(char *path, size_t maxlen) const; // status_t get(LSPString *path) const; // status_t get(Path *path) const; void test_get_set() { Path p, dp, bp; char path[PATH_MAX]; LSPString spath, dpath; printf("Testing get and set...\n"); UTEST_ASSERT(p.set(TEST_PATH1) == STATUS_OK); UTEST_ASSERT(p.set(cnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.get(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.get(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(p.get(path, 10) == STATUS_TOO_BIG); UTEST_ASSERT(strcmp(path, TEST_PATH1) == 0); UTEST_ASSERT(spath.set_utf8(TEST_PATH2)); UTEST_ASSERT(p.set(&spath) == STATUS_OK); UTEST_ASSERT(p.set(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.get(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.get(&dpath) == STATUS_OK); UTEST_ASSERT(dpath.equals(&spath)); UTEST_ASSERT(dp.set(&p) == STATUS_OK); UTEST_ASSERT(dp.set(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(dp.get(&bp) == STATUS_OK); UTEST_ASSERT(dp.get(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(bp.equals(&dp)); UTEST_ASSERT(bp.equals(&p)); UTEST_ASSERT(bp.equals(TEST_PATH2)); UTEST_ASSERT(bp.equals(&spath)); } // status_t concat(const char *path); // status_t concat(LSPString *path); // status_t concat(Path *path); void test_concat() { Path p; LSPString sstr; Path spath; printf("Testing concat...\n"); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(p.concat(FILE_SEPARATOR_S "bin") == STATUS_OK); UTEST_ASSERT(p.concat(cnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); p.clear(); UTEST_ASSERT(p.concat(TEST_ROOT) == STATUS_OK); UTEST_ASSERT(p.is_root()); p.clear(); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(sstr.set_utf8(FILE_SEPARATOR_S "bin")); UTEST_ASSERT(p.concat(&sstr) == STATUS_OK); UTEST_ASSERT(p.concat(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); p.clear(); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(spath.set(&sstr) == STATUS_OK); UTEST_ASSERT(p.concat(&spath) == STATUS_OK); UTEST_ASSERT(p.concat(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); p.clear(); UTEST_ASSERT(sstr.set_utf8(TEST_ROOT)); UTEST_ASSERT(p.concat(&sstr) == STATUS_OK); UTEST_ASSERT(p.is_root()); p.clear(); UTEST_ASSERT(spath.set(&sstr) == STATUS_OK); UTEST_ASSERT(p.concat(&spath) == STATUS_OK); UTEST_ASSERT(p.is_root()); } // status_t append_child(const char *path); // status_t append_child(LSPString *path); // status_t append_child(Path *path); void test_append_child() { Path p; LSPString sstr; Path spath; printf("Testing append_child...\n"); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(p.append_child("bin") == STATUS_OK); UTEST_ASSERT(p.append_child(cnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); p.clear(); UTEST_ASSERT(sstr.set_utf8("bin")); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(p.append_child(&sstr) == STATUS_OK); UTEST_ASSERT(p.append_child(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); p.clear(); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(spath.set(&sstr) == STATUS_OK); UTEST_ASSERT(p.append_child(&spath) == STATUS_OK); UTEST_ASSERT(p.append_child(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); UTEST_ASSERT(sstr.set_utf8(TEST_ROOT)); UTEST_ASSERT(spath.set(&sstr) == STATUS_OK); UTEST_ASSERT(p.append_child(TEST_ROOT) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.append_child(&sstr) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.append_child(&spath) == STATUS_INVALID_VALUE); sstr.clear(); spath.clear(); UTEST_ASSERT(p.append_child("") == STATUS_OK); UTEST_ASSERT(p.append_child(&sstr) == STATUS_OK); UTEST_ASSERT(p.append_child(&spath) == STATUS_OK); UTEST_ASSERT(p.equals(TEST_PATH3)); } // status_t remove_last(); // status_t remove_last(char *path, size_t maxlen); // status_t remove_last(LSPString *path); // status_t remove_last(Path *path); void test_remove_last() { Path p; char path[PATH_MAX]; LSPString sstr, xstr; Path spath; printf("Testing remove_last...\n"); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.remove_last() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_PATH4)); UTEST_ASSERT(p.set(TEST_PATH5) == STATUS_OK); UTEST_ASSERT(p.remove_last() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_ROOT)); UTEST_ASSERT(p.set(TEST_ROOT) == STATUS_OK); UTEST_ASSERT(p.remove_last() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_ROOT)); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.remove_last(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(p.remove_last(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.remove_last(path, 3) == STATUS_TOO_BIG); UTEST_ASSERT(p.equals(TEST_PATH2_FIRST)); UTEST_ASSERT(strcmp(path, TEST_PATH2_LAST) == 0); UTEST_ASSERT(xstr.set_utf8(TEST_PATH2_LAST)); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.remove_last(&sstr) == STATUS_OK); UTEST_ASSERT(p.remove_last(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH2_FIRST)); UTEST_ASSERT(sstr.equals(&xstr)); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.remove_last(&spath) == STATUS_OK); UTEST_ASSERT(p.remove_last(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH2_FIRST)); UTEST_ASSERT(spath.equals(&xstr)); } // status_t without_last(char *path, size_t maxlen); // status_t without_last(LSPString *path); // status_t without_last(Path *path); void test_without_last() { Path p; char path[PATH_MAX]; LSPString sstr, xstr; Path spath; printf("Testing without_last...\n"); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.without_last(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(p.without_last(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.without_last(path, 3) == STATUS_TOO_BIG); UTEST_ASSERT(p.equals(TEST_PATH2)); UTEST_ASSERT(strcmp(path, TEST_PATH4) == 0); UTEST_ASSERT(xstr.set_utf8(TEST_PATH4)); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.without_last(&sstr) == STATUS_OK); UTEST_ASSERT(p.without_last(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH2)); UTEST_ASSERT(sstr.equals(&xstr)); UTEST_ASSERT(p.set(TEST_PATH2) == STATUS_OK); UTEST_ASSERT(p.without_last(&spath) == STATUS_OK); UTEST_ASSERT(p.without_last(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH2)); UTEST_ASSERT(spath.equals(&xstr)); } // status_t remove_first(); // status_t remove_first(char *path, size_t maxlen); // status_t remove_first(LSPString *path); // status_t remove_first(Path *path); void test_remove_first() { Path p; char path[PATH_MAX]; LSPString sstr, xstr; Path spath; printf("Testing remove_first...\n"); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_first() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_PATH3_LAST)); UTEST_ASSERT(p.set(TEST_ROOT) == STATUS_OK); UTEST_ASSERT(p.remove_first() == STATUS_NOT_FOUND); UTEST_ASSERT(p.equals(TEST_ROOT)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_first(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(p.remove_first(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.remove_first(path, 3) == STATUS_TOO_BIG); UTEST_ASSERT(p.equals(TEST_PATH3_LAST)); UTEST_ASSERT(strcmp(path, TEST_PATH3_FIRST) == 0); UTEST_ASSERT(xstr.set_utf8(TEST_PATH3_FIRST)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_first(&sstr) == STATUS_OK); UTEST_ASSERT(p.remove_first(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3_LAST)); UTEST_ASSERT(sstr.equals(&xstr)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_first(&spath) == STATUS_OK); UTEST_ASSERT(p.remove_first(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3_LAST)); UTEST_ASSERT(spath.equals(&xstr)); } // status_t without_first(char *path, size_t maxlen); // status_t without_first(LSPString *path); // status_t without_first(Path *path); void test_without_first() { Path p; char path[PATH_MAX]; LSPString sstr, xstr; Path spath; printf("Testing without_first...\n"); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.without_first(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(p.without_first(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.without_first(path, 1) == STATUS_TOO_BIG); UTEST_ASSERT(p.equals(TEST_PATH3)); UTEST_ASSERT(strcmp(path, TEST_PATH3_LAST) == 0); UTEST_ASSERT(xstr.set_utf8(TEST_PATH3_LAST)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.without_first(&sstr) == STATUS_OK); UTEST_ASSERT(p.without_first(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); UTEST_ASSERT(sstr.equals(&xstr)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.without_first(&spath) == STATUS_OK); UTEST_ASSERT(p.without_first(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals(TEST_PATH3)); UTEST_ASSERT(spath.equals(&xstr)); } // status_t remove_base(const char *path); // status_t remove_base(const LSPString *path); // status_t remove_base(const Path *path); void test_remove_base() { Path p, xp; LSPString xs; printf("Testing remove_base...\n"); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(p.remove_base(cnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals("bin")); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.is_empty()); UTEST_ASSERT(xs.set_utf8(TEST_PATH4)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base(&xs) == STATUS_OK); UTEST_ASSERT(p.remove_base(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals("bin")); UTEST_ASSERT(xs.set_utf8(TEST_PATH3)); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base(&xs) == STATUS_OK); UTEST_ASSERT(p.is_empty()); UTEST_ASSERT(xp.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base(&xp) == STATUS_OK); UTEST_ASSERT(p.remove_base(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT(p.equals("bin")); UTEST_ASSERT(xp.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base(&xp) == STATUS_OK); UTEST_ASSERT(p.is_empty()); UTEST_ASSERT(p.set(TEST_PATH3) == STATUS_OK); UTEST_ASSERT(p.remove_base() == STATUS_OK); UTEST_ASSERT(p.equals("bin")); UTEST_ASSERT(p.set(TEST_PATH4) == STATUS_OK); UTEST_ASSERT(p.remove_base() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_PATH4_LAST)); } // void clear() // bool is_absolute() const; // bool is_relative() const; // bool is_empty() const // bool is_root() const; // status_t root(); void test_flags() { Path p; printf("Testing flags...\n"); UTEST_ASSERT(!p.is_absolute()); UTEST_ASSERT(p.is_relative()); UTEST_ASSERT(p.is_empty()); UTEST_ASSERT(!p.is_root()); UTEST_ASSERT(p.root() == STATUS_BAD_STATE); UTEST_ASSERT(p.set(TEST_ROOT) == STATUS_OK); UTEST_ASSERT(p.is_absolute()); UTEST_ASSERT(!p.is_relative()); UTEST_ASSERT(!p.is_empty()); UTEST_ASSERT(p.is_root()); UTEST_ASSERT(p.root() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_ROOT)); UTEST_ASSERT(p.set(TEST_PATH1) == STATUS_OK); UTEST_ASSERT(p.is_absolute()); UTEST_ASSERT(!p.is_relative()); UTEST_ASSERT(!p.is_empty()); UTEST_ASSERT(!p.is_root()); UTEST_ASSERT(p.root() == STATUS_OK); UTEST_ASSERT(p.equals(TEST_ROOT)); UTEST_ASSERT(p.is_root()); UTEST_ASSERT(p.set("bin") == STATUS_OK); UTEST_ASSERT(!p.is_absolute()); UTEST_ASSERT(p.is_relative()); UTEST_ASSERT(!p.is_empty()); UTEST_ASSERT(!p.is_root()); UTEST_ASSERT(p.root() == STATUS_BAD_STATE); UTEST_ASSERT(!p.equals(TEST_ROOT)); UTEST_ASSERT(!p.is_root()); } // status_t get_canonical(char *path, size_t maxlen) const; // status_t get_canonical(LSPString *path) const; // status_t get_canonical(Path *path) const; // bool is_canonical() const; // status_t canonicalize(); void test_canonical() { Path p, xp; LSPString xs; char path[PATH_MAX]; printf("Testing canonical paths...\n"); // UTEST_ASSERT(p.set(TEST_PATH1) == STATUS_OK); // UTEST_ASSERT(p.is_canonical()); // UTEST_ASSERT(p.set(TEST_ROOT) == STATUS_OK); // UTEST_ASSERT(p.is_canonical()); // p.clear(); // UTEST_ASSERT(p.is_canonical()); for (const char **cp=cpaths; *cp != NULL; cp += 2) { printf(" testing \"%s\" -> \"%s\"\n", cp[0], cp[1]); UTEST_ASSERT(p.set(cp[0]) == STATUS_OK); UTEST_ASSERT(!p.is_canonical()); UTEST_ASSERT(p.get_canonical(path, PATH_MAX) == STATUS_OK); UTEST_ASSERT(p.get_canonical(cnull, PATH_MAX) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT_MSG(strcmp(path, cp[1]) == 0, "canonicalized: \"%s\" -> \"%s\"\n", p.get(), path); UTEST_ASSERT(p.equals(cp[0])); UTEST_ASSERT(p.get_canonical(&xp) == STATUS_OK); UTEST_ASSERT(p.get_canonical(pnull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT_MSG(xp.equals(cp[1]), "canonicalized: \"%s\" -> \"%s\"\n", p.get(), xp.get()); UTEST_ASSERT(p.equals(cp[0])); UTEST_ASSERT(p.get_canonical(&xs) == STATUS_OK); UTEST_ASSERT(p.get_canonical(snull) == STATUS_BAD_ARGUMENTS); UTEST_ASSERT_MSG(xp.equals(&xs), "canonicalized: \"%s\" -> \"%s\"\n", p.get(), xs.get_utf8()); UTEST_ASSERT(p.equals(cp[0])); UTEST_ASSERT_MSG(p.canonicalize() == STATUS_OK, "canonicalized: \"%s\" -> \"%s\"\n", cp[0], p.get()); UTEST_ASSERT(p.is_canonical()); UTEST_ASSERT(p.equals(cp[1])); } } void test_dots() { struct dot_t { const char *path; bool dot; bool dotdot; }; static const dot_t dots[] = { { "", false, false }, { ".", true, false }, { "..", false, true }, { "...", false, false }, { FILE_SEPARATOR_S "..", false, true }, { FILE_SEPARATOR_S ".", true, false }, { FILE_SEPARATOR_S "...", false, false }, { FILE_SEPARATOR_S, false, false }, { "." FILE_SEPARATOR_S "a", false, false }, { ".." FILE_SEPARATOR_S "a", false, false }, { "a" FILE_SEPARATOR_S ".", true, false }, { "a" FILE_SEPARATOR_S "..", false, true }, { "a" FILE_SEPARATOR_S "...", false, false }, { NULL, false, false } }; io::Path p; LSPString s; for (const dot_t *d = dots; d->path != NULL; ++d) { printf("Testing \"%s\"\n", d->path); UTEST_ASSERT(Path::is_dot(d->path) == d->dot); UTEST_ASSERT(Path::is_dotdot(d->path) == d->dotdot); UTEST_ASSERT(Path::is_dots(d->path) == (d->dot || d->dotdot)); UTEST_ASSERT(p.set(d->path) == STATUS_OK); UTEST_ASSERT(p.is_dot() == d->dot); UTEST_ASSERT(p.is_dotdot() == d->dotdot); UTEST_ASSERT(p.is_dots() == (d->dot || d->dotdot)); UTEST_ASSERT(Path::is_dot(&p) == d->dot); UTEST_ASSERT(Path::is_dotdot(&p) == d->dotdot); UTEST_ASSERT(Path::is_dots(&p) == (d->dot || d->dotdot)); UTEST_ASSERT(s.set_utf8(d->path)); UTEST_ASSERT(Path::is_dot(&s) == d->dot); UTEST_ASSERT(Path::is_dotdot(&s) == d->dotdot); UTEST_ASSERT(Path::is_dots(&s) == (d->dot || d->dotdot)); } } void test_relative() { struct rel_t { const char *child; const char *base; status_t code; const char *res; }; static const rel_t paths[] = { { "", "", STATUS_NOT_FOUND, "" }, { "", "/", STATUS_NOT_FOUND, NULL }, { "/", "/", STATUS_OK, "" }, { "a", "a", STATUS_OK, "" }, { "abc", "a", STATUS_NOT_FOUND, NULL }, { "a", "abc", STATUS_NOT_FOUND, NULL }, { "/a", "/a", STATUS_OK, "" }, { "/a/b", "/a", STATUS_OK, "b" }, { "/a/b/c", "/a", STATUS_OK, "b/c" }, { "a", "b", STATUS_NOT_FOUND, NULL }, { "/a", "/b", STATUS_OK, "../a" }, { "/b", "/a", STATUS_OK, "../b" }, { "/a/b/c", "/a/b/d", STATUS_OK, "../c" }, { "/a/b", "/a/b/d", STATUS_OK, ".." }, { "/a/", "/a/b/d/", STATUS_OK, "../.." }, { "/a/x", "/a/b/d/", STATUS_OK, "../../x" }, { "/a/c/../b", "/a/../a/b/d", STATUS_OK, ".." }, { NULL, NULL, 0, NULL } }; printf("Testing as_relative() methods...\n"); for (const rel_t *d = paths; d->child != NULL; ++d) { if (d->code == STATUS_OK) printf("Testing \"%s\" - \"%s\" -> \"%s\" \n", d->child, d->base, d->res); else printf("Testing \"%s\" - \"%s\" -> error(%d) \n", d->child, d->base, int(d->code)); io::Path base, child, res; UTEST_ASSERT(base.set(d->base) == STATUS_OK); UTEST_ASSERT(child.set(d->child) == STATUS_OK); status_t code = child.as_relative(&base); UTEST_ASSERT_MSG(code == d->code, "Invalid code %d", int(code)); if (d->code == STATUS_OK) { UTEST_ASSERT(res.set(d->res) == STATUS_OK); UTEST_ASSERT_MSG(child.equals(&res), "Returned path: %s", child.as_utf8()); } } } void test_ext() { struct file_t { const char *path; const char *noext; const char *ext; }; LSPString spath; io::Path ipath; char cpath[32]; static const file_t files[] = { { "", "", ""}, { "a", "a", ""}, { "long_file", "long_file", ""}, { "file.ext", "file", "ext"}, { ".config", "", "config"}, { "file.ext1.ext2", "file.ext1", "ext2"}, { "/path/a", "a", ""}, { "/path/long_file", "long_file", ""}, { "/path/file.ext", "file", "ext"}, { "/path/.config", "", "config"}, { "/path/file.ext1.ext2", "file.ext1", "ext2"}, { NULL, NULL, NULL } }; printf("Testing get_ext() and get_noext() methods...\n"); for (const file_t *f = files; f->path != NULL; ++f) { io::Path tmp; UTEST_ASSERT(tmp.set(f->path) == STATUS_OK); // noext() printf(" testing noext('%s') \n", f->path); UTEST_ASSERT(tmp.get_last_noext(&spath) == STATUS_OK); UTEST_ASSERT(tmp.get_last_noext(&ipath) == STATUS_OK); UTEST_ASSERT(tmp.get_last_noext(cpath, sizeof(cpath)) == STATUS_OK); UTEST_ASSERT(spath.equals_ascii(f->noext)); UTEST_ASSERT(ipath.as_string()->equals_ascii(f->noext)); UTEST_ASSERT(strcmp(cpath, f->noext) == 0); // ext() printf(" testing ext('%s') \n", f->path); UTEST_ASSERT(tmp.get_ext(&spath) == STATUS_OK); UTEST_ASSERT(tmp.get_ext(&ipath) == STATUS_OK); UTEST_ASSERT(tmp.get_ext(cpath, sizeof(cpath)) == STATUS_OK); UTEST_ASSERT(spath.equals_ascii(f->ext)); UTEST_ASSERT(ipath.as_string()->equals_ascii(f->ext)); UTEST_ASSERT(strcmp(cpath, f->ext) == 0); } } UTEST_MAIN { test_get_set(); test_get_set_last(); test_get_set_parent(); test_concat(); test_append_child(); test_remove_last(); test_without_last(); test_remove_first(); test_without_first(); test_remove_base(); test_flags(); test_canonical(); test_dots(); test_relative(); test_ext(); } UTEST_END;