]> 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 source to Ceph Pacific 16.2.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/operations.hpp>
53 #include <boost/filesystem/exception.hpp>
54
55 #include <boost/config.hpp>
56 # if defined( BOOST_NO_STD_WSTRING )
57 # error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support
58 # endif
59
60 #include <boost/utility.hpp>
61 #include <boost/next_prior.hpp>
62 #include <iostream>
63 #include <sstream>
64 #include <string>
65 #include <vector>
66 #include <cstring>
67 #include <cassert>
68 #include <boost/core/lightweight_test.hpp>
69 #include <boost/detail/lightweight_main.hpp>
70
71 namespace fs = boost::filesystem;
72 using boost::filesystem::path;
73 using boost::next;
74 using boost::prior;
75
76 #ifdef BOOST_WINDOWS_API
77 # define BOOST_DIR_SEP "\\"
78 #else
79 # define BOOST_DIR_SEP "/"
80 #endif
81
82 #define PATH_TEST_EQ(a, b) check(a, b, __FILE__, __LINE__)
83
84 namespace
85 {
86 std::string platform(BOOST_PLATFORM);
87
88 void check(const fs::path & source,
89 const std::string & expected, const char* file, int line)
90 {
91 if (source.string() == expected)
92 return;
93
94 std::cout << file
95 << '(' << line << "): source: \"" << source.string()
96 << "\" != expected: \"" << expected
97 << "\"" << std::endl;
98
99 ++::boost::detail::test_errors();
100 }
101
102 path p1("fe/fi/fo/fum");
103 path p2(p1);
104 path p3;
105 path p4("foobar");
106 path p5;
107
108 // exception_tests -----------------------------------------------------------------//
109
110 void exception_tests()
111 {
112 std::cout << "exception_tests..." << std::endl;
113 const std::string str_1("string-1");
114 boost::system::error_code ec(12345, boost::system::system_category());
115 try { throw fs::filesystem_error(str_1, ec); }
116 catch (const fs::filesystem_error & ex)
117 {
118 //std::cout << ex.what() << "*" << std::endl;
119 //BOOST_TEST(std::strcmp(ex.what(),
120 // "string-1: Unknown error") == 0);
121 BOOST_TEST(ex.code() == ec);
122 }
123
124 try { throw fs::filesystem_error(str_1, "p1", "p2", ec); }
125 catch (const fs::filesystem_error & ex)
126 {
127 //std::cout << ex.what() << "*" << std::endl;
128 //BOOST_TEST(std::strcmp(ex.what(),
129 // "string-1: Unknown error: \"p1\", \"p2\"") == 0);
130 BOOST_TEST(ex.code() == ec);
131 BOOST_TEST(ex.path1() == "p1");
132 BOOST_TEST(ex.path2() == "p2");
133 }
134 }
135
136 // overload_tests ------------------------------------------------------------------//
137
138 // These verify various overloads don't cause compiler errors
139 // They pre-date operations_unit_test.cpp
140
141 void overload_tests()
142 {
143 std::cout << "overload_tests..." << std::endl;
144
145 fs::exists(p1);
146 fs::exists("foo");
147 fs::exists(std::string("foo"));
148
149 fs::exists(p1 / path("foo"));
150 fs::exists(p1 / "foo");
151 fs::exists(p1 / std::string("foo"));
152
153 fs::exists("foo" / p1);
154 fs::exists(std::string("foo") / p1);
155
156 p4 /= path("foo");
157 p4 /= "foo";
158 p4 /= std::string("foo");
159 }
160
161 // iterator_tests ------------------------------------------------------------------//
162
163 void iterator_tests()
164 {
165 std::cout << "iterator_tests..." << std::endl;
166
167 path itr_ck = "";
168 path::const_iterator itr = itr_ck.begin();
169 BOOST_TEST(itr == itr_ck.end());
170
171 itr_ck = "/";
172 itr = itr_ck.begin();
173 BOOST_TEST(itr->string() == "/");
174 BOOST_TEST(++itr == itr_ck.end());
175 BOOST_TEST((--itr)->string() == "/");
176
177 itr_ck = "foo";
178 BOOST_TEST(*itr_ck.begin() == std::string("foo"));
179 BOOST_TEST(boost::next(itr_ck.begin()) == itr_ck.end());
180 BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo"));
181 BOOST_TEST(boost::prior(itr_ck.end()) == itr_ck.begin());
182
183 itr_ck = path("/foo");
184 BOOST_TEST((itr_ck.begin())->string() == "/");
185 BOOST_TEST(*boost::next(itr_ck.begin()) == std::string("foo"));
186 BOOST_TEST(boost::next(boost::next(itr_ck.begin())) == itr_ck.end());
187 BOOST_TEST(boost::next(itr_ck.begin()) == boost::prior(itr_ck.end()));
188 BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo"));
189 BOOST_TEST(*boost::prior(boost::prior(itr_ck.end())) == std::string("/"));
190 BOOST_TEST(boost::prior(boost::prior(itr_ck.end())) == itr_ck.begin());
191
192 itr_ck = "/foo/bar";
193 itr = itr_ck.begin();
194 BOOST_TEST(itr->string() == "/");
195 BOOST_TEST(*++itr == std::string("foo"));
196 BOOST_TEST(*++itr == std::string("bar"));
197 BOOST_TEST(++itr == itr_ck.end());
198 PATH_TEST_EQ(*--itr, "bar");
199 PATH_TEST_EQ(*--itr, "foo");
200 PATH_TEST_EQ(*--itr, "/");
201
202 itr_ck = "../f"; // previously failed due to short name bug
203 itr = itr_ck.begin();
204 PATH_TEST_EQ(itr->string(), "..");
205 PATH_TEST_EQ(*++itr, "f");
206 BOOST_TEST(++itr == itr_ck.end());
207 PATH_TEST_EQ(*--itr, "f");
208 PATH_TEST_EQ(*--itr, "..");
209
210 // POSIX says treat "/foo/bar/" as "/foo/bar/."
211 itr_ck = "/foo/bar/";
212 itr = itr_ck.begin();
213 PATH_TEST_EQ(itr->string(), "/");
214 PATH_TEST_EQ(*++itr, "foo");
215 BOOST_TEST(itr != itr_ck.end());
216 PATH_TEST_EQ(*++itr, "bar");
217 BOOST_TEST(itr != itr_ck.end());
218 PATH_TEST_EQ(*++itr, ".");
219 BOOST_TEST(itr != itr_ck.end()); // verify the . isn't also seen as end()
220 BOOST_TEST(++itr == itr_ck.end());
221 PATH_TEST_EQ(*--itr, ".");
222 PATH_TEST_EQ(*--itr, "bar");
223 PATH_TEST_EQ(*--itr, "foo");
224 PATH_TEST_EQ(*--itr, "/");
225
226 // POSIX says treat "/f/b/" as "/f/b/."
227 itr_ck = "/f/b/";
228 itr = itr_ck.begin();
229 PATH_TEST_EQ(itr->string(), "/");
230 PATH_TEST_EQ(*++itr, "f");
231 PATH_TEST_EQ(*++itr, "b");
232 PATH_TEST_EQ(*++itr, ".");
233 BOOST_TEST(itr != itr_ck.end()); // verify the . isn't also seen as end()
234 BOOST_TEST(++itr == itr_ck.end());
235 PATH_TEST_EQ(*--itr, ".");
236 PATH_TEST_EQ(*--itr, "b");
237 PATH_TEST_EQ(*--itr, "f");
238 PATH_TEST_EQ(*--itr, "/");
239
240 // POSIX says treat "a/b/" as "a/b/."
241 // Although similar to the prior test case, this failed the ". isn't end" test due to
242 // a bug while the prior case did not fail.
243 itr_ck = "a/b/";
244 itr = itr_ck.begin();
245 PATH_TEST_EQ(*itr, "a");
246 PATH_TEST_EQ(*++itr, "b");
247 PATH_TEST_EQ(*++itr, ".");
248 BOOST_TEST(itr != itr_ck.end()); // verify the . isn't also seen as end()
249 BOOST_TEST(++itr == itr_ck.end());
250 PATH_TEST_EQ(*--itr, ".");
251 PATH_TEST_EQ(*--itr, "b");
252 PATH_TEST_EQ(*--itr, "a");
253
254 itr_ck = "//net";
255 itr = itr_ck.begin();
256 // two leading slashes are permitted by POSIX (as implementation defined),
257 // while for Windows it is always well defined (as a network name)
258 PATH_TEST_EQ(itr->string(), "//net");
259 BOOST_TEST(++itr == itr_ck.end());
260 PATH_TEST_EQ(*--itr, "//net");
261
262 itr_ck = "//net/";
263 itr = itr_ck.begin();
264 PATH_TEST_EQ(itr->string(), "//net");
265 PATH_TEST_EQ(*++itr, "/");
266 BOOST_TEST(++itr == itr_ck.end());
267 PATH_TEST_EQ(*--itr, "/");
268 PATH_TEST_EQ(*--itr, "//net");
269
270 itr_ck = "//foo///bar///";
271 itr = itr_ck.begin();
272 PATH_TEST_EQ(itr->string(), "//foo");
273 PATH_TEST_EQ(*++itr, "/");
274 PATH_TEST_EQ(*++itr, "bar");
275 PATH_TEST_EQ(*++itr, ".");
276 BOOST_TEST(++itr == itr_ck.end());
277 PATH_TEST_EQ(*--itr, ".");
278 PATH_TEST_EQ(*--itr, "bar");
279 PATH_TEST_EQ(*--itr, "/");
280 PATH_TEST_EQ(*--itr, "//foo");
281
282 itr_ck = "///foo///bar///";
283 itr = itr_ck.begin();
284 // three or more leading slashes are to be treated as a single slash
285 PATH_TEST_EQ(itr->string(), "/");
286 PATH_TEST_EQ(*++itr, "foo");
287 PATH_TEST_EQ(*++itr, "bar");
288 PATH_TEST_EQ(*++itr, ".");
289 BOOST_TEST(++itr == itr_ck.end());
290 PATH_TEST_EQ(*--itr, ".");
291 PATH_TEST_EQ(*--itr, "bar");
292 PATH_TEST_EQ(*--itr, "foo");
293 PATH_TEST_EQ(*--itr, "/");
294
295 if (platform == "Windows")
296 {
297 itr_ck = "c:/";
298 itr = itr_ck.begin();
299 PATH_TEST_EQ(itr->string(), "c:");
300 PATH_TEST_EQ(*++itr, std::string("/"));
301 BOOST_TEST(++itr == itr_ck.end());
302 PATH_TEST_EQ(*--itr, "/");
303 PATH_TEST_EQ(*--itr, "c:");
304
305 itr_ck = "c:\\";
306 itr = itr_ck.begin();
307 PATH_TEST_EQ(itr->string(), "c:");
308 PATH_TEST_EQ(*++itr, "/"); // test that iteration returns generic format
309 BOOST_TEST(++itr == itr_ck.end());
310 PATH_TEST_EQ(*--itr, "/"); // test that iteration returns generic format
311 PATH_TEST_EQ(*--itr, "c:");
312
313 itr_ck = "c:/foo";
314 itr = itr_ck.begin();
315 BOOST_TEST(*itr == std::string("c:"));
316 BOOST_TEST(*++itr == std::string("/"));
317 BOOST_TEST(*++itr == std::string("foo"));
318 BOOST_TEST(++itr == itr_ck.end());
319 BOOST_TEST(*--itr == std::string("foo"));
320 BOOST_TEST((--itr)->string() == "/");
321 BOOST_TEST(*--itr == std::string("c:"));
322
323 itr_ck = "c:\\foo";
324 itr = itr_ck.begin();
325 BOOST_TEST(*itr == std::string("c:"));
326 BOOST_TEST(*++itr == std::string("\\"));
327 BOOST_TEST(*++itr == std::string("foo"));
328 BOOST_TEST(++itr == itr_ck.end());
329 BOOST_TEST(*--itr == std::string("foo"));
330 BOOST_TEST(*--itr == std::string("\\"));
331 BOOST_TEST(*--itr == std::string("c:"));
332
333 itr_ck = "\\\\\\foo\\\\\\bar\\\\\\";
334 itr = itr_ck.begin();
335 // three or more leading slashes are to be treated as a single slash
336 PATH_TEST_EQ(itr->string(), "/");
337 PATH_TEST_EQ(*++itr, "foo");
338 PATH_TEST_EQ(*++itr, "bar");
339 PATH_TEST_EQ(*++itr, ".");
340 BOOST_TEST(++itr == itr_ck.end());
341 PATH_TEST_EQ(*--itr, ".");
342 PATH_TEST_EQ(*--itr, "bar");
343 PATH_TEST_EQ(*--itr, "foo");
344 PATH_TEST_EQ(*--itr, "/");
345
346 itr_ck = "c:foo";
347 itr = itr_ck.begin();
348 BOOST_TEST(*itr == std::string("c:"));
349 BOOST_TEST(*++itr == std::string("foo"));
350 BOOST_TEST(++itr == itr_ck.end());
351 BOOST_TEST(*--itr == std::string("foo"));
352 BOOST_TEST(*--itr == std::string("c:"));
353
354 itr_ck = "c:foo/";
355 itr = itr_ck.begin();
356 BOOST_TEST(*itr == std::string("c:"));
357 BOOST_TEST(*++itr == std::string("foo"));
358 BOOST_TEST(*++itr == std::string("."));
359 BOOST_TEST(++itr == itr_ck.end());
360 BOOST_TEST(*--itr == std::string("."));
361 BOOST_TEST(*--itr == std::string("foo"));
362 BOOST_TEST(*--itr == std::string("c:"));
363
364 itr_ck = path("c:");
365 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
366 BOOST_TEST(next(itr_ck.begin()) == itr_ck.end());
367 BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin());
368 BOOST_TEST(*prior(itr_ck.end()) == std::string("c:"));
369
370 itr_ck = path("c:/");
371 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
372 BOOST_TEST(*next(itr_ck.begin()) == std::string("/"));
373 BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end());
374 BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin());
375 BOOST_TEST(*prior(itr_ck.end()) == std::string("/"));
376 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:"));
377
378 itr_ck = path("c:foo");
379 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
380 BOOST_TEST(*next(itr_ck.begin()) == std::string("foo"));
381 BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end());
382 BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin());
383 BOOST_TEST(*prior(itr_ck.end()) == std::string("foo"));
384 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:"));
385
386 itr_ck = path("c:/foo");
387 BOOST_TEST(*itr_ck.begin() == std::string("c:"));
388 BOOST_TEST(*next(itr_ck.begin()) == std::string("/"));
389 BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo"));
390 BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end());
391 BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin());
392 BOOST_TEST(*prior(itr_ck.end()) == std::string("foo"));
393 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/"));
394 BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("c:"));
395
396 itr_ck = path("//net");
397 BOOST_TEST(*itr_ck.begin() == std::string("//net"));
398 BOOST_TEST(next(itr_ck.begin()) == itr_ck.end());
399 BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin());
400 BOOST_TEST(*prior(itr_ck.end()) == std::string("//net"));
401
402 itr_ck = path("//net/");
403 PATH_TEST_EQ(itr_ck.begin()->string(), "//net");
404 PATH_TEST_EQ(next(itr_ck.begin())->string(), "/");
405 BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end());
406 BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin());
407 PATH_TEST_EQ(prior(itr_ck.end())->string(), "/");
408 PATH_TEST_EQ(prior(prior(itr_ck.end()))->string(), "//net");
409
410 itr_ck = path("//net/foo");
411 BOOST_TEST(*itr_ck.begin() == std::string("//net"));
412 BOOST_TEST(*next(itr_ck.begin()) == std::string("/"));
413 BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo"));
414 BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end());
415 BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin());
416 BOOST_TEST(*prior(itr_ck.end()) == std::string("foo"));
417 BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/"));
418 BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("//net"));
419
420 itr_ck = path("prn:");
421 BOOST_TEST(*itr_ck.begin() == std::string("prn:"));
422 BOOST_TEST(next(itr_ck.begin()) == itr_ck.end());
423 BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin());
424 BOOST_TEST(*prior(itr_ck.end()) == std::string("prn:"));
425 }
426 else
427 {
428 itr_ck = "///";
429 itr = itr_ck.begin();
430 PATH_TEST_EQ(itr->string(), "/");
431 BOOST_TEST(++itr == itr_ck.end());
432 }
433 }
434
435 // non_member_tests ----------------------------------------------------------------//
436
437 void non_member_tests()
438 {
439 std::cout << "non_member_tests..." << std::endl;
440
441 // test non-member functions, particularly operator overloads
442
443 path e, e2;
444 std::string es, es2;
445 char ecs[] = "";
446 char ecs2[] = "";
447
448 char acs[] = "a";
449 std::string as(acs);
450 path a(as);
451
452 char acs2[] = "a";
453 std::string as2(acs2);
454 path a2(as2);
455
456 char bcs[] = "b";
457 std::string bs(bcs);
458 path b(bs);
459
460 // swap
461 a.swap(b);
462 BOOST_TEST(a.string() == "b");
463 BOOST_TEST(b.string() == "a");
464 fs::swap(a, b);
465 BOOST_TEST(a.string() == "a");
466 BOOST_TEST(b.string() == "b");
467
468 // probe operator /
469 PATH_TEST_EQ(path("") / ".", ".");
470 PATH_TEST_EQ(path("") / "..", "..");
471 if (platform == "Windows")
472 {
473 BOOST_TEST(path("foo\\bar") == "foo/bar");
474 BOOST_TEST((b / a).native() == path("b\\a").native());
475 BOOST_TEST((bs / a).native() == path("b\\a").native());
476 BOOST_TEST((bcs / a).native() == path("b\\a").native());
477 BOOST_TEST((b / as).native() == path("b\\a").native());
478 BOOST_TEST((b / acs).native() == path("b\\a").native());
479 PATH_TEST_EQ(path("a") / "b", "a\\b");
480 PATH_TEST_EQ(path("..") / "", "..");
481 PATH_TEST_EQ(path("foo") / path("bar"), "foo\\bar"); // path arg
482 PATH_TEST_EQ(path("foo") / "bar", "foo\\bar"); // const char* arg
483 PATH_TEST_EQ(path("foo") / path("woo/bar").filename(), "foo\\bar"); // const std::string & arg
484 PATH_TEST_EQ("foo" / path("bar"), "foo\\bar");
485 PATH_TEST_EQ(path("..") / ".." , "..\\..");
486 PATH_TEST_EQ(path("/") / ".." , "/..");
487 PATH_TEST_EQ(path("/..") / ".." , "/..\\..");
488 PATH_TEST_EQ(path("..") / "foo" , "..\\foo");
489 PATH_TEST_EQ(path("foo") / ".." , "foo\\..");
490 PATH_TEST_EQ(path("..") / "f" , "..\\f");
491 PATH_TEST_EQ(path("/..") / "f" , "/..\\f");
492 PATH_TEST_EQ(path("f") / ".." , "f\\..");
493 PATH_TEST_EQ(path("foo") / ".." / ".." , "foo\\..\\..");
494 PATH_TEST_EQ(path("foo") / ".." / ".." / ".." , "foo\\..\\..\\..");
495 PATH_TEST_EQ(path("f") / ".." / "b" , "f\\..\\b");
496 PATH_TEST_EQ(path("foo") / ".." / "bar" , "foo\\..\\bar");
497 PATH_TEST_EQ(path("foo") / "bar" / ".." , "foo\\bar\\..");
498 PATH_TEST_EQ(path("foo") / "bar" / ".." / "..", "foo\\bar\\..\\..");
499 PATH_TEST_EQ(path("foo") / "bar" / ".." / "blah", "foo\\bar\\..\\blah");
500 PATH_TEST_EQ(path("f") / "b" / ".." , "f\\b\\..");
501 PATH_TEST_EQ(path("f") / "b" / ".." / "a", "f\\b\\..\\a");
502 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / "..", "foo\\bar\\blah\\..\\..");
503 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo\\bar\\blah\\..\\..\\bletch");
504
505 PATH_TEST_EQ(path(".") / "foo", ".\\foo");
506 PATH_TEST_EQ(path(".") / "..", ".\\..");
507 PATH_TEST_EQ(path("foo") / ".", "foo\\.");
508 PATH_TEST_EQ(path("..") / ".", "..\\.");
509 PATH_TEST_EQ(path(".") / ".", ".\\.");
510 PATH_TEST_EQ(path(".") / "." / ".", ".\\.\\.");
511 PATH_TEST_EQ(path(".") / "foo" / ".", ".\\foo\\.");
512 PATH_TEST_EQ(path("foo") / "." / "bar", "foo\\.\\bar");
513 PATH_TEST_EQ(path("foo") / "." / ".", "foo\\.\\.");
514 PATH_TEST_EQ(path("foo") / "." / "..", "foo\\.\\..");
515 PATH_TEST_EQ(path(".") / "." / "..", ".\\.\\..");
516 PATH_TEST_EQ(path(".") / ".." / ".", ".\\..\\.");
517 PATH_TEST_EQ(path("..") / "." / ".", "..\\.\\.");
518 }
519 else // POSIX
520 {
521 PATH_TEST_EQ(b / a, "b/a");
522 PATH_TEST_EQ(bs / a, "b/a");
523 PATH_TEST_EQ(bcs / a, "b/a");
524 PATH_TEST_EQ(b / as, "b/a");
525 PATH_TEST_EQ(b / acs, "b/a");
526 PATH_TEST_EQ(path("a") / "b", "a/b");
527 PATH_TEST_EQ(path("..") / "", "..");
528 PATH_TEST_EQ(path("") / "..", "..");
529 PATH_TEST_EQ(path("foo") / path("bar"), "foo/bar"); // path arg
530 PATH_TEST_EQ(path("foo") / "bar", "foo/bar"); // const char* arg
531 PATH_TEST_EQ(path("foo") / path("woo/bar").filename(), "foo/bar"); // const std::string & arg
532 PATH_TEST_EQ("foo" / path("bar"), "foo/bar");
533 PATH_TEST_EQ(path("..") / ".." , "../..");
534 PATH_TEST_EQ(path("/") / ".." , "/..");
535 PATH_TEST_EQ(path("/..") / ".." , "/../..");
536 PATH_TEST_EQ(path("..") / "foo" , "../foo");
537 PATH_TEST_EQ(path("foo") / ".." , "foo/..");
538 PATH_TEST_EQ(path("..") / "f" , "../f");
539 PATH_TEST_EQ(path("/..") / "f" , "/../f");
540 PATH_TEST_EQ(path("f") / ".." , "f/..");
541 PATH_TEST_EQ(path("foo") / ".." / ".." , "foo/../..");
542 PATH_TEST_EQ(path("foo") / ".." / ".." / ".." , "foo/../../..");
543 PATH_TEST_EQ(path("f") / ".." / "b" , "f/../b");
544 PATH_TEST_EQ(path("foo") / ".." / "bar" , "foo/../bar");
545 PATH_TEST_EQ(path("foo") / "bar" / ".." , "foo/bar/..");
546 PATH_TEST_EQ(path("foo") / "bar" / ".." / "..", "foo/bar/../..");
547 PATH_TEST_EQ(path("foo") / "bar" / ".." / "blah", "foo/bar/../blah");
548 PATH_TEST_EQ(path("f") / "b" / ".." , "f/b/..");
549 PATH_TEST_EQ(path("f") / "b" / ".." / "a", "f/b/../a");
550 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / "..", "foo/bar/blah/../..");
551 PATH_TEST_EQ(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo/bar/blah/../../bletch");
552
553 PATH_TEST_EQ(path(".") / "foo", "./foo");
554 PATH_TEST_EQ(path(".") / "..", "./..");
555 PATH_TEST_EQ(path("foo") / ".", "foo/.");
556 PATH_TEST_EQ(path("..") / ".", "../.");
557 PATH_TEST_EQ(path(".") / ".", "./.");
558 PATH_TEST_EQ(path(".") / "." / ".", "././.");
559 PATH_TEST_EQ(path(".") / "foo" / ".", "./foo/.");
560 PATH_TEST_EQ(path("foo") / "." / "bar", "foo/./bar");
561 PATH_TEST_EQ(path("foo") / "." / ".", "foo/./.");
562 PATH_TEST_EQ(path("foo") / "." / "..", "foo/./..");
563 PATH_TEST_EQ(path(".") / "." / "..", "././..");
564 PATH_TEST_EQ(path(".") / ".." / ".", "./../.");
565 PATH_TEST_EQ(path("..") / "." / ".", ".././.");
566 }
567
568 // probe operator <
569 BOOST_TEST(!(e < e2));
570 BOOST_TEST(!(es < e2));
571 BOOST_TEST(!(ecs < e2));
572 BOOST_TEST(!(e < es2));
573 BOOST_TEST(!(e < ecs2));
574
575 BOOST_TEST(e < a);
576 BOOST_TEST(es < a);
577 BOOST_TEST(ecs < a);
578 BOOST_TEST(e < as);
579 BOOST_TEST(e < acs);
580
581 BOOST_TEST(a < b);
582 BOOST_TEST(as < b);
583 BOOST_TEST(acs < b);
584 BOOST_TEST(a < bs);
585 BOOST_TEST(a < bcs);
586
587 BOOST_TEST(!(a < a2));
588 BOOST_TEST(!(as < a2));
589 BOOST_TEST(!(acs < a2));
590 BOOST_TEST(!(a < as2));
591 BOOST_TEST(!(a < acs2));
592
593 // make sure basic_path overloads don't conflict with std::string overloads
594
595 BOOST_TEST(!(as < as));
596 BOOST_TEST(!(as < acs));
597 BOOST_TEST(!(acs < as));
598
599 // character set reality check before lexicographical tests
600 BOOST_TEST(std::string("a.b") < std::string("a/b"));
601 // verify compare is actually lexicographical
602 BOOST_TEST(path("a/b") < path("a.b"));
603 BOOST_TEST(path("a/b") == path("a///b"));
604 BOOST_TEST(path("a/b/") == path("a/b/."));
605 BOOST_TEST(path("a/b") != path("a/b/"));
606
607 // make sure the derivative operators also work
608
609 BOOST_TEST(b > a);
610 BOOST_TEST(b > as);
611 BOOST_TEST(b > acs);
612 BOOST_TEST(bs > a);
613 BOOST_TEST(bcs > a);
614
615 BOOST_TEST(!(a2 > a));
616 BOOST_TEST(!(a2 > as));
617 BOOST_TEST(!(a2 > acs));
618 BOOST_TEST(!(as2 > a));
619 BOOST_TEST(!(acs2 > a));
620
621 BOOST_TEST(a <= b);
622 BOOST_TEST(as <= b);
623 BOOST_TEST(acs <= b);
624 BOOST_TEST(a <= bs);
625 BOOST_TEST(a <= bcs);
626
627 BOOST_TEST(a <= a2);
628 BOOST_TEST(as <= a2);
629 BOOST_TEST(acs <= a2);
630 BOOST_TEST(a <= as2);
631 BOOST_TEST(a <= acs2);
632
633 BOOST_TEST(b >= a);
634 BOOST_TEST(bs >= a);
635 BOOST_TEST(bcs >= a);
636 BOOST_TEST(b >= as);
637 BOOST_TEST(b >= acs);
638
639 BOOST_TEST(a2 >= a);
640 BOOST_TEST(as2 >= a);
641 BOOST_TEST(acs2 >= a);
642 BOOST_TEST(a2 >= as);
643 BOOST_TEST(a2 >= acs);
644
645 // operator == and != are implemented separately, so test separately
646
647 path p101("fe/fi/fo/fum");
648 path p102(p101);
649 path p103("fe/fi/fo/fumm");
650 BOOST_TEST(p101.string() != p103.string());
651
652 // check each overload
653 BOOST_TEST(p101 != p103);
654 BOOST_TEST(p101 != p103.string());
655 BOOST_TEST(p101 != p103.string().c_str());
656 BOOST_TEST(p101.string() != p103);
657 BOOST_TEST(p101.string().c_str() != p103);
658
659 p103 = p102;
660 BOOST_TEST(p101.string() == p103.string());
661
662 // check each overload
663 BOOST_TEST(p101 == p103);
664 BOOST_TEST(p101 == p103.string());
665 BOOST_TEST(p101 == p103.string().c_str());
666 BOOST_TEST(p101.string() == p103);
667 BOOST_TEST(p101.string().c_str() == p103);
668
669 if (platform == "Windows")
670 {
671 std::cout << " Windows relational tests..." << std::endl;
672 path p10 ("c:\\file");
673 path p11 ("c:/file");
674 // check each overload
675 BOOST_TEST(p10.generic_string() == p11.generic_string());
676 BOOST_TEST(p10 == p11);
677 BOOST_TEST(p10 == p11.string());
678 BOOST_TEST(p10 == p11.string().c_str());
679 BOOST_TEST(p10.string() == p11);
680 BOOST_TEST(p10.string().c_str() == p11);
681 BOOST_TEST(p10 == L"c:\\file");
682 BOOST_TEST(p10 == L"c:/file");
683 BOOST_TEST(p11 == L"c:\\file");
684 BOOST_TEST(p11 == L"c:/file");
685 BOOST_TEST(L"c:\\file" == p10);
686 BOOST_TEST(L"c:/file" == p10);
687 BOOST_TEST(L"c:\\file" == p11);
688 BOOST_TEST(L"c:/file" == p11);
689
690 BOOST_TEST(!(p10.generic_string() != p11.generic_string()));
691 BOOST_TEST(!(p10 != p11));
692 BOOST_TEST(!(p10 != p11.string()));
693 BOOST_TEST(!(p10 != p11.string().c_str()));
694 BOOST_TEST(!(p10.string() != p11));
695 BOOST_TEST(!(p10.string().c_str() != p11));
696 BOOST_TEST(!(p10 != L"c:\\file"));
697 BOOST_TEST(!(p10 != L"c:/file"));
698 BOOST_TEST(!(p11 != L"c:\\file"));
699 BOOST_TEST(!(p11 != L"c:/file"));
700 BOOST_TEST(!(L"c:\\file" != p10));
701 BOOST_TEST(!(L"c:/file" != p10));
702 BOOST_TEST(!(L"c:\\file" != p11));
703 BOOST_TEST(!(L"c:/file" != p11));
704
705 BOOST_TEST(!(p10.string() < p11.string()));
706 BOOST_TEST(!(p10 < p11));
707 BOOST_TEST(!(p10 < p11.string()));
708 BOOST_TEST(!(p10 < p11.string().c_str()));
709 BOOST_TEST(!(p10.string() < p11));
710 BOOST_TEST(!(p10.string().c_str() < p11));
711 BOOST_TEST(!(p10 < L"c:\\file"));
712 BOOST_TEST(!(p10 < L"c:/file"));
713 BOOST_TEST(!(p11 < L"c:\\file"));
714 BOOST_TEST(!(p11 < L"c:/file"));
715 BOOST_TEST(!(L"c:\\file" < p10));
716 BOOST_TEST(!(L"c:/file" < p10));
717 BOOST_TEST(!(L"c:\\file" < p11));
718 BOOST_TEST(!(L"c:/file" < p11));
719
720 BOOST_TEST(!(p10.generic_string() > p11.generic_string()));
721 BOOST_TEST(!(p10 > p11));
722 BOOST_TEST(!(p10 > p11.string()));
723 BOOST_TEST(!(p10 > p11.string().c_str()));
724 BOOST_TEST(!(p10.string() > p11));
725 BOOST_TEST(!(p10.string().c_str() > p11));
726 BOOST_TEST(!(p10 > L"c:\\file"));
727 BOOST_TEST(!(p10 > L"c:/file"));
728 BOOST_TEST(!(p11 > L"c:\\file"));
729 BOOST_TEST(!(p11 > L"c:/file"));
730 BOOST_TEST(!(L"c:\\file" > p10));
731 BOOST_TEST(!(L"c:/file" > p10));
732 BOOST_TEST(!(L"c:\\file" > p11));
733 BOOST_TEST(!(L"c:/file" > p11));
734 }
735
736 // relative
737
738 BOOST_TEST(fs::relative("/abc/def", "/abc") == path("def"));
739 BOOST_TEST(fs::relative("abc/def", "abc") == path("def"));
740 BOOST_TEST(fs::relative("/abc/xyz/def", "/abc") == path("xyz/def"));
741 BOOST_TEST(fs::relative("abc/xyz/def", "abc") == path("xyz/def"));
742
743 if (platform == "Windows")
744 {
745 std::cout << " Windows relatie tests..." << std::endl;
746 BOOST_TEST(fs::relative("\\abc\\xyz\\def", "/abc") == path("xyz/def"));
747 std::cout << " fs::relative(\"/abc/xyz/def\", \"/abc\") is "
748 << fs::relative("/abc/xyz/def", "/abc") << std::endl;
749 BOOST_TEST(fs::relative("abc\\xyz\\def", "abc") == path("xyz/def"));
750 }
751 }
752
753 // query_and_decomposition_tests ---------------------------------------------------//
754 //
755 // remove_filename() is also tested here, because its specification depends on
756 // a decomposition function.
757
758 void query_and_decomposition_tests()
759 {
760 std::cout << "query_and_decomposition_tests..." << std::endl;
761
762 // these are the examples given in reference docs, so check they work
763 BOOST_TEST(path("/foo/bar.txt").parent_path() == "/foo");
764 BOOST_TEST(path("/foo/bar").parent_path() == "/foo");
765 BOOST_TEST(path("/foo/bar/").parent_path() == "/foo/bar");
766 BOOST_TEST(path("/").parent_path() == "");
767 BOOST_TEST(path(".").parent_path() == "");
768 BOOST_TEST(path("..").parent_path() == "");
769 BOOST_TEST(path("/foo/bar.txt").filename() == "bar.txt");
770 BOOST_TEST(path("/foo/bar").filename() == "bar");
771 BOOST_TEST(path("/foo/bar/").filename() == ".");
772 BOOST_TEST(path("/").filename() == "/");
773 BOOST_TEST(path(".").filename() == ".");
774 BOOST_TEST(path("..").filename() == "..");
775
776 // stem() tests not otherwise covered
777 BOOST_TEST(path(".").stem() == ".");
778 BOOST_TEST(path("..").stem() == "..");
779 BOOST_TEST(path(".a").stem() == "");
780 BOOST_TEST(path("b").stem() == "b");
781 BOOST_TEST(path("a/b.txt").stem() == "b");
782 BOOST_TEST(path("a/b.").stem() == "b");
783 BOOST_TEST(path("a.b.c").stem() == "a.b");
784 BOOST_TEST(path("a.b.c.").stem() == "a.b.c");
785
786 // extension() tests not otherwise covered
787 BOOST_TEST(path(".").extension() == "");
788 BOOST_TEST(path("..").extension() == "");
789 BOOST_TEST(path(".a").extension() == ".a");
790 BOOST_TEST(path("a/b").extension() == "");
791 BOOST_TEST(path("a.b/c").extension() == "");
792 BOOST_TEST(path("a/b.txt").extension() == ".txt");
793 BOOST_TEST(path("a/b.").extension() == ".");
794 BOOST_TEST(path("a.b.c").extension() == ".c");
795 BOOST_TEST(path("a.b.c.").extension() == ".");
796 BOOST_TEST(path("a/").extension() == "");
797
798 // main q & d test sequence
799 path p;
800 path q;
801
802 p = q = "";
803 BOOST_TEST(p.relative_path().string() == "");
804 BOOST_TEST(p.parent_path().string() == "");
805 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
806 BOOST_TEST(p.filename() == "");
807 BOOST_TEST(p.stem() == "");
808 BOOST_TEST(p.extension() == "");
809 BOOST_TEST(p.root_name() == "");
810 BOOST_TEST(p.root_directory() == "");
811 BOOST_TEST(p.root_path().string() == "");
812 BOOST_TEST(!p.has_root_path());
813 BOOST_TEST(!p.has_root_name());
814 BOOST_TEST(!p.has_root_directory());
815 BOOST_TEST(!p.has_relative_path());
816 BOOST_TEST(!p.has_filename());
817 BOOST_TEST(!p.has_stem());
818 BOOST_TEST(!p.has_extension());
819 BOOST_TEST(!p.has_parent_path());
820 BOOST_TEST(!p.is_absolute());
821
822 p = q = "/";
823 BOOST_TEST(p.relative_path().string() == "");
824 BOOST_TEST(p.parent_path().string() == "");
825 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
826 BOOST_TEST(p.filename() == "/");
827 BOOST_TEST(p.stem() == "/");
828 BOOST_TEST(p.extension() == "");
829 BOOST_TEST(p.root_name() == "");
830 BOOST_TEST(p.root_directory() == "/");
831 BOOST_TEST(p.root_path().string() == "/");
832 BOOST_TEST(p.has_root_path());
833 BOOST_TEST(!p.has_root_name());
834 BOOST_TEST(p.has_root_directory());
835 BOOST_TEST(!p.has_relative_path());
836 BOOST_TEST(p.has_filename());
837 BOOST_TEST(p.has_stem());
838 BOOST_TEST(!p.has_extension());
839 BOOST_TEST(!p.has_parent_path());
840 if (platform == "POSIX")
841 BOOST_TEST(p.is_absolute());
842 else
843 BOOST_TEST(!p.is_absolute());
844
845 p = q = "//";
846 PATH_TEST_EQ(p.relative_path().string(), "");
847 PATH_TEST_EQ(p.parent_path().string(), "");
848 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
849 PATH_TEST_EQ(p.filename(), "//");
850 PATH_TEST_EQ(p.stem(), "//");
851 PATH_TEST_EQ(p.extension(), "");
852 PATH_TEST_EQ(p.root_name(), "//");
853 PATH_TEST_EQ(p.root_directory(), "");
854 PATH_TEST_EQ(p.root_path().string(), "//");
855 BOOST_TEST(p.has_root_path());
856 BOOST_TEST(p.has_root_name());
857 BOOST_TEST(!p.has_root_directory());
858 BOOST_TEST(!p.has_relative_path());
859 BOOST_TEST(p.has_filename());
860 BOOST_TEST(p.has_stem());
861 BOOST_TEST(!p.has_extension());
862 BOOST_TEST(!p.has_parent_path());
863 BOOST_TEST(!p.is_absolute());
864
865 p = q = "///";
866 PATH_TEST_EQ(p.relative_path().string(), "");
867 PATH_TEST_EQ(p.parent_path().string(), "");
868 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
869 PATH_TEST_EQ(p.filename(), "/");
870 PATH_TEST_EQ(p.stem(), "/");
871 PATH_TEST_EQ(p.extension(), "");
872 PATH_TEST_EQ(p.root_name(), "");
873 PATH_TEST_EQ(p.root_directory(), "/");
874 PATH_TEST_EQ(p.root_path().string(), "/");
875 BOOST_TEST(p.has_root_path());
876 BOOST_TEST(!p.has_root_name());
877 BOOST_TEST(p.has_root_directory());
878 BOOST_TEST(!p.has_relative_path());
879 BOOST_TEST(p.has_filename());
880 BOOST_TEST(p.has_stem());
881 BOOST_TEST(!p.has_extension());
882 BOOST_TEST(!p.has_parent_path());
883 if (platform == "POSIX")
884 BOOST_TEST(p.is_absolute());
885 else
886 BOOST_TEST(!p.is_absolute());
887
888 p = q = ".";
889 BOOST_TEST(p.relative_path().string() == ".");
890 BOOST_TEST(p.parent_path().string() == "");
891 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
892 BOOST_TEST(p.filename() == ".");
893 BOOST_TEST(p.stem() == ".");
894 BOOST_TEST(p.extension() == "");
895 BOOST_TEST(p.root_name() == "");
896 BOOST_TEST(p.root_directory() == "");
897 BOOST_TEST(p.root_path().string() == "");
898 BOOST_TEST(!p.has_root_path());
899 BOOST_TEST(!p.has_root_name());
900 BOOST_TEST(!p.has_root_directory());
901 BOOST_TEST(p.has_relative_path());
902 BOOST_TEST(p.has_filename());
903 BOOST_TEST(p.has_stem());
904 BOOST_TEST(!p.has_extension());
905 BOOST_TEST(!p.has_parent_path());
906 BOOST_TEST(!p.is_absolute());
907
908 p = q = "..";
909 BOOST_TEST(p.relative_path().string() == "..");
910 BOOST_TEST(p.parent_path().string() == "");
911 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
912 BOOST_TEST(p.filename() == "..");
913 BOOST_TEST(p.stem() == "..");
914 BOOST_TEST(p.extension() == "");
915 BOOST_TEST(p.root_name() == "");
916 BOOST_TEST(p.root_directory() == "");
917 BOOST_TEST(p.root_path().string() == "");
918 BOOST_TEST(!p.has_root_path());
919 BOOST_TEST(!p.has_root_name());
920 BOOST_TEST(!p.has_root_directory());
921 BOOST_TEST(p.has_relative_path());
922 BOOST_TEST(p.has_filename());
923 BOOST_TEST(p.has_stem());
924 BOOST_TEST(!p.has_extension());
925 BOOST_TEST(!p.has_parent_path());
926 BOOST_TEST(!p.is_absolute());
927
928 p = q = "foo";
929 BOOST_TEST(p.relative_path().string() == "foo");
930 BOOST_TEST(p.parent_path().string() == "");
931 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
932 BOOST_TEST(p.filename() == "foo");
933 BOOST_TEST(p.stem() == "foo");
934 BOOST_TEST(p.extension() == "");
935 BOOST_TEST(p.root_name() == "");
936 BOOST_TEST(p.root_directory() == "");
937 BOOST_TEST(p.root_path().string() == "");
938 BOOST_TEST(!p.has_root_path());
939 BOOST_TEST(!p.has_root_name());
940 BOOST_TEST(!p.has_root_directory());
941 BOOST_TEST(p.has_relative_path());
942 BOOST_TEST(p.has_filename());
943 BOOST_TEST(p.has_stem());
944 BOOST_TEST(!p.has_extension());
945 BOOST_TEST(!p.has_parent_path());
946 BOOST_TEST(!p.is_absolute());
947
948 p = q = "/foo";
949 PATH_TEST_EQ(p.relative_path().string(), "foo");
950 PATH_TEST_EQ(p.parent_path().string(), "/");
951 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
952 PATH_TEST_EQ(p.filename(), "foo");
953 PATH_TEST_EQ(p.stem(), "foo");
954 PATH_TEST_EQ(p.extension(), "");
955 PATH_TEST_EQ(p.root_name(), "");
956 PATH_TEST_EQ(p.root_directory(), "/");
957 PATH_TEST_EQ(p.root_path().string(), "/");
958 BOOST_TEST(p.has_root_path());
959 BOOST_TEST(!p.has_root_name());
960 BOOST_TEST(p.has_root_directory());
961 BOOST_TEST(p.has_relative_path());
962 BOOST_TEST(p.has_filename());
963 BOOST_TEST(p.has_stem());
964 BOOST_TEST(!p.has_extension());
965 BOOST_TEST(p.has_parent_path());
966 if (platform == "POSIX")
967 BOOST_TEST(p.is_absolute());
968 else
969 BOOST_TEST(!p.is_absolute());
970
971 p = q = "/foo/";
972 PATH_TEST_EQ(p.relative_path().string(), "foo/");
973 PATH_TEST_EQ(p.parent_path().string(), "/foo");
974 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
975 PATH_TEST_EQ(p.filename(), ".");
976 PATH_TEST_EQ(p.stem(), ".");
977 PATH_TEST_EQ(p.extension(), "");
978 PATH_TEST_EQ(p.root_name(), "");
979 PATH_TEST_EQ(p.root_directory(), "/");
980 PATH_TEST_EQ(p.root_path().string(), "/");
981 BOOST_TEST(p.has_root_path());
982 BOOST_TEST(!p.has_root_name());
983 BOOST_TEST(p.has_root_directory());
984 BOOST_TEST(p.has_relative_path());
985 BOOST_TEST(p.has_filename());
986 BOOST_TEST(p.has_stem());
987 BOOST_TEST(!p.has_extension());
988 BOOST_TEST(p.has_parent_path());
989 if (platform == "POSIX")
990 BOOST_TEST(p.is_absolute());
991 else
992 BOOST_TEST(!p.is_absolute());
993
994 p = q = "///foo";
995 PATH_TEST_EQ(p.relative_path().string(), "foo");
996 PATH_TEST_EQ(p.parent_path().string(), "/");
997 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
998 PATH_TEST_EQ(p.filename(), "foo");
999 PATH_TEST_EQ(p.root_name(), "");
1000 PATH_TEST_EQ(p.root_directory(), "/");
1001 PATH_TEST_EQ(p.root_path().string(), "/");
1002 BOOST_TEST(p.has_root_path());
1003 BOOST_TEST(!p.has_root_name());
1004 BOOST_TEST(p.has_root_directory());
1005 BOOST_TEST(p.has_relative_path());
1006 BOOST_TEST(p.has_filename());
1007 BOOST_TEST(p.has_parent_path());
1008 if (platform == "POSIX")
1009 BOOST_TEST(p.is_absolute());
1010 else
1011 BOOST_TEST(!p.is_absolute());
1012
1013 p = q = "foo/bar";
1014 BOOST_TEST(p.relative_path().string() == "foo/bar");
1015 BOOST_TEST(p.parent_path().string() == "foo");
1016 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1017 BOOST_TEST(p.filename() == "bar");
1018 BOOST_TEST(p.stem() == "bar");
1019 BOOST_TEST(p.extension() == "");
1020 BOOST_TEST(p.root_name() == "");
1021 BOOST_TEST(p.root_directory() == "");
1022 BOOST_TEST(p.root_path().string() == "");
1023 BOOST_TEST(!p.has_root_path());
1024 BOOST_TEST(!p.has_root_name());
1025 BOOST_TEST(!p.has_root_directory());
1026 BOOST_TEST(p.has_relative_path());
1027 BOOST_TEST(p.has_filename());
1028 BOOST_TEST(p.has_stem());
1029 BOOST_TEST(!p.has_extension());
1030 BOOST_TEST(p.has_parent_path());
1031 BOOST_TEST(!p.is_absolute());
1032
1033 p = q = "../foo";
1034 BOOST_TEST(p.relative_path().string() == "../foo");
1035 BOOST_TEST(p.parent_path().string() == "..");
1036 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1037 BOOST_TEST(p.filename() == "foo");
1038 BOOST_TEST(p.root_name() == "");
1039 BOOST_TEST(p.root_directory() == "");
1040 BOOST_TEST(p.root_path().string() == "");
1041 BOOST_TEST(!p.has_root_path());
1042 BOOST_TEST(!p.has_root_name());
1043 BOOST_TEST(!p.has_root_directory());
1044 BOOST_TEST(p.has_relative_path());
1045 BOOST_TEST(p.has_filename());
1046 BOOST_TEST(p.has_parent_path());
1047 BOOST_TEST(!p.is_absolute());
1048
1049 p = q = "..///foo";
1050 PATH_TEST_EQ(p.relative_path().string(), "..///foo");
1051 PATH_TEST_EQ(p.parent_path().string(), "..");
1052 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1053 PATH_TEST_EQ(p.filename(), "foo");
1054 PATH_TEST_EQ(p.root_name(), "");
1055 PATH_TEST_EQ(p.root_directory(), "");
1056 PATH_TEST_EQ(p.root_path().string(), "");
1057 BOOST_TEST(!p.has_root_path());
1058 BOOST_TEST(!p.has_root_name());
1059 BOOST_TEST(!p.has_root_directory());
1060 BOOST_TEST(p.has_relative_path());
1061 BOOST_TEST(p.has_filename());
1062 BOOST_TEST(p.has_parent_path());
1063 BOOST_TEST(!p.is_absolute());
1064
1065 p = q = "/foo/bar";
1066 BOOST_TEST(p.relative_path().string() == "foo/bar");
1067 BOOST_TEST(p.parent_path().string() == "/foo");
1068 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1069 BOOST_TEST(p.filename() == "bar");
1070 BOOST_TEST(p.root_name() == "");
1071 BOOST_TEST(p.root_directory() == "/");
1072 BOOST_TEST(p.root_path().string() == "/");
1073 BOOST_TEST(p.has_root_path());
1074 BOOST_TEST(!p.has_root_name());
1075 BOOST_TEST(p.has_root_directory());
1076 BOOST_TEST(p.has_relative_path());
1077 BOOST_TEST(p.has_filename());
1078 BOOST_TEST(p.has_parent_path());
1079 if (platform == "POSIX")
1080 BOOST_TEST(p.is_absolute());
1081 else
1082 BOOST_TEST(!p.is_absolute());
1083
1084 // Both POSIX and Windows allow two leading slashs
1085 // (POSIX meaning is implementation defined)
1086 PATH_TEST_EQ(path("//resource"), "//resource");
1087 PATH_TEST_EQ(path("//resource/"), "//resource/");
1088 PATH_TEST_EQ(path("//resource/foo"), "//resource/foo");
1089
1090 p = q = path("//net");
1091 PATH_TEST_EQ(p.string(), "//net");
1092 PATH_TEST_EQ(p.relative_path().string(), "");
1093 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1094 PATH_TEST_EQ(p.parent_path().string(), "");
1095 PATH_TEST_EQ(p.filename(), "//net");
1096 PATH_TEST_EQ(p.root_name(), "//net");
1097 PATH_TEST_EQ(p.root_directory(), "");
1098 PATH_TEST_EQ(p.root_path().string(), "//net");
1099 BOOST_TEST(p.has_root_path());
1100 BOOST_TEST(p.has_root_name());
1101 BOOST_TEST(!p.has_root_directory());
1102 BOOST_TEST(!p.has_relative_path());
1103 BOOST_TEST(p.has_filename());
1104 BOOST_TEST(!p.has_parent_path());
1105 BOOST_TEST(!p.is_absolute());
1106
1107 p = q = path("//net/");
1108 BOOST_TEST(p.relative_path().string() == "");
1109 BOOST_TEST(p.parent_path().string() == "//net");
1110 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1111 BOOST_TEST(p.filename() == "/");
1112 BOOST_TEST(p.root_name() == "//net");
1113 BOOST_TEST(p.root_directory() == "/");
1114 BOOST_TEST(p.root_path().string() == "//net/");
1115 BOOST_TEST(p.has_root_path());
1116 BOOST_TEST(p.has_root_name());
1117 BOOST_TEST(p.has_root_directory());
1118 BOOST_TEST(!p.has_relative_path());
1119 BOOST_TEST(p.has_filename());
1120 BOOST_TEST(p.has_parent_path());
1121 BOOST_TEST(p.is_absolute());
1122
1123 p = q = path("//net/foo");
1124 BOOST_TEST(p.relative_path().string() == "foo");
1125 BOOST_TEST(p.parent_path().string() == "//net/");
1126 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1127 BOOST_TEST(p.filename() == "foo");
1128 BOOST_TEST(p.root_name() == "//net");
1129 BOOST_TEST(p.root_directory() == "/");
1130 BOOST_TEST(p.root_path().string() == "//net/");
1131 BOOST_TEST(p.has_root_path());
1132 BOOST_TEST(p.has_root_name());
1133 BOOST_TEST(p.has_root_directory());
1134 BOOST_TEST(p.has_relative_path());
1135 BOOST_TEST(p.has_filename());
1136 BOOST_TEST(p.has_parent_path());
1137 BOOST_TEST(p.is_absolute());
1138
1139 p = q = path("//net///foo");
1140 PATH_TEST_EQ(p.relative_path().string(), "foo");
1141 PATH_TEST_EQ(p.parent_path().string(), "//net/");
1142 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1143 PATH_TEST_EQ(p.filename(), "foo");
1144 PATH_TEST_EQ(p.root_name(), "//net");
1145 PATH_TEST_EQ(p.root_directory(), "/");
1146 PATH_TEST_EQ(p.root_path().string(), "//net/");
1147 BOOST_TEST(p.has_root_path());
1148 BOOST_TEST(p.has_root_name());
1149 BOOST_TEST(p.has_root_directory());
1150 BOOST_TEST(p.has_relative_path());
1151 BOOST_TEST(p.has_filename());
1152 BOOST_TEST(p.has_parent_path());
1153 BOOST_TEST(p.is_absolute());
1154
1155 // ticket 2739, infinite recursion leading to stack overflow, was caused
1156 // by failure to handle this case correctly on Windows.
1157 p = path(":");
1158 PATH_TEST_EQ(p.parent_path().string(), "");
1159 PATH_TEST_EQ(p.filename(), ":");
1160 BOOST_TEST(!p.has_parent_path());
1161 BOOST_TEST(p.has_filename());
1162
1163 // test some similar cases that both POSIX and Windows should handle identically
1164 p = path("c:");
1165 PATH_TEST_EQ(p.parent_path().string(), "");
1166 PATH_TEST_EQ(p.filename(), "c:");
1167 BOOST_TEST(!p.has_parent_path());
1168 BOOST_TEST(p.has_filename());
1169 p = path("cc:");
1170 PATH_TEST_EQ(p.parent_path().string(), "");
1171 PATH_TEST_EQ(p.filename(), "cc:");
1172 BOOST_TEST(!p.has_parent_path());
1173 BOOST_TEST(p.has_filename());
1174
1175 // Windows specific tests
1176 if (platform == "Windows")
1177 {
1178
1179 //p = q = L"\\\\?\\";
1180 //BOOST_TEST(p.relative_path().string() == "");
1181 //BOOST_TEST(p.parent_path().string() == "");
1182 //PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1183 //BOOST_TEST(p.filename() == "");
1184 //BOOST_TEST(p.stem() == "");
1185 //BOOST_TEST(p.extension() == "");
1186 //BOOST_TEST(p.root_name() == "");
1187 //BOOST_TEST(p.root_directory() == "");
1188 //BOOST_TEST(p.root_path().string() == "");
1189 //BOOST_TEST(!p.has_root_path());
1190 //BOOST_TEST(!p.has_root_name());
1191 //BOOST_TEST(!p.has_root_directory());
1192 //BOOST_TEST(!p.has_relative_path());
1193 //BOOST_TEST(!p.has_filename());
1194 //BOOST_TEST(!p.has_stem());
1195 //BOOST_TEST(!p.has_extension());
1196 //BOOST_TEST(!p.has_parent_path());
1197 //BOOST_TEST(!p.is_absolute());
1198
1199 p = q = path("c:");
1200 BOOST_TEST(p.relative_path().string() == "");
1201 BOOST_TEST(p.parent_path().string() == "");
1202 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1203 BOOST_TEST(p.filename() == "c:");
1204 BOOST_TEST(p.root_name() == "c:");
1205 BOOST_TEST(p.root_directory() == "");
1206 BOOST_TEST(p.root_path().string() == "c:");
1207 BOOST_TEST(p.has_root_path());
1208 BOOST_TEST(p.has_root_name());
1209 BOOST_TEST(!p.has_root_directory());
1210 BOOST_TEST(!p.has_relative_path());
1211 BOOST_TEST(p.has_filename());
1212 BOOST_TEST(!p.has_parent_path());
1213 BOOST_TEST(!p.is_absolute());
1214
1215 //p = q = path(L"\\\\?\\c:");
1216 //BOOST_TEST(p.relative_path().string() == "");
1217 //BOOST_TEST(p.parent_path().string() == "");
1218 //PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1219 //BOOST_TEST(p.filename() == "c:");
1220 //BOOST_TEST(p.root_name() == "c:");
1221 //BOOST_TEST(p.root_directory() == "");
1222 //BOOST_TEST(p.root_path().string() == "c:");
1223 //BOOST_TEST(p.has_root_path());
1224 //BOOST_TEST(p.has_root_name());
1225 //BOOST_TEST(!p.has_root_directory());
1226 //BOOST_TEST(!p.has_relative_path());
1227 //BOOST_TEST(p.has_filename());
1228 //BOOST_TEST(!p.has_parent_path());
1229 //BOOST_TEST(!p.is_absolute());
1230
1231 p = q = path("c:foo");
1232 BOOST_TEST(p.relative_path().string() == "foo");
1233 BOOST_TEST(p.parent_path().string() == "c:");
1234 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1235 BOOST_TEST(p.filename() == "foo");
1236 BOOST_TEST(p.root_name() == "c:");
1237 BOOST_TEST(p.root_directory() == "");
1238 BOOST_TEST(p.root_path().string() == "c:");
1239 BOOST_TEST(p.has_root_path());
1240 BOOST_TEST(p.has_root_name());
1241 BOOST_TEST(!p.has_root_directory());
1242 BOOST_TEST(p.has_relative_path());
1243 BOOST_TEST(p.has_filename());
1244 BOOST_TEST(p.has_parent_path());
1245 BOOST_TEST(!p.is_absolute());
1246
1247 //p = q = path(L"\\\\?\\c:foo");
1248 //BOOST_TEST(p.relative_path().string() == "foo");
1249 //BOOST_TEST(p.parent_path().string() == "c:");
1250 //PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1251 //BOOST_TEST(p.filename() == "foo");
1252 //BOOST_TEST(p.root_name() == "c:");
1253 //BOOST_TEST(p.root_directory() == "");
1254 //BOOST_TEST(p.root_path().string() == "c:");
1255 //BOOST_TEST(p.has_root_path());
1256 //BOOST_TEST(p.has_root_name());
1257 //BOOST_TEST(!p.has_root_directory());
1258 //BOOST_TEST(p.has_relative_path());
1259 //BOOST_TEST(p.has_filename());
1260 //BOOST_TEST(p.has_parent_path());
1261 //BOOST_TEST(!p.is_absolute());
1262
1263 p = q = path("c:/");
1264 BOOST_TEST(p.relative_path().string() == "");
1265 BOOST_TEST(p.parent_path().string() == "c:");
1266 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1267 BOOST_TEST(p.filename() == "/");
1268 BOOST_TEST(p.root_name() == "c:");
1269 BOOST_TEST(p.root_directory() == "/");
1270 BOOST_TEST(p.root_path().string() == "c:/");
1271 BOOST_TEST(p.has_root_path());
1272 BOOST_TEST(p.has_root_name());
1273 BOOST_TEST(p.has_root_directory());
1274 BOOST_TEST(!p.has_relative_path());
1275 BOOST_TEST(p.has_filename());
1276 BOOST_TEST(p.has_parent_path());
1277 BOOST_TEST(p.is_absolute());
1278
1279 p = q = path("c:..");
1280 BOOST_TEST(p.relative_path().string() == "..");
1281 BOOST_TEST(p.parent_path().string() == "c:");
1282 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1283 BOOST_TEST(p.filename() == "..");
1284 BOOST_TEST(p.root_name() == "c:");
1285 BOOST_TEST(p.root_directory() == "");
1286 BOOST_TEST(p.root_path().string() == "c:");
1287 BOOST_TEST(p.has_root_path());
1288 BOOST_TEST(p.has_root_name());
1289 BOOST_TEST(!p.has_root_directory());
1290 BOOST_TEST(p.has_relative_path());
1291 BOOST_TEST(p.has_filename());
1292 BOOST_TEST(p.has_parent_path());
1293 BOOST_TEST(!p.is_absolute());
1294
1295 p = q = path("c:/foo");
1296 PATH_TEST_EQ(p.relative_path().string(), "foo");
1297 PATH_TEST_EQ(p.parent_path().string(), "c:/");
1298 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1299 PATH_TEST_EQ(p.filename(), "foo");
1300 PATH_TEST_EQ(p.root_name(), "c:");
1301 PATH_TEST_EQ(p.root_directory(), "/");
1302 PATH_TEST_EQ(p.root_path().string(), "c:/");
1303 BOOST_TEST(p.has_root_path());
1304 BOOST_TEST(p.has_root_name());
1305 BOOST_TEST(p.has_root_directory());
1306 BOOST_TEST(p.has_relative_path());
1307 BOOST_TEST(p.has_filename());
1308 BOOST_TEST(p.has_parent_path());
1309 BOOST_TEST(p.is_absolute());
1310
1311 p = q = path("c://foo");
1312 PATH_TEST_EQ(p.relative_path().string(), "foo");
1313 PATH_TEST_EQ(p.parent_path().string(), "c:/");
1314 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1315 PATH_TEST_EQ(p.filename(), "foo");
1316 PATH_TEST_EQ(p.root_name(), "c:");
1317 PATH_TEST_EQ(p.root_directory(), "/");
1318 PATH_TEST_EQ(p.root_path().string(), "c:/");
1319 BOOST_TEST(p.has_root_path());
1320 BOOST_TEST(p.has_root_name());
1321 BOOST_TEST(p.has_root_directory());
1322 BOOST_TEST(p.has_relative_path());
1323 BOOST_TEST(p.has_filename());
1324 BOOST_TEST(p.has_parent_path());
1325 BOOST_TEST(p.is_absolute());
1326
1327 p = q = path("c:\\foo\\bar");
1328 PATH_TEST_EQ(p.relative_path().string(), "foo\\bar");
1329 PATH_TEST_EQ(p.parent_path().string(), "c:\\foo");
1330 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1331 PATH_TEST_EQ(p.filename(), "bar");
1332 PATH_TEST_EQ(p.root_name(), "c:");
1333 PATH_TEST_EQ(p.root_directory(), "\\");
1334 PATH_TEST_EQ(p.root_path().string(), "c:\\");
1335 BOOST_TEST(p.has_root_path());
1336 BOOST_TEST(p.has_root_name());
1337 BOOST_TEST(p.has_root_directory());
1338 BOOST_TEST(p.has_relative_path());
1339 BOOST_TEST(p.has_filename());
1340 BOOST_TEST(p.has_parent_path());
1341 BOOST_TEST(p.is_absolute());
1342
1343 p = q = path("prn:");
1344 BOOST_TEST(p.relative_path().string() == "");
1345 BOOST_TEST(p.parent_path().string() == "");
1346 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1347 BOOST_TEST(p.filename() == "prn:");
1348 BOOST_TEST(p.root_name() == "prn:");
1349 BOOST_TEST(p.root_directory() == "");
1350 BOOST_TEST(p.root_path().string() == "prn:");
1351 BOOST_TEST(p.has_root_path());
1352 BOOST_TEST(p.has_root_name());
1353 BOOST_TEST(!p.has_root_directory());
1354 BOOST_TEST(!p.has_relative_path());
1355 BOOST_TEST(p.has_filename());
1356 BOOST_TEST(!p.has_parent_path());
1357 BOOST_TEST(!p.is_absolute());
1358
1359 p = q = path("\\\\net\\\\\\foo");
1360 PATH_TEST_EQ(p.relative_path().string(), "foo");
1361 PATH_TEST_EQ(p.parent_path().string(), "\\\\net\\");
1362 PATH_TEST_EQ(q.remove_filename().string(), p.parent_path().string());
1363 PATH_TEST_EQ(p.filename(), "foo");
1364 PATH_TEST_EQ(p.root_name(), "\\\\net");
1365 PATH_TEST_EQ(p.root_directory(), "\\");
1366 PATH_TEST_EQ(p.root_path().string(), "\\\\net\\");
1367 BOOST_TEST(p.has_root_path());
1368 BOOST_TEST(p.has_root_name());
1369 BOOST_TEST(p.has_root_directory());
1370 BOOST_TEST(p.has_relative_path());
1371 BOOST_TEST(p.has_filename());
1372 BOOST_TEST(p.has_parent_path());
1373 BOOST_TEST(p.is_absolute());
1374 } // Windows
1375
1376 else
1377 { // POSIX
1378 PATH_TEST_EQ(path("/foo/bar/"), "/foo/bar/");
1379 PATH_TEST_EQ(path("//foo//bar//"), "//foo//bar//");
1380 PATH_TEST_EQ(path("///foo///bar///"), "///foo///bar///");
1381
1382 p = path("/usr/local/bin:/usr/bin:/bin");
1383 BOOST_TEST(p.string() == "/usr/local/bin:/usr/bin:/bin");
1384 } // POSIX
1385 }
1386
1387 // composition_tests ----------------------------------------------------------------//
1388
1389 void composition_tests()
1390 {
1391 std::cout << "composition_tests..." << std::endl;
1392
1393 }
1394
1395 // construction_tests ---------------------------------------------------------------//
1396
1397 void construction_tests()
1398 {
1399 std::cout << "construction_tests..." << std::endl;
1400
1401 PATH_TEST_EQ("", "");
1402
1403 PATH_TEST_EQ("foo", "foo");
1404 PATH_TEST_EQ("f", "f");
1405
1406 PATH_TEST_EQ("foo/", "foo/");
1407 PATH_TEST_EQ("f/", "f/");
1408 PATH_TEST_EQ("foo/..", "foo/..");
1409 PATH_TEST_EQ("foo/../", "foo/../");
1410 PATH_TEST_EQ("foo/bar/../..", "foo/bar/../..");
1411 PATH_TEST_EQ("foo/bar/../../", "foo/bar/../../");
1412 PATH_TEST_EQ("/", "/");
1413 PATH_TEST_EQ("/f", "/f");
1414
1415 PATH_TEST_EQ("/foo", "/foo");
1416 PATH_TEST_EQ("/foo/bar/", "/foo/bar/");
1417 PATH_TEST_EQ("//foo//bar//", "//foo//bar//");
1418 PATH_TEST_EQ("///foo///bar///", "///foo///bar///");
1419 PATH_TEST_EQ("\\/foo\\/bar\\/", "\\/foo\\/bar\\/");
1420 PATH_TEST_EQ("\\//foo\\//bar\\//", "\\//foo\\//bar\\//");
1421
1422 if (platform == "Windows")
1423 {
1424 PATH_TEST_EQ(path("c:") / "foo", "c:foo");
1425 PATH_TEST_EQ(path("c:") / "/foo", "c:/foo");
1426
1427 PATH_TEST_EQ("\\foo\\bar\\", "\\foo\\bar\\");
1428 PATH_TEST_EQ("\\\\foo\\\\bar\\\\", "\\\\foo\\\\bar\\\\");
1429 PATH_TEST_EQ("\\\\\\foo\\\\\\bar\\\\\\", "\\\\\\foo\\\\\\bar\\\\\\");
1430
1431 PATH_TEST_EQ("\\", "\\");
1432 PATH_TEST_EQ("\\f", "\\f");
1433 PATH_TEST_EQ("\\foo", "\\foo");
1434 PATH_TEST_EQ("foo\\bar", "foo\\bar");
1435 PATH_TEST_EQ("foo bar", "foo bar");
1436 PATH_TEST_EQ("c:", "c:");
1437 PATH_TEST_EQ("c:/", "c:/");
1438 PATH_TEST_EQ("c:.", "c:.");
1439 PATH_TEST_EQ("c:./foo", "c:./foo");
1440 PATH_TEST_EQ("c:.\\foo", "c:.\\foo");
1441 PATH_TEST_EQ("c:..", "c:..");
1442 PATH_TEST_EQ("c:/.", "c:/.");
1443 PATH_TEST_EQ("c:/..", "c:/..");
1444 PATH_TEST_EQ("c:/../", "c:/../");
1445 PATH_TEST_EQ("c:\\..\\", "c:\\..\\");
1446 PATH_TEST_EQ("c:/../..", "c:/../..");
1447 PATH_TEST_EQ("c:/../foo", "c:/../foo");
1448 PATH_TEST_EQ("c:\\..\\foo", "c:\\..\\foo");
1449 PATH_TEST_EQ("c:../foo", "c:../foo");
1450 PATH_TEST_EQ("c:..\\foo", "c:..\\foo");
1451 PATH_TEST_EQ("c:/../../foo", "c:/../../foo");
1452 PATH_TEST_EQ("c:\\..\\..\\foo", "c:\\..\\..\\foo");
1453 PATH_TEST_EQ("c:foo/..", "c:foo/..");
1454 PATH_TEST_EQ("c:/foo/..", "c:/foo/..");
1455 PATH_TEST_EQ("c:/..foo", "c:/..foo");
1456 PATH_TEST_EQ("c:foo", "c:foo");
1457 PATH_TEST_EQ("c:/foo", "c:/foo");
1458 PATH_TEST_EQ("\\\\netname", "\\\\netname");
1459 PATH_TEST_EQ("\\\\netname\\", "\\\\netname\\");
1460 PATH_TEST_EQ("\\\\netname\\foo", "\\\\netname\\foo");
1461 PATH_TEST_EQ("c:/foo", "c:/foo");
1462 PATH_TEST_EQ("prn:", "prn:");
1463 }
1464 else
1465 {
1466 }
1467
1468 PATH_TEST_EQ("foo/bar", "foo/bar");
1469 PATH_TEST_EQ("a/b", "a/b"); // probe for length effects
1470 PATH_TEST_EQ("..", "..");
1471 PATH_TEST_EQ("../..", "../..");
1472 PATH_TEST_EQ("/..", "/..");
1473 PATH_TEST_EQ("/../..", "/../..");
1474 PATH_TEST_EQ("../foo", "../foo");
1475 PATH_TEST_EQ("foo/..", "foo/..");
1476 PATH_TEST_EQ("foo/..bar", "foo/..bar");
1477 PATH_TEST_EQ("../f", "../f");
1478 PATH_TEST_EQ("/../f", "/../f");
1479 PATH_TEST_EQ("f/..", "f/..");
1480 PATH_TEST_EQ("foo/../..", "foo/../..");
1481 PATH_TEST_EQ("foo/../../..", "foo/../../..");
1482 PATH_TEST_EQ("foo/../bar", "foo/../bar");
1483 PATH_TEST_EQ("foo/bar/..", "foo/bar/..");
1484 PATH_TEST_EQ("foo/bar/../..", "foo/bar/../..");
1485 PATH_TEST_EQ("foo/bar/../blah", "foo/bar/../blah");
1486 PATH_TEST_EQ("f/../b", "f/../b");
1487 PATH_TEST_EQ("f/b/..", "f/b/..");
1488 PATH_TEST_EQ("f/b/../a", "f/b/../a");
1489 PATH_TEST_EQ("foo/bar/blah/../..", "foo/bar/blah/../..");
1490 PATH_TEST_EQ("foo/bar/blah/../../bletch", "foo/bar/blah/../../bletch");
1491 PATH_TEST_EQ("...", "...");
1492 PATH_TEST_EQ("....", "....");
1493 PATH_TEST_EQ("foo/...", "foo/...");
1494 PATH_TEST_EQ("abc.", "abc.");
1495 PATH_TEST_EQ("abc..", "abc..");
1496 PATH_TEST_EQ("foo/abc.", "foo/abc.");
1497 PATH_TEST_EQ("foo/abc..", "foo/abc..");
1498
1499 PATH_TEST_EQ(".abc", ".abc");
1500 PATH_TEST_EQ("a.c", "a.c");
1501 PATH_TEST_EQ("..abc", "..abc");
1502 PATH_TEST_EQ("a..c", "a..c");
1503 PATH_TEST_EQ("foo/.abc", "foo/.abc");
1504 PATH_TEST_EQ("foo/a.c", "foo/a.c");
1505 PATH_TEST_EQ("foo/..abc", "foo/..abc");
1506 PATH_TEST_EQ("foo/a..c", "foo/a..c");
1507
1508 PATH_TEST_EQ(".", ".");
1509 PATH_TEST_EQ("./foo", "./foo");
1510 PATH_TEST_EQ("./..", "./..");
1511 PATH_TEST_EQ("./../foo", "./../foo");
1512 PATH_TEST_EQ("foo/.", "foo/.");
1513 PATH_TEST_EQ("../.", "../.");
1514 PATH_TEST_EQ("./.", "./.");
1515 PATH_TEST_EQ("././.", "././.");
1516 PATH_TEST_EQ("./foo/.", "./foo/.");
1517 PATH_TEST_EQ("foo/./bar", "foo/./bar");
1518 PATH_TEST_EQ("foo/./.", "foo/./.");
1519 PATH_TEST_EQ("foo/./..", "foo/./..");
1520 PATH_TEST_EQ("foo/./../bar", "foo/./../bar");
1521 PATH_TEST_EQ("foo/../.", "foo/../.");
1522 PATH_TEST_EQ("././..", "././..");
1523 PATH_TEST_EQ("./../.", "./../.");
1524 PATH_TEST_EQ(".././.", ".././.");
1525 }
1526
1527 // append_tests --------------------------------------------------------------------//
1528
1529 void append_test_aux(const path & p, const std::string & s, const std::string & expect)
1530 {
1531 PATH_TEST_EQ((p / path(s)).string(), expect);
1532 PATH_TEST_EQ((p / s.c_str()).string(), expect);
1533 PATH_TEST_EQ((p / s).string(), expect);
1534 path x(p);
1535 x.append(s.begin(), s.end());
1536 PATH_TEST_EQ(x.string(), expect);
1537 }
1538
1539 void append_tests()
1540 {
1541 std::cout << "append_tests..." << std::endl;
1542
1543 // There are many control paths to be exercised, since empty paths and arguments,
1544 // paths with trailing separators, arguments with leading separators, with or without
1545 // other characters being present, are all separate cases that need to be tested.
1546 // Furthermore, some of the code to be tested is specific to argument categories,
1547 // so that results in further permutations to be tested.
1548
1549 //// code to generate test cases
1550 ////
1551 //// expected results must be checked by hand
1552 //// "foo\bar" expected result must be edited by hand and moved for Windows/POSIX
1553 ////
1554 //const char* x[] = { "", "/", "foo", "foo/" };
1555 //const char* y[] = { "", "/", "bar", "/bar" };
1556
1557 //for (int i = 0; i < sizeof(x)/sizeof(char*); ++i)
1558 // for (int j = 0; j < sizeof(y)/sizeof(char*); ++j)
1559 // {
1560 // std::cout << "\n PATH_TEST_EQ(path(\"" << x[i] << "\") / \"" << y[j] << "\", \""
1561 // << path(x[i]) / y[j] << "\");\n";
1562 // std::cout << " append_test_aux(\"" << x[i] << "\", \"" << y[j] << "\", \""
1563 // << path(x[i]) / y[j] << "\");\n";
1564 // }
1565
1566 PATH_TEST_EQ(path("") / "", "");
1567 append_test_aux("", "", "");
1568
1569 PATH_TEST_EQ(path("") / "/", "/");
1570 append_test_aux("", "/", "/");
1571
1572 PATH_TEST_EQ(path("") / "bar", "bar");
1573 append_test_aux("", "bar", "bar");
1574
1575 PATH_TEST_EQ(path("") / "/bar", "/bar");
1576 append_test_aux("", "/bar", "/bar");
1577
1578 PATH_TEST_EQ(path("/") / "", "/");
1579 append_test_aux("/", "", "/");
1580
1581 PATH_TEST_EQ(path("/") / "/", "//");
1582 append_test_aux("/", "/", "//");
1583
1584 PATH_TEST_EQ(path("/") / "bar", "/bar");
1585 append_test_aux("/", "bar", "/bar");
1586
1587 PATH_TEST_EQ(path("/") / "/bar", "//bar");
1588 append_test_aux("/", "/bar", "//bar");
1589
1590 PATH_TEST_EQ(path("foo") / "", "foo");
1591 append_test_aux("foo", "", "foo");
1592
1593 PATH_TEST_EQ(path("foo") / "/", "foo/");
1594 append_test_aux("foo", "/", "foo/");
1595
1596 PATH_TEST_EQ(path("foo") / "/bar", "foo/bar");
1597 append_test_aux("foo", "/bar", "foo/bar");
1598
1599 PATH_TEST_EQ(path("foo/") / "", "foo/");
1600 append_test_aux("foo/", "", "foo/");
1601
1602 PATH_TEST_EQ(path("foo/") / "/", "foo//");
1603 append_test_aux("foo/", "/", "foo//");
1604
1605 PATH_TEST_EQ(path("foo/") / "bar", "foo/bar");
1606 append_test_aux("foo/", "bar", "foo/bar");
1607
1608
1609 if (platform == "Windows")
1610 {
1611 PATH_TEST_EQ(path("foo") / "bar", "foo\\bar");
1612 append_test_aux("foo", "bar", "foo\\bar");
1613
1614 PATH_TEST_EQ(path("foo\\") / "\\bar", "foo\\\\bar");
1615 append_test_aux("foo\\", "\\bar", "foo\\\\bar");
1616
1617 // hand created test case specific to Windows
1618 PATH_TEST_EQ(path("c:") / "bar", "c:bar");
1619 append_test_aux("c:", "bar", "c:bar");
1620 }
1621 else
1622 {
1623 PATH_TEST_EQ(path("foo") / "bar", "foo/bar");
1624 append_test_aux("foo", "bar", "foo/bar");
1625 }
1626
1627 // ticket #6819
1628 union
1629 {
1630 char a[1];
1631 char b[3];
1632 } u;
1633
1634 u.b[0] = 'a';
1635 u.b[1] = 'b';
1636 u.b[2] = '\0';
1637
1638 path p6819;
1639 p6819 /= u.a;
1640 BOOST_TEST_EQ(p6819, path("ab"));
1641 }
1642
1643 // self_assign_and_append_tests ------------------------------------------------------//
1644
1645 void self_assign_and_append_tests()
1646 {
1647 std::cout << "self_assign_and_append_tests..." << std::endl;
1648
1649 path p;
1650
1651 p = "snafubar";
1652 PATH_TEST_EQ(p = p, "snafubar");
1653
1654 p = "snafubar";
1655 p = p.c_str();
1656 PATH_TEST_EQ(p, "snafubar");
1657
1658 p = "snafubar";
1659 p.assign(p.c_str(), path::codecvt());
1660 PATH_TEST_EQ(p, "snafubar");
1661
1662 p = "snafubar";
1663 PATH_TEST_EQ(p = p.c_str()+5, "bar");
1664
1665 p = "snafubar";
1666 PATH_TEST_EQ(p.assign(p.c_str() + 5, p.c_str() + 7), "ba");
1667
1668 p = "snafubar";
1669 p /= p;
1670 PATH_TEST_EQ(p, "snafubar" BOOST_DIR_SEP "snafubar");
1671
1672 p = "snafubar";
1673 p /= p.c_str();
1674 PATH_TEST_EQ(p, "snafubar" BOOST_DIR_SEP "snafubar");
1675
1676 p = "snafubar";
1677 p.append(p.c_str(), path::codecvt());
1678 PATH_TEST_EQ(p, "snafubar" BOOST_DIR_SEP "snafubar");
1679
1680 p = "snafubar";
1681 PATH_TEST_EQ(p.append(p.c_str() + 5, p.c_str() + 7), "snafubar" BOOST_DIR_SEP "ba");
1682 }
1683
1684
1685 // name_function_tests -------------------------------------------------------------//
1686
1687 void name_function_tests()
1688 {
1689 std::cout << "name_function_tests..." << std::endl;
1690
1691 BOOST_TEST(fs::portable_posix_name(std::string("x")));
1692 BOOST_TEST(fs::windows_name(std::string("x")));
1693 BOOST_TEST(fs::portable_name(std::string("x")));
1694 BOOST_TEST(fs::portable_directory_name(std::string("x")));
1695 BOOST_TEST(fs::portable_file_name(std::string("x")));
1696
1697 BOOST_TEST(fs::portable_posix_name(std::string(".")));
1698 BOOST_TEST(fs::windows_name(std::string(".")));
1699 BOOST_TEST(fs::portable_name(std::string(".")));
1700 BOOST_TEST(fs::portable_directory_name(std::string(".")));
1701 BOOST_TEST(!fs::portable_file_name(std::string(".")));
1702
1703 BOOST_TEST(fs::portable_posix_name(std::string("..")));
1704 BOOST_TEST(fs::windows_name(std::string("..")));
1705 BOOST_TEST(fs::portable_name(std::string("..")));
1706 BOOST_TEST(fs::portable_directory_name(std::string("..")));
1707 BOOST_TEST(!fs::portable_file_name(std::string("..")));
1708
1709 BOOST_TEST(!fs::native(std::string("")));
1710 BOOST_TEST(!fs::portable_posix_name(std::string("")));
1711 BOOST_TEST(!fs::windows_name(std::string("")));
1712 BOOST_TEST(!fs::portable_name(std::string("")));
1713 BOOST_TEST(!fs::portable_directory_name(std::string("")));
1714 BOOST_TEST(!fs::portable_file_name(std::string("")));
1715
1716 BOOST_TEST(!fs::native(std::string(" ")));
1717 BOOST_TEST(!fs::portable_posix_name(std::string(" ")));
1718 BOOST_TEST(!fs::windows_name(std::string(" ")));
1719 BOOST_TEST(!fs::portable_name(std::string(" ")));
1720 BOOST_TEST(!fs::portable_directory_name(std::string(" ")));
1721 BOOST_TEST(!fs::portable_file_name(std::string(" ")));
1722
1723 BOOST_TEST(!fs::portable_posix_name(std::string(":")));
1724 BOOST_TEST(!fs::windows_name(std::string(":")));
1725 BOOST_TEST(!fs::portable_name(std::string(":")));
1726 BOOST_TEST(!fs::portable_directory_name(std::string(":")));
1727 BOOST_TEST(!fs::portable_file_name(std::string(":")));
1728
1729 BOOST_TEST(fs::portable_posix_name(std::string("-")));
1730 BOOST_TEST(fs::windows_name(std::string("-")));
1731 BOOST_TEST(!fs::portable_name(std::string("-")));
1732 BOOST_TEST(!fs::portable_directory_name(std::string("-")));
1733 BOOST_TEST(!fs::portable_file_name(std::string("-")));
1734
1735 BOOST_TEST(!fs::portable_posix_name(std::string("foo bar")));
1736 BOOST_TEST(fs::windows_name(std::string("foo bar")));
1737 BOOST_TEST(!fs::windows_name(std::string(" bar")));
1738 BOOST_TEST(!fs::windows_name(std::string("foo ")));
1739 BOOST_TEST(!fs::portable_name(std::string("foo bar")));
1740 BOOST_TEST(!fs::portable_directory_name(std::string("foo bar")));
1741 BOOST_TEST(!fs::portable_file_name(std::string("foo bar")));
1742
1743 BOOST_TEST(fs::portable_posix_name(std::string("foo.bar")));
1744 BOOST_TEST(fs::windows_name(std::string("foo.bar")));
1745 BOOST_TEST(fs::portable_name(std::string("foo.bar")));
1746 BOOST_TEST(!fs::portable_directory_name(std::string("foo.bar")));
1747 BOOST_TEST(fs::portable_file_name(std::string("foo.bar")));
1748
1749 BOOST_TEST(fs::portable_posix_name(std::string("foo.barf")));
1750 BOOST_TEST(fs::windows_name(std::string("foo.barf")));
1751 BOOST_TEST(fs::portable_name(std::string("foo.barf")));
1752 BOOST_TEST(!fs::portable_directory_name(std::string("foo.barf")));
1753 BOOST_TEST(!fs::portable_file_name(std::string("foo.barf")));
1754
1755 BOOST_TEST(fs::portable_posix_name(std::string(".foo")));
1756 BOOST_TEST(fs::windows_name(std::string(".foo")));
1757 BOOST_TEST(!fs::portable_name(std::string(".foo")));
1758 BOOST_TEST(!fs::portable_directory_name(std::string(".foo")));
1759 BOOST_TEST(!fs::portable_file_name(std::string(".foo")));
1760
1761 BOOST_TEST(fs::portable_posix_name(std::string("foo.")));
1762 BOOST_TEST(!fs::windows_name(std::string("foo.")));
1763 BOOST_TEST(!fs::portable_name(std::string("foo.")));
1764 BOOST_TEST(!fs::portable_directory_name(std::string("foo.")));
1765 BOOST_TEST(!fs::portable_file_name(std::string("foo.")));
1766 }
1767
1768 // replace_extension_tests ---------------------------------------------------------//
1769
1770 void replace_extension_tests()
1771 {
1772 std::cout << "replace_extension_tests..." << std::endl;
1773
1774 BOOST_TEST(path().replace_extension().empty());
1775 BOOST_TEST(path().replace_extension("a") == ".a");
1776 BOOST_TEST(path().replace_extension("a.") == ".a.");
1777 BOOST_TEST(path().replace_extension(".a") == ".a");
1778 BOOST_TEST(path().replace_extension("a.txt") == ".a.txt");
1779 // see the rationale in html docs for explanation why this works:
1780 BOOST_TEST(path().replace_extension(".txt") == ".txt");
1781
1782 BOOST_TEST(path("a.txt").replace_extension() == "a");
1783 BOOST_TEST(path("a.txt").replace_extension("") == "a");
1784 BOOST_TEST(path("a.txt").replace_extension(".") == "a.");
1785 BOOST_TEST(path("a.txt").replace_extension(".tex") == "a.tex");
1786 BOOST_TEST(path("a.txt").replace_extension("tex") == "a.tex");
1787 BOOST_TEST(path("a.").replace_extension(".tex") == "a.tex");
1788 BOOST_TEST(path("a.").replace_extension("tex") == "a.tex");
1789 BOOST_TEST(path("a").replace_extension(".txt") == "a.txt");
1790 BOOST_TEST(path("a").replace_extension("txt") == "a.txt");
1791 BOOST_TEST(path("a.b.txt").replace_extension(".tex") == "a.b.tex");
1792 BOOST_TEST(path("a.b.txt").replace_extension("tex") == "a.b.tex");
1793 BOOST_TEST(path("a/b").replace_extension(".c") == "a/b.c");
1794 PATH_TEST_EQ(path("a.txt/b").replace_extension(".c"), "a.txt/b.c"); // ticket 4702
1795 BOOST_TEST(path("foo.txt").replace_extension("exe") == "foo.exe"); // ticket 5118
1796 BOOST_TEST(path("foo.txt").replace_extension(".tar.bz2")
1797 == "foo.tar.bz2"); // ticket 5118
1798 }
1799
1800 // make_preferred_tests ------------------------------------------------------------//
1801
1802 void make_preferred_tests()
1803 {
1804 std::cout << "make_preferred_tests..." << std::endl;
1805
1806 if (platform == "Windows")
1807 {
1808 BOOST_TEST(path("//abc\\def/ghi").make_preferred().native()
1809 == path("\\\\abc\\def\\ghi").native());
1810 }
1811 else
1812 {
1813 BOOST_TEST(path("//abc\\def/ghi").make_preferred().native()
1814 == path("//abc\\def/ghi").native());
1815 }
1816 }
1817
1818 // lexically_normal_tests ----------------------------------------------------------//
1819
1820 void lexically_normal_tests()
1821 {
1822 std::cout << "lexically_normal_tests..." << std::endl;
1823
1824 // Note: lexically_lexically_normal() uses /= to build up some results, so these results will
1825 // have the platform's preferred separator. Since that is immaterial to the correct
1826 // functioning of lexically_lexically_normal(), the test results are converted to generic form,
1827 // and the expected results are also given in generic form. Otherwise many of the
1828 // tests would incorrectly be reported as failing on Windows.
1829
1830 PATH_TEST_EQ(path("").lexically_normal().generic_path(), "");
1831 PATH_TEST_EQ(path("/").lexically_normal().generic_path(), "/");
1832 PATH_TEST_EQ(path("//").lexically_normal().generic_path(), "//");
1833 PATH_TEST_EQ(path("///").lexically_normal().generic_path(), "/");
1834 PATH_TEST_EQ(path("f").lexically_normal().generic_path(), "f");
1835 PATH_TEST_EQ(path("foo").lexically_normal().generic_path(), "foo");
1836 PATH_TEST_EQ(path("foo/").lexically_normal().generic_path(), "foo/.");
1837 PATH_TEST_EQ(path("f/").lexically_normal().generic_path(), "f/.");
1838 PATH_TEST_EQ(path("/foo").lexically_normal().generic_path(), "/foo");
1839 PATH_TEST_EQ(path("foo/bar").lexically_normal().generic_path(), "foo/bar");
1840 PATH_TEST_EQ(path("..").lexically_normal().generic_path(), "..");
1841 PATH_TEST_EQ(path("../..").lexically_normal().generic_path(), "../..");
1842 PATH_TEST_EQ(path("/..").lexically_normal().generic_path(), "/..");
1843 PATH_TEST_EQ(path("/../..").lexically_normal().generic_path(), "/../..");
1844 PATH_TEST_EQ(path("../foo").lexically_normal().generic_path(), "../foo");
1845 PATH_TEST_EQ(path("foo/..").lexically_normal().generic_path(), ".");
1846 PATH_TEST_EQ(path("foo/../").lexically_normal().generic_path(), "./.");
1847 PATH_TEST_EQ((path("foo") / "..").lexically_normal().generic_path() , ".");
1848 PATH_TEST_EQ(path("foo/...").lexically_normal().generic_path(), "foo/...");
1849 PATH_TEST_EQ(path("foo/.../").lexically_normal().generic_path(), "foo/.../.");
1850 PATH_TEST_EQ(path("foo/..bar").lexically_normal().generic_path(), "foo/..bar");
1851 PATH_TEST_EQ(path("../f").lexically_normal().generic_path(), "../f");
1852 PATH_TEST_EQ(path("/../f").lexically_normal().generic_path(), "/../f");
1853 PATH_TEST_EQ(path("f/..").lexically_normal().generic_path(), ".");
1854 PATH_TEST_EQ((path("f") / "..").lexically_normal().generic_path() , ".");
1855 PATH_TEST_EQ(path("foo/../..").lexically_normal().generic_path(), "..");
1856 PATH_TEST_EQ(path("foo/../../").lexically_normal().generic_path(), "../.");
1857 PATH_TEST_EQ(path("foo/../../..").lexically_normal().generic_path(), "../..");
1858 PATH_TEST_EQ(path("foo/../../../").lexically_normal().generic_path(), "../../.");
1859 PATH_TEST_EQ(path("foo/../bar").lexically_normal().generic_path(), "bar");
1860 PATH_TEST_EQ(path("foo/../bar/").lexically_normal().generic_path(), "bar/.");
1861 PATH_TEST_EQ(path("foo/bar/..").lexically_normal().generic_path(), "foo");
1862 PATH_TEST_EQ(path("foo/./bar/..").lexically_normal().generic_path(), "foo");
1863 std::cout << path("foo/./bar/..").lexically_normal() << std::endl; // outputs "foo"
1864 PATH_TEST_EQ(path("foo/bar/../").lexically_normal().generic_path(), "foo/.");
1865 PATH_TEST_EQ(path("foo/./bar/../").lexically_normal().generic_path(), "foo/.");
1866 std::cout << path("foo/./bar/../").lexically_normal() << std::endl; // POSIX: "foo/.", Windows: "foo\."
1867 PATH_TEST_EQ(path("foo/bar/../..").lexically_normal().generic_path(), ".");
1868 PATH_TEST_EQ(path("foo/bar/../../").lexically_normal().generic_path(), "./.");
1869 PATH_TEST_EQ(path("foo/bar/../blah").lexically_normal().generic_path(), "foo/blah");
1870 PATH_TEST_EQ(path("f/../b").lexically_normal().generic_path(), "b");
1871 PATH_TEST_EQ(path("f/b/..").lexically_normal().generic_path(), "f");
1872 PATH_TEST_EQ(path("f/b/../").lexically_normal().generic_path(), "f/.");
1873 PATH_TEST_EQ(path("f/b/../a").lexically_normal().generic_path(), "f/a");
1874 PATH_TEST_EQ(path("foo/bar/blah/../..").lexically_normal().generic_path(), "foo");
1875 PATH_TEST_EQ(path("foo/bar/blah/../../bletch").lexically_normal().generic_path(), "foo/bletch");
1876 PATH_TEST_EQ(path("//net").lexically_normal().generic_path(), "//net");
1877 PATH_TEST_EQ(path("//net/").lexically_normal().generic_path(), "//net/");
1878 PATH_TEST_EQ(path("//..net").lexically_normal().generic_path(), "//..net");
1879 PATH_TEST_EQ(path("//net/..").lexically_normal().generic_path(), "//net/..");
1880 PATH_TEST_EQ(path("//net/foo").lexically_normal().generic_path(), "//net/foo");
1881 PATH_TEST_EQ(path("//net/foo/").lexically_normal().generic_path(), "//net/foo/.");
1882 PATH_TEST_EQ(path("//net/foo/..").lexically_normal().generic_path(), "//net/");
1883 PATH_TEST_EQ(path("//net/foo/../").lexically_normal().generic_path(), "//net/.");
1884
1885 PATH_TEST_EQ(path("/net/foo/bar").lexically_normal().generic_path(), "/net/foo/bar");
1886 PATH_TEST_EQ(path("/net/foo/bar/").lexically_normal().generic_path(), "/net/foo/bar/.");
1887 PATH_TEST_EQ(path("/net/foo/..").lexically_normal().generic_path(), "/net");
1888 PATH_TEST_EQ(path("/net/foo/../").lexically_normal().generic_path(), "/net/.");
1889
1890 PATH_TEST_EQ(path("//net//foo//bar").lexically_normal().generic_path(), "//net/foo/bar");
1891 PATH_TEST_EQ(path("//net//foo//bar//").lexically_normal().generic_path(), "//net/foo/bar/.");
1892 PATH_TEST_EQ(path("//net//foo//..").lexically_normal().generic_path(), "//net/");
1893 PATH_TEST_EQ(path("//net//foo//..//").lexically_normal().generic_path(), "//net/.");
1894
1895 PATH_TEST_EQ(path("///net///foo///bar").lexically_normal().generic_path(), "/net/foo/bar");
1896 PATH_TEST_EQ(path("///net///foo///bar///").lexically_normal().generic_path(), "/net/foo/bar/.");
1897 PATH_TEST_EQ(path("///net///foo///..").lexically_normal().generic_path(), "/net");
1898 PATH_TEST_EQ(path("///net///foo///..///").lexically_normal().generic_path(), "/net/.");
1899
1900 if (platform == "Windows")
1901 {
1902 PATH_TEST_EQ(path("c:..").lexically_normal().generic_path(), "c:..");
1903 PATH_TEST_EQ(path("c:foo/..").lexically_normal().generic_path(), "c:");
1904
1905 PATH_TEST_EQ(path("c:foo/../").lexically_normal().generic_path(), "c:.");
1906
1907 PATH_TEST_EQ(path("c:/foo/..").lexically_normal().generic_path(), "c:/");
1908 PATH_TEST_EQ(path("c:/foo/../").lexically_normal().generic_path(), "c:/.");
1909 PATH_TEST_EQ(path("c:/..").lexically_normal().generic_path(), "c:/..");
1910 PATH_TEST_EQ(path("c:/../").lexically_normal().generic_path(), "c:/../.");
1911 PATH_TEST_EQ(path("c:/../..").lexically_normal().generic_path(), "c:/../..");
1912 PATH_TEST_EQ(path("c:/../../").lexically_normal().generic_path(), "c:/../../.");
1913 PATH_TEST_EQ(path("c:/../foo").lexically_normal().generic_path(), "c:/../foo");
1914 PATH_TEST_EQ(path("c:/../foo/").lexically_normal().generic_path(), "c:/../foo/.");
1915 PATH_TEST_EQ(path("c:/../../foo").lexically_normal().generic_path(), "c:/../../foo");
1916 PATH_TEST_EQ(path("c:/../../foo/").lexically_normal().generic_path(), "c:/../../foo/.");
1917 PATH_TEST_EQ(path("c:/..foo").lexically_normal().generic_path(), "c:/..foo");
1918 }
1919 else // POSIX
1920 {
1921 PATH_TEST_EQ(path("c:..").lexically_normal(), "c:..");
1922 PATH_TEST_EQ(path("c:foo/..").lexically_normal(), ".");
1923 PATH_TEST_EQ(path("c:foo/../").lexically_normal(), "./.");
1924 PATH_TEST_EQ(path("c:/foo/..").lexically_normal(), "c:");
1925 PATH_TEST_EQ(path("c:/foo/../").lexically_normal(), "c:/.");
1926 PATH_TEST_EQ(path("c:/..").lexically_normal(), ".");
1927 PATH_TEST_EQ(path("c:/../").lexically_normal(), "./.");
1928 PATH_TEST_EQ(path("c:/../..").lexically_normal(), "..");
1929 PATH_TEST_EQ(path("c:/../../").lexically_normal(), "../.");
1930 PATH_TEST_EQ(path("c:/../foo").lexically_normal(), "foo");
1931 PATH_TEST_EQ(path("c:/../foo/").lexically_normal(), "foo/.");
1932 PATH_TEST_EQ(path("c:/../../foo").lexically_normal(), "../foo");
1933 PATH_TEST_EQ(path("c:/../../foo/").lexically_normal(), "../foo/.");
1934 PATH_TEST_EQ(path("c:/..foo").lexically_normal(), "c:/..foo");
1935 }
1936 }
1937
1938 inline void odr_use(const path::value_type& c)
1939 {
1940 static const path::value_type dummy = '\0';
1941 BOOST_TEST(&c != &dummy);
1942 }
1943
1944 } // unnamed namespace
1945
1946 static boost::filesystem::path ticket_6737 = "FilePath"; // #6737 reported this crashed
1947 // on VC++ debug mode build
1948 const boost::filesystem::path ticket_6690("test"); // #6690 another V++ static init crash
1949
1950 //--------------------------------------------------------------------------------------//
1951 // //
1952 // main //
1953 // //
1954 //--------------------------------------------------------------------------------------//
1955
1956 int cpp_main(int, char*[])
1957 {
1958 // The choice of platform is make at runtime rather than compile-time
1959 // so that compile errors for all platforms will be detected even though
1960 // only the current platform is runtime tested.
1961 platform = (platform == "Win32" || platform == "Win64" || platform == "Cygwin")
1962 ? "Windows"
1963 : "POSIX";
1964 std::cout << "Platform is " << platform << '\n';
1965
1966 BOOST_TEST(p1.string() != p3.string());
1967 p3 = p2;
1968 BOOST_TEST(p1.string() == p3.string());
1969
1970 path p04("foobar");
1971 BOOST_TEST(p04.string() == "foobar");
1972 p04 = p04; // self-assignment
1973 BOOST_TEST(p04.string() == "foobar");
1974
1975 construction_tests();
1976 append_tests();
1977 self_assign_and_append_tests();
1978 overload_tests();
1979 query_and_decomposition_tests();
1980 composition_tests();
1981 iterator_tests();
1982 non_member_tests();
1983 exception_tests();
1984 name_function_tests();
1985 replace_extension_tests();
1986 make_preferred_tests();
1987 lexically_normal_tests();
1988
1989 // verify deprecated names still available
1990
1991 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED
1992
1993 p1.branch_path();
1994 p1.leaf();
1995 path p_remove_leaf;
1996 p_remove_leaf.remove_leaf();
1997
1998 # endif
1999
2000 std::string s1("//:somestring"); // this used to be treated specially
2001
2002 // check the path member templates
2003 p5.assign(s1.begin(), s1.end());
2004
2005 PATH_TEST_EQ(p5.string(), "//:somestring");
2006 p5 = s1;
2007 PATH_TEST_EQ(p5.string(), "//:somestring");
2008
2009 // this code, courtesy of David Whetstone, detects a now fixed bug that
2010 // derefereced the end iterator (assuming debug build with checked itors)
2011 std::vector<char> v1;
2012 p5.assign(v1.begin(), v1.end());
2013 std::string s2(v1.begin(), v1.end());
2014 PATH_TEST_EQ(p5.string(), s2);
2015 p5.assign(s1.begin(), s1.begin() + 1);
2016 PATH_TEST_EQ(p5.string(), "/");
2017
2018 BOOST_TEST(p1 != p4);
2019 BOOST_TEST(p1.string() == p2.string());
2020 BOOST_TEST(p1.string() == p3.string());
2021 BOOST_TEST(path("foo").filename() == "foo");
2022 BOOST_TEST(path("foo").parent_path().string() == "");
2023 BOOST_TEST(p1.filename() == "fum");
2024 BOOST_TEST(p1.parent_path().string() == "fe/fi/fo");
2025 BOOST_TEST(path("").empty() == true);
2026 BOOST_TEST(path("foo").empty() == false);
2027
2028 // inserter and extractor tests
2029 # if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // bypass VC++ 7.0 and earlier
2030 std::cout << "\nInserter and extractor test...";
2031 std::stringstream ss;
2032 ss << fs::path("foo/bar") << std::endl;
2033 fs::path round_trip;
2034 ss >> round_trip;
2035 BOOST_TEST(round_trip.string() == "foo/bar");
2036 std::cout << round_trip.string() << "..." << round_trip << " complete\n";
2037 # endif
2038
2039 // Check that path constants have definitions
2040 // https://svn.boost.org/trac10/ticket/12759
2041 odr_use(path::separator);
2042 odr_use(path::preferred_separator);
2043 odr_use(path::dot);
2044
2045 return ::boost::report_errors();
2046 }
Ceph