]> git.proxmox.com Git - ceph.git/blob - ceph/src/boost/libs/filesystem/test/path_test.cpp
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update ceph source to reef 18.1.2
[ceph.git] / ceph / src / boost / libs / filesystem / test / path_test.cpp
1 // path_test program -----------------------------------------------------------------//
2
3 // Copyright Beman Dawes 2002, 2008
4 // Copyright Vladimir Prus 2002
5
6 // Use, modification, and distribution is subject to the Boost Software
7 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9
10 // See library home page at http://www.boost.org/libs/filesystem
11
12 // basic_path's stem(), extension(), and replace_extension() tests are based
13 // on basename(), extension(), and change_extension() tests from the original
14 // convenience_test.cpp by Vladimir Prus.
15
16 //--------------------------------------------------------------------------------------//
17 // //
18 // Caution //
19 // //
20 // The class path relational operators (==, !=, <, etc.) on Windows treat slash and //
21 // backslash as equal. Thus any tests on Windows where the difference between slash //
22 // and backslash is significant should compare strings rather than paths. //
23 // //
24 // BOOST_TEST(path == path) // '\\' and '/' are equal //
25 // BOOST_TEST(path == convertable to string) // '\\' and '/' are equal //
26 // PATH_TEST_EQ(path, path) // '\\' and '/' are equal //
27 // //
28 // BOOST_TEST(path.string() == path.string()) // '\\' and '/' are not equal //
29 // BOOST_TEST(path.string() == //
30 // convertable to string) // '\\' and '/' are not equal //
31 // PATH_TEST_EQ(path.string(), //
32 // convertable to string) // '\\' and '/' are not equal //
33 // //
34 // The last of these is often what is needed, so the PATH_TEST_EQ macro is provided. //
35 // It converts its first argument to a path, and then performs a .string() on it, //
36 // eliminating much boilerplate .string() or even path(...).string() code. //
37 // //
38 // PATH_TEST_EQ(path, convertable to string) // '\\' and '/' are not equal //
39 // //
40 //--------------------------------------------------------------------------------------//
41
42 #include <boost/config/warning_disable.hpp>
43
44 // See deprecated_test for tests of deprecated features
45 #ifndef BOOST_FILESYSTEM_NO_DEPRECATED
46 #define BOOST_FILESYSTEM_NO_DEPRECATED
47 #endif
48 #ifndef BOOST_SYSTEM_NO_DEPRECATED
49 #define BOOST_SYSTEM_NO_DEPRECATED
50 #endif
51
52 #include <boost/filesystem/path.hpp>
53 #include <boost/filesystem/operations.hpp>
54 #include <boost/filesystem/exception.hpp>
55
56 #include <boost/next_prior.hpp>
57 #include <iostream>
58 #include <sstream>
59 #include <string>
60 #include <vector>
61 #include <cstring>
62 #include <boost/core/lightweight_test.hpp>
63 #include <boost/detail/lightweight_main.hpp>
64
65 namespace fs = boost::filesystem;
66 using boost::filesystem::path;
67 using boost::next;
68 using boost::prior;
69
70 #ifdef BOOST_WINDOWS_API
71 #define BOOST_DIR_SEP "\\"
72 #else
73 #define BOOST_DIR_SEP "/"
74 #endif
75
76 #if BOOST_FILESYSTEM_VERSION == 3
77 #define BOOST_FILESYSTEM_V3_TRAILING_DOT "."
78 #else
79 #define BOOST_FILESYSTEM_V3_TRAILING_DOT ""
80 #endif
81
82 #define PATH_TEST_EQ(a, b) check(a, b, __FILE__, __LINE__)
83
84 namespace {
85
86 class derived_from_path :
87 public fs::path
88 {
89 public:
90 derived_from_path() {}
91 derived_from_path(derived_from_path const& that) : fs::path(static_cast< fs::path const& >(that)) {}
92 template< typename T >
93 derived_from_path(T const& that) : fs::path(that) {}
94
95 derived_from_path& operator= (derived_from_path const& that)
96 {
97 *static_cast< fs::path* >(this) = that;
98 return *this;
99 }
100 template< typename T >
101 derived_from_path& operator= (T const& that)
102 {
103 *static_cast< fs::path* >(this) = that;
104 return *this;
105 }
106 };
107
108 class convertible_to_path
109 {
110 private:
111 fs::path m_path;
112
113 public:
114 convertible_to_path() {}
115 convertible_to_path(convertible_to_path const& that) : m_path(that.m_path) {}
116 template< typename T >
117 convertible_to_path(T const& that) : m_path(that) {}
118
119 convertible_to_path& operator= (convertible_to_path const& that)
120 {
121 m_path = that.m_path;
122 return *this;
123 }
124 template< typename T >
125 convertible_to_path& operator= (T const& that)
126 {
127 m_path = that;
128 return *this;
129 }
130
131 operator fs::path() const { return m_path; }
132 };
133
134
135 std::string platform(BOOST_PLATFORM);
136
137 void check(const fs::path& source, const std::string& expected, const char* file, int line)
138 {
139 if (source.string() == expected)
140 return;
141
142 std::cout << file
143 << '(' << line << "): source: \"" << source.string()
144 << "\" != expected: \"" << expected
145 << "\"" << std::endl;
146
147 ++::boost::detail::test_errors();
148 }
149
150 path p1("fe/fi/fo/fum");
151 path p2(p1);
152 path p3;
153 path p4("foobar");
154 path p5;
155
156 // exception_tests -----------------------------------------------------------------//
157
158 void exception_tests()
159 {
160 std::cout << "exception_tests..." << std::endl;
161 const std::string str_1("string-1");
162 boost::system::error_code ec(12345, boost::system::system_category());
163 try
164 {
165 throw fs::filesystem_error(str_1, ec);
166 }
167 catch (const fs::filesystem_error& ex)
168 {
169 //std::cout << ex.what() << "*" << std::endl;
170 //BOOST_TEST(std::strcmp(ex.what(),
171 // "string-1: Unknown error") == 0);
172 BOOST_TEST(ex.code() == ec);
173 }
174
175 try
176 {
177 throw fs::filesystem_error(str_1, "p1", "p2", ec);
178 }
179 catch (const fs::filesystem_error& ex)
180 {
181 //std::cout << ex.what() << "*" << std::endl;
182 //BOOST_TEST(std::strcmp(ex.what(),
183 // "string-1: Unknown error: \"p1\", \"p2\"") == 0);
184 BOOST_TEST(ex.code() == ec);
185 BOOST_TEST(ex.path1() == "p1");
186 BOOST_TEST(ex.path2() == "p2");
187 }
188 }
189
190 // overload_tests ------------------------------------------------------------------//
191
192 // These verify various overloads don't cause compiler errors
193 // They pre-date operations_unit_test.cpp
194
195 void overload_tests()
196 {
197 std::cout << "overload_tests..." << std::endl;
198
199 fs::exists(p1);
200 fs::exists("foo");
201 fs::exists(std::string("foo"));
202
203 fs::exists(p1 / path("foo"));
204 fs::exists(p1 / "foo");
205 fs::exists(p1 / std::string("foo"));
206
207 fs::exists("foo" / p1);
208 fs::exists(std::string("foo") / p1);
209
210 p4 /= path("foo");
211 p4 /= "foo";
212 p4 /= std::string("foo");
213 }
214
215 // iterator_tests ------------------------------------------------------------------//
216
217 void iterator_tests()
218 {
219 std::cout << "iterator_tests..." << std::endl;
220
221 path itr_ck = "";
222 path::const_iterator itr = itr_ck.begin();
223 BOOST_TEST(itr == itr_ck.end());
224
225 itr_ck = "/";
226 itr = itr_ck.begin();
227 BOOST_TEST(itr->string() == "/");
228 BOOST_TEST(++itr == itr_ck.end());
229 BOOST_TEST((--itr)->string() == "/");
230
231 itr_ck = "foo";
232 BOOST_TEST(*itr_ck.begin() == std::string("foo"));
233 BOOST_TEST(boost::next(itr_ck.begin()) == itr_ck.end());
234 BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo"));
235 BOOST_TEST(boost::prior(itr_ck.end()) == itr_ck.begin());
236
237 itr_ck = path("/foo");
238 BOOST_TEST((itr_ck.begin())->string() == "/");
239 BOOST_TEST(*boost::next(itr_ck.begin()) == std::string("foo"));
240 BOOST_TEST(boost::next(boost::next(itr_ck.begin())) == itr_ck.end());
241 BOOST_TEST(boost::next(itr_ck.begin()) == boost::prior(itr_ck.end()));
242 BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo"));
243 BOOST_TEST(*boost::prior(boost::prior(itr_ck.end())) == std::string("/"));
244 BOOST_TEST(boost::prior(boost::prior(itr_ck.end())) == itr_ck.begin());
245
246 itr_ck = "/foo/bar";
247 itr = itr_ck.begin();
248 path::const_iterator itr_begin = itr;
249 BOOST_TEST(itr->string() == "/");
250 BOOST_TEST(*++itr == std::string("foo"));
251 BOOST_TEST(*++itr == std::string("bar"));
252 BOOST_TEST(++itr == itr_ck.end());
253 PATH_TEST_EQ(*--itr, "bar");
254 PATH_TEST_EQ(*--itr, "foo");
255 PATH_TEST_EQ(*--itr, "/");
256 BOOST_TEST(itr == itr_begin);
257
258 itr_ck = "../f"; // previously failed due to short name bug
259 itr_begin = itr = itr_ck.begin();
260 PATH_TEST_EQ(itr->string(), "..");
261 PATH_TEST_EQ(*++itr, "f");
262 BOOST_TEST(++itr == itr_ck.end());
263 PATH_TEST_EQ(*--itr, "f");
264 PATH_TEST_EQ(*--itr, "..");
265 BOOST_TEST(itr == itr_begin);
266
267 // POSIX says treat "/foo/bar/" as "/foo/bar/."
268 itr_ck = "/foo/bar/";
269 itr_begin = itr = itr_ck.begin();
270 PATH_TEST_EQ(itr->string(), "/");
271 PATH_TEST_EQ(*++itr, "foo");
272 BOOST_TEST(itr != itr_ck.end());
273 PATH_TEST_EQ(*++itr, "bar");
274 BOOST_TEST(itr != itr_ck.end());
275 PATH_TEST_EQ(*++itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
276 BOOST_TEST(itr != itr_ck.end()); // verify the . isn't also seen as end()
277 BOOST_TEST(++itr == itr_ck.end());
278 PATH_TEST_EQ(*--itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
279 PATH_TEST_EQ(*--itr, "bar");
280 PATH_TEST_EQ(*--itr, "foo");
281 PATH_TEST_EQ(*--itr, "/");
282 BOOST_TEST(itr == itr_begin);
283
284 // POSIX says treat "/f/b/" as "/f/b/."
285 itr_ck = "/f/b/";
286 itr_begin = itr = itr_ck.begin();
287 PATH_TEST_EQ(itr->string(), "/");
288 PATH_TEST_EQ(*++itr, "f");
289 PATH_TEST_EQ(*++itr, "b");
290 PATH_TEST_EQ(*++itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
291 BOOST_TEST(itr != itr_ck.end()); // verify the . isn't also seen as end()
292 BOOST_TEST(++itr == itr_ck.end());
293 PATH_TEST_EQ(*--itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
294 PATH_TEST_EQ(*--itr, "b");
295 PATH_TEST_EQ(*--itr, "f");
296 PATH_TEST_EQ(*--itr, "/");
297 BOOST_TEST(itr == itr_begin);
298
299 // POSIX says treat "a/b/" as "a/b/."
300 // Although similar to the prior test case, this failed the ". isn't end" test due to
301 // a bug while the prior case did not fail.
302 itr_ck = "a/b/";
303 itr_begin = itr = itr_ck.begin();
304 PATH_TEST_EQ(*itr, "a");
305 PATH_TEST_EQ(*++itr, "b");
306 PATH_TEST_EQ(*++itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
307 BOOST_TEST(itr != itr_ck.end()); // verify the . isn't also seen as end()
308 BOOST_TEST(++itr == itr_ck.end());
309 PATH_TEST_EQ(*--itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
310 PATH_TEST_EQ(*--itr, "b");
311 PATH_TEST_EQ(*--itr, "a");
312 BOOST_TEST(itr == itr_begin);
313
314 itr_ck = "//net";
315 itr_begin = itr = itr_ck.begin();
316 // two leading slashes are permitted by POSIX (as implementation defined),
317 // while for Windows it is always well defined (as a network name)
318 PATH_TEST_EQ(itr->string(), "//net");
319 BOOST_TEST(++itr == itr_ck.end());
320 PATH_TEST_EQ(*--itr, "//net");
321 BOOST_TEST(itr == itr_begin);
322
323 itr_ck = "//net/";
324 itr_begin = itr = itr_ck.begin();
325 PATH_TEST_EQ(itr->string(), "//net");
326 PATH_TEST_EQ(*++itr, "/");
327 BOOST_TEST(++itr == itr_ck.end());
328 PATH_TEST_EQ(*--itr, "/");
329 PATH_TEST_EQ(*--itr, "//net");
330 BOOST_TEST(itr == itr_begin);
331
332 itr_ck = "//foo///bar///";
333 itr_begin = itr = itr_ck.begin();
334 PATH_TEST_EQ(itr->string(), "//foo");
335 PATH_TEST_EQ(*++itr, "/");
336 PATH_TEST_EQ(*++itr, "bar");
337 PATH_TEST_EQ(*++itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
338 BOOST_TEST(++itr == itr_ck.end());
339 PATH_TEST_EQ(*--itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
340 PATH_TEST_EQ(*--itr, "bar");
341 PATH_TEST_EQ(*--itr, "/");
342 PATH_TEST_EQ(*--itr, "//foo");
343 BOOST_TEST(itr == itr_begin);
344
345 itr_ck = "///foo///bar///";
346 itr_begin = itr = itr_ck.begin();
347 // three or more leading slashes are to be treated as a single slash
348 PATH_TEST_EQ(itr->string(), "/");
349 PATH_TEST_EQ(*++itr, "foo");
350 PATH_TEST_EQ(*++itr, "bar");
351 PATH_TEST_EQ(*++itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
352 BOOST_TEST(++itr == itr_ck.end());
353 PATH_TEST_EQ(*--itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
354 PATH_TEST_EQ(*--itr, "bar");
355 PATH_TEST_EQ(*--itr, "foo");
356 PATH_TEST_EQ(*--itr, "/");
357 BOOST_TEST(itr == itr_begin);
358
359 if (platform == "Windows")
360 {
361 itr_ck = "c:/";
362 itr_begin = itr = itr_ck.begin();
363 PATH_TEST_EQ(itr->string(), "c:");
364 PATH_TEST_EQ(*++itr, std::string("/"));
365 BOOST_TEST(++itr == itr_ck.end());
366 PATH_TEST_EQ(*--itr, "/");
367 PATH_TEST_EQ(*--itr, "c:");
368 BOOST_TEST(itr == itr_begin);
369
370 itr_ck = "c:\\";
371 itr_begin = itr = itr_ck.begin();
372 PATH_TEST_EQ(itr->string(), "c:");
373 PATH_TEST_EQ(*++itr, "/"); // test that iteration returns generic format
374 BOOST_TEST(++itr == itr_ck.end());
375 PATH_TEST_EQ(*--itr, "/"); // test that iteration returns generic format
376 PATH_TEST_EQ(*--itr, "c:");
377 BOOST_TEST(itr == itr_begin);
378
379 itr_ck = "c:/foo";
380 itr_begin = itr = itr_ck.begin();
381 PATH_TEST_EQ(*itr, "c:");
382 PATH_TEST_EQ(*++itr, "/");
383 PATH_TEST_EQ(*++itr, "foo");
384 BOOST_TEST(++itr == itr_ck.end());
385 PATH_TEST_EQ(*--itr, "foo");
386 PATH_TEST_EQ(*--itr, "/");
387 PATH_TEST_EQ(*--itr, "c:");
388 BOOST_TEST(itr == itr_begin);
389
390 itr_ck = "c:\\foo";
391 itr_begin = itr = itr_ck.begin();
392 BOOST_TEST_EQ(*itr, "c:");
393 BOOST_TEST_EQ(*++itr, "\\");
394 BOOST_TEST_EQ(*++itr, "foo");
395 BOOST_TEST(++itr == itr_ck.end());
396 BOOST_TEST_EQ(*--itr, "foo");
397 BOOST_TEST_EQ(*--itr, "\\");
398 BOOST_TEST_EQ(*--itr, "c:");
399 BOOST_TEST(itr == itr_begin);
400
401 itr_ck = "\\\\?\\c:\\foo";
402 itr_begin = itr = itr_ck.begin();
403 BOOST_TEST_EQ(*itr, "\\\\?\\c:");
404 BOOST_TEST_EQ(*++itr, "\\");
405 BOOST_TEST_EQ(*++itr, "foo");
406 BOOST_TEST(++itr == itr_ck.end());
407 BOOST_TEST_EQ(*--itr, "foo");
408 BOOST_TEST_EQ(*--itr, "\\");
409 BOOST_TEST_EQ(*--itr, "\\\\?\\c:");
410 BOOST_TEST(itr == itr_begin);
411
412 itr_ck = "\\\\.\\c:\\foo";
413 itr_begin = itr = itr_ck.begin();
414 BOOST_TEST_EQ(*itr, "\\\\.\\c:");
415 BOOST_TEST_EQ(*++itr, "\\");
416 BOOST_TEST_EQ(*++itr, "foo");
417 BOOST_TEST(++itr == itr_ck.end());
418 BOOST_TEST_EQ(*--itr, "foo");
419 BOOST_TEST_EQ(*--itr, "\\");
420 BOOST_TEST_EQ(*--itr, "\\\\.\\c:");
421 BOOST_TEST(itr == itr_begin);
422
423 itr_ck = "\\??\\c:\\foo";
424 itr_begin = itr = itr_ck.begin();
425 BOOST_TEST_EQ(*itr, "\\??\\c:");
426 BOOST_TEST_EQ(*++itr, "\\");
427 BOOST_TEST_EQ(*++itr, "foo");
428 BOOST_TEST(++itr == itr_ck.end());
429 BOOST_TEST_EQ(*--itr, "foo");
430 BOOST_TEST_EQ(*--itr, "\\");
431 BOOST_TEST_EQ(*--itr, "\\??\\c:");
432 BOOST_TEST(itr == itr_begin);
433
434 itr_ck = "\\\\\\foo\\\\\\bar\\\\\\";
435 itr_begin = itr = itr_ck.begin();
436 // three or more leading slashes are to be treated as a single slash
437 PATH_TEST_EQ(itr->string(), "/");
438 PATH_TEST_EQ(*++itr, "foo");
439 PATH_TEST_EQ(*++itr, "bar");
440 PATH_TEST_EQ(*++itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
441 BOOST_TEST(++itr == itr_ck.end());
442 PATH_TEST_EQ(*--itr, BOOST_FILESYSTEM_V3_TRAILING_DOT);
443 PATH_TEST_EQ(*--itr, "bar");
444 PATH_TEST_EQ(*--itr, "foo");
445 PATH_TEST_EQ(*--itr, "/");
446 BOOST_TEST(itr == itr_begin);
447
448 itr_ck = "c:foo";
449 itr_begin = itr = itr_ck.begin();
450 BOOST_TEST(*itr == std::string("c:"));
451 BOOST_TEST(*++itr == std::string("foo"));
452 BOOST_TEST(++itr == itr_ck.end());
453 BOOST_TEST(*--itr == std::string("foo"));
454 BOOST_TEST(*--itr == std::string("c:"));
455 BOOST_TEST(itr == itr_begin);
456
457 itr_ck = "c:foo/";
458 itr_begin = itr = itr_ck.begin();
459 BOOST_TEST(*itr == std::string("c:"));
460 BOOST_TEST(*++itr == std::string("foo"));
461 BOOST_TEST(*++itr == std::string(BOOST_FILESYSTEM_V3_TRAILING_DOT));
462 BOOST_TEST(++itr == itr_ck.end());
463 BOOST_TEST(*--itr == std::string(BOOST_FILESYSTEM_V3_TRAILING_DOT));
464 BOOST_TEST(*--itr == std::string("foo"));
465 BOOST_TEST(*--itr == std::string("c:"));
466 BOOST_TEST(itr == itr_begin);
467
468 itr_ck = path("c:");
469 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
470 BOOST_TEST(next(itr_ck.begin()) == itr_ck.end());
471 BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin());
472 BOOST_TEST(*prior(itr_ck.end()) == std::string("c:"));
473
474 itr_ck = path("c:/");
475 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
476 BOOST_TEST(*next(itr_ck.begin()) == std::string("/"));
477 BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end());
478 BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin());
479 BOOST_TEST(*prior(itr_ck.end()) == std::string("/"));
480 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:"));
481
482 itr_ck = path("c:foo");
483 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
484 BOOST_TEST(*next(itr_ck.begin()) == std::string("foo"));
485 BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end());
486 BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin());
487 BOOST_TEST(*prior(itr_ck.end()) == std::string("foo"));
488 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:"));
489
490 itr_ck = path("c:/foo");
491 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
492 BOOST_TEST(*next(itr_ck.begin()) == std::string("/"));
493 BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo"));
494 BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end());
495 BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin());
496 BOOST_TEST(*prior(itr_ck.end()) == std::string("foo"));
497 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/"));
498 BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("c:"));
499
500 itr_ck = path("//net");
501 BOOST_TEST(*itr_ck.begin() == std::string("//net"));
502 BOOST_TEST(next(itr_ck.begin()) == itr_ck.end());
503 BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin());
504 BOOST_TEST(*prior(itr_ck.end()) == std::string("//net"));
505
506 itr_ck = path("//net/");
507 PATH_TEST_EQ(itr_ck.begin()->string(), "//net");
508 PATH_TEST_EQ(next(itr_ck.begin())->string(), "/");
509 BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end());
510 BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin());
511 PATH_TEST_EQ(prior(itr_ck.end())->string(), "/");
512 PATH_TEST_EQ(prior(prior(itr_ck.end()))->string(), "//net");
513
514 itr_ck = path("//net/foo");
515 BOOST_TEST(*itr_ck.begin() == std::string("//net"));
516 BOOST_TEST(*next(itr_ck.begin()) == std::string("/"));
517 BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo"));
518 BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end());
519 BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin());
520 BOOST_TEST(*prior(itr_ck.end()) == std::string("foo"));
521 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/"));
522 BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("//net"));
523
524 itr_ck = path("prn:");
525 BOOST_TEST(*itr_ck.begin() == std::string("prn:"));
526 BOOST_TEST(next(itr_ck.begin()) == itr_ck.end());
527 BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin());
528 BOOST_TEST(*prior(itr_ck.end()) == std::string("prn:"));
529 }
530 else
531 {
532 itr_ck = "///";
533 itr = itr_ck.begin();
534 PATH_TEST_EQ(itr->string(), "/");
535 BOOST_TEST(++itr == itr_ck.end());
536 }
537 }
538
539 // non_member_tests ----------------------------------------------------------------//
540
541 void non_member_tests()
542 {
543 std::cout << "non_member_tests..." << std::endl;
544
545 // test non-member functions, particularly operator overloads
546
547 path e, e2;
548 std::string es, es2;
549 char ecs[] = "";
550 char ecs2[] = "";
551
552 char acs[] = "a";
553 std::string as(acs);
554 path a(as);
555
556 char acs2[] = "a";
557 std::string as2(acs2);
558 path a2(as2);
559
560 char bcs[] = "b";
561 std::string bs(bcs);
562 path b(bs);
563
564 // swap
565 a.swap(b);
566 BOOST_TEST(a.string() == "b");
567 BOOST_TEST(b.string() == "a");
568 fs::swap(a, b);
569 BOOST_TEST(a.string() == "a");
570 BOOST_TEST(b.string() == "b");
571
572 // probe operator /
573 PATH_TEST_EQ(path("") / ".", ".");
574 PATH_TEST_EQ(path("") / "..", "..");
575 #if BOOST_FILESYSTEM_VERSION == 3
576 PATH_TEST_EQ(path("/") / "/", "//");
577 PATH_TEST_EQ(path("/") / "/foo", "//foo");
578 PATH_TEST_EQ(path("/foo") / "/bar", "/foo/bar");
579 #else
580 PATH_TEST_EQ(path("/") / "/", "/");
581 PATH_TEST_EQ(path("/") / "/foo", "/foo");
582 PATH_TEST_EQ(path("/foo") / "/bar", "/bar");
583 #endif
584
585 if (platform == "Windows")
586 {
587 BOOST_TEST(path("foo\\bar") == "foo/bar");
588 BOOST_TEST((b / a).native() == path("b\\a").native());
589 BOOST_TEST((bs / a).native() == path("b\\a").native());
590 BOOST_TEST((bcs / a).native() == path("b\\a").native());
591 BOOST_TEST((b / as).native() == path("b\\a").native());
592 BOOST_TEST((b / acs).native() == path("b\\a").native());
593 PATH_TEST_EQ(path("a") / "b", "a\\b");
594 PATH_TEST_EQ(path("foo") / path("bar"), "foo\\bar"); // path arg
595 PATH_TEST_EQ(path("foo") / "bar", "foo\\bar"); // const char* arg
596 PATH_TEST_EQ(path("foo") / path("woo/bar").filename(), "foo\\bar"); // const std::string & arg
597 PATH_TEST_EQ("foo" / path("bar"), "foo\\bar");
598 #if BOOST_FILESYSTEM_VERSION == 3
599 PATH_TEST_EQ(path("..") / "", "..");
600 #else
601 PATH_TEST_EQ(path("..") / "", "..\\");
602 #endif
603 PATH_TEST_EQ(path("..") / "..", "..\\..");
604 PATH_TEST_EQ(path("/") / "..", "/..");
605 PATH_TEST_EQ(path("/..") / "..", "/..\\..");
606 PATH_TEST_EQ(path("..") / "foo", "..\\foo");
607 PATH_TEST_EQ(path("foo") / "..", "foo\\..");
608 PATH_TEST_EQ(path("..") / "f", "..\\f");
609 PATH_TEST_EQ(path("/..") / "f", "/..\\f");
610 PATH_TEST_EQ(path("f") / "..", "f\\..");
611 PATH_TEST_EQ(path("foo") / ".." / "..", "foo\\..\\..");
612 PATH_TEST_EQ(path("foo") / ".." / ".." / "..", "foo\\..\\..\\..");
613 PATH_TEST_EQ(path("f") / ".." / "b", "f\\..\\b");
614 PATH_TEST_EQ(path("foo") / ".." / "bar", "foo\\..\\bar");
615 PATH_TEST_EQ(path("foo") / "bar" / "..", "foo\\bar\\..");
616 PATH_TEST_EQ(path("foo") / "bar" / ".." / "..", "foo\\bar\\..\\..");
617 PATH_TEST_EQ(path("foo") / "bar" / ".." / "blah", "foo\\bar\\..\\blah");
618 PATH_TEST_EQ(path("f") / "b" / "..", "f\\b\\..");
619 PATH_TEST_EQ(path("f") / "b" / ".." / "a", "f\\b\\..\\a");
620 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / "..", "foo\\bar\\blah\\..\\..");
621 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo\\bar\\blah\\..\\..\\bletch");
622
623 PATH_TEST_EQ(path(".") / "foo", ".\\foo");
624 PATH_TEST_EQ(path(".") / "..", ".\\..");
625 PATH_TEST_EQ(path("foo") / ".", "foo\\.");
626 PATH_TEST_EQ(path("..") / ".", "..\\.");
627 PATH_TEST_EQ(path(".") / ".", ".\\.");
628 PATH_TEST_EQ(path(".") / "." / ".", ".\\.\\.");
629 PATH_TEST_EQ(path(".") / "foo" / ".", ".\\foo\\.");
630 PATH_TEST_EQ(path("foo") / "." / "bar", "foo\\.\\bar");
631 PATH_TEST_EQ(path("foo") / "." / ".", "foo\\.\\.");
632 PATH_TEST_EQ(path("foo") / "." / "..", "foo\\.\\..");
633 PATH_TEST_EQ(path(".") / "." / "..", ".\\.\\..");
634 PATH_TEST_EQ(path(".") / ".." / ".", ".\\..\\.");
635 PATH_TEST_EQ(path("..") / "." / ".", "..\\.\\.");
636
637 #if BOOST_FILESYSTEM_VERSION == 3
638 PATH_TEST_EQ(path("\\\\net1\\foo") / "\\\\net2\\bar", "\\\\net1\\foo\\\\net2\\bar");
639 PATH_TEST_EQ(path("\\\\net1\\foo") / "\\bar", "\\\\net1\\foo\\bar");
640 PATH_TEST_EQ(path("c:\\foo") / "d:\\bar", "c:\\foo\\d:\\bar");
641 PATH_TEST_EQ(path("c:\\foo") / "\\bar", "c:\\foo\\bar");
642 PATH_TEST_EQ(path("c:foo") / "\\bar", "c:foo\\bar");
643 #else
644 PATH_TEST_EQ(path("\\\\net1\\foo") / "\\\\net2\\bar", "\\\\net2\\bar");
645 PATH_TEST_EQ(path("\\\\net1\\foo") / "\\bar", "\\\\net1\\bar");
646 PATH_TEST_EQ(path("c:\\foo") / "d:\\bar", "d:\\bar");
647 PATH_TEST_EQ(path("c:\\foo") / "\\bar", "c:\\bar");
648 PATH_TEST_EQ(path("c:foo") / "\\bar", "c:\\bar");
649 #endif
650 PATH_TEST_EQ(path("c:foo") / "bar", "c:foo\\bar");
651 }
652 else // POSIX
653 {
654 PATH_TEST_EQ(b / a, "b/a");
655 PATH_TEST_EQ(bs / a, "b/a");
656 PATH_TEST_EQ(bcs / a, "b/a");
657 PATH_TEST_EQ(b / as, "b/a");
658 PATH_TEST_EQ(b / acs, "b/a");
659 PATH_TEST_EQ(path("a") / "b", "a/b");
660 PATH_TEST_EQ(path("") / "..", "..");
661 PATH_TEST_EQ(path("foo") / path("bar"), "foo/bar"); // path arg
662 PATH_TEST_EQ(path("foo") / "bar", "foo/bar"); // const char* arg
663 PATH_TEST_EQ(path("foo") / path("woo/bar").filename(), "foo/bar"); // const std::string & arg
664 PATH_TEST_EQ("foo" / path("bar"), "foo/bar");
665 #if BOOST_FILESYSTEM_VERSION == 3
666 PATH_TEST_EQ(path("..") / "", "..");
667 #else
668 PATH_TEST_EQ(path("..") / "", "../");
669 #endif
670 PATH_TEST_EQ(path("..") / "..", "../..");
671 PATH_TEST_EQ(path("/") / "..", "/..");
672 PATH_TEST_EQ(path("/..") / "..", "/../..");
673 PATH_TEST_EQ(path("..") / "foo", "../foo");
674 PATH_TEST_EQ(path("foo") / "..", "foo/..");
675 PATH_TEST_EQ(path("..") / "f", "../f");
676 PATH_TEST_EQ(path("/..") / "f", "/../f");
677 PATH_TEST_EQ(path("f") / "..", "f/..");
678 PATH_TEST_EQ(path("foo") / ".." / "..", "foo/../..");
679 PATH_TEST_EQ(path("foo") / ".." / ".." / "..", "foo/../../..");
680 PATH_TEST_EQ(path("f") / ".." / "b", "f/../b");
681 PATH_TEST_EQ(path("foo") / ".." / "bar", "foo/../bar");
682 PATH_TEST_EQ(path("foo") / "bar" / "..", "foo/bar/..");
683 PATH_TEST_EQ(path("foo") / "bar" / ".." / "..", "foo/bar/../..");
684 PATH_TEST_EQ(path("foo") / "bar" / ".." / "blah", "foo/bar/../blah");
685 PATH_TEST_EQ(path("f") / "b" / "..", "f/b/..");
686 PATH_TEST_EQ(path("f") / "b" / ".." / "a", "f/b/../a");
687 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / "..", "foo/bar/blah/../..");
688 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo/bar/blah/../../bletch");
689
690 PATH_TEST_EQ(path(".") / "foo", "./foo");
691 PATH_TEST_EQ(path(".") / "..", "./..");
692 PATH_TEST_EQ(path("foo") / ".", "foo/.");
693 PATH_TEST_EQ(path("..") / ".", "../.");
694 PATH_TEST_EQ(path(".") / ".", "./.");
695 PATH_TEST_EQ(path(".") / "." / ".", "././.");
696 PATH_TEST_EQ(path(".") / "foo" / ".", "./foo/.");
697 PATH_TEST_EQ(path("foo") / "." / "bar", "foo/./bar");
698 PATH_TEST_EQ(path("foo") / "." / ".", "foo/./.");
699 PATH_TEST_EQ(path("foo") / "." / "..", "foo/./..");
700 PATH_TEST_EQ(path(".") / "." / "..", "././..");
701 PATH_TEST_EQ(path(".") / ".." / ".", "./../.");
702 PATH_TEST_EQ(path("..") / "." / ".", ".././.");
703
704 #if BOOST_FILESYSTEM_VERSION == 3
705 PATH_TEST_EQ(path("//net1/foo") / "//net2/bar", "//net1/foo//net2/bar");
706 PATH_TEST_EQ(path("//net1/foo") / "/bar", "//net1/foo/bar");
707 #else
708 PATH_TEST_EQ(path("//net1/foo") / "//net2/bar", "//net2/bar");
709 PATH_TEST_EQ(path("//net1/foo") / "/bar", "/bar");
710 #endif
711 PATH_TEST_EQ(path("//net1/foo") / "bar", "//net1/foo/bar");
712 }
713
714 // probe operator <
715 BOOST_TEST(!(e < e2));
716 BOOST_TEST(!(es < e2));
717 BOOST_TEST(!(ecs < e2));
718 BOOST_TEST(!(e < es2));
719 BOOST_TEST(!(e < ecs2));
720
721 BOOST_TEST(e < a);
722 BOOST_TEST(es < a);
723 BOOST_TEST(ecs < a);
724 BOOST_TEST(e < as);
725 BOOST_TEST(e < acs);
726
727 BOOST_TEST(a < b);
728 BOOST_TEST(as < b);
729 BOOST_TEST(acs < b);
730 BOOST_TEST(a < bs);
731 BOOST_TEST(a < bcs);
732
733 BOOST_TEST(!(a < a2));
734 BOOST_TEST(!(as < a2));
735 BOOST_TEST(!(acs < a2));
736 BOOST_TEST(!(a < as2));
737 BOOST_TEST(!(a < acs2));
738
739 // make sure basic_path overloads don't conflict with std::string overloads
740
741 BOOST_TEST(!(as < as));
742 BOOST_TEST(!(as < acs));
743 BOOST_TEST(!(acs < as));
744
745 // character set reality check before lexicographical tests
746 BOOST_TEST(std::string("a.b") < std::string("a/b"));
747 // verify compare is actually lexicographical
748 BOOST_TEST(path("a/b") < path("a.b"));
749 BOOST_TEST(path("a/b") == path("a///b"));
750 #if BOOST_FILESYSTEM_VERSION == 3
751 BOOST_TEST(path("a/b/") == path("a/b/."));
752 #else
753 BOOST_TEST(path("a/b/") != path("a/b/."));
754 #endif
755 BOOST_TEST(path("a/b") != path("a/b/"));
756
757 // make sure the derivative operators also work
758
759 BOOST_TEST(b > a);
760 BOOST_TEST(b > as);
761 BOOST_TEST(b > acs);
762 BOOST_TEST(bs > a);
763 BOOST_TEST(bcs > a);
764
765 BOOST_TEST(!(a2 > a));
766 BOOST_TEST(!(a2 > as));
767 BOOST_TEST(!(a2 > acs));
768 BOOST_TEST(!(as2 > a));
769 BOOST_TEST(!(acs2 > a));
770
771 BOOST_TEST(a <= b);
772 BOOST_TEST(as <= b);
773 BOOST_TEST(acs <= b);
774 BOOST_TEST(a <= bs);
775 BOOST_TEST(a <= bcs);
776
777 BOOST_TEST(a <= a2);
778 BOOST_TEST(as <= a2);
779 BOOST_TEST(acs <= a2);
780 BOOST_TEST(a <= as2);
781 BOOST_TEST(a <= acs2);
782
783 BOOST_TEST(b >= a);
784 BOOST_TEST(bs >= a);
785 BOOST_TEST(bcs >= a);
786 BOOST_TEST(b >= as);
787 BOOST_TEST(b >= acs);
788
789 BOOST_TEST(a2 >= a);
790 BOOST_TEST(as2 >= a);
791 BOOST_TEST(acs2 >= a);
792 BOOST_TEST(a2 >= as);
793 BOOST_TEST(a2 >= acs);
794
795 // operator == and != are implemented separately, so test separately
796
797 path p101("fe/fi/fo/fum");
798 path p102(p101);
799 path p103("fe/fi/fo/fumm");
800 BOOST_TEST(p101.string() != p103.string());
801
802 // check each overload
803 BOOST_TEST(p101 != p103);
804 BOOST_TEST(p101 != p103.string());
805 BOOST_TEST(p101 != p103.string().c_str());
806 BOOST_TEST(p101.string() != p103);
807 BOOST_TEST(p101.string().c_str() != p103);
808
809 p103 = p102;
810 BOOST_TEST(p101.string() == p103.string());
811
812 // check each overload
813 BOOST_TEST(p101 == p103);
814 BOOST_TEST(p101 == p103.string());
815 BOOST_TEST(p101 == p103.string().c_str());
816 BOOST_TEST(p101.string() == p103);
817 BOOST_TEST(p101.string().c_str() == p103);
818
819 if (platform == "Windows")
820 {
821 std::cout << " Windows relational tests..." << std::endl;
822 path p10("c:\\file");
823 path p11("c:/file");
824 // check each overload
825 BOOST_TEST(p10.generic_string() == p11.generic_string());
826 BOOST_TEST(p10 == p11);
827 BOOST_TEST(p10 == p11.string());
828 BOOST_TEST(p10 == p11.string().c_str());
829 BOOST_TEST(p10.string() == p11);
830 BOOST_TEST(p10.string().c_str() == p11);
831 BOOST_TEST(p10 == L"c:\\file");
832 BOOST_TEST(p10 == L"c:/file");
833 BOOST_TEST(p11 == L"c:\\file");
834 BOOST_TEST(p11 == L"c:/file");
835 BOOST_TEST(L"c:\\file" == p10);
836 BOOST_TEST(L"c:/file" == p10);
837 BOOST_TEST(L"c:\\file" == p11);
838 BOOST_TEST(L"c:/file" == p11);
839
840 BOOST_TEST(!(p10.generic_string() != p11.generic_string()));
841 BOOST_TEST(!(p10 != p11));
842 BOOST_TEST(!(p10 != p11.string()));
843 BOOST_TEST(!(p10 != p11.string().c_str()));
844 BOOST_TEST(!(p10.string() != p11));
845 BOOST_TEST(!(p10.string().c_str() != p11));
846 BOOST_TEST(!(p10 != L"c:\\file"));
847 BOOST_TEST(!(p10 != L"c:/file"));
848 BOOST_TEST(!(p11 != L"c:\\file"));
849 BOOST_TEST(!(p11 != L"c:/file"));
850 BOOST_TEST(!(L"c:\\file" != p10));
851 BOOST_TEST(!(L"c:/file" != p10));
852 BOOST_TEST(!(L"c:\\file" != p11));
853 BOOST_TEST(!(L"c:/file" != p11));
854
855 BOOST_TEST(!(p10.string() < p11.string()));
856 BOOST_TEST(!(p10 < p11));
857 BOOST_TEST(!(p10 < p11.string()));
858 BOOST_TEST(!(p10 < p11.string().c_str()));
859 BOOST_TEST(!(p10.string() < p11));
860 BOOST_TEST(!(p10.string().c_str() < p11));
861 BOOST_TEST(!(p10 < L"c:\\file"));
862 BOOST_TEST(!(p10 < L"c:/file"));
863 BOOST_TEST(!(p11 < L"c:\\file"));
864 BOOST_TEST(!(p11 < L"c:/file"));
865 BOOST_TEST(!(L"c:\\file" < p10));
866 BOOST_TEST(!(L"c:/file" < p10));
867 BOOST_TEST(!(L"c:\\file" < p11));
868 BOOST_TEST(!(L"c:/file" < p11));
869
870 BOOST_TEST(!(p10.generic_string() > p11.generic_string()));
871 BOOST_TEST(!(p10 > p11));
872 BOOST_TEST(!(p10 > p11.string()));
873 BOOST_TEST(!(p10 > p11.string().c_str()));
874 BOOST_TEST(!(p10.string() > p11));
875 BOOST_TEST(!(p10.string().c_str() > p11));
876 BOOST_TEST(!(p10 > L"c:\\file"));
877 BOOST_TEST(!(p10 > L"c:/file"));
878 BOOST_TEST(!(p11 > L"c:\\file"));
879 BOOST_TEST(!(p11 > L"c:/file"));
880 BOOST_TEST(!(L"c:\\file" > p10));
881 BOOST_TEST(!(L"c:/file" > p10));
882 BOOST_TEST(!(L"c:\\file" > p11));
883 BOOST_TEST(!(L"c:/file" > p11));
884 }
885
886 // relative
887
888 BOOST_TEST(fs::relative("/abc/def", "/abc") == path("def"));
889 BOOST_TEST(fs::relative("abc/def", "abc") == path("def"));
890 BOOST_TEST(fs::relative("/abc/xyz/def", "/abc") == path("xyz/def"));
891 BOOST_TEST(fs::relative("abc/xyz/def", "abc") == path("xyz/def"));
892
893 if (platform == "Windows")
894 {
895 std::cout << " Windows relatie tests..." << std::endl;
896 BOOST_TEST(fs::relative("\\abc\\xyz\\def", "/abc") == path("xyz/def"));
897 std::cout << " fs::relative(\"/abc/xyz/def\", \"/abc\") is "
898 << fs::relative("/abc/xyz/def", "/abc") << std::endl;
899 BOOST_TEST(fs::relative("abc\\xyz\\def", "abc") == path("xyz/def"));
900 }
901 }
902
903 // query_and_decomposition_tests ---------------------------------------------------//
904 //
905 // remove_filename() is also tested here, because its specification depends on
906 // a decomposition function.
907
908 void query_and_decomposition_tests()
909 {
910 std::cout << "query_and_decomposition_tests..." << std::endl;
911
912 // these are the examples given in reference docs, so check they work
913 BOOST_TEST(path("/foo/bar.txt").parent_path() == "/foo");
914 BOOST_TEST(path("/foo/bar").parent_path() == "/foo");
915 BOOST_TEST(path("/foo/bar/").parent_path() == "/foo/bar");
916 BOOST_TEST(path("/").parent_path() == "");
917 BOOST_TEST(path(".").parent_path() == "");
918 BOOST_TEST(path("..").parent_path() == "");
919 BOOST_TEST(path("/foo/bar.txt").filename() == "bar.txt");
920 BOOST_TEST(path("/foo/bar").filename() == "bar");
921 BOOST_TEST(path("/foo/bar/").filename() == BOOST_FILESYSTEM_V3_TRAILING_DOT);
922 #if BOOST_FILESYSTEM_VERSION == 3
923 BOOST_TEST(path("/").filename() == "/");
924 #else
925 BOOST_TEST(path("/").filename() == "");
926 #endif
927 BOOST_TEST(path(".").filename() == ".");
928 BOOST_TEST(path("..").filename() == "..");
929
930 // stem() tests not otherwise covered
931 BOOST_TEST(path(".").stem() == ".");
932 BOOST_TEST(path("..").stem() == "..");
933 #if BOOST_FILESYSTEM_VERSION == 3
934 BOOST_TEST(path(".a").stem() == "");
935 #else
936 BOOST_TEST(path(".a").stem() == ".a");
937 #endif
938 BOOST_TEST(path("b").stem() == "b");
939 BOOST_TEST(path("a/b.txt").stem() == "b");
940 BOOST_TEST(path("a/b.").stem() == "b");
941 BOOST_TEST(path("a.b.c").stem() == "a.b");
942 BOOST_TEST(path("a.b.c.").stem() == "a.b.c");
943
944 // extension() tests not otherwise covered
945 BOOST_TEST(path(".").extension() == "");
946 BOOST_TEST(path("..").extension() == "");
947 #if BOOST_FILESYSTEM_VERSION == 3
948 BOOST_TEST(path(".a").extension() == ".a");
949 #else
950 BOOST_TEST(path(".a").extension() == "");
951 #endif
952 BOOST_TEST(path("a/b").extension() == "");
953 BOOST_TEST(path("a.b/c").extension() == "");
954 BOOST_TEST(path("a/b.txt").extension() == ".txt");
955 BOOST_TEST(path("a/b.").extension() == ".");
956 BOOST_TEST(path("a.b.c").extension() == ".c");
957 BOOST_TEST(path("a.b.c.").extension() == ".");
958 BOOST_TEST(path("a/").extension() == "");
959
960 // main q & d test sequence
961 path p;
962 path q;
963
964 p = q = "";
965 BOOST_TEST(p.relative_path().string() == "");
966 BOOST_TEST(p.parent_path().string() == "");
967 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
968 BOOST_TEST(p.filename() == "");
969 BOOST_TEST(p.stem() == "");
970 BOOST_TEST(p.extension() == "");
971 BOOST_TEST(p.root_name() == "");
972 BOOST_TEST(p.root_directory() == "");
973 BOOST_TEST(p.root_path().string() == "");
974 BOOST_TEST(!p.has_root_path());
975 BOOST_TEST(!p.has_root_name());
976 BOOST_TEST(!p.has_root_directory());
977 BOOST_TEST(!p.has_relative_path());
978 BOOST_TEST(!p.has_filename());
979 BOOST_TEST(!p.has_stem());
980 BOOST_TEST(!p.has_extension());
981 BOOST_TEST(!p.has_parent_path());
982 BOOST_TEST(!p.is_absolute());
983
984 p = q = "/";
985 BOOST_TEST(p.relative_path().string() == "");
986 BOOST_TEST(p.parent_path().string() == "");
987 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
988 #if BOOST_FILESYSTEM_VERSION == 3
989 BOOST_TEST(p.filename() == "/");
990 BOOST_TEST(p.stem() == "/");
991 #else
992 BOOST_TEST(p.filename() == "");
993 BOOST_TEST(p.stem() == "");
994 #endif
995 BOOST_TEST(p.extension() == "");
996 BOOST_TEST(p.root_name() == "");
997 BOOST_TEST(p.root_directory() == "/");
998 BOOST_TEST(p.root_path().string() == "/");
999 BOOST_TEST(p.has_root_path());
1000 BOOST_TEST(!p.has_root_name());
1001 BOOST_TEST(p.has_root_directory());
1002 BOOST_TEST(!p.has_relative_path());
1003 #if BOOST_FILESYSTEM_VERSION == 3
1004 BOOST_TEST(p.has_filename());
1005 BOOST_TEST(p.has_stem());
1006 #else
1007 BOOST_TEST(!p.has_filename());
1008 BOOST_TEST(!p.has_stem());
1009 #endif
1010 BOOST_TEST(!p.has_extension());
1011 BOOST_TEST(!p.has_parent_path());
1012 if (platform == "POSIX")
1013 BOOST_TEST(p.is_absolute());
1014 else
1015 BOOST_TEST(!p.is_absolute());
1016
1017 p = q = "//";
1018 PATH_TEST_EQ(p.relative_path().string(), "");
1019 PATH_TEST_EQ(p.parent_path().string(), "");
1020 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1021 #if BOOST_FILESYSTEM_VERSION == 3
1022 PATH_TEST_EQ(p.filename(), "//");
1023 PATH_TEST_EQ(p.stem(), "//");
1024 #else
1025 PATH_TEST_EQ(p.filename(), "");
1026 PATH_TEST_EQ(p.stem(), "");
1027 #endif
1028 PATH_TEST_EQ(p.extension(), "");
1029 PATH_TEST_EQ(p.root_name(), "//");
1030 PATH_TEST_EQ(p.root_directory(), "");
1031 PATH_TEST_EQ(p.root_path().string(), "//");
1032 BOOST_TEST(p.has_root_path());
1033 BOOST_TEST(p.has_root_name());
1034 BOOST_TEST(!p.has_root_directory());
1035 BOOST_TEST(!p.has_relative_path());
1036 #if BOOST_FILESYSTEM_VERSION == 3
1037 BOOST_TEST(p.has_filename());
1038 BOOST_TEST(p.has_stem());
1039 #else
1040 BOOST_TEST(!p.has_filename());
1041 BOOST_TEST(!p.has_stem());
1042 #endif
1043 BOOST_TEST(!p.has_extension());
1044 BOOST_TEST(!p.has_parent_path());
1045 BOOST_TEST(!p.is_absolute());
1046
1047 p = q = "///";
1048 PATH_TEST_EQ(p.relative_path().string(), "");
1049 PATH_TEST_EQ(p.parent_path().string(), "");
1050 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1051 #if BOOST_FILESYSTEM_VERSION == 3
1052 PATH_TEST_EQ(p.filename(), "/");
1053 PATH_TEST_EQ(p.stem(), "/");
1054 #else
1055 PATH_TEST_EQ(p.filename(), "");
1056 PATH_TEST_EQ(p.stem(), "");
1057 #endif
1058 PATH_TEST_EQ(p.extension(), "");
1059 PATH_TEST_EQ(p.root_name(), "");
1060 PATH_TEST_EQ(p.root_directory(), "/");
1061 PATH_TEST_EQ(p.root_path().string(), "/");
1062 BOOST_TEST(p.has_root_path());
1063 BOOST_TEST(!p.has_root_name());
1064 BOOST_TEST(p.has_root_directory());
1065 BOOST_TEST(!p.has_relative_path());
1066 #if BOOST_FILESYSTEM_VERSION == 3
1067 BOOST_TEST(p.has_filename());
1068 BOOST_TEST(p.has_stem());
1069 #else
1070 BOOST_TEST(!p.has_filename());
1071 BOOST_TEST(!p.has_stem());
1072 #endif
1073 BOOST_TEST(!p.has_extension());
1074 BOOST_TEST(!p.has_parent_path());
1075 if (platform == "POSIX")
1076 BOOST_TEST(p.is_absolute());
1077 else
1078 BOOST_TEST(!p.is_absolute());
1079
1080 p = q = ".";
1081 BOOST_TEST(p.relative_path().string() == ".");
1082 BOOST_TEST(p.parent_path().string() == "");
1083 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1084 BOOST_TEST(p.filename() == ".");
1085 BOOST_TEST(p.stem() == ".");
1086 BOOST_TEST(p.extension() == "");
1087 BOOST_TEST(p.root_name() == "");
1088 BOOST_TEST(p.root_directory() == "");
1089 BOOST_TEST(p.root_path().string() == "");
1090 BOOST_TEST(!p.has_root_path());
1091 BOOST_TEST(!p.has_root_name());
1092 BOOST_TEST(!p.has_root_directory());
1093 BOOST_TEST(p.has_relative_path());
1094 BOOST_TEST(p.has_filename());
1095 BOOST_TEST(p.has_stem());
1096 BOOST_TEST(!p.has_extension());
1097 BOOST_TEST(!p.has_parent_path());
1098 BOOST_TEST(!p.is_absolute());
1099
1100 p = q = "..";
1101 BOOST_TEST(p.relative_path().string() == "..");
1102 BOOST_TEST(p.parent_path().string() == "");
1103 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1104 BOOST_TEST(p.filename() == "..");
1105 BOOST_TEST(p.stem() == "..");
1106 BOOST_TEST(p.extension() == "");
1107 BOOST_TEST(p.root_name() == "");
1108 BOOST_TEST(p.root_directory() == "");
1109 BOOST_TEST(p.root_path().string() == "");
1110 BOOST_TEST(!p.has_root_path());
1111 BOOST_TEST(!p.has_root_name());
1112 BOOST_TEST(!p.has_root_directory());
1113 BOOST_TEST(p.has_relative_path());
1114 BOOST_TEST(p.has_filename());
1115 BOOST_TEST(p.has_stem());
1116 BOOST_TEST(!p.has_extension());
1117 BOOST_TEST(!p.has_parent_path());
1118 BOOST_TEST(!p.is_absolute());
1119
1120 p = q = "foo";
1121 BOOST_TEST(p.relative_path().string() == "foo");
1122 BOOST_TEST(p.parent_path().string() == "");
1123 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1124 BOOST_TEST(p.filename() == "foo");
1125 BOOST_TEST(p.stem() == "foo");
1126 BOOST_TEST(p.extension() == "");
1127 BOOST_TEST(p.root_name() == "");
1128 BOOST_TEST(p.root_directory() == "");
1129 BOOST_TEST(p.root_path().string() == "");
1130 BOOST_TEST(!p.has_root_path());
1131 BOOST_TEST(!p.has_root_name());
1132 BOOST_TEST(!p.has_root_directory());
1133 BOOST_TEST(p.has_relative_path());
1134 BOOST_TEST(p.has_filename());
1135 BOOST_TEST(p.has_stem());
1136 BOOST_TEST(!p.has_extension());
1137 BOOST_TEST(!p.has_parent_path());
1138 BOOST_TEST(!p.is_absolute());
1139
1140 p = q = "/foo";
1141 PATH_TEST_EQ(p.relative_path().string(), "foo");
1142 PATH_TEST_EQ(p.parent_path().string(), "/");
1143 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1144 PATH_TEST_EQ(p.filename(), "foo");
1145 PATH_TEST_EQ(p.stem(), "foo");
1146 PATH_TEST_EQ(p.extension(), "");
1147 PATH_TEST_EQ(p.root_name(), "");
1148 PATH_TEST_EQ(p.root_directory(), "/");
1149 PATH_TEST_EQ(p.root_path().string(), "/");
1150 BOOST_TEST(p.has_root_path());
1151 BOOST_TEST(!p.has_root_name());
1152 BOOST_TEST(p.has_root_directory());
1153 BOOST_TEST(p.has_relative_path());
1154 BOOST_TEST(p.has_filename());
1155 BOOST_TEST(p.has_stem());
1156 BOOST_TEST(!p.has_extension());
1157 BOOST_TEST(p.has_parent_path());
1158 if (platform == "POSIX")
1159 BOOST_TEST(p.is_absolute());
1160 else
1161 BOOST_TEST(!p.is_absolute());
1162
1163 p = q = "/foo/";
1164 PATH_TEST_EQ(p.relative_path().string(), "foo/");
1165 PATH_TEST_EQ(p.parent_path().string(), "/foo");
1166 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1167 PATH_TEST_EQ(p.filename(), BOOST_FILESYSTEM_V3_TRAILING_DOT);
1168 PATH_TEST_EQ(p.stem(), BOOST_FILESYSTEM_V3_TRAILING_DOT);
1169 PATH_TEST_EQ(p.extension(), "");
1170 PATH_TEST_EQ(p.root_name(), "");
1171 PATH_TEST_EQ(p.root_directory(), "/");
1172 PATH_TEST_EQ(p.root_path().string(), "/");
1173 BOOST_TEST(p.has_root_path());
1174 BOOST_TEST(!p.has_root_name());
1175 BOOST_TEST(p.has_root_directory());
1176 BOOST_TEST(p.has_relative_path());
1177 #if BOOST_FILESYSTEM_VERSION == 3
1178 BOOST_TEST(p.has_filename());
1179 BOOST_TEST(p.has_stem());
1180 #else
1181 BOOST_TEST(!p.has_filename());
1182 BOOST_TEST(!p.has_stem());
1183 #endif
1184 BOOST_TEST(!p.has_extension());
1185 BOOST_TEST(p.has_parent_path());
1186 if (platform == "POSIX")
1187 BOOST_TEST(p.is_absolute());
1188 else
1189 BOOST_TEST(!p.is_absolute());
1190
1191 p = q = "///foo";
1192 PATH_TEST_EQ(p.relative_path().string(), "foo");
1193 PATH_TEST_EQ(p.parent_path().string(), "/");
1194 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1195 PATH_TEST_EQ(p.filename(), "foo");
1196 PATH_TEST_EQ(p.root_name(), "");
1197 PATH_TEST_EQ(p.root_directory(), "/");
1198 PATH_TEST_EQ(p.root_path().string(), "/");
1199 BOOST_TEST(p.has_root_path());
1200 BOOST_TEST(!p.has_root_name());
1201 BOOST_TEST(p.has_root_directory());
1202 BOOST_TEST(p.has_relative_path());
1203 BOOST_TEST(p.has_filename());
1204 BOOST_TEST(p.has_parent_path());
1205 if (platform == "POSIX")
1206 BOOST_TEST(p.is_absolute());
1207 else
1208 BOOST_TEST(!p.is_absolute());
1209
1210 p = q = "foo/bar";
1211 BOOST_TEST(p.relative_path().string() == "foo/bar");
1212 BOOST_TEST(p.parent_path().string() == "foo");
1213 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1214 BOOST_TEST(p.filename() == "bar");
1215 BOOST_TEST(p.stem() == "bar");
1216 BOOST_TEST(p.extension() == "");
1217 BOOST_TEST(p.root_name() == "");
1218 BOOST_TEST(p.root_directory() == "");
1219 BOOST_TEST(p.root_path().string() == "");
1220 BOOST_TEST(!p.has_root_path());
1221 BOOST_TEST(!p.has_root_name());
1222 BOOST_TEST(!p.has_root_directory());
1223 BOOST_TEST(p.has_relative_path());
1224 BOOST_TEST(p.has_filename());
1225 BOOST_TEST(p.has_stem());
1226 BOOST_TEST(!p.has_extension());
1227 BOOST_TEST(p.has_parent_path());
1228 BOOST_TEST(!p.is_absolute());
1229
1230 p = q = "../foo";
1231 BOOST_TEST(p.relative_path().string() == "../foo");
1232 BOOST_TEST(p.parent_path().string() == "..");
1233 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1234 BOOST_TEST(p.filename() == "foo");
1235 BOOST_TEST(p.root_name() == "");
1236 BOOST_TEST(p.root_directory() == "");
1237 BOOST_TEST(p.root_path().string() == "");
1238 BOOST_TEST(!p.has_root_path());
1239 BOOST_TEST(!p.has_root_name());
1240 BOOST_TEST(!p.has_root_directory());
1241 BOOST_TEST(p.has_relative_path());
1242 BOOST_TEST(p.has_filename());
1243 BOOST_TEST(p.has_parent_path());
1244 BOOST_TEST(!p.is_absolute());
1245
1246 p = q = "..///foo";
1247 PATH_TEST_EQ(p.relative_path().string(), "..///foo");
1248 PATH_TEST_EQ(p.parent_path().string(), "..");
1249 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1250 PATH_TEST_EQ(p.filename(), "foo");
1251 PATH_TEST_EQ(p.root_name(), "");
1252 PATH_TEST_EQ(p.root_directory(), "");
1253 PATH_TEST_EQ(p.root_path().string(), "");
1254 BOOST_TEST(!p.has_root_path());
1255 BOOST_TEST(!p.has_root_name());
1256 BOOST_TEST(!p.has_root_directory());
1257 BOOST_TEST(p.has_relative_path());
1258 BOOST_TEST(p.has_filename());
1259 BOOST_TEST(p.has_parent_path());
1260 BOOST_TEST(!p.is_absolute());
1261
1262 p = q = "/foo/bar";
1263 BOOST_TEST(p.relative_path().string() == "foo/bar");
1264 BOOST_TEST(p.parent_path().string() == "/foo");
1265 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1266 BOOST_TEST(p.filename() == "bar");
1267 BOOST_TEST(p.root_name() == "");
1268 BOOST_TEST(p.root_directory() == "/");
1269 BOOST_TEST(p.root_path().string() == "/");
1270 BOOST_TEST(p.has_root_path());
1271 BOOST_TEST(!p.has_root_name());
1272 BOOST_TEST(p.has_root_directory());
1273 BOOST_TEST(p.has_relative_path());
1274 BOOST_TEST(p.has_filename());
1275 BOOST_TEST(p.has_parent_path());
1276 if (platform == "POSIX")
1277 BOOST_TEST(p.is_absolute());
1278 else
1279 BOOST_TEST(!p.is_absolute());
1280
1281 // Both POSIX and Windows allow two leading slashs
1282 // (POSIX meaning is implementation defined)
1283 PATH_TEST_EQ(path("//resource"), "//resource");
1284 PATH_TEST_EQ(path("//resource/"), "//resource/");
1285 PATH_TEST_EQ(path("//resource/foo"), "//resource/foo");
1286
1287 p = q = path("//net");
1288 PATH_TEST_EQ(p.string(), "//net");
1289 PATH_TEST_EQ(p.relative_path().string(), "");
1290 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1291 PATH_TEST_EQ(p.parent_path().string(), "");
1292 #if BOOST_FILESYSTEM_VERSION == 3
1293 PATH_TEST_EQ(p.filename(), "//net");
1294 #else
1295 PATH_TEST_EQ(p.filename(), "");
1296 #endif
1297 PATH_TEST_EQ(p.root_name(), "//net");
1298 PATH_TEST_EQ(p.root_directory(), "");
1299 PATH_TEST_EQ(p.root_path().string(), "//net");
1300 BOOST_TEST(p.has_root_path());
1301 BOOST_TEST(p.has_root_name());
1302 BOOST_TEST(!p.has_root_directory());
1303 BOOST_TEST(!p.has_relative_path());
1304 #if BOOST_FILESYSTEM_VERSION == 3
1305 BOOST_TEST(p.has_filename());
1306 #else
1307 BOOST_TEST(!p.has_filename());
1308 #endif
1309 BOOST_TEST(!p.has_parent_path());
1310 BOOST_TEST(!p.is_absolute());
1311
1312 p = q = path("//net/");
1313 BOOST_TEST(p.relative_path().string() == "");
1314 BOOST_TEST(p.parent_path().string() == "//net");
1315 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1316 #if BOOST_FILESYSTEM_VERSION == 3
1317 BOOST_TEST(p.filename() == "/");
1318 #else
1319 BOOST_TEST(p.filename() == "");
1320 #endif
1321 BOOST_TEST(p.root_name() == "//net");
1322 BOOST_TEST(p.root_directory() == "/");
1323 BOOST_TEST(p.root_path().string() == "//net/");
1324 BOOST_TEST(p.has_root_path());
1325 BOOST_TEST(p.has_root_name());
1326 BOOST_TEST(p.has_root_directory());
1327 BOOST_TEST(!p.has_relative_path());
1328 #if BOOST_FILESYSTEM_VERSION == 3
1329 BOOST_TEST(p.has_filename());
1330 #else
1331 BOOST_TEST(!p.has_filename());
1332 #endif
1333 BOOST_TEST(p.has_parent_path());
1334 BOOST_TEST(p.is_absolute());
1335
1336 p = q = path("//net/foo");
1337 BOOST_TEST(p.relative_path().string() == "foo");
1338 BOOST_TEST(p.parent_path().string() == "//net/");
1339 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1340 BOOST_TEST(p.filename() == "foo");
1341 BOOST_TEST(p.root_name() == "//net");
1342 BOOST_TEST(p.root_directory() == "/");
1343 BOOST_TEST(p.root_path().string() == "//net/");
1344 BOOST_TEST(p.has_root_path());
1345 BOOST_TEST(p.has_root_name());
1346 BOOST_TEST(p.has_root_directory());
1347 BOOST_TEST(p.has_relative_path());
1348 BOOST_TEST(p.has_filename());
1349 BOOST_TEST(p.has_parent_path());
1350 BOOST_TEST(p.is_absolute());
1351
1352 p = q = path("//net///foo");
1353 PATH_TEST_EQ(p.relative_path().string(), "foo");
1354 PATH_TEST_EQ(p.parent_path().string(), "//net/");
1355 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1356 PATH_TEST_EQ(p.filename(), "foo");
1357 PATH_TEST_EQ(p.root_name(), "//net");
1358 PATH_TEST_EQ(p.root_directory(), "/");
1359 PATH_TEST_EQ(p.root_path().string(), "//net/");
1360 BOOST_TEST(p.has_root_path());
1361 BOOST_TEST(p.has_root_name());
1362 BOOST_TEST(p.has_root_directory());
1363 BOOST_TEST(p.has_relative_path());
1364 BOOST_TEST(p.has_filename());
1365 BOOST_TEST(p.has_parent_path());
1366 BOOST_TEST(p.is_absolute());
1367
1368 // ticket 2739, infinite recursion leading to stack overflow, was caused
1369 // by failure to handle this case correctly on Windows.
1370 p = path(":");
1371 PATH_TEST_EQ(p.parent_path().string(), "");
1372 PATH_TEST_EQ(p.filename(), ":");
1373 BOOST_TEST(!p.has_parent_path());
1374 BOOST_TEST(p.has_filename());
1375
1376
1377 // Windows specific tests
1378 if (platform == "Windows")
1379 {
1380 p = q = path("\\\\?\\");
1381 PATH_TEST_EQ(p.relative_path().string(), "");
1382 PATH_TEST_EQ(p.parent_path().string(), "");
1383 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1384 #if BOOST_FILESYSTEM_VERSION == 3
1385 PATH_TEST_EQ(p.filename(), "\\\\?\\");
1386 PATH_TEST_EQ(p.stem(), "\\\\?\\");
1387 #else
1388 PATH_TEST_EQ(p.filename(), "");
1389 PATH_TEST_EQ(p.stem(), "");
1390 #endif
1391 PATH_TEST_EQ(p.extension(), "");
1392 PATH_TEST_EQ(p.root_name(), "\\\\?\\");
1393 PATH_TEST_EQ(p.root_directory(), "");
1394 PATH_TEST_EQ(p.root_path().string(), "\\\\?\\");
1395 BOOST_TEST(p.has_root_path());
1396 BOOST_TEST(p.has_root_name());
1397 BOOST_TEST(!p.has_root_directory());
1398 BOOST_TEST(!p.has_relative_path());
1399 #if BOOST_FILESYSTEM_VERSION == 3
1400 BOOST_TEST(p.has_filename());
1401 BOOST_TEST(p.has_stem());
1402 #else
1403 BOOST_TEST(!p.has_filename());
1404 BOOST_TEST(!p.has_stem());
1405 #endif
1406 BOOST_TEST(!p.has_extension());
1407 BOOST_TEST(!p.has_parent_path());
1408 BOOST_TEST(!p.is_absolute());
1409
1410 p = q = path("\\\\.\\");
1411 PATH_TEST_EQ(p.relative_path().string(), "");
1412 PATH_TEST_EQ(p.parent_path().string(), "");
1413 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1414 #if BOOST_FILESYSTEM_VERSION == 3
1415 PATH_TEST_EQ(p.filename(), "\\\\.\\");
1416 PATH_TEST_EQ(p.stem(), "\\\\");
1417 PATH_TEST_EQ(p.extension(), ".\\");
1418 #else
1419 PATH_TEST_EQ(p.filename(), "");
1420 PATH_TEST_EQ(p.stem(), "");
1421 PATH_TEST_EQ(p.extension(), "");
1422 #endif
1423 PATH_TEST_EQ(p.root_name(), "\\\\.\\");
1424 PATH_TEST_EQ(p.root_directory(), "");
1425 PATH_TEST_EQ(p.root_path().string(), "\\\\.\\");
1426 BOOST_TEST(p.has_root_path());
1427 BOOST_TEST(p.has_root_name());
1428 BOOST_TEST(!p.has_root_directory());
1429 BOOST_TEST(!p.has_relative_path());
1430 #if BOOST_FILESYSTEM_VERSION == 3
1431 BOOST_TEST(p.has_filename());
1432 BOOST_TEST(p.has_stem());
1433 BOOST_TEST(p.has_extension());
1434 #else
1435 BOOST_TEST(!p.has_filename());
1436 BOOST_TEST(!p.has_stem());
1437 BOOST_TEST(!p.has_extension());
1438 #endif
1439 BOOST_TEST(!p.has_parent_path());
1440 BOOST_TEST(!p.is_absolute());
1441
1442 p = q = path("\\??\\");
1443 PATH_TEST_EQ(p.relative_path().string(), "");
1444 PATH_TEST_EQ(p.parent_path().string(), "");
1445 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1446 #if BOOST_FILESYSTEM_VERSION == 3
1447 PATH_TEST_EQ(p.filename(), "\\??\\");
1448 PATH_TEST_EQ(p.stem(), "\\??\\");
1449 #else
1450 PATH_TEST_EQ(p.filename(), "");
1451 PATH_TEST_EQ(p.stem(), "");
1452 #endif
1453 PATH_TEST_EQ(p.extension(), "");
1454 PATH_TEST_EQ(p.root_name(), "\\??\\");
1455 PATH_TEST_EQ(p.root_directory(), "");
1456 PATH_TEST_EQ(p.root_path().string(), "\\??\\");
1457 BOOST_TEST(p.has_root_path());
1458 BOOST_TEST(p.has_root_name());
1459 BOOST_TEST(!p.has_root_directory());
1460 BOOST_TEST(!p.has_relative_path());
1461 #if BOOST_FILESYSTEM_VERSION == 3
1462 BOOST_TEST(p.has_filename());
1463 BOOST_TEST(p.has_stem());
1464 #else
1465 BOOST_TEST(!p.has_filename());
1466 BOOST_TEST(!p.has_stem());
1467 #endif
1468 BOOST_TEST(!p.has_extension());
1469 BOOST_TEST(!p.has_parent_path());
1470 BOOST_TEST(!p.is_absolute());
1471
1472 p = q = path("c:");
1473 PATH_TEST_EQ(p.relative_path().string(), "");
1474 PATH_TEST_EQ(p.parent_path().string(), "");
1475 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1476 #if BOOST_FILESYSTEM_VERSION == 3
1477 PATH_TEST_EQ(p.filename(), "c:");
1478 #else
1479 PATH_TEST_EQ(p.filename(), "");
1480 #endif
1481 PATH_TEST_EQ(p.root_name(), "c:");
1482 PATH_TEST_EQ(p.root_directory(), "");
1483 PATH_TEST_EQ(p.root_path().string(), "c:");
1484 BOOST_TEST(p.has_root_path());
1485 BOOST_TEST(p.has_root_name());
1486 BOOST_TEST(!p.has_root_directory());
1487 BOOST_TEST(!p.has_relative_path());
1488 #if BOOST_FILESYSTEM_VERSION == 3
1489 BOOST_TEST(p.has_filename());
1490 #else
1491 BOOST_TEST(!p.has_filename());
1492 #endif
1493 BOOST_TEST(!p.has_parent_path());
1494 BOOST_TEST(!p.is_absolute());
1495
1496 p = q = path("\\\\?\\c:");
1497 PATH_TEST_EQ(p.relative_path().string(), "");
1498 PATH_TEST_EQ(p.parent_path().string(), "");
1499 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1500 #if BOOST_FILESYSTEM_VERSION == 3
1501 PATH_TEST_EQ(p.filename(), "\\\\?\\c:");
1502 #else
1503 PATH_TEST_EQ(p.filename(), "");
1504 #endif
1505 PATH_TEST_EQ(p.root_name(), "\\\\?\\c:");
1506 PATH_TEST_EQ(p.root_directory(), "");
1507 PATH_TEST_EQ(p.root_path().string(), "\\\\?\\c:");
1508 BOOST_TEST(p.has_root_path());
1509 BOOST_TEST(p.has_root_name());
1510 BOOST_TEST(!p.has_root_directory());
1511 BOOST_TEST(!p.has_relative_path());
1512 #if BOOST_FILESYSTEM_VERSION == 3
1513 BOOST_TEST(p.has_filename());
1514 #else
1515 BOOST_TEST(!p.has_filename());
1516 #endif
1517 BOOST_TEST(!p.has_parent_path());
1518 BOOST_TEST(!p.is_absolute());
1519
1520 p = q = path("\\\\.\\c:");
1521 PATH_TEST_EQ(p.relative_path().string(), "");
1522 PATH_TEST_EQ(p.parent_path().string(), "");
1523 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1524 #if BOOST_FILESYSTEM_VERSION == 3
1525 PATH_TEST_EQ(p.filename(), "\\\\.\\c:");
1526 #else
1527 PATH_TEST_EQ(p.filename(), "");
1528 #endif
1529 PATH_TEST_EQ(p.root_name(), "\\\\.\\c:");
1530 PATH_TEST_EQ(p.root_directory(), "");
1531 PATH_TEST_EQ(p.root_path().string(), "\\\\.\\c:");
1532 BOOST_TEST(p.has_root_path());
1533 BOOST_TEST(p.has_root_name());
1534 BOOST_TEST(!p.has_root_directory());
1535 BOOST_TEST(!p.has_relative_path());
1536 #if BOOST_FILESYSTEM_VERSION == 3
1537 BOOST_TEST(p.has_filename());
1538 #else
1539 BOOST_TEST(!p.has_filename());
1540 #endif
1541 BOOST_TEST(!p.has_parent_path());
1542 BOOST_TEST(!p.is_absolute());
1543
1544 p = q = path("\\??\\c:");
1545 PATH_TEST_EQ(p.relative_path().string(), "");
1546 PATH_TEST_EQ(p.parent_path().string(), "");
1547 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1548 #if BOOST_FILESYSTEM_VERSION == 3
1549 PATH_TEST_EQ(p.filename(), "\\??\\c:");
1550 #else
1551 PATH_TEST_EQ(p.filename(), "");
1552 #endif
1553 PATH_TEST_EQ(p.root_name(), "\\??\\c:");
1554 PATH_TEST_EQ(p.root_directory(), "");
1555 PATH_TEST_EQ(p.root_path().string(), "\\??\\c:");
1556 BOOST_TEST(p.has_root_path());
1557 BOOST_TEST(p.has_root_name());
1558 BOOST_TEST(!p.has_root_directory());
1559 BOOST_TEST(!p.has_relative_path());
1560 #if BOOST_FILESYSTEM_VERSION == 3
1561 BOOST_TEST(p.has_filename());
1562 #else
1563 BOOST_TEST(!p.has_filename());
1564 #endif
1565 BOOST_TEST(!p.has_parent_path());
1566 BOOST_TEST(!p.is_absolute());
1567
1568 p = q = path("c:foo");
1569 PATH_TEST_EQ(p.relative_path().string(), "foo");
1570 PATH_TEST_EQ(p.parent_path().string(), "c:");
1571 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1572 PATH_TEST_EQ(p.filename(), "foo");
1573 PATH_TEST_EQ(p.root_name(), "c:");
1574 PATH_TEST_EQ(p.root_directory(), "");
1575 PATH_TEST_EQ(p.root_path().string(), "c:");
1576 BOOST_TEST(p.has_root_path());
1577 BOOST_TEST(p.has_root_name());
1578 BOOST_TEST(!p.has_root_directory());
1579 BOOST_TEST(p.has_relative_path());
1580 BOOST_TEST(p.has_filename());
1581 BOOST_TEST(p.has_parent_path());
1582 BOOST_TEST(!p.is_absolute());
1583
1584 p = q = path("\\\\?\\c:foo");
1585 PATH_TEST_EQ(p.relative_path().string(), "foo");
1586 PATH_TEST_EQ(p.parent_path().string(), "\\\\?\\c:");
1587 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1588 PATH_TEST_EQ(p.filename(), "foo");
1589 PATH_TEST_EQ(p.root_name(), "\\\\?\\c:");
1590 PATH_TEST_EQ(p.root_directory(), "");
1591 PATH_TEST_EQ(p.root_path().string(), "\\\\?\\c:");
1592 BOOST_TEST(p.has_root_path());
1593 BOOST_TEST(p.has_root_name());
1594 BOOST_TEST(!p.has_root_directory());
1595 BOOST_TEST(p.has_relative_path());
1596 BOOST_TEST(p.has_filename());
1597 BOOST_TEST(p.has_parent_path());
1598 BOOST_TEST(!p.is_absolute());
1599
1600 p = q = path("\\\\.\\c:foo");
1601 PATH_TEST_EQ(p.relative_path().string(), "foo");
1602 PATH_TEST_EQ(p.parent_path().string(), "\\\\.\\c:");
1603 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1604 PATH_TEST_EQ(p.filename(), "foo");
1605 PATH_TEST_EQ(p.root_name(), "\\\\.\\c:");
1606 PATH_TEST_EQ(p.root_directory(), "");
1607 PATH_TEST_EQ(p.root_path().string(), "\\\\.\\c:");
1608 BOOST_TEST(p.has_root_path());
1609 BOOST_TEST(p.has_root_name());
1610 BOOST_TEST(!p.has_root_directory());
1611 BOOST_TEST(p.has_relative_path());
1612 BOOST_TEST(p.has_filename());
1613 BOOST_TEST(p.has_parent_path());
1614 BOOST_TEST(!p.is_absolute());
1615
1616 p = q = path("\\??\\c:foo");
1617 PATH_TEST_EQ(p.relative_path().string(), "foo");
1618 PATH_TEST_EQ(p.parent_path().string(), "\\??\\c:");
1619 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1620 PATH_TEST_EQ(p.filename(), "foo");
1621 PATH_TEST_EQ(p.root_name(), "\\??\\c:");
1622 PATH_TEST_EQ(p.root_directory(), "");
1623 PATH_TEST_EQ(p.root_path().string(), "\\??\\c:");
1624 BOOST_TEST(p.has_root_path());
1625 BOOST_TEST(p.has_root_name());
1626 BOOST_TEST(!p.has_root_directory());
1627 BOOST_TEST(p.has_relative_path());
1628 BOOST_TEST(p.has_filename());
1629 BOOST_TEST(p.has_parent_path());
1630 BOOST_TEST(!p.is_absolute());
1631
1632 p = q = path("c:/");
1633 PATH_TEST_EQ(p.relative_path().string(), "");
1634 PATH_TEST_EQ(p.parent_path().string(), "c:");
1635 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1636 #if BOOST_FILESYSTEM_VERSION == 3
1637 PATH_TEST_EQ(p.filename(), "/");
1638 #else
1639 PATH_TEST_EQ(p.filename(), "");
1640 #endif
1641 PATH_TEST_EQ(p.root_name(), "c:");
1642 PATH_TEST_EQ(p.root_directory(), "/");
1643 PATH_TEST_EQ(p.root_path().string(), "c:/");
1644 BOOST_TEST(p.has_root_path());
1645 BOOST_TEST(p.has_root_name());
1646 BOOST_TEST(p.has_root_directory());
1647 BOOST_TEST(!p.has_relative_path());
1648 #if BOOST_FILESYSTEM_VERSION == 3
1649 BOOST_TEST(p.has_filename());
1650 #else
1651 BOOST_TEST(!p.has_filename());
1652 #endif
1653 BOOST_TEST(p.has_parent_path());
1654 BOOST_TEST(p.is_absolute());
1655
1656 p = q = path("\\\\?\\c:\\");
1657 PATH_TEST_EQ(p.relative_path().string(), "");
1658 PATH_TEST_EQ(p.parent_path().string(), "\\\\?\\c:");
1659 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1660 #if BOOST_FILESYSTEM_VERSION == 3
1661 PATH_TEST_EQ(p.filename(), "\\");
1662 #else
1663 PATH_TEST_EQ(p.filename(), "");
1664 #endif
1665 PATH_TEST_EQ(p.root_name(), "\\\\?\\c:");
1666 PATH_TEST_EQ(p.root_directory(), "\\");
1667 PATH_TEST_EQ(p.root_path().string(), "\\\\?\\c:\\");
1668 BOOST_TEST(p.has_root_path());
1669 BOOST_TEST(p.has_root_name());
1670 BOOST_TEST(p.has_root_directory());
1671 BOOST_TEST(!p.has_relative_path());
1672 #if BOOST_FILESYSTEM_VERSION == 3
1673 BOOST_TEST(p.has_filename());
1674 #else
1675 BOOST_TEST(!p.has_filename());
1676 #endif
1677 BOOST_TEST(p.has_parent_path());
1678 BOOST_TEST(p.is_absolute());
1679
1680 p = q = path("\\\\.\\c:\\");
1681 PATH_TEST_EQ(p.relative_path().string(), "");
1682 PATH_TEST_EQ(p.parent_path().string(), "\\\\.\\c:");
1683 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1684 #if BOOST_FILESYSTEM_VERSION == 3
1685 PATH_TEST_EQ(p.filename(), "\\");
1686 #else
1687 PATH_TEST_EQ(p.filename(), "");
1688 #endif
1689 PATH_TEST_EQ(p.root_name(), "\\\\.\\c:");
1690 PATH_TEST_EQ(p.root_directory(), "\\");
1691 PATH_TEST_EQ(p.root_path().string(), "\\\\.\\c:\\");
1692 BOOST_TEST(p.has_root_path());
1693 BOOST_TEST(p.has_root_name());
1694 BOOST_TEST(p.has_root_directory());
1695 BOOST_TEST(!p.has_relative_path());
1696 #if BOOST_FILESYSTEM_VERSION == 3
1697 BOOST_TEST(p.has_filename());
1698 #else
1699 BOOST_TEST(!p.has_filename());
1700 #endif
1701 BOOST_TEST(p.has_parent_path());
1702 BOOST_TEST(p.is_absolute());
1703
1704 p = q = path("\\??\\c:\\");
1705 PATH_TEST_EQ(p.relative_path().string(), "");
1706 PATH_TEST_EQ(p.parent_path().string(), "\\??\\c:");
1707 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1708 #if BOOST_FILESYSTEM_VERSION == 3
1709 PATH_TEST_EQ(p.filename(), "\\");
1710 #else
1711 PATH_TEST_EQ(p.filename(), "");
1712 #endif
1713 PATH_TEST_EQ(p.root_name(), "\\??\\c:");
1714 PATH_TEST_EQ(p.root_directory(), "\\");
1715 PATH_TEST_EQ(p.root_path().string(), "\\??\\c:\\");
1716 BOOST_TEST(p.has_root_path());
1717 BOOST_TEST(p.has_root_name());
1718 BOOST_TEST(p.has_root_directory());
1719 BOOST_TEST(!p.has_relative_path());
1720 #if BOOST_FILESYSTEM_VERSION == 3
1721 BOOST_TEST(p.has_filename());
1722 #else
1723 BOOST_TEST(!p.has_filename());
1724 #endif
1725 BOOST_TEST(p.has_parent_path());
1726 BOOST_TEST(p.is_absolute());
1727
1728 p = q = path("c:..");
1729 PATH_TEST_EQ(p.relative_path().string(), "..");
1730 PATH_TEST_EQ(p.parent_path().string(), "c:");
1731 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1732 PATH_TEST_EQ(p.filename(), "..");
1733 PATH_TEST_EQ(p.root_name(), "c:");
1734 PATH_TEST_EQ(p.root_directory(), "");
1735 PATH_TEST_EQ(p.root_path().string(), "c:");
1736 BOOST_TEST(p.has_root_path());
1737 BOOST_TEST(p.has_root_name());
1738 BOOST_TEST(!p.has_root_directory());
1739 BOOST_TEST(p.has_relative_path());
1740 BOOST_TEST(p.has_filename());
1741 BOOST_TEST(p.has_parent_path());
1742 BOOST_TEST(!p.is_absolute());
1743
1744 p = q = path("c:/foo");
1745 PATH_TEST_EQ(p.relative_path().string(), "foo");
1746 PATH_TEST_EQ(p.parent_path().string(), "c:/");
1747 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1748 PATH_TEST_EQ(p.filename(), "foo");
1749 PATH_TEST_EQ(p.root_name(), "c:");
1750 PATH_TEST_EQ(p.root_directory(), "/");
1751 PATH_TEST_EQ(p.root_path().string(), "c:/");
1752 BOOST_TEST(p.has_root_path());
1753 BOOST_TEST(p.has_root_name());
1754 BOOST_TEST(p.has_root_directory());
1755 BOOST_TEST(p.has_relative_path());
1756 BOOST_TEST(p.has_filename());
1757 BOOST_TEST(p.has_parent_path());
1758 BOOST_TEST(p.is_absolute());
1759
1760 p = q = path("c://foo");
1761 PATH_TEST_EQ(p.relative_path().string(), "foo");
1762 PATH_TEST_EQ(p.parent_path().string(), "c:/");
1763 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1764 PATH_TEST_EQ(p.filename(), "foo");
1765 PATH_TEST_EQ(p.root_name(), "c:");
1766 PATH_TEST_EQ(p.root_directory(), "/");
1767 PATH_TEST_EQ(p.root_path().string(), "c:/");
1768 BOOST_TEST(p.has_root_path());
1769 BOOST_TEST(p.has_root_name());
1770 BOOST_TEST(p.has_root_directory());
1771 BOOST_TEST(p.has_relative_path());
1772 BOOST_TEST(p.has_filename());
1773 BOOST_TEST(p.has_parent_path());
1774 BOOST_TEST(p.is_absolute());
1775
1776 p = q = path("c:\\foo\\bar");
1777 PATH_TEST_EQ(p.relative_path().string(), "foo\\bar");
1778 PATH_TEST_EQ(p.parent_path().string(), "c:\\foo");
1779 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1780 PATH_TEST_EQ(p.filename(), "bar");
1781 PATH_TEST_EQ(p.root_name(), "c:");
1782 PATH_TEST_EQ(p.root_directory(), "\\");
1783 PATH_TEST_EQ(p.root_path().string(), "c:\\");
1784 BOOST_TEST(p.has_root_path());
1785 BOOST_TEST(p.has_root_name());
1786 BOOST_TEST(p.has_root_directory());
1787 BOOST_TEST(p.has_relative_path());
1788 BOOST_TEST(p.has_filename());
1789 BOOST_TEST(p.has_parent_path());
1790 BOOST_TEST(p.is_absolute());
1791
1792 p = q = path("\\\\?\\c:\\foo\\bar");
1793 PATH_TEST_EQ(p.relative_path().string(), "foo\\bar");
1794 PATH_TEST_EQ(p.parent_path().string(), "\\\\?\\c:\\foo");
1795 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1796 PATH_TEST_EQ(p.filename(), "bar");
1797 PATH_TEST_EQ(p.root_name(), "\\\\?\\c:");
1798 PATH_TEST_EQ(p.root_directory(), "\\");
1799 PATH_TEST_EQ(p.root_path().string(), "\\\\?\\c:\\");
1800 BOOST_TEST(p.has_root_path());
1801 BOOST_TEST(p.has_root_name());
1802 BOOST_TEST(p.has_root_directory());
1803 BOOST_TEST(p.has_relative_path());
1804 BOOST_TEST(p.has_filename());
1805 BOOST_TEST(p.has_parent_path());
1806 BOOST_TEST(p.is_absolute());
1807
1808 p = q = path("\\\\.\\c:\\foo\\bar");
1809 PATH_TEST_EQ(p.relative_path().string(), "foo\\bar");
1810 PATH_TEST_EQ(p.parent_path().string(), "\\\\.\\c:\\foo");
1811 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1812 PATH_TEST_EQ(p.filename(), "bar");
1813 PATH_TEST_EQ(p.root_name(), "\\\\.\\c:");
1814 PATH_TEST_EQ(p.root_directory(), "\\");
1815 PATH_TEST_EQ(p.root_path().string(), "\\\\.\\c:\\");
1816 BOOST_TEST(p.has_root_path());
1817 BOOST_TEST(p.has_root_name());
1818 BOOST_TEST(p.has_root_directory());
1819 BOOST_TEST(p.has_relative_path());
1820 BOOST_TEST(p.has_filename());
1821 BOOST_TEST(p.has_parent_path());
1822 BOOST_TEST(p.is_absolute());
1823
1824 p = q = path("\\??\\c:\\foo\\bar");
1825 PATH_TEST_EQ(p.relative_path().string(), "foo\\bar");
1826 PATH_TEST_EQ(p.parent_path().string(), "\\??\\c:\\foo");
1827 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1828 PATH_TEST_EQ(p.filename(), "bar");
1829 PATH_TEST_EQ(p.root_name(), "\\??\\c:");
1830 PATH_TEST_EQ(p.root_directory(), "\\");
1831 PATH_TEST_EQ(p.root_path().string(), "\\??\\c:\\");
1832 BOOST_TEST(p.has_root_path());
1833 BOOST_TEST(p.has_root_name());
1834 BOOST_TEST(p.has_root_directory());
1835 BOOST_TEST(p.has_relative_path());
1836 BOOST_TEST(p.has_filename());
1837 BOOST_TEST(p.has_parent_path());
1838 BOOST_TEST(p.is_absolute());
1839
1840 p = q = path("prn:");
1841 PATH_TEST_EQ(p.relative_path().string(), "");
1842 PATH_TEST_EQ(p.parent_path().string(), "");
1843 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1844 #if BOOST_FILESYSTEM_VERSION == 3
1845 PATH_TEST_EQ(p.filename(), "prn:");
1846 #else
1847 PATH_TEST_EQ(p.filename(), "");
1848 #endif
1849 PATH_TEST_EQ(p.root_name(), "prn:");
1850 PATH_TEST_EQ(p.root_directory(), "");
1851 PATH_TEST_EQ(p.root_path().string(), "prn:");
1852 BOOST_TEST(p.has_root_path());
1853 BOOST_TEST(p.has_root_name());
1854 BOOST_TEST(!p.has_root_directory());
1855 BOOST_TEST(!p.has_relative_path());
1856 #if BOOST_FILESYSTEM_VERSION == 3
1857 BOOST_TEST(p.has_filename());
1858 #else
1859 BOOST_TEST(!p.has_filename());
1860 #endif
1861 BOOST_TEST(!p.has_parent_path());
1862 BOOST_TEST(!p.is_absolute());
1863
1864 p = q = path("\\\\net\\\\\\foo");
1865 PATH_TEST_EQ(p.relative_path().string(), "foo");
1866 PATH_TEST_EQ(p.parent_path().string(), "\\\\net\\");
1867 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1868 PATH_TEST_EQ(p.filename(), "foo");
1869 PATH_TEST_EQ(p.root_name(), "\\\\net");
1870 PATH_TEST_EQ(p.root_directory(), "\\");
1871 PATH_TEST_EQ(p.root_path().string(), "\\\\net\\");
1872 BOOST_TEST(p.has_root_path());
1873 BOOST_TEST(p.has_root_name());
1874 BOOST_TEST(p.has_root_directory());
1875 BOOST_TEST(p.has_relative_path());
1876 BOOST_TEST(p.has_filename());
1877 BOOST_TEST(p.has_parent_path());
1878 BOOST_TEST(p.is_absolute());
1879 } // Windows
1880
1881 else
1882 { // POSIX
1883 p = path("c:");
1884 PATH_TEST_EQ(p.parent_path().string(), "");
1885 PATH_TEST_EQ(p.filename(), "c:");
1886 BOOST_TEST(!p.has_parent_path());
1887 BOOST_TEST(p.has_filename());
1888
1889 p = path("cc:");
1890 PATH_TEST_EQ(p.parent_path().string(), "");
1891 PATH_TEST_EQ(p.filename(), "cc:");
1892 BOOST_TEST(!p.has_parent_path());
1893 BOOST_TEST(p.has_filename());
1894
1895 PATH_TEST_EQ(path("/foo/bar/"), "/foo/bar/");
1896 PATH_TEST_EQ(path("//foo//bar//"), "//foo//bar//");
1897 PATH_TEST_EQ(path("///foo///bar///"), "///foo///bar///");
1898
1899 p = path("/usr/local/bin:/usr/bin:/bin");
1900 BOOST_TEST(p.string() == "/usr/local/bin:/usr/bin:/bin");
1901 } // POSIX
1902 }
1903
1904 // composition_tests ----------------------------------------------------------------//
1905
1906 void composition_tests()
1907 {
1908 std::cout << "composition_tests..." << std::endl;
1909 }
1910
1911 // construction_tests ---------------------------------------------------------------//
1912
1913 void construction_tests()
1914 {
1915 std::cout << "construction_tests..." << std::endl;
1916
1917 PATH_TEST_EQ("", "");
1918
1919 PATH_TEST_EQ("foo", "foo");
1920 PATH_TEST_EQ("f", "f");
1921
1922 PATH_TEST_EQ("foo/", "foo/");
1923 PATH_TEST_EQ("f/", "f/");
1924 PATH_TEST_EQ("foo/..", "foo/..");
1925 PATH_TEST_EQ("foo/../", "foo/../");
1926 PATH_TEST_EQ("foo/bar/../..", "foo/bar/../..");
1927 PATH_TEST_EQ("foo/bar/../../", "foo/bar/../../");
1928 PATH_TEST_EQ("/", "/");
1929 PATH_TEST_EQ("/f", "/f");
1930
1931 PATH_TEST_EQ("/foo", "/foo");
1932 PATH_TEST_EQ("/foo/bar/", "/foo/bar/");
1933 PATH_TEST_EQ("//foo//bar//", "//foo//bar//");
1934 PATH_TEST_EQ("///foo///bar///", "///foo///bar///");
1935 PATH_TEST_EQ("\\/foo\\/bar\\/", "\\/foo\\/bar\\/");
1936 PATH_TEST_EQ("\\//foo\\//bar\\//", "\\//foo\\//bar\\//");
1937
1938 if (platform == "Windows")
1939 {
1940 PATH_TEST_EQ(path("c:") / "foo", "c:foo");
1941 PATH_TEST_EQ(path("c:") / "/foo", "c:/foo");
1942
1943 PATH_TEST_EQ("\\foo\\bar\\", "\\foo\\bar\\");
1944 PATH_TEST_EQ("\\\\foo\\\\bar\\\\", "\\\\foo\\\\bar\\\\");
1945 PATH_TEST_EQ("\\\\\\foo\\\\\\bar\\\\\\", "\\\\\\foo\\\\\\bar\\\\\\");
1946
1947 PATH_TEST_EQ("\\", "\\");
1948 PATH_TEST_EQ("\\f", "\\f");
1949 PATH_TEST_EQ("\\foo", "\\foo");
1950 PATH_TEST_EQ("foo\\bar", "foo\\bar");
1951 PATH_TEST_EQ("foo bar", "foo bar");
1952 PATH_TEST_EQ("c:", "c:");
1953 PATH_TEST_EQ("c:/", "c:/");
1954 PATH_TEST_EQ("c:.", "c:.");
1955 PATH_TEST_EQ("c:./foo", "c:./foo");
1956 PATH_TEST_EQ("c:.\\foo", "c:.\\foo");
1957 PATH_TEST_EQ("c:..", "c:..");
1958 PATH_TEST_EQ("c:/.", "c:/.");
1959 PATH_TEST_EQ("c:/..", "c:/..");
1960 PATH_TEST_EQ("c:/../", "c:/../");
1961 PATH_TEST_EQ("c:\\..\\", "c:\\..\\");
1962 PATH_TEST_EQ("c:/../..", "c:/../..");
1963 PATH_TEST_EQ("c:/../foo", "c:/../foo");
1964 PATH_TEST_EQ("c:\\..\\foo", "c:\\..\\foo");
1965 PATH_TEST_EQ("c:../foo", "c:../foo");
1966 PATH_TEST_EQ("c:..\\foo", "c:..\\foo");
1967 PATH_TEST_EQ("c:/../../foo", "c:/../../foo");
1968 PATH_TEST_EQ("c:\\..\\..\\foo", "c:\\..\\..\\foo");
1969 PATH_TEST_EQ("c:foo/..", "c:foo/..");
1970 PATH_TEST_EQ("c:/foo/..", "c:/foo/..");
1971 PATH_TEST_EQ("c:/..foo", "c:/..foo");
1972 PATH_TEST_EQ("c:foo", "c:foo");
1973 PATH_TEST_EQ("c:/foo", "c:/foo");
1974 PATH_TEST_EQ("\\\\netname", "\\\\netname");
1975 PATH_TEST_EQ("\\\\netname\\", "\\\\netname\\");
1976 PATH_TEST_EQ("\\\\netname\\foo", "\\\\netname\\foo");
1977 PATH_TEST_EQ("c:/foo", "c:/foo");
1978 PATH_TEST_EQ("prn:", "prn:");
1979 }
1980 else
1981 {
1982 }
1983
1984 PATH_TEST_EQ("foo/bar", "foo/bar");
1985 PATH_TEST_EQ("a/b", "a/b"); // probe for length effects
1986 PATH_TEST_EQ("..", "..");
1987 PATH_TEST_EQ("../..", "../..");
1988 PATH_TEST_EQ("/..", "/..");
1989 PATH_TEST_EQ("/../..", "/../..");
1990 PATH_TEST_EQ("../foo", "../foo");
1991 PATH_TEST_EQ("foo/..", "foo/..");
1992 PATH_TEST_EQ("foo/..bar", "foo/..bar");
1993 PATH_TEST_EQ("../f", "../f");
1994 PATH_TEST_EQ("/../f", "/../f");
1995 PATH_TEST_EQ("f/..", "f/..");
1996 PATH_TEST_EQ("foo/../..", "foo/../..");
1997 PATH_TEST_EQ("foo/../../..", "foo/../../..");
1998 PATH_TEST_EQ("foo/../bar", "foo/../bar");
1999 PATH_TEST_EQ("foo/bar/..", "foo/bar/..");
2000 PATH_TEST_EQ("foo/bar/../..", "foo/bar/../..");
2001 PATH_TEST_EQ("foo/bar/../blah", "foo/bar/../blah");
2002 PATH_TEST_EQ("f/../b", "f/../b");
2003 PATH_TEST_EQ("f/b/..", "f/b/..");
2004 PATH_TEST_EQ("f/b/../a", "f/b/../a");
2005 PATH_TEST_EQ("foo/bar/blah/../..", "foo/bar/blah/../..");
2006 PATH_TEST_EQ("foo/bar/blah/../../bletch", "foo/bar/blah/../../bletch");
2007 PATH_TEST_EQ("...", "...");
2008 PATH_TEST_EQ("....", "....");
2009 PATH_TEST_EQ("foo/...", "foo/...");
2010 PATH_TEST_EQ("abc.", "abc.");
2011 PATH_TEST_EQ("abc..", "abc..");
2012 PATH_TEST_EQ("foo/abc.", "foo/abc.");
2013 PATH_TEST_EQ("foo/abc..", "foo/abc..");
2014
2015 PATH_TEST_EQ(".abc", ".abc");
2016 PATH_TEST_EQ("a.c", "a.c");
2017 PATH_TEST_EQ("..abc", "..abc");
2018 PATH_TEST_EQ("a..c", "a..c");
2019 PATH_TEST_EQ("foo/.abc", "foo/.abc");
2020 PATH_TEST_EQ("foo/a.c", "foo/a.c");
2021 PATH_TEST_EQ("foo/..abc", "foo/..abc");
2022 PATH_TEST_EQ("foo/a..c", "foo/a..c");
2023
2024 PATH_TEST_EQ(".", ".");
2025 PATH_TEST_EQ("./foo", "./foo");
2026 PATH_TEST_EQ("./..", "./..");
2027 PATH_TEST_EQ("./../foo", "./../foo");
2028 PATH_TEST_EQ("foo/.", "foo/.");
2029 PATH_TEST_EQ("../.", "../.");
2030 PATH_TEST_EQ("./.", "./.");
2031 PATH_TEST_EQ("././.", "././.");
2032 PATH_TEST_EQ("./foo/.", "./foo/.");
2033 PATH_TEST_EQ("foo/./bar", "foo/./bar");
2034 PATH_TEST_EQ("foo/./.", "foo/./.");
2035 PATH_TEST_EQ("foo/./..", "foo/./..");
2036 PATH_TEST_EQ("foo/./../bar", "foo/./../bar");
2037 PATH_TEST_EQ("foo/../.", "foo/../.");
2038 PATH_TEST_EQ("././..", "././..");
2039 PATH_TEST_EQ("./../.", "./../.");
2040 PATH_TEST_EQ(".././.", ".././.");
2041 }
2042
2043 // append_tests --------------------------------------------------------------------//
2044
2045 #define APPEND_TEST(pth, appnd, expected)\
2046 {\
2047 const path p(pth);\
2048 const std::string s(appnd);\
2049 PATH_TEST_EQ(p / appnd, expected);\
2050 PATH_TEST_EQ((p / path(s)).string(), expected);\
2051 PATH_TEST_EQ((p / s.c_str()).string(), expected);\
2052 PATH_TEST_EQ((p / s).string(), expected);\
2053 path p1(p);\
2054 p1 /= appnd;\
2055 PATH_TEST_EQ(p1, expected);\
2056 path p2(p);\
2057 p2 /= derived_from_path(appnd);\
2058 PATH_TEST_EQ(p2, expected);\
2059 path p3(p);\
2060 p3 /= convertible_to_path(appnd);\
2061 PATH_TEST_EQ(p3, expected);\
2062 path p4(p);\
2063 p4.append(s.begin(), s.end());\
2064 PATH_TEST_EQ(p4.string(), expected);\
2065 }
2066
2067 void append_tests()
2068 {
2069 std::cout << "append_tests..." << std::endl;
2070
2071 // There are many control paths to be exercised, since empty paths and arguments,
2072 // paths with trailing separators, arguments with leading separators, with or without
2073 // other characters being present, are all separate cases that need to be tested.
2074 // Furthermore, some of the code to be tested is specific to argument categories,
2075 // so that results in further permutations to be tested.
2076
2077 //// code to generate test cases
2078 ////
2079 //// expected results must be checked by hand
2080 //// "foo\bar" expected result must be edited by hand and moved for Windows/POSIX
2081 ////
2082 //const char* x[] = { "", "/", "foo", "foo/" };
2083 //const char* y[] = { "", "/", "bar", "/bar" };
2084
2085 //for (int i = 0; i < sizeof(x)/sizeof(char*); ++i)
2086 // for (int j = 0; j < sizeof(y)/sizeof(char*); ++j)
2087 // {
2088 // std::cout << " APPEND_TEST(\"" << x[i] << "\", \"" << y[j] << "\", \""
2089 // << path(x[i]) / y[j] << "\");\n";
2090 // }
2091
2092 APPEND_TEST("", "", "");
2093 APPEND_TEST("", "/", "/");
2094 APPEND_TEST("", "bar", "bar");
2095 APPEND_TEST("", "/bar", "/bar");
2096
2097 APPEND_TEST("/", "", "/");
2098 #if BOOST_FILESYSTEM_VERSION == 3
2099 APPEND_TEST("/", "/", "//");
2100 #else
2101 APPEND_TEST("/", "/", "/");
2102 #endif
2103 APPEND_TEST("/", "bar", "/bar");
2104 #if BOOST_FILESYSTEM_VERSION == 3
2105 APPEND_TEST("/", "/bar", "//bar");
2106 #else
2107 APPEND_TEST("/", "/bar", "/bar");
2108 #endif
2109
2110 #if BOOST_FILESYSTEM_VERSION == 3
2111 APPEND_TEST("foo", "/", "foo/");
2112 #else
2113 APPEND_TEST("foo", "/", "/");
2114 #endif
2115 #if BOOST_FILESYSTEM_VERSION == 3
2116 APPEND_TEST("foo", "/bar", "foo/bar");
2117 #else
2118 APPEND_TEST("foo", "/bar", "/bar");
2119 #endif
2120
2121 APPEND_TEST("foo/", "", "foo/");
2122 #if BOOST_FILESYSTEM_VERSION == 3
2123 APPEND_TEST("foo/", "/", "foo//");
2124 #else
2125 APPEND_TEST("foo/", "/", "/");
2126 #endif
2127 APPEND_TEST("foo/", "bar", "foo/bar");
2128
2129 if (platform == "Windows")
2130 {
2131 #if BOOST_FILESYSTEM_VERSION == 3
2132 APPEND_TEST("foo", "", "foo");
2133 #else
2134 APPEND_TEST("foo", "", "foo\\");
2135 #endif
2136 APPEND_TEST("foo", "bar", "foo\\bar");
2137
2138 #if BOOST_FILESYSTEM_VERSION == 3
2139 APPEND_TEST("foo\\", "\\bar", "foo\\\\bar");
2140 #else
2141 APPEND_TEST("foo\\", "\\bar", "\\bar");
2142 #endif
2143
2144 // hand created test case specific to Windows
2145 APPEND_TEST("c:", "bar", "c:bar");
2146 }
2147 else
2148 {
2149 #if BOOST_FILESYSTEM_VERSION == 3
2150 APPEND_TEST("foo", "", "foo");
2151 #else
2152 APPEND_TEST("foo", "", "foo/");
2153 #endif
2154 APPEND_TEST("foo", "bar", "foo/bar");
2155 }
2156
2157 // ticket #6819
2158 union
2159 {
2160 char a[1];
2161 char b[3];
2162 } u;
2163
2164 u.b[0] = 'a';
2165 u.b[1] = 'b';
2166 u.b[2] = '\0';
2167
2168 path p6819;
2169 p6819 /= u.a;
2170 BOOST_TEST_EQ(p6819, path("ab"));
2171 }
2172
2173 // concat_tests --------------------------------------------------------------------//
2174
2175 #define CONCAT_TEST(pth, appnd, expected)\
2176 {\
2177 const path p(pth);\
2178 const std::string s(appnd);\
2179 path p1(p);\
2180 p1 += appnd;\
2181 PATH_TEST_EQ(p1.string(), expected);\
2182 path p2(p);\
2183 p2 += path(appnd);\
2184 PATH_TEST_EQ(p2.string(), expected);\
2185 path p3(p);\
2186 p3 += s;\
2187 PATH_TEST_EQ(p3.string(), expected);\
2188 path p4(p);\
2189 p4 += s.c_str();\
2190 PATH_TEST_EQ(p4.string(), expected);\
2191 path p5(p);\
2192 p5 += derived_from_path(appnd);\
2193 PATH_TEST_EQ(p5, expected);\
2194 path p6(p);\
2195 p6 += convertible_to_path(appnd);\
2196 PATH_TEST_EQ(p6, expected);\
2197 path p7(p);\
2198 p7.concat(s.begin(), s.end());\
2199 PATH_TEST_EQ(p7.string(), expected);\
2200 }
2201
2202 void concat_tests()
2203 {
2204 std::cout << "concat_tests..." << std::endl;
2205
2206 CONCAT_TEST("", "", "");
2207 CONCAT_TEST("", "/", "/");
2208 CONCAT_TEST("", "bar", "bar");
2209 CONCAT_TEST("", "/bar", "/bar");
2210
2211 CONCAT_TEST("/", "", "/");
2212 CONCAT_TEST("/", "/", "//");
2213 CONCAT_TEST("/", "bar", "/bar");
2214 CONCAT_TEST("/", "/bar", "//bar");
2215
2216 CONCAT_TEST("foo", "/", "foo/");
2217 CONCAT_TEST("foo", "/bar", "foo/bar");
2218
2219 CONCAT_TEST("foo/", "", "foo/");
2220 CONCAT_TEST("foo/", "/", "foo//");
2221 CONCAT_TEST("foo/", "bar", "foo/bar");
2222
2223 CONCAT_TEST("foo", "", "foo");
2224 CONCAT_TEST("foo", "bar", "foobar");
2225 CONCAT_TEST("foo\\", "\\bar", "foo\\\\bar");
2226 CONCAT_TEST("c:", "bar", "c:bar");
2227 }
2228
2229 // self_assign_append_concat_tests -------------------------------------------------//
2230
2231 void self_assign_append_concat_tests()
2232 {
2233 std::cout << "self_assign_append_concat_tests..." << std::endl;
2234
2235 path p;
2236
2237 p = "snafubar";
2238 PATH_TEST_EQ(p = p, "snafubar");
2239
2240 p = "snafubar";
2241 p = p.c_str();
2242 PATH_TEST_EQ(p, "snafubar");
2243
2244 p = "snafubar";
2245 p.assign(p.c_str(), path::codecvt());
2246 PATH_TEST_EQ(p, "snafubar");
2247
2248 p = "snafubar";
2249 PATH_TEST_EQ(p = p.c_str() + 5, "bar");
2250
2251 p = "snafubar";
2252 PATH_TEST_EQ(p.assign(p.c_str() + 5, p.c_str() + 7), "ba");
2253
2254 p = "snafubar";
2255 p /= p;
2256 PATH_TEST_EQ(p, "snafubar" BOOST_DIR_SEP "snafubar");
2257
2258 p = "snafubar";
2259 p /= p.c_str();
2260 PATH_TEST_EQ(p, "snafubar" BOOST_DIR_SEP "snafubar");
2261
2262 p = "snafubar";
2263 p.append(p.c_str(), path::codecvt());
2264 PATH_TEST_EQ(p, "snafubar" BOOST_DIR_SEP "snafubar");
2265
2266 p = "snafubar";
2267 PATH_TEST_EQ(p.append(p.c_str() + 5, p.c_str() + 7), "snafubar" BOOST_DIR_SEP "ba");
2268
2269 p = "snafubar";
2270 p += p;
2271 PATH_TEST_EQ(p, "snafubarsnafubar");
2272
2273 p = "snafubar";
2274 p += p.c_str();
2275 PATH_TEST_EQ(p, "snafubarsnafubar");
2276
2277 p = "snafubar";
2278 p.concat(p.c_str(), path::codecvt());
2279 PATH_TEST_EQ(p, "snafubarsnafubar");
2280
2281 p = "snafubar";
2282 PATH_TEST_EQ(p.concat(p.c_str() + 5, p.c_str() + 7), "snafubarba");
2283 }
2284
2285 // name_function_tests -------------------------------------------------------------//
2286
2287 void name_function_tests()
2288 {
2289 std::cout << "name_function_tests..." << std::endl;
2290
2291 BOOST_TEST(fs::portable_posix_name(std::string("x")));
2292 BOOST_TEST(fs::windows_name(std::string("x")));
2293 BOOST_TEST(fs::portable_name(std::string("x")));
2294 BOOST_TEST(fs::portable_directory_name(std::string("x")));
2295 BOOST_TEST(fs::portable_file_name(std::string("x")));
2296
2297 BOOST_TEST(fs::portable_posix_name(std::string(".")));
2298 BOOST_TEST(fs::windows_name(std::string(".")));
2299 BOOST_TEST(fs::portable_name(std::string(".")));
2300 BOOST_TEST(fs::portable_directory_name(std::string(".")));
2301 BOOST_TEST(!fs::portable_file_name(std::string(".")));
2302
2303 BOOST_TEST(fs::portable_posix_name(std::string("..")));
2304 BOOST_TEST(fs::windows_name(std::string("..")));
2305 BOOST_TEST(fs::portable_name(std::string("..")));
2306 BOOST_TEST(fs::portable_directory_name(std::string("..")));
2307 BOOST_TEST(!fs::portable_file_name(std::string("..")));
2308
2309 BOOST_TEST(!fs::native(std::string("")));
2310 BOOST_TEST(!fs::portable_posix_name(std::string("")));
2311 BOOST_TEST(!fs::windows_name(std::string("")));
2312 BOOST_TEST(!fs::portable_name(std::string("")));
2313 BOOST_TEST(!fs::portable_directory_name(std::string("")));
2314 BOOST_TEST(!fs::portable_file_name(std::string("")));
2315
2316 BOOST_TEST(!fs::native(std::string(" ")));
2317 BOOST_TEST(!fs::portable_posix_name(std::string(" ")));
2318 BOOST_TEST(!fs::windows_name(std::string(" ")));
2319 BOOST_TEST(!fs::portable_name(std::string(" ")));
2320 BOOST_TEST(!fs::portable_directory_name(std::string(" ")));
2321 BOOST_TEST(!fs::portable_file_name(std::string(" ")));
2322
2323 BOOST_TEST(!fs::portable_posix_name(std::string(":")));
2324 BOOST_TEST(!fs::windows_name(std::string(":")));
2325 BOOST_TEST(!fs::portable_name(std::string(":")));
2326 BOOST_TEST(!fs::portable_directory_name(std::string(":")));
2327 BOOST_TEST(!fs::portable_file_name(std::string(":")));
2328
2329 BOOST_TEST(fs::portable_posix_name(std::string("-")));
2330 BOOST_TEST(fs::windows_name(std::string("-")));
2331 BOOST_TEST(!fs::portable_name(std::string("-")));
2332 BOOST_TEST(!fs::portable_directory_name(std::string("-")));
2333 BOOST_TEST(!fs::portable_file_name(std::string("-")));
2334
2335 BOOST_TEST(!fs::portable_posix_name(std::string("foo bar")));
2336 BOOST_TEST(fs::windows_name(std::string("foo bar")));
2337 BOOST_TEST(!fs::windows_name(std::string(" bar")));
2338 BOOST_TEST(!fs::windows_name(std::string("foo ")));
2339 BOOST_TEST(!fs::portable_name(std::string("foo bar")));
2340 BOOST_TEST(!fs::portable_directory_name(std::string("foo bar")));
2341 BOOST_TEST(!fs::portable_file_name(std::string("foo bar")));
2342
2343 BOOST_TEST(fs::portable_posix_name(std::string("foo.bar")));
2344 BOOST_TEST(fs::windows_name(std::string("foo.bar")));
2345 BOOST_TEST(fs::portable_name(std::string("foo.bar")));
2346 BOOST_TEST(!fs::portable_directory_name(std::string("foo.bar")));
2347 BOOST_TEST(fs::portable_file_name(std::string("foo.bar")));
2348
2349 BOOST_TEST(fs::portable_posix_name(std::string("foo.barf")));
2350 BOOST_TEST(fs::windows_name(std::string("foo.barf")));
2351 BOOST_TEST(fs::portable_name(std::string("foo.barf")));
2352 BOOST_TEST(!fs::portable_directory_name(std::string("foo.barf")));
2353 BOOST_TEST(!fs::portable_file_name(std::string("foo.barf")));
2354
2355 BOOST_TEST(fs::portable_posix_name(std::string(".foo")));
2356 BOOST_TEST(fs::windows_name(std::string(".foo")));
2357 BOOST_TEST(!fs::portable_name(std::string(".foo")));
2358 BOOST_TEST(!fs::portable_directory_name(std::string(".foo")));
2359 BOOST_TEST(!fs::portable_file_name(std::string(".foo")));
2360
2361 BOOST_TEST(fs::portable_posix_name(std::string("foo.")));
2362 BOOST_TEST(!fs::windows_name(std::string("foo.")));
2363 BOOST_TEST(!fs::portable_name(std::string("foo.")));
2364 BOOST_TEST(!fs::portable_directory_name(std::string("foo.")));
2365 BOOST_TEST(!fs::portable_file_name(std::string("foo.")));
2366 }
2367
2368 // replace_extension_tests ---------------------------------------------------------//
2369
2370 void replace_extension_tests()
2371 {
2372 std::cout << "replace_extension_tests..." << std::endl;
2373
2374 BOOST_TEST(path().replace_extension().empty());
2375 BOOST_TEST(path().replace_extension("a") == ".a");
2376 BOOST_TEST(path().replace_extension("a.") == ".a.");
2377 BOOST_TEST(path().replace_extension(".a") == ".a");
2378 BOOST_TEST(path().replace_extension("a.txt") == ".a.txt");
2379 // see the rationale in html docs for explanation why this works:
2380 BOOST_TEST(path().replace_extension(".txt") == ".txt");
2381
2382 BOOST_TEST(path("a.txt").replace_extension() == "a");
2383 BOOST_TEST(path("a.txt").replace_extension("") == "a");
2384 BOOST_TEST(path("a.txt").replace_extension(".") == "a.");
2385 BOOST_TEST(path("a.txt").replace_extension(".tex") == "a.tex");
2386 BOOST_TEST(path("a.txt").replace_extension("tex") == "a.tex");
2387 BOOST_TEST(path("a.").replace_extension(".tex") == "a.tex");
2388 BOOST_TEST(path("a.").replace_extension("tex") == "a.tex");
2389 BOOST_TEST(path("a").replace_extension(".txt") == "a.txt");
2390 BOOST_TEST(path("a").replace_extension("txt") == "a.txt");
2391 BOOST_TEST(path("a.b.txt").replace_extension(".tex") == "a.b.tex");
2392 BOOST_TEST(path("a.b.txt").replace_extension("tex") == "a.b.tex");
2393 BOOST_TEST(path("a/b").replace_extension(".c") == "a/b.c");
2394 PATH_TEST_EQ(path("a.txt/b").replace_extension(".c"), "a.txt/b.c"); // ticket 4702
2395 BOOST_TEST(path("foo.txt").replace_extension("exe") == "foo.exe"); // ticket 5118
2396 BOOST_TEST(path("foo.txt").replace_extension(".tar.bz2") == "foo.tar.bz2"); // ticket 5118
2397 }
2398
2399 // make_preferred_tests ------------------------------------------------------------//
2400
2401 void make_preferred_tests()
2402 {
2403 std::cout << "make_preferred_tests..." << std::endl;
2404
2405 if (platform == "Windows")
2406 {
2407 BOOST_TEST(path("//abc\\def/ghi").make_preferred().native() == path("\\\\abc\\def\\ghi").native());
2408 }
2409 else
2410 {
2411 BOOST_TEST(path("//abc\\def/ghi").make_preferred().native() == path("//abc\\def/ghi").native());
2412 }
2413 }
2414
2415 // lexically_normal_tests ----------------------------------------------------------//
2416
2417 void lexically_normal_tests()
2418 {
2419 std::cout << "lexically_normal_tests..." << std::endl;
2420
2421 // Note: lexically_normal() uses /= to build up some results, so these results will
2422 // have the platform's preferred separator. Since that is immaterial to the correct
2423 // functioning of lexically_normal(), the test results are converted to generic form,
2424 // and the expected results are also given in generic form. Otherwise many of the
2425 // tests would incorrectly be reported as failing on Windows.
2426
2427 PATH_TEST_EQ(path("").lexically_normal().generic_path(), "");
2428 PATH_TEST_EQ(path("/").lexically_normal().generic_path(), "/");
2429 PATH_TEST_EQ(path("//").lexically_normal().generic_path(), "//");
2430 PATH_TEST_EQ(path("///").lexically_normal().generic_path(), "/");
2431 PATH_TEST_EQ(path("f").lexically_normal().generic_path(), "f");
2432 PATH_TEST_EQ(path("foo").lexically_normal().generic_path(), "foo");
2433 PATH_TEST_EQ(path("foo/").lexically_normal().generic_path(), "foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2434 PATH_TEST_EQ(path("f/").lexically_normal().generic_path(), "f/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2435 PATH_TEST_EQ(path("/foo").lexically_normal().generic_path(), "/foo");
2436 PATH_TEST_EQ(path("/./foo").lexically_normal().generic_path(), "/foo");
2437 PATH_TEST_EQ(path("/./foo/.").lexically_normal().generic_path(), "/foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2438 PATH_TEST_EQ(path("foo/bar").lexically_normal().generic_path(), "foo/bar");
2439 PATH_TEST_EQ(path("..").lexically_normal().generic_path(), "..");
2440 PATH_TEST_EQ(path("../..").lexically_normal().generic_path(), "../..");
2441 PATH_TEST_EQ(path("/..").lexically_normal().generic_path(), "/..");
2442 PATH_TEST_EQ(path("/../..").lexically_normal().generic_path(), "/../..");
2443 PATH_TEST_EQ(path("../foo").lexically_normal().generic_path(), "../foo");
2444 PATH_TEST_EQ(path("foo/..").lexically_normal().generic_path(), ".");
2445 PATH_TEST_EQ(path("foo/../").lexically_normal().generic_path(), ".");
2446 PATH_TEST_EQ((path("foo") / "..").lexically_normal().generic_path(), ".");
2447 PATH_TEST_EQ(path("foo/...").lexically_normal().generic_path(), "foo/...");
2448 PATH_TEST_EQ(path("foo/.../").lexically_normal().generic_path(), "foo/.../" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2449 PATH_TEST_EQ(path("foo/..bar").lexically_normal().generic_path(), "foo/..bar");
2450 PATH_TEST_EQ(path("../f").lexically_normal().generic_path(), "../f");
2451 PATH_TEST_EQ(path("/../f").lexically_normal().generic_path(), "/../f");
2452 PATH_TEST_EQ(path("f/..").lexically_normal().generic_path(), ".");
2453 PATH_TEST_EQ((path("f") / "..").lexically_normal().generic_path(), ".");
2454 PATH_TEST_EQ(path("foo/../..").lexically_normal().generic_path(), "..");
2455 #if BOOST_FILESYSTEM_VERSION == 3
2456 PATH_TEST_EQ(path("foo/../../").lexically_normal().generic_path(), "../.");
2457 #else
2458 PATH_TEST_EQ(path("foo/../../").lexically_normal().generic_path(), "..");
2459 #endif
2460 PATH_TEST_EQ(path("foo/../../..").lexically_normal().generic_path(), "../..");
2461 #if BOOST_FILESYSTEM_VERSION == 3
2462 PATH_TEST_EQ(path("foo/../../../").lexically_normal().generic_path(), "../../.");
2463 #else
2464 PATH_TEST_EQ(path("foo/../../../").lexically_normal().generic_path(), "../..");
2465 #endif
2466 PATH_TEST_EQ(path("foo/../bar").lexically_normal().generic_path(), "bar");
2467 PATH_TEST_EQ(path("foo/../bar/").lexically_normal().generic_path(), "bar/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2468 PATH_TEST_EQ(path("foo/bar/..").lexically_normal().generic_path(), "foo");
2469 PATH_TEST_EQ(path("foo/./bar/..").lexically_normal().generic_path(), "foo");
2470 std::cout << path("foo/./bar/..").lexically_normal() << std::endl; // outputs "foo"
2471 PATH_TEST_EQ(path("foo/bar/../").lexically_normal().generic_path(), "foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2472 PATH_TEST_EQ(path("foo/./bar/../").lexically_normal().generic_path(), "foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2473 std::cout << path("foo/./bar/../").lexically_normal() << std::endl; // POSIX: "foo/", Windows: "foo\" (with a trailing dot for v3)
2474 PATH_TEST_EQ(path("foo/bar/../..").lexically_normal().generic_path(), ".");
2475 PATH_TEST_EQ(path("foo/bar/../../").lexically_normal().generic_path(), ".");
2476 PATH_TEST_EQ(path("foo/bar/../blah").lexically_normal().generic_path(), "foo/blah");
2477 PATH_TEST_EQ(path("f/../b").lexically_normal().generic_path(), "b");
2478 PATH_TEST_EQ(path("f/b/..").lexically_normal().generic_path(), "f");
2479 PATH_TEST_EQ(path("f/b/../").lexically_normal().generic_path(), "f/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2480 PATH_TEST_EQ(path("f/b/../a").lexically_normal().generic_path(), "f/a");
2481 PATH_TEST_EQ(path("foo/bar/blah/../..").lexically_normal().generic_path(), "foo");
2482 PATH_TEST_EQ(path("foo/bar/blah/../../bletch").lexically_normal().generic_path(), "foo/bletch");
2483 PATH_TEST_EQ(path("//net").lexically_normal().generic_path(), "//net");
2484 PATH_TEST_EQ(path("//net/").lexically_normal().generic_path(), "//net/");
2485 PATH_TEST_EQ(path("//..net").lexically_normal().generic_path(), "//..net");
2486 PATH_TEST_EQ(path("//net/..").lexically_normal().generic_path(), "//net/..");
2487 PATH_TEST_EQ(path("//net/foo").lexically_normal().generic_path(), "//net/foo");
2488 PATH_TEST_EQ(path("//net/foo/").lexically_normal().generic_path(), "//net/foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2489 PATH_TEST_EQ(path("//net/foo/..").lexically_normal().generic_path(), "//net/");
2490 PATH_TEST_EQ(path("//net/foo/../").lexically_normal().generic_path(), "//net/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2491
2492 PATH_TEST_EQ(path("/net/foo/bar").lexically_normal().generic_path(), "/net/foo/bar");
2493 PATH_TEST_EQ(path("/net/foo/bar/").lexically_normal().generic_path(), "/net/foo/bar/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2494 PATH_TEST_EQ(path("/net/foo/..").lexically_normal().generic_path(), "/net");
2495 PATH_TEST_EQ(path("/net/foo/../").lexically_normal().generic_path(), "/net/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2496
2497 PATH_TEST_EQ(path("//net//foo//bar").lexically_normal().generic_path(), "//net/foo/bar");
2498 PATH_TEST_EQ(path("//net//foo//bar//").lexically_normal().generic_path(), "//net/foo/bar/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2499 PATH_TEST_EQ(path("//net//foo//..").lexically_normal().generic_path(), "//net/");
2500 PATH_TEST_EQ(path("//net//foo//..//").lexically_normal().generic_path(), "//net/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2501
2502 PATH_TEST_EQ(path("///net///foo///bar").lexically_normal().generic_path(), "/net/foo/bar");
2503 PATH_TEST_EQ(path("///net///foo///bar///").lexically_normal().generic_path(), "/net/foo/bar/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2504 PATH_TEST_EQ(path("///net///foo///..").lexically_normal().generic_path(), "/net");
2505 PATH_TEST_EQ(path("///net///foo///..///").lexically_normal().generic_path(), "/net/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2506
2507 if (platform == "Windows")
2508 {
2509 BOOST_TEST_EQ(path("c:/foo/bar").lexically_normal().string(), "c:\\foo\\bar");
2510
2511 PATH_TEST_EQ(path("c:foo").lexically_normal().generic_path(), "c:foo");
2512 PATH_TEST_EQ(path("c:..").lexically_normal().generic_path(), "c:..");
2513 PATH_TEST_EQ(path("c:foo/..").lexically_normal().generic_path(), "c:");
2514
2515 PATH_TEST_EQ(path("c:foo/../").lexically_normal().generic_path(), "c:" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2516
2517 PATH_TEST_EQ(path("c:/foo/..").lexically_normal().generic_path(), "c:/");
2518 PATH_TEST_EQ(path("c:/foo/../").lexically_normal().generic_path(), "c:/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2519 PATH_TEST_EQ(path("c:/..").lexically_normal().generic_path(), "c:/..");
2520 #if BOOST_FILESYSTEM_VERSION == 3
2521 PATH_TEST_EQ(path("c:/../").lexically_normal().generic_path(), "c:/../.");
2522 #else
2523 PATH_TEST_EQ(path("c:/../").lexically_normal().generic_path(), "c:/..");
2524 #endif
2525 PATH_TEST_EQ(path("c:/../..").lexically_normal().generic_path(), "c:/../..");
2526 #if BOOST_FILESYSTEM_VERSION == 3
2527 PATH_TEST_EQ(path("c:/../../").lexically_normal().generic_path(), "c:/../../.");
2528 #else
2529 PATH_TEST_EQ(path("c:/../../").lexically_normal().generic_path(), "c:/../..");
2530 #endif
2531 PATH_TEST_EQ(path("c:/../foo").lexically_normal().generic_path(), "c:/../foo");
2532 PATH_TEST_EQ(path("c:/../foo/").lexically_normal().generic_path(), "c:/../foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2533 PATH_TEST_EQ(path("c:/../../foo").lexically_normal().generic_path(), "c:/../../foo");
2534 PATH_TEST_EQ(path("c:/../../foo/").lexically_normal().generic_path(), "c:/../../foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2535 PATH_TEST_EQ(path("c:/..foo").lexically_normal().generic_path(), "c:/..foo");
2536 }
2537 else // POSIX
2538 {
2539 PATH_TEST_EQ(path("c:..").lexically_normal(), "c:..");
2540 PATH_TEST_EQ(path("c:foo/..").lexically_normal(), ".");
2541 PATH_TEST_EQ(path("c:foo/../").lexically_normal(), ".");
2542 PATH_TEST_EQ(path("c:/foo/..").lexically_normal(), "c:");
2543 PATH_TEST_EQ(path("c:/foo/../").lexically_normal(), "c:/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2544 PATH_TEST_EQ(path("c:/..").lexically_normal(), ".");
2545 PATH_TEST_EQ(path("c:/../").lexically_normal(), ".");
2546 PATH_TEST_EQ(path("c:/../..").lexically_normal(), "..");
2547 #if BOOST_FILESYSTEM_VERSION == 3
2548 PATH_TEST_EQ(path("c:/../../").lexically_normal(), "../.");
2549 #else
2550 PATH_TEST_EQ(path("c:/../../").lexically_normal(), "..");
2551 #endif
2552 PATH_TEST_EQ(path("c:/../foo").lexically_normal(), "foo");
2553 PATH_TEST_EQ(path("c:/../foo/").lexically_normal(), "foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2554 PATH_TEST_EQ(path("c:/../../foo").lexically_normal(), "../foo");
2555 PATH_TEST_EQ(path("c:/../../foo/").lexically_normal(), "../foo/" BOOST_FILESYSTEM_V3_TRAILING_DOT);
2556 PATH_TEST_EQ(path("c:/..foo").lexically_normal(), "c:/..foo");
2557 }
2558 }
2559
2560 inline void odr_use(const path::value_type& c)
2561 {
2562 static const path::value_type dummy = '\0';
2563 BOOST_TEST(&c != &dummy);
2564 }
2565
2566 } // unnamed namespace
2567
2568 static boost::filesystem::path ticket_6737 = "FilePath"; // #6737 reported this crashed
2569 // on VC++ debug mode build
2570 const boost::filesystem::path ticket_6690("test"); // #6690 another V++ static init crash
2571
2572 //--------------------------------------------------------------------------------------//
2573 // //
2574 // main //
2575 // //
2576 //--------------------------------------------------------------------------------------//
2577
2578 int cpp_main(int, char*[])
2579 {
2580 // The choice of platform is make at runtime rather than compile-time
2581 // so that compile errors for all platforms will be detected even though
2582 // only the current platform is runtime tested.
2583 platform = (platform == "Win32" || platform == "Win64" || platform == "Cygwin") ? "Windows" : "POSIX";
2584 std::cout << "Platform is " << platform << '\n';
2585
2586 BOOST_TEST(p1.string() != p3.string());
2587 p3 = p2;
2588 BOOST_TEST(p1.string() == p3.string());
2589
2590 path p04("foobar");
2591 BOOST_TEST(p04.string() == "foobar");
2592 p04 = p04; // self-assignment
2593 BOOST_TEST(p04.string() == "foobar");
2594
2595 construction_tests();
2596 append_tests();
2597 concat_tests();
2598 self_assign_append_concat_tests();
2599 overload_tests();
2600 query_and_decomposition_tests();
2601 composition_tests();
2602 iterator_tests();
2603 non_member_tests();
2604 exception_tests();
2605 name_function_tests();
2606 replace_extension_tests();
2607 make_preferred_tests();
2608 lexically_normal_tests();
2609
2610 // verify deprecated names still available
2611
2612 #ifndef BOOST_FILESYSTEM_NO_DEPRECATED
2613
2614 p1.branch_path();
2615 p1.leaf();
2616 path p_remove_leaf;
2617 p_remove_leaf.remove_leaf();
2618
2619 #endif
2620
2621 std::string s1("//:somestring"); // this used to be treated specially
2622
2623 // check the path member templates
2624 p5.assign(s1.begin(), s1.end());
2625
2626 PATH_TEST_EQ(p5.string(), "//:somestring");
2627 p5 = s1;
2628 PATH_TEST_EQ(p5.string(), "//:somestring");
2629
2630 // this code, courtesy of David Whetstone, detects a now fixed bug that
2631 // derefereced the end iterator (assuming debug build with checked itors)
2632 std::vector< char > v1;
2633 p5.assign(v1.begin(), v1.end());
2634 std::string s2(v1.begin(), v1.end());
2635 PATH_TEST_EQ(p5.string(), s2);
2636 p5.assign(s1.begin(), s1.begin() + 1);
2637 PATH_TEST_EQ(p5.string(), "/");
2638
2639 BOOST_TEST(p1 != p4);
2640 BOOST_TEST(p1.string() == p2.string());
2641 BOOST_TEST(p1.string() == p3.string());
2642 BOOST_TEST(path("foo").filename() == "foo");
2643 BOOST_TEST(path("foo").parent_path().string() == "");
2644 BOOST_TEST(p1.filename() == "fum");
2645 BOOST_TEST(p1.parent_path().string() == "fe/fi/fo");
2646 BOOST_TEST(path("").empty() == true);
2647 BOOST_TEST(path("foo").empty() == false);
2648
2649 // inserter and extractor tests
2650 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // bypass VC++ 7.0 and earlier
2651 std::cout << "\nInserter and extractor test...";
2652 std::stringstream ss;
2653 ss << fs::path("foo/bar") << std::endl;
2654 fs::path round_trip;
2655 ss >> round_trip;
2656 BOOST_TEST(round_trip.string() == "foo/bar");
2657 std::cout << round_trip.string() << "..." << round_trip << " complete\n";
2658 #endif
2659
2660 // Check that path constants have definitions
2661 // https://svn.boost.org/trac10/ticket/12759
2662 odr_use(path::separator);
2663 odr_use(path::preferred_separator);
2664 odr_use(path::dot);
2665
2666 return ::boost::report_errors();
2667 }
Ceph