| // path_test program -----------------------------------------------------------------// |
| |
| // Copyright Beman Dawes 2002, 2008 |
| // Copyright Vladimir Prus 2002 |
| |
| // Use, modification, and distribution is subject to the Boost Software |
| // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| // See library home page at http://www.boost.org/libs/filesystem |
| |
| // basic_path's stem(), extension(), and replace_extension() tests are based |
| // on basename(), extension(), and change_extension() tests from the original |
| // convenience_test.cpp by Vladimir Prus. |
| |
| #define BOOST_FILESYSTEM_VERSION 3 |
| |
| #include <boost/config.hpp> |
| |
| # if defined( BOOST_NO_STD_WSTRING ) |
| # error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support |
| # endif |
| |
| #include <boost/config/warning_disable.hpp> |
| |
| // See deprecated_test for tests of deprecated features |
| #ifndef BOOST_FILESYSTEM_NO_DEPRECATED |
| # define BOOST_FILESYSTEM_NO_DEPRECATED |
| #endif |
| #ifndef BOOST_SYSTEM_NO_DEPRECATED |
| # define BOOST_SYSTEM_NO_DEPRECATED |
| #endif |
| |
| #include <boost/filesystem/operations.hpp> |
| #include <boost/utility.hpp> |
| #include <iostream> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| #include <cstring> |
| #include <cassert> |
| |
| namespace fs = boost::filesystem; |
| using boost::filesystem::path; |
| |
| #include <boost/detail/lightweight_test.hpp> |
| |
| #define PATH_CHECK(a, b) check(a, b, __FILE__, __LINE__) |
| #define CHECK_EQUAL(a,b) check_equal(a, b, __FILE__, __LINE__) |
| |
| namespace |
| { |
| std::string platform(BOOST_PLATFORM); |
| |
| void check(const fs::path & source, |
| const std::string & expected, const char* file, int line) |
| { |
| if (source.string() == expected) |
| return; |
| |
| std::cout << file |
| << '(' << line << "): source: \"" << source |
| << "\" != expected: \"" << expected |
| << "\"" << std::endl; |
| |
| ++::boost::detail::test_errors(); |
| } |
| |
| void check_equal(const fs::path & source, |
| const std::string & expected, const char* file, int line) |
| { |
| if (source == expected) return; |
| |
| ++::boost::detail::test_errors(); |
| |
| std::cout << file << '(' << line << "): source: \"" << source |
| << "\" != expected: \"" << expected |
| << "\"" << std::endl; |
| } |
| |
| path p1("fe/fi/fo/fum"); |
| path p2(p1); |
| path p3; |
| path p4("foobar"); |
| path p5; |
| |
| // exception_tests -----------------------------------------------------------------// |
| |
| void exception_tests() |
| { |
| std::cout << "exception_tests..." << std::endl; |
| const std::string str_1("string-1"); |
| boost::system::error_code ec(12345, boost::system::system_category()); |
| try { throw fs::filesystem_error(str_1, ec); } |
| catch (const fs::filesystem_error & ex) |
| { |
| //std::cout << ex.what() << "*" << std::endl; |
| //BOOST_TEST(std::strcmp(ex.what(), |
| // "string-1: Unknown error") == 0); |
| BOOST_TEST(ex.code() == ec); |
| } |
| |
| try { throw fs::filesystem_error(str_1, "p1", "p2", ec); } |
| catch (const fs::filesystem_error & ex) |
| { |
| //std::cout << ex.what() << "*" << std::endl; |
| //BOOST_TEST(std::strcmp(ex.what(), |
| // "string-1: Unknown error: \"p1\", \"p2\"") == 0); |
| BOOST_TEST(ex.code() == ec); |
| BOOST_TEST(ex.path1() == "p1"); |
| BOOST_TEST(ex.path2() == "p2"); |
| } |
| } |
| |
| // overload_tests ------------------------------------------------------------------// |
| |
| // These verify various overloads don't cause compiler errors |
| // They pre-date operations_unit_test.cpp |
| |
| void overload_tests() |
| { |
| std::cout << "overload_tests..." << std::endl; |
| |
| fs::exists(p1); |
| fs::exists("foo"); |
| fs::exists(std::string("foo")); |
| |
| fs::exists(p1 / path("foo")); |
| fs::exists(p1 / "foo"); |
| fs::exists(p1 / std::string("foo")); |
| |
| fs::exists("foo" / p1); |
| fs::exists(std::string("foo") / p1); |
| |
| p4 /= path("foo"); |
| p4 /= "foo"; |
| p4 /= std::string("foo"); |
| } |
| |
| // iterator_tests ------------------------------------------------------------------// |
| |
| void iterator_tests() |
| { |
| std::cout << "iterator_tests..." << std::endl; |
| |
| path itr_ck = ""; |
| path::const_iterator itr = itr_ck.begin(); |
| BOOST_TEST(itr == itr_ck.end()); |
| |
| itr_ck = "/"; |
| itr = itr_ck.begin(); |
| BOOST_TEST(*itr == std::string("/")); |
| BOOST_TEST(++itr == itr_ck.end()); |
| BOOST_TEST(*--itr == std::string("/")); |
| |
| itr_ck = "foo"; |
| BOOST_TEST(*itr_ck.begin() == std::string("foo")); |
| BOOST_TEST(boost::next(itr_ck.begin()) == itr_ck.end()); |
| BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo")); |
| BOOST_TEST(boost::prior(itr_ck.end()) == itr_ck.begin()); |
| |
| itr_ck = path("/foo"); |
| BOOST_TEST(*itr_ck.begin() == std::string("/")); |
| BOOST_TEST(*boost::next(itr_ck.begin()) == std::string("foo")); |
| BOOST_TEST(boost::next(boost::next(itr_ck.begin())) == itr_ck.end()); |
| BOOST_TEST(boost::next(itr_ck.begin()) == boost::prior(itr_ck.end())); |
| BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo")); |
| BOOST_TEST(*boost::prior(boost::prior(itr_ck.end())) == std::string("/")); |
| BOOST_TEST(boost::prior(boost::prior(itr_ck.end())) == itr_ck.begin()); |
| |
| itr_ck = "/foo/bar"; |
| itr = itr_ck.begin(); |
| BOOST_TEST(*itr == std::string("/")); |
| BOOST_TEST(*++itr == std::string("foo")); |
| BOOST_TEST(*++itr == std::string("bar")); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "bar"); |
| CHECK_EQUAL(*--itr, "foo"); |
| CHECK_EQUAL(*--itr, "/"); |
| |
| itr_ck = "../f"; // previously failed due to short name bug |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, ".."); |
| CHECK_EQUAL(*++itr, "f"); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "f"); |
| CHECK_EQUAL(*--itr, ".."); |
| |
| // POSIX says treat "/foo/bar/" as "/foo/bar/." |
| itr_ck = "/foo/bar/"; |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, "/"); |
| CHECK_EQUAL(*++itr, "foo"); |
| CHECK_EQUAL(*++itr, "bar"); |
| CHECK_EQUAL(*++itr, "."); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "."); |
| CHECK_EQUAL(*--itr, "bar"); |
| CHECK_EQUAL(*--itr, "foo"); |
| CHECK_EQUAL(*--itr, "/"); |
| |
| // POSIX says treat "/f/b/" as "/f/b/." |
| itr_ck = "/f/b/"; |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, "/"); |
| CHECK_EQUAL(*++itr, "f"); |
| CHECK_EQUAL(*++itr, "b"); |
| CHECK_EQUAL(*++itr, "."); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "."); |
| CHECK_EQUAL(*--itr, "b"); |
| CHECK_EQUAL(*--itr, "f"); |
| CHECK_EQUAL(*--itr, "/"); |
| |
| itr_ck = "//net"; |
| itr = itr_ck.begin(); |
| // two leading slashes are permitted by POSIX (as implementation defined), |
| // while for Windows it is always well defined (as a network name) |
| CHECK_EQUAL(*itr, "//net"); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "//net"); |
| |
| itr_ck = "//net/"; |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, "//net"); |
| CHECK_EQUAL(*++itr, "/"); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "/"); |
| CHECK_EQUAL(*--itr, "//net"); |
| |
| itr_ck = "//foo///bar///"; |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, "//foo"); |
| CHECK_EQUAL(*++itr, "/"); |
| CHECK_EQUAL(*++itr, "bar"); |
| CHECK_EQUAL(*++itr, "."); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "."); |
| CHECK_EQUAL(*--itr, "bar"); |
| CHECK_EQUAL(*--itr, "/"); |
| CHECK_EQUAL(*--itr, "//foo"); |
| |
| itr_ck = "///foo///bar///"; |
| itr = itr_ck.begin(); |
| // three or more leading slashes are to be treated as a single slash |
| CHECK_EQUAL(*itr, "/"); |
| CHECK_EQUAL(*++itr, "foo"); |
| CHECK_EQUAL(*++itr, "bar"); |
| CHECK_EQUAL(*++itr, "."); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "."); |
| CHECK_EQUAL(*--itr, "bar"); |
| CHECK_EQUAL(*--itr, "foo"); |
| CHECK_EQUAL(*--itr, "/"); |
| |
| if (platform == "Windows") |
| { |
| itr_ck = "c:/"; |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, "c:"); |
| CHECK_EQUAL(*++itr, "/"); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "/"); |
| CHECK_EQUAL(*--itr, "c:"); |
| |
| itr_ck = "c:\\foo"; |
| itr = itr_ck.begin(); |
| BOOST_TEST(*itr == std::string("c:")); |
| BOOST_TEST(*++itr == std::string("/")); |
| BOOST_TEST(*++itr == std::string("foo")); |
| BOOST_TEST(++itr == itr_ck.end()); |
| BOOST_TEST(*--itr == std::string("foo")); |
| BOOST_TEST(*--itr == std::string("/")); |
| BOOST_TEST(*--itr == std::string("c:")); |
| |
| itr_ck = "\\\\\\foo\\\\\\bar\\\\\\"; |
| itr = itr_ck.begin(); |
| // three or more leading slashes are to be treated as a single slash |
| CHECK_EQUAL(*itr, "/"); |
| CHECK_EQUAL(*++itr, "foo"); |
| CHECK_EQUAL(*++itr, "bar"); |
| CHECK_EQUAL(*++itr, "."); |
| BOOST_TEST(++itr == itr_ck.end()); |
| CHECK_EQUAL(*--itr, "."); |
| CHECK_EQUAL(*--itr, "bar"); |
| CHECK_EQUAL(*--itr, "foo"); |
| CHECK_EQUAL(*--itr, "/"); |
| |
| itr_ck = "c:foo"; |
| itr = itr_ck.begin(); |
| BOOST_TEST(*itr == std::string("c:")); |
| BOOST_TEST(*++itr == std::string("foo")); |
| BOOST_TEST(++itr == itr_ck.end()); |
| BOOST_TEST(*--itr == std::string("foo")); |
| BOOST_TEST(*--itr == std::string("c:")); |
| |
| itr_ck = "c:foo/"; |
| itr = itr_ck.begin(); |
| BOOST_TEST(*itr == std::string("c:")); |
| BOOST_TEST(*++itr == std::string("foo")); |
| BOOST_TEST(*++itr == std::string(".")); |
| BOOST_TEST(++itr == itr_ck.end()); |
| BOOST_TEST(*--itr == std::string(".")); |
| BOOST_TEST(*--itr == std::string("foo")); |
| BOOST_TEST(*--itr == std::string("c:")); |
| |
| itr_ck = path("c:"); |
| BOOST_TEST(*itr_ck.begin() == std::string("c:")); |
| BOOST_TEST(next(itr_ck.begin()) == itr_ck.end()); |
| BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("c:")); |
| |
| itr_ck = path("c:/"); |
| BOOST_TEST(*itr_ck.begin() == std::string("c:")); |
| BOOST_TEST(*next(itr_ck.begin()) == std::string("/")); |
| BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end()); |
| BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("/")); |
| BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:")); |
| |
| itr_ck = path("c:foo"); |
| BOOST_TEST(*itr_ck.begin() == std::string("c:")); |
| BOOST_TEST(*next(itr_ck.begin()) == std::string("foo")); |
| BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end()); |
| BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("foo")); |
| BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:")); |
| |
| itr_ck = path("c:/foo"); |
| BOOST_TEST(*itr_ck.begin() == std::string("c:")); |
| BOOST_TEST(*next(itr_ck.begin()) == std::string("/")); |
| BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo")); |
| BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end()); |
| BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("foo")); |
| BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/")); |
| BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("c:")); |
| |
| itr_ck = path("//net"); |
| BOOST_TEST(*itr_ck.begin() == std::string("//net")); |
| BOOST_TEST(next(itr_ck.begin()) == itr_ck.end()); |
| BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("//net")); |
| |
| itr_ck = path("//net/"); |
| CHECK_EQUAL(*itr_ck.begin(), "//net"); |
| CHECK_EQUAL(*next(itr_ck.begin()), "/"); |
| BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end()); |
| BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin()); |
| CHECK_EQUAL(*prior(itr_ck.end()), "/"); |
| CHECK_EQUAL(*prior(prior(itr_ck.end())), "//net"); |
| |
| itr_ck = path("//net/foo"); |
| BOOST_TEST(*itr_ck.begin() == std::string("//net")); |
| BOOST_TEST(*next(itr_ck.begin()) == std::string("/")); |
| BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo")); |
| BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end()); |
| BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("foo")); |
| BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/")); |
| BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("//net")); |
| |
| itr_ck = path("prn:"); |
| BOOST_TEST(*itr_ck.begin() == std::string("prn:")); |
| BOOST_TEST(next(itr_ck.begin()) == itr_ck.end()); |
| BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin()); |
| BOOST_TEST(*prior(itr_ck.end()) == std::string("prn:")); |
| } |
| else |
| { |
| itr_ck = "///"; |
| itr = itr_ck.begin(); |
| CHECK_EQUAL(*itr, "/"); |
| BOOST_TEST(++itr == itr_ck.end()); |
| } |
| } |
| |
| // non_member_tests ----------------------------------------------------------------// |
| |
| void non_member_tests() |
| { |
| std::cout << "non_member_tests..." << std::endl; |
| |
| // test non-member functions, particularly operator overloads |
| |
| path e, e2; |
| std::string es, es2; |
| char ecs[] = ""; |
| char ecs2[] = ""; |
| |
| char acs[] = "a"; |
| std::string as(acs); |
| path a(as); |
| |
| char acs2[] = "a"; |
| std::string as2(acs2); |
| path a2(as2); |
| |
| char bcs[] = "b"; |
| std::string bs(bcs); |
| path b(bs); |
| |
| // swap |
| a.swap(b); |
| BOOST_TEST(a.string() == "b"); |
| BOOST_TEST(b.string() == "a"); |
| fs::swap(a, b); |
| BOOST_TEST(a.string() == "a"); |
| BOOST_TEST(b.string() == "b"); |
| |
| // probe operator / |
| PATH_CHECK(path("") / ".", "."); |
| PATH_CHECK(path("") / "..", ".."); |
| if (platform == "Windows") |
| { |
| BOOST_TEST(path("foo\\bar") == "foo/bar"); |
| BOOST_TEST((b / a).string() == "b\\a"); |
| BOOST_TEST((bs / a).string() == "b\\a"); |
| BOOST_TEST((bcs / a).string() == "b\\a"); |
| BOOST_TEST((b / as).string() == "b\\a"); |
| BOOST_TEST((b / acs).string() == "b\\a"); |
| PATH_CHECK(path("a") / "b", "a\\b"); |
| PATH_CHECK(path("..") / "", ".."); |
| PATH_CHECK(path("foo") / path("bar"), "foo\\bar"); // path arg |
| PATH_CHECK(path("foo") / "bar", "foo\\bar"); // const char* arg |
| PATH_CHECK(path("foo") / path("woo/bar").filename(), "foo\\bar"); // const std::string & arg |
| PATH_CHECK("foo" / path("bar"), "foo\\bar"); |
| PATH_CHECK(path("..") / ".." , "..\\.."); |
| PATH_CHECK(path("/") / ".." , "/.."); |
| PATH_CHECK(path("/..") / ".." , "/..\\.."); |
| PATH_CHECK(path("..") / "foo" , "..\\foo"); |
| PATH_CHECK(path("foo") / ".." , "foo\\.."); |
| PATH_CHECK(path("..") / "f" , "..\\f"); |
| PATH_CHECK(path("/..") / "f" , "/..\\f"); |
| PATH_CHECK(path("f") / ".." , "f\\.."); |
| PATH_CHECK(path("foo") / ".." / ".." , "foo\\..\\.."); |
| PATH_CHECK(path("foo") / ".." / ".." / ".." , "foo\\..\\..\\.."); |
| PATH_CHECK(path("f") / ".." / "b" , "f\\..\\b"); |
| PATH_CHECK(path("foo") / ".." / "bar" , "foo\\..\\bar"); |
| PATH_CHECK(path("foo") / "bar" / ".." , "foo\\bar\\.."); |
| PATH_CHECK(path("foo") / "bar" / ".." / "..", "foo\\bar\\..\\.."); |
| PATH_CHECK(path("foo") / "bar" / ".." / "blah", "foo\\bar\\..\\blah"); |
| PATH_CHECK(path("f") / "b" / ".." , "f\\b\\.."); |
| PATH_CHECK(path("f") / "b" / ".." / "a", "f\\b\\..\\a"); |
| PATH_CHECK(path("foo") / "bar" / "blah" / ".." / "..", "foo\\bar\\blah\\..\\.."); |
| PATH_CHECK(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo\\bar\\blah\\..\\..\\bletch"); |
| |
| PATH_CHECK(path(".") / "foo", ".\\foo"); |
| PATH_CHECK(path(".") / "..", ".\\.."); |
| PATH_CHECK(path("foo") / ".", "foo\\."); |
| PATH_CHECK(path("..") / ".", "..\\."); |
| PATH_CHECK(path(".") / ".", ".\\."); |
| PATH_CHECK(path(".") / "." / ".", ".\\.\\."); |
| PATH_CHECK(path(".") / "foo" / ".", ".\\foo\\."); |
| PATH_CHECK(path("foo") / "." / "bar", "foo\\.\\bar"); |
| PATH_CHECK(path("foo") / "." / ".", "foo\\.\\."); |
| PATH_CHECK(path("foo") / "." / "..", "foo\\.\\.."); |
| PATH_CHECK(path(".") / "." / "..", ".\\.\\.."); |
| PATH_CHECK(path(".") / ".." / ".", ".\\..\\."); |
| PATH_CHECK(path("..") / "." / ".", "..\\.\\."); |
| } |
| else // POSIX |
| { |
| BOOST_TEST((b / a).string() == "b/a"); |
| BOOST_TEST((bs / a).string() == "b/a"); |
| BOOST_TEST((bcs / a).string() == "b/a"); |
| BOOST_TEST((b / as).string() == "b/a"); |
| BOOST_TEST((b / acs).string() == "b/a"); |
| PATH_CHECK(path("a") / "b", "a/b"); |
| PATH_CHECK(path("..") / "", ".."); |
| PATH_CHECK(path("") / "..", ".."); |
| PATH_CHECK(path("foo") / path("bar"), "foo/bar"); // path arg |
| PATH_CHECK(path("foo") / "bar", "foo/bar"); // const char* arg |
| PATH_CHECK(path("foo") / path("woo/bar").filename(), "foo/bar"); // const std::string & arg |
| PATH_CHECK("foo" / path("bar"), "foo/bar"); |
| PATH_CHECK(path("..") / ".." , "../.."); |
| PATH_CHECK(path("/") / ".." , "/.."); |
| PATH_CHECK(path("/..") / ".." , "/../.."); |
| PATH_CHECK(path("..") / "foo" , "../foo"); |
| PATH_CHECK(path("foo") / ".." , "foo/.."); |
| PATH_CHECK(path("..") / "f" , "../f"); |
| PATH_CHECK(path("/..") / "f" , "/../f"); |
| PATH_CHECK(path("f") / ".." , "f/.."); |
| PATH_CHECK(path("foo") / ".." / ".." , "foo/../.."); |
| PATH_CHECK(path("foo") / ".." / ".." / ".." , "foo/../../.."); |
| PATH_CHECK(path("f") / ".." / "b" , "f/../b"); |
| PATH_CHECK(path("foo") / ".." / "bar" , "foo/../bar"); |
| PATH_CHECK(path("foo") / "bar" / ".." , "foo/bar/.."); |
| PATH_CHECK(path("foo") / "bar" / ".." / "..", "foo/bar/../.."); |
| PATH_CHECK(path("foo") / "bar" / ".." / "blah", "foo/bar/../blah"); |
| PATH_CHECK(path("f") / "b" / ".." , "f/b/.."); |
| PATH_CHECK(path("f") / "b" / ".." / "a", "f/b/../a"); |
| PATH_CHECK(path("foo") / "bar" / "blah" / ".." / "..", "foo/bar/blah/../.."); |
| PATH_CHECK(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo/bar/blah/../../bletch"); |
| |
| PATH_CHECK(path(".") / "foo", "./foo"); |
| PATH_CHECK(path(".") / "..", "./.."); |
| PATH_CHECK(path("foo") / ".", "foo/."); |
| PATH_CHECK(path("..") / ".", "../."); |
| PATH_CHECK(path(".") / ".", "./."); |
| PATH_CHECK(path(".") / "." / ".", "././."); |
| PATH_CHECK(path(".") / "foo" / ".", "./foo/."); |
| PATH_CHECK(path("foo") / "." / "bar", "foo/./bar"); |
| PATH_CHECK(path("foo") / "." / ".", "foo/./."); |
| PATH_CHECK(path("foo") / "." / "..", "foo/./.."); |
| PATH_CHECK(path(".") / "." / "..", "././.."); |
| PATH_CHECK(path(".") / ".." / ".", "./../."); |
| PATH_CHECK(path("..") / "." / ".", ".././."); |
| } |
| |
| // probe operator < |
| BOOST_TEST(!(e < e2)); |
| BOOST_TEST(!(es < e2)); |
| BOOST_TEST(!(ecs < e2)); |
| BOOST_TEST(!(e < es2)); |
| BOOST_TEST(!(e < ecs2)); |
| |
| BOOST_TEST(e < a); |
| BOOST_TEST(es < a); |
| BOOST_TEST(ecs < a); |
| BOOST_TEST(e < as); |
| BOOST_TEST(e < acs); |
| |
| BOOST_TEST(a < b); |
| BOOST_TEST(as < b); |
| BOOST_TEST(acs < b); |
| BOOST_TEST(a < bs); |
| BOOST_TEST(a < bcs); |
| |
| BOOST_TEST(!(a < a2)); |
| BOOST_TEST(!(as < a2)); |
| BOOST_TEST(!(acs < a2)); |
| BOOST_TEST(!(a < as2)); |
| BOOST_TEST(!(a < acs2)); |
| |
| // make sure basic_path overloads don't conflict with std::string overloads |
| |
| BOOST_TEST(!(as < as)); |
| BOOST_TEST(!(as < acs)); |
| BOOST_TEST(!(acs < as)); |
| |
| // reality check character set is as expected |
| BOOST_TEST(std::string("a.b") < std::string("a/b")); |
| // verify compare is actually lexicographical |
| BOOST_TEST(path("a/b") < path("a.b")); |
| |
| // make sure the derivative operators also work |
| |
| BOOST_TEST(b > a); |
| BOOST_TEST(b > as); |
| BOOST_TEST(b > acs); |
| BOOST_TEST(bs > a); |
| BOOST_TEST(bcs > a); |
| |
| BOOST_TEST(!(a2 > a)); |
| BOOST_TEST(!(a2 > as)); |
| BOOST_TEST(!(a2 > acs)); |
| BOOST_TEST(!(as2 > a)); |
| BOOST_TEST(!(acs2 > a)); |
| |
| BOOST_TEST(a <= b); |
| BOOST_TEST(as <= b); |
| BOOST_TEST(acs <= b); |
| BOOST_TEST(a <= bs); |
| BOOST_TEST(a <= bcs); |
| |
| BOOST_TEST(a <= a2); |
| BOOST_TEST(as <= a2); |
| BOOST_TEST(acs <= a2); |
| BOOST_TEST(a <= as2); |
| BOOST_TEST(a <= acs2); |
| |
| BOOST_TEST(b >= a); |
| BOOST_TEST(bs >= a); |
| BOOST_TEST(bcs >= a); |
| BOOST_TEST(b >= as); |
| BOOST_TEST(b >= acs); |
| |
| BOOST_TEST(a2 >= a); |
| BOOST_TEST(as2 >= a); |
| BOOST_TEST(acs2 >= a); |
| BOOST_TEST(a2 >= as); |
| BOOST_TEST(a2 >= acs); |
| |
| // operator == and != are implemented separately, so test separately |
| |
| path p1("fe/fi/fo/fum"); |
| path p2(p1); |
| path p3("fe/fi/fo/fumm"); |
| BOOST_TEST(p1.string() != p3.string()); |
| |
| // check each overload |
| BOOST_TEST(p1 != p3); |
| BOOST_TEST(p1 != p3.string()); |
| BOOST_TEST(p1 != p3.string().c_str()); |
| BOOST_TEST(p1.string() != p3); |
| BOOST_TEST(p1.string().c_str() != p3); |
| |
| p3 = p2; |
| BOOST_TEST(p1.string() == p3.string()); |
| |
| // check each overload |
| BOOST_TEST(p1 == p3); |
| BOOST_TEST(p1 == p3.string()); |
| BOOST_TEST(p1 == p3.string().c_str()); |
| BOOST_TEST(p1.string() == p3); |
| BOOST_TEST(p1.string().c_str() == p3); |
| |
| if (platform == "Windows") |
| { |
| std::cout << "Windows relational tests..." << std::endl; |
| path p10 ("c:\\file"); |
| path p11 ("c:/file"); |
| // check each overload |
| BOOST_TEST(p10.generic_string() == p11.generic_string()); |
| BOOST_TEST(p10 == p11); |
| BOOST_TEST(p10 == p11.string()); |
| BOOST_TEST(p10 == p11.string().c_str()); |
| BOOST_TEST(p10.string() == p11); |
| BOOST_TEST(p10.string().c_str() == p11); |
| BOOST_TEST(p10 == L"c:\\file"); |
| BOOST_TEST(p10 == L"c:/file"); |
| BOOST_TEST(p11 == L"c:\\file"); |
| BOOST_TEST(p11 == L"c:/file"); |
| BOOST_TEST(L"c:\\file" == p10); |
| BOOST_TEST(L"c:/file" == p10); |
| BOOST_TEST(L"c:\\file" == p11); |
| BOOST_TEST(L"c:/file" == p11); |
| |
| BOOST_TEST(!(p10.generic_string() != p11.generic_string())); |
| BOOST_TEST(!(p10 != p11)); |
| BOOST_TEST(!(p10 != p11.string())); |
| BOOST_TEST(!(p10 != p11.string().c_str())); |
| BOOST_TEST(!(p10.string() != p11)); |
| BOOST_TEST(!(p10.string().c_str() != p11)); |
| BOOST_TEST(!(p10 != L"c:\\file")); |
| BOOST_TEST(!(p10 != L"c:/file")); |
| BOOST_TEST(!(p11 != L"c:\\file")); |
| BOOST_TEST(!(p11 != L"c:/file")); |
| BOOST_TEST(!(L"c:\\file" != p10)); |
| BOOST_TEST(!(L"c:/file" != p10)); |
| BOOST_TEST(!(L"c:\\file" != p11)); |
| BOOST_TEST(!(L"c:/file" != p11)); |
| |
| BOOST_TEST(!(p10.string() < p11.string())); |
| BOOST_TEST(!(p10 < p11)); |
| BOOST_TEST(!(p10 < p11.string())); |
| BOOST_TEST(!(p10 < p11.string().c_str())); |
| BOOST_TEST(!(p10.string() < p11)); |
| BOOST_TEST(!(p10.string().c_str() < p11)); |
| BOOST_TEST(!(p10 < L"c:\\file")); |
| BOOST_TEST(!(p10 < L"c:/file")); |
| BOOST_TEST(!(p11 < L"c:\\file")); |
| BOOST_TEST(!(p11 < L"c:/file")); |
| BOOST_TEST(!(L"c:\\file" < p10)); |
| BOOST_TEST(!(L"c:/file" < p10)); |
| BOOST_TEST(!(L"c:\\file" < p11)); |
| BOOST_TEST(!(L"c:/file" < p11)); |
| |
| BOOST_TEST(!(p10.generic_string() > p11.generic_string())); |
| BOOST_TEST(!(p10 > p11)); |
| BOOST_TEST(!(p10 > p11.string())); |
| BOOST_TEST(!(p10 > p11.string().c_str())); |
| BOOST_TEST(!(p10.string() > p11)); |
| BOOST_TEST(!(p10.string().c_str() > p11)); |
| BOOST_TEST(!(p10 > L"c:\\file")); |
| BOOST_TEST(!(p10 > L"c:/file")); |
| BOOST_TEST(!(p11 > L"c:\\file")); |
| BOOST_TEST(!(p11 > L"c:/file")); |
| BOOST_TEST(!(L"c:\\file" > p10)); |
| BOOST_TEST(!(L"c:/file" > p10)); |
| BOOST_TEST(!(L"c:\\file" > p11)); |
| BOOST_TEST(!(L"c:/file" > p11)); |
| } |
| } |
| |
| // query_and_decomposition_tests ---------------------------------------------------// |
| // |
| // remove_filename() is also tested here, because its specification depends on |
| // a decomposition function. |
| |
| void query_and_decomposition_tests() |
| { |
| std::cout << "query_and_decomposition_tests..." << std::endl; |
| |
| // stem() tests not otherwise covered |
| BOOST_TEST(path("b").stem() == "b"); |
| BOOST_TEST(path("a/b.txt").stem() == "b"); |
| BOOST_TEST(path("a/b.").stem() == "b"); |
| BOOST_TEST(path("a.b.c").stem() == "a.b"); |
| BOOST_TEST(path("a.b.c.").stem() == "a.b.c"); |
| |
| // extension() tests not otherwise covered |
| BOOST_TEST(path("a/b").extension() == ""); |
| BOOST_TEST(path("a.b/c").extension() == ""); |
| BOOST_TEST(path("a/b.txt").extension() == ".txt"); |
| BOOST_TEST(path("a/b.").extension() == "."); |
| BOOST_TEST(path("a.b.c").extension() == ".c"); |
| BOOST_TEST(path("a.b.c.").extension() == "."); |
| BOOST_TEST(path("a/").extension() == ""); |
| |
| // main q & d test sequence |
| path p; |
| path q; |
| |
| p = q = ""; |
| BOOST_TEST(p.relative_path().string() == ""); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == ""); |
| BOOST_TEST(p.stem() == ""); |
| BOOST_TEST(p.extension() == ""); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(!p.has_filename()); |
| BOOST_TEST(!p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "/"; |
| BOOST_TEST(p.relative_path().string() == ""); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "/"); |
| BOOST_TEST(p.stem() == "/"); |
| BOOST_TEST(p.extension() == ""); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == "/"); |
| BOOST_TEST(p.root_path().string() == "/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| if (platform == "POSIX") |
| BOOST_TEST(p.is_absolute()); |
| else |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "//"; |
| CHECK_EQUAL(p.relative_path().string(), ""); |
| CHECK_EQUAL(p.parent_path().string(), ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "//"); |
| CHECK_EQUAL(p.stem(), "//"); |
| CHECK_EQUAL(p.extension(), ""); |
| CHECK_EQUAL(p.root_name(), "//"); |
| CHECK_EQUAL(p.root_directory(), ""); |
| CHECK_EQUAL(p.root_path().string(), "//"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "///"; |
| CHECK_EQUAL(p.relative_path().string(), ""); |
| CHECK_EQUAL(p.parent_path().string(), ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "/"); |
| CHECK_EQUAL(p.stem(), "/"); |
| CHECK_EQUAL(p.extension(), ""); |
| CHECK_EQUAL(p.root_name(), ""); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| if (platform == "POSIX") |
| BOOST_TEST(p.is_absolute()); |
| else |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "."; |
| BOOST_TEST(p.relative_path().string() == "."); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "."); |
| BOOST_TEST(p.stem() == "."); |
| BOOST_TEST(p.extension() == ""); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = ".."; |
| BOOST_TEST(p.relative_path().string() == ".."); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == ".."); |
| BOOST_TEST(p.stem() == ".."); |
| BOOST_TEST(p.extension() == ""); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "foo"; |
| BOOST_TEST(p.relative_path().string() == "foo"); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "foo"); |
| BOOST_TEST(p.stem() == "foo"); |
| BOOST_TEST(p.extension() == ""); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "/foo"; |
| CHECK_EQUAL(p.relative_path().string(), "foo"); |
| CHECK_EQUAL(p.parent_path().string(), "/"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.stem(), "foo"); |
| CHECK_EQUAL(p.extension(), ""); |
| CHECK_EQUAL(p.root_name(), ""); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(p.has_parent_path()); |
| if (platform == "POSIX") |
| BOOST_TEST(p.is_absolute()); |
| else |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "/foo/"; |
| CHECK_EQUAL(p.relative_path().string(), "foo/"); |
| CHECK_EQUAL(p.parent_path().string(), "/foo"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "."); |
| CHECK_EQUAL(p.stem(), "."); |
| CHECK_EQUAL(p.extension(), ""); |
| CHECK_EQUAL(p.root_name(), ""); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(p.has_parent_path()); |
| if (platform == "POSIX") |
| BOOST_TEST(p.is_absolute()); |
| else |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "///foo"; |
| CHECK_EQUAL(p.relative_path().string(), "foo"); |
| CHECK_EQUAL(p.parent_path().string(), "/"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.root_name(), ""); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| if (platform == "POSIX") |
| BOOST_TEST(p.is_absolute()); |
| else |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "foo/bar"; |
| BOOST_TEST(p.relative_path().string() == "foo/bar"); |
| BOOST_TEST(p.parent_path().string() == "foo"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "bar"); |
| BOOST_TEST(p.stem() == "bar"); |
| BOOST_TEST(p.extension() == ""); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_stem()); |
| BOOST_TEST(!p.has_extension()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "../foo"; |
| BOOST_TEST(p.relative_path().string() == "../foo"); |
| BOOST_TEST(p.parent_path().string() == ".."); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "foo"); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "..///foo"; |
| CHECK_EQUAL(p.relative_path().string(), "..///foo"); |
| CHECK_EQUAL(p.parent_path().string(), ".."); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.root_name(), ""); |
| CHECK_EQUAL(p.root_directory(), ""); |
| CHECK_EQUAL(p.root_path().string(), ""); |
| BOOST_TEST(!p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = "/foo/bar"; |
| BOOST_TEST(p.relative_path().string() == "foo/bar"); |
| BOOST_TEST(p.parent_path().string() == "/foo"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "bar"); |
| BOOST_TEST(p.root_name() == ""); |
| BOOST_TEST(p.root_directory() == "/"); |
| BOOST_TEST(p.root_path().string() == "/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(!p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| if (platform == "POSIX") |
| BOOST_TEST(p.is_absolute()); |
| else |
| BOOST_TEST(!p.is_absolute()); |
| |
| // Both POSIX and Windows allow two leading slashs |
| // (POSIX meaning is implementation defined) |
| PATH_CHECK(path("//resource"), "//resource"); |
| PATH_CHECK(path("//resource/"), "//resource/"); |
| PATH_CHECK(path("//resource/foo"), "//resource/foo"); |
| |
| p = q = path("//net"); |
| CHECK_EQUAL(p.string(), "//net"); |
| CHECK_EQUAL(p.relative_path().string(), ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.parent_path().string(), ""); |
| CHECK_EQUAL(p.filename(), "//net"); |
| CHECK_EQUAL(p.root_name(), "//net"); |
| CHECK_EQUAL(p.root_directory(), ""); |
| CHECK_EQUAL(p.root_path().string(), "//net"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = path("//net/"); |
| BOOST_TEST(p.relative_path().string() == ""); |
| BOOST_TEST(p.parent_path().string() == "//net"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "/"); |
| BOOST_TEST(p.root_name() == "//net"); |
| BOOST_TEST(p.root_directory() == "/"); |
| BOOST_TEST(p.root_path().string() == "//net/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| p = q = path("//net/foo"); |
| BOOST_TEST(p.relative_path().string() == "foo"); |
| BOOST_TEST(p.parent_path().string() == "//net/"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "foo"); |
| BOOST_TEST(p.root_name() == "//net"); |
| BOOST_TEST(p.root_directory() == "/"); |
| BOOST_TEST(p.root_path().string() == "//net/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| p = q = path("//net///foo"); |
| CHECK_EQUAL(p.relative_path().string(), "foo"); |
| CHECK_EQUAL(p.parent_path().string(), "//net/"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.root_name(), "//net"); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "//net/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| if (platform == "Windows") |
| { |
| |
| p = q = path("c:"); |
| BOOST_TEST(p.relative_path().string() == ""); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "c:"); |
| BOOST_TEST(p.root_name() == "c:"); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == "c:"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = path("c:foo"); |
| BOOST_TEST(p.relative_path().string() == "foo"); |
| BOOST_TEST(p.parent_path().string() == "c:"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "foo"); |
| BOOST_TEST(p.root_name() == "c:"); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == "c:"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = path("c:/"); |
| BOOST_TEST(p.relative_path().string() == ""); |
| BOOST_TEST(p.parent_path().string() == "c:"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "/"); |
| BOOST_TEST(p.root_name() == "c:"); |
| BOOST_TEST(p.root_directory() == "/"); |
| BOOST_TEST(p.root_path().string() == "c:/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| p = q = path("c:.."); |
| BOOST_TEST(p.relative_path().string() == ".."); |
| BOOST_TEST(p.parent_path().string() == "c:"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == ".."); |
| BOOST_TEST(p.root_name() == "c:"); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == "c:"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = path("c:/foo"); |
| CHECK_EQUAL(p.relative_path().string(), "foo"); |
| CHECK_EQUAL(p.parent_path().string(), "c:/"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.root_name(), "c:"); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "c:/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| p = q = path("c://foo"); |
| CHECK_EQUAL(p.relative_path().string(), "foo"); |
| CHECK_EQUAL(p.parent_path().string(), "c:/"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.root_name(), "c:"); |
| CHECK_EQUAL(p.root_directory(), "/"); |
| CHECK_EQUAL(p.root_path().string(), "c:/"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| p = q = path("c:\\foo\\bar"); |
| CHECK_EQUAL(p.relative_path().string(), "foo\\bar"); |
| CHECK_EQUAL(p.parent_path().string(), "c:\\foo"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "bar"); |
| CHECK_EQUAL(p.root_name(), "c:"); |
| CHECK_EQUAL(p.root_directory(), "\\"); |
| CHECK_EQUAL(p.root_path().string(), "c:\\"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| |
| p = q = path("prn:"); |
| BOOST_TEST(p.relative_path().string() == ""); |
| BOOST_TEST(p.parent_path().string() == ""); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| BOOST_TEST(p.filename() == "prn:"); |
| BOOST_TEST(p.root_name() == "prn:"); |
| BOOST_TEST(p.root_directory() == ""); |
| BOOST_TEST(p.root_path().string() == "prn:"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(!p.has_root_directory()); |
| BOOST_TEST(!p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(!p.has_parent_path()); |
| BOOST_TEST(!p.is_absolute()); |
| |
| p = q = path("\\\\net\\\\\\foo"); |
| CHECK_EQUAL(p.relative_path().string(), "foo"); |
| CHECK_EQUAL(p.parent_path().string(), "\\\\net\\"); |
| BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); |
| CHECK_EQUAL(p.filename(), "foo"); |
| CHECK_EQUAL(p.root_name(), "\\\\net"); |
| CHECK_EQUAL(p.root_directory(), "\\"); |
| CHECK_EQUAL(p.root_path().string(), "\\\\net\\"); |
| BOOST_TEST(p.has_root_path()); |
| BOOST_TEST(p.has_root_name()); |
| BOOST_TEST(p.has_root_directory()); |
| BOOST_TEST(p.has_relative_path()); |
| BOOST_TEST(p.has_filename()); |
| BOOST_TEST(p.has_parent_path()); |
| BOOST_TEST(p.is_absolute()); |
| } // Windows |
| |
| else |
| { // POSIX |
| PATH_CHECK(path("/foo/bar/"), "/foo/bar/"); |
| PATH_CHECK(path("//foo//bar//"), "//foo//bar//"); |
| PATH_CHECK(path("///foo///bar///"), "///foo///bar///"); |
| |
| p = path("/usr/local/bin:/usr/bin:/bin"); |
| BOOST_TEST(p.string() == "/usr/local/bin:/usr/bin:/bin"); |
| } // POSIX |
| } |
| |
| // composition_tests ----------------------------------------------------------------// |
| |
| void composition_tests() |
| { |
| std::cout << "composition_tests..." << std::endl; |
| |
| } |
| |
| // construction_tests ---------------------------------------------------------------// |
| |
| void construction_tests() |
| { |
| std::cout << "construction_tests..." << std::endl; |
| |
| PATH_CHECK("", ""); |
| |
| PATH_CHECK("foo", "foo"); |
| PATH_CHECK("f", "f"); |
| |
| PATH_CHECK("foo/", "foo/"); |
| PATH_CHECK("f/", "f/"); |
| PATH_CHECK("foo/..", "foo/.."); |
| PATH_CHECK("foo/../", "foo/../"); |
| PATH_CHECK("foo/bar/../..", "foo/bar/../.."); |
| PATH_CHECK("foo/bar/../../", "foo/bar/../../"); |
| PATH_CHECK(path("/"), "/"); |
| PATH_CHECK(path("/f"), "/f"); |
| |
| PATH_CHECK("/foo", "/foo"); |
| PATH_CHECK(path("/foo/bar/"), "/foo/bar/"); |
| PATH_CHECK(path("//foo//bar//"), "//foo//bar//"); |
| PATH_CHECK(path("///foo///bar///"), "///foo///bar///"); |
| PATH_CHECK(path("\\/foo\\/bar\\/"), "\\/foo\\/bar\\/"); |
| PATH_CHECK(path("\\//foo\\//bar\\//"), "\\//foo\\//bar\\//"); |
| |
| if (platform == "Windows") |
| { |
| PATH_CHECK(path("c:") / "foo", "c:foo"); |
| PATH_CHECK(path("c:") / "/foo", "c:/foo"); |
| |
| PATH_CHECK(path("\\foo\\bar\\"), "\\foo\\bar\\"); |
| PATH_CHECK(path("\\\\foo\\\\bar\\\\"), "\\\\foo\\\\bar\\\\"); |
| PATH_CHECK(path("\\\\\\foo\\\\\\bar\\\\\\"), "\\\\\\foo\\\\\\bar\\\\\\"); |
| |
| PATH_CHECK(path("\\"), "\\"); |
| PATH_CHECK(path("\\f"), "\\f"); |
| PATH_CHECK(path("\\foo"), "\\foo"); |
| PATH_CHECK(path("foo\\bar"), "foo\\bar"); |
| PATH_CHECK(path("foo bar"), "foo bar"); |
| PATH_CHECK(path("c:"), "c:"); |
| PATH_CHECK(path("c:/"), "c:/"); |
| PATH_CHECK(path("c:."), "c:."); |
| PATH_CHECK(path("c:./foo"), "c:./foo"); |
| PATH_CHECK(path("c:.\\foo"), "c:.\\foo"); |
| PATH_CHECK(path("c:.."), "c:.."); |
| PATH_CHECK(path("c:/."), "c:/."); |
| PATH_CHECK(path("c:/.."), "c:/.."); |
| PATH_CHECK(path("c:/../"), "c:/../"); |
| PATH_CHECK(path("c:\\..\\"), "c:\\..\\"); |
| PATH_CHECK(path("c:/../.."), "c:/../.."); |
| PATH_CHECK(path("c:/../foo"), "c:/../foo"); |
| PATH_CHECK(path("c:\\..\\foo"), "c:\\..\\foo"); |
| PATH_CHECK(path("c:../foo"), "c:../foo"); |
| PATH_CHECK(path("c:..\\foo"), "c:..\\foo"); |
| PATH_CHECK(path("c:/../../foo"), "c:/../../foo"); |
| PATH_CHECK(path("c:\\..\\..\\foo"), "c:\\..\\..\\foo"); |
| PATH_CHECK(path("c:foo/.."), "c:foo/.."); |
| PATH_CHECK(path("c:/foo/.."), "c:/foo/.."); |
| PATH_CHECK(path("c:/..foo"), "c:/..foo"); |
| PATH_CHECK(path("c:foo"), "c:foo"); |
| PATH_CHECK(path("c:/foo"), "c:/foo"); |
| PATH_CHECK(path("\\\\netname"), "\\\\netname"); |
| PATH_CHECK(path("\\\\netname\\"), "\\\\netname\\"); |
| PATH_CHECK(path("\\\\netname\\foo"), "\\\\netname\\foo"); |
| PATH_CHECK(path("c:/foo"), "c:/foo"); |
| PATH_CHECK(path("prn:"), "prn:"); |
| } |
| else |
| { |
| } |
| |
| PATH_CHECK("foo/bar", "foo/bar"); |
| PATH_CHECK("a/b", "a/b"); // probe for length effects |
| PATH_CHECK("..", ".."); |
| PATH_CHECK("../..", "../.."); |
| PATH_CHECK("/..", "/.."); |
| PATH_CHECK("/../..", "/../.."); |
| PATH_CHECK("../foo", "../foo"); |
| PATH_CHECK("foo/..", "foo/.."); |
| PATH_CHECK(path("foo/..bar"), "foo/..bar"); |
| PATH_CHECK("../f", "../f"); |
| PATH_CHECK("/../f", "/../f"); |
| PATH_CHECK("f/..", "f/.."); |
| PATH_CHECK("foo/../..", "foo/../.."); |
| PATH_CHECK("foo/../../..", "foo/../../.."); |
| PATH_CHECK("foo/../bar", "foo/../bar"); |
| PATH_CHECK("foo/bar/..", "foo/bar/.."); |
| PATH_CHECK("foo/bar/../..", "foo/bar/../.."); |
| PATH_CHECK("foo/bar/../blah", "foo/bar/../blah"); |
| PATH_CHECK("f/../b", "f/../b"); |
| PATH_CHECK("f/b/..", "f/b/.."); |
| PATH_CHECK("f/b/../a", "f/b/../a"); |
| PATH_CHECK("foo/bar/blah/../..", "foo/bar/blah/../.."); |
| PATH_CHECK("foo/bar/blah/../../bletch", "foo/bar/blah/../../bletch"); |
| PATH_CHECK("...", "..."); |
| PATH_CHECK("....", "...."); |
| PATH_CHECK("foo/...", "foo/..."); |
| PATH_CHECK("abc.", "abc."); |
| PATH_CHECK("abc..", "abc.."); |
| PATH_CHECK("foo/abc.", "foo/abc."); |
| PATH_CHECK("foo/abc..", "foo/abc.."); |
| |
| PATH_CHECK(path(".abc"), ".abc"); |
| PATH_CHECK("a.c", "a.c"); |
| PATH_CHECK(path("..abc"), "..abc"); |
| PATH_CHECK("a..c", "a..c"); |
| PATH_CHECK(path("foo/.abc"), "foo/.abc"); |
| PATH_CHECK("foo/a.c", "foo/a.c"); |
| PATH_CHECK(path("foo/..abc"), "foo/..abc"); |
| PATH_CHECK("foo/a..c", "foo/a..c"); |
| |
| PATH_CHECK(".", "."); |
| PATH_CHECK("./foo", "./foo"); |
| PATH_CHECK("./..", "./.."); |
| PATH_CHECK("./../foo", "./../foo"); |
| PATH_CHECK("foo/.", "foo/."); |
| PATH_CHECK("../.", "../."); |
| PATH_CHECK("./.", "./."); |
| PATH_CHECK("././.", "././."); |
| PATH_CHECK("./foo/.", "./foo/."); |
| PATH_CHECK("foo/./bar", "foo/./bar"); |
| PATH_CHECK("foo/./.", "foo/./."); |
| PATH_CHECK("foo/./..", "foo/./.."); |
| PATH_CHECK("foo/./../bar", "foo/./../bar"); |
| PATH_CHECK("foo/../.", "foo/../."); |
| PATH_CHECK("././..", "././.."); |
| PATH_CHECK("./../.", "./../."); |
| PATH_CHECK(".././.", ".././."); |
| } |
| |
| // append_tests --------------------------------------------------------------------// |
| |
| void append_test_aux(const path & p, const std::string & s, const std::string & expect) |
| { |
| PATH_CHECK(p / path(s), expect); |
| PATH_CHECK(p / s.c_str(), expect); |
| PATH_CHECK(p / s, expect); |
| path x(p); |
| x.append(s.begin(), s.end()); |
| PATH_CHECK(x, expect); |
| } |
| |
| void append_tests() |
| { |
| std::cout << "append_tests..." << std::endl; |
| |
| // There are many control paths to be exercised, since empty paths and arguments, |
| // paths with trailing separators, arguments with leading separators, with or without |
| // other characters being present, are all separate cases that need to be tested. |
| // Furthermore, some of the code to be tested is specific to argument categories, |
| // so that results in further permutations to be tested. |
| |
| //// code to generate test cases |
| //// |
| //// expected results must be checked by hand |
| //// "foo\bar" expected result must be edited by hand and moved for Windows/POSIX |
| //// |
| //const char* x[] = { "", "/", "foo", "foo/" }; |
| //const char* y[] = { "", "/", "bar", "/bar" }; |
| |
| //for (int i = 0; i < sizeof(x)/sizeof(char*); ++i) |
| // for (int j = 0; j < sizeof(y)/sizeof(char*); ++j) |
| // { |
| // std::cout << "\n PATH_CHECK(path(\"" << x[i] << "\") / \"" << y[j] << "\", \"" |
| // << path(x[i]) / y[j] << "\");\n"; |
| // std::cout << " append_test_aux(\"" << x[i] << "\", \"" << y[j] << "\", \"" |
| // << path(x[i]) / y[j] << "\");\n"; |
| // } |
| |
| PATH_CHECK(path("") / "", ""); |
| append_test_aux("", "", ""); |
| |
| PATH_CHECK(path("") / "/", "/"); |
| append_test_aux("", "/", "/"); |
| |
| PATH_CHECK(path("") / "bar", "bar"); |
| append_test_aux("", "bar", "bar"); |
| |
| PATH_CHECK(path("") / "/bar", "/bar"); |
| append_test_aux("", "/bar", "/bar"); |
| |
| PATH_CHECK(path("/") / "", "/"); |
| append_test_aux("/", "", "/"); |
| |
| PATH_CHECK(path("/") / "/", "//"); |
| append_test_aux("/", "/", "//"); |
| |
| PATH_CHECK(path("/") / "bar", "/bar"); |
| append_test_aux("/", "bar", "/bar"); |
| |
| PATH_CHECK(path("/") / "/bar", "//bar"); |
| append_test_aux("/", "/bar", "//bar"); |
| |
| PATH_CHECK(path("foo") / "", "foo"); |
| append_test_aux("foo", "", "foo"); |
| |
| PATH_CHECK(path("foo") / "/", "foo/"); |
| append_test_aux("foo", "/", "foo/"); |
| |
| PATH_CHECK(path("foo") / "/bar", "foo/bar"); |
| append_test_aux("foo", "/bar", "foo/bar"); |
| |
| PATH_CHECK(path("foo/") / "", "foo/"); |
| append_test_aux("foo/", "", "foo/"); |
| |
| PATH_CHECK(path("foo/") / "/", "foo//"); |
| append_test_aux("foo/", "/", "foo//"); |
| |
| PATH_CHECK(path("foo/") / "bar", "foo/bar"); |
| append_test_aux("foo/", "bar", "foo/bar"); |
| |
| PATH_CHECK(path("foo/") / "/bar", "foo//bar"); |
| append_test_aux("foo/", "/bar", "foo//bar"); |
| |
| if (platform == "Windows") |
| { |
| PATH_CHECK(path("foo") / "bar", "foo\\bar"); |
| append_test_aux("foo", "bar", "foo\\bar"); |
| |
| // hand created test case specific to Windows |
| PATH_CHECK(path("c:") / "bar", "c:bar"); |
| append_test_aux("c:", "bar", "c:bar"); |
| } |
| else |
| { |
| PATH_CHECK(path("foo") / "bar", "foo/bar"); |
| append_test_aux("foo", "bar", "foo/bar"); |
| } |
| |
| } |
| |
| // name_function_tests -------------------------------------------------------------// |
| |
| void name_function_tests() |
| { |
| std::cout << "name_function_tests..." << std::endl; |
| |
| BOOST_TEST(fs::portable_posix_name(std::string("x"))); |
| BOOST_TEST(fs::windows_name(std::string("x"))); |
| BOOST_TEST(fs::portable_name(std::string("x"))); |
| BOOST_TEST(fs::portable_directory_name(std::string("x"))); |
| BOOST_TEST(fs::portable_file_name(std::string("x"))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string("."))); |
| BOOST_TEST(fs::windows_name(std::string("."))); |
| BOOST_TEST(fs::portable_name(std::string("."))); |
| BOOST_TEST(fs::portable_directory_name(std::string("."))); |
| BOOST_TEST(!fs::portable_file_name(std::string("."))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string(".."))); |
| BOOST_TEST(fs::windows_name(std::string(".."))); |
| BOOST_TEST(fs::portable_name(std::string(".."))); |
| BOOST_TEST(fs::portable_directory_name(std::string(".."))); |
| BOOST_TEST(!fs::portable_file_name(std::string(".."))); |
| |
| BOOST_TEST(!fs::native(std::string(""))); |
| BOOST_TEST(!fs::portable_posix_name(std::string(""))); |
| BOOST_TEST(!fs::windows_name(std::string(""))); |
| BOOST_TEST(!fs::portable_name(std::string(""))); |
| BOOST_TEST(!fs::portable_directory_name(std::string(""))); |
| BOOST_TEST(!fs::portable_file_name(std::string(""))); |
| |
| BOOST_TEST(!fs::native(std::string(" "))); |
| BOOST_TEST(!fs::portable_posix_name(std::string(" "))); |
| BOOST_TEST(!fs::windows_name(std::string(" "))); |
| BOOST_TEST(!fs::portable_name(std::string(" "))); |
| BOOST_TEST(!fs::portable_directory_name(std::string(" "))); |
| BOOST_TEST(!fs::portable_file_name(std::string(" "))); |
| |
| BOOST_TEST(!fs::portable_posix_name(std::string(":"))); |
| BOOST_TEST(!fs::windows_name(std::string(":"))); |
| BOOST_TEST(!fs::portable_name(std::string(":"))); |
| BOOST_TEST(!fs::portable_directory_name(std::string(":"))); |
| BOOST_TEST(!fs::portable_file_name(std::string(":"))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string("-"))); |
| BOOST_TEST(fs::windows_name(std::string("-"))); |
| BOOST_TEST(!fs::portable_name(std::string("-"))); |
| BOOST_TEST(!fs::portable_directory_name(std::string("-"))); |
| BOOST_TEST(!fs::portable_file_name(std::string("-"))); |
| |
| BOOST_TEST(!fs::portable_posix_name(std::string("foo bar"))); |
| BOOST_TEST(fs::windows_name(std::string("foo bar"))); |
| BOOST_TEST(!fs::windows_name(std::string(" bar"))); |
| BOOST_TEST(!fs::windows_name(std::string("foo "))); |
| BOOST_TEST(!fs::portable_name(std::string("foo bar"))); |
| BOOST_TEST(!fs::portable_directory_name(std::string("foo bar"))); |
| BOOST_TEST(!fs::portable_file_name(std::string("foo bar"))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string("foo.bar"))); |
| BOOST_TEST(fs::windows_name(std::string("foo.bar"))); |
| BOOST_TEST(fs::portable_name(std::string("foo.bar"))); |
| BOOST_TEST(!fs::portable_directory_name(std::string("foo.bar"))); |
| BOOST_TEST(fs::portable_file_name(std::string("foo.bar"))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string("foo.barf"))); |
| BOOST_TEST(fs::windows_name(std::string("foo.barf"))); |
| BOOST_TEST(fs::portable_name(std::string("foo.barf"))); |
| BOOST_TEST(!fs::portable_directory_name(std::string("foo.barf"))); |
| BOOST_TEST(!fs::portable_file_name(std::string("foo.barf"))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string(".foo"))); |
| BOOST_TEST(fs::windows_name(std::string(".foo"))); |
| BOOST_TEST(!fs::portable_name(std::string(".foo"))); |
| BOOST_TEST(!fs::portable_directory_name(std::string(".foo"))); |
| BOOST_TEST(!fs::portable_file_name(std::string(".foo"))); |
| |
| BOOST_TEST(fs::portable_posix_name(std::string("foo."))); |
| BOOST_TEST(!fs::windows_name(std::string("foo."))); |
| BOOST_TEST(!fs::portable_name(std::string("foo."))); |
| BOOST_TEST(!fs::portable_directory_name(std::string("foo."))); |
| BOOST_TEST(!fs::portable_file_name(std::string("foo."))); |
| } |
| |
| // replace_extension_tests ---------------------------------------------------// |
| |
| void replace_extension_tests() |
| { |
| std::cout << "replace_extension_tests..." << std::endl; |
| |
| BOOST_TEST(path().replace_extension().empty()); |
| BOOST_TEST(path().replace_extension("a").empty()); |
| BOOST_TEST(path().replace_extension("a.") == "."); |
| BOOST_TEST(path().replace_extension("a.txt") == ".txt"); |
| // see the rationale in html docs for explanation why this works: |
| BOOST_TEST(path().replace_extension(".txt") == ".txt"); |
| |
| BOOST_TEST(path("a.txt").replace_extension() == "a"); |
| BOOST_TEST(path("a.txt").replace_extension("") == "a"); |
| BOOST_TEST(path("a.txt").replace_extension(".") == "a."); |
| BOOST_TEST(path("a.txt").replace_extension(".tex") == "a.tex"); |
| BOOST_TEST(path("a.txt").replace_extension("tex") == "a"); |
| BOOST_TEST(path("a.").replace_extension(".tex") == "a.tex"); |
| BOOST_TEST(path("a.").replace_extension("tex") == "a"); |
| BOOST_TEST(path("a").replace_extension(".txt") == "a.txt"); |
| BOOST_TEST(path("a").replace_extension("txt") == "a"); |
| BOOST_TEST(path("a.b.txt").replace_extension(".tex") == "a.b.tex"); |
| BOOST_TEST(path("a.b.txt").replace_extension("tex") == "a.b"); |
| BOOST_TEST(path("a/b").replace_extension(".c") == "a/b.c"); |
| BOOST_TEST_EQ(path("a.txt/b").replace_extension(".c"), "a.txt/b.c"); // ticket 4702 |
| } |
| |
| } // unnamed namespace |
| |
| //--------------------------------------------------------------------------------------// |
| // // |
| // main // |
| // // |
| //--------------------------------------------------------------------------------------// |
| |
| int main(int, char*[]) |
| { |
| // The choice of platform is make at runtime rather than compile-time |
| // so that compile errors for all platforms will be detected even though |
| // only the current platform is runtime tested. |
| platform = (platform == "Win32" || platform == "Win64" || platform == "Cygwin") |
| ? "Windows" |
| : "POSIX"; |
| std::cout << "Platform is " << platform << '\n'; |
| |
| BOOST_TEST(p1.string() != p3.string()); |
| p3 = p2; |
| BOOST_TEST(p1.string() == p3.string()); |
| |
| path p4("foobar"); |
| BOOST_TEST(p4.string() == "foobar"); |
| p4 = p4; // self-assignment |
| BOOST_TEST(p4.string() == "foobar"); |
| |
| construction_tests(); |
| append_tests(); |
| overload_tests(); |
| query_and_decomposition_tests(); |
| composition_tests(); |
| iterator_tests(); |
| non_member_tests(); |
| exception_tests(); |
| name_function_tests(); |
| replace_extension_tests(); |
| |
| // verify deprecated names still available |
| |
| # ifndef BOOST_FILESYSTEM_NO_DEPRECATED |
| |
| p1.branch_path(); |
| p1.leaf(); |
| path p_remove_leaf; |
| p_remove_leaf.remove_leaf(); |
| |
| # endif |
| |
| std::string s1("//:somestring"); // this used to be treated specially |
| |
| // check the path member templates |
| p5.assign(s1.begin(), s1.end()); |
| |
| PATH_CHECK(p5, "//:somestring"); |
| p5 = s1; |
| PATH_CHECK(p5, "//:somestring"); |
| |
| // this code, courtesy of David Whetstone, detects a now fixed bug that |
| // derefereced the end iterator (assuming debug build with checked itors) |
| std::vector<char> v1; |
| p5.assign(v1.begin(), v1.end()); |
| std::string s2(v1.begin(), v1.end()); |
| PATH_CHECK(p5, s2); |
| p5.assign(s1.begin(), s1.begin() + 1); |
| PATH_CHECK(p5, "/"); |
| |
| BOOST_TEST(p1 != p4); |
| BOOST_TEST(p1.string() == p2.string()); |
| BOOST_TEST(p1.string() == p3.string()); |
| BOOST_TEST(path("foo").filename() == "foo"); |
| BOOST_TEST(path("foo").parent_path().string() == ""); |
| BOOST_TEST(p1.filename() == "fum"); |
| BOOST_TEST(p1.parent_path().string() == "fe/fi/fo"); |
| BOOST_TEST(path("").empty() == true); |
| BOOST_TEST(path("foo").empty() == false); |
| |
| // inserter and extractor tests |
| # if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // bypass VC++ 7.0 and earlier |
| std::cout << "\nInserter and extractor test..."; |
| std::stringstream ss; |
| ss << fs::path("foo/bar") << std::endl; |
| fs::path round_trip; |
| ss >> round_trip; |
| BOOST_TEST(round_trip.string() == "foo/bar"); |
| std::cout << round_trip.string() << "..." << round_trip << " complete\n"; |
| # endif |
| |
| return ::boost::report_errors(); |
| } |
