Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_33_1/libs/filesystem/test/path_test.cpp @ 12

Last change on this file since 12 was 12, checked in by landauf, 17 years ago

added boost
File size: 32.6 KB
Line 
1//  path_test program  -------------------------------------------------------//
2
3//  Copyright Beman Dawes 2002.
4//  Use, modification, and distribution is subject to the Boost Software
5//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
6//  http://www.boost.org/LICENSE_1_0.txt)
7
8//  See library home page at http://www.boost.org/libs/filesystem
9
10#include <boost/filesystem/operations.hpp>
11#include <boost/filesystem/exception.hpp>
12#include <boost/utility.hpp>
13#include <iostream>
14#include <string>
15#include <cstring>
16#include <cassert>
17
18namespace fs = boost::filesystem;
19using boost::filesystem::path;
20using boost::next;
21using boost::prior;
22
23#include <boost/test/minimal.hpp>
24
25#define PATH_CHECK( a, b ) check( a, b, __LINE__ )
26
27namespace {
28  int errors;
29
30  void check( const fs::path & source,
31              const std::string & expected, int line )
32  {
33    if ( source.string()== expected ) return;
34
35    ++errors;
36
37    std::cout << '(' << line << ") source.string(): \"" << source.string()
38              << "\" != expected: \"" << expected
39              << "\"" << std::endl;
40  }
41
42  void check_throw( const std::string & arg )
43  {
44    try
45    {
46      fs::path arg_path( arg );
47      ++errors;
48      std::cout << "failed to throw with argument \"" << arg
49                << "\"" << std::endl;
50    }
51    catch ( const fs::filesystem_error & /*ex*/ )
52    {
53//      std::cout << ex.what() << "\n";
54    }
55  }
56
57} // unnamed namespace
58
59int test_main( int, char*[] )
60{
61  std::string platform( BOOST_PLATFORM );
62
63  // The choice of platform is make at runtime rather than compile-time
64  // so that compile errors for all platforms will be detected even though
65  // only the current platform is runtime tested.
66# if defined( BOOST_POSIX )
67    platform = "POSIX";
68# elif defined( BOOST_WINDOWS )
69    platform = "Windows";
70# else
71    platform = ( platform == "Win32" || platform == "Win64" || platform == "Cygwin" )
72               ? "Windows"
73               : "POSIX";
74# endif
75  std::cout << "Platform is " << platform << '\n';
76
77  BOOST_CHECK( path::default_name_check_writable() );
78  BOOST_CHECK( path::default_name_check() == fs::portable_name );
79  BOOST_CHECK( !path::default_name_check_writable() );
80  bool default_name_check_threw = false;
81  try { path::default_name_check( fs::no_check ); }
82  catch ( const fs::filesystem_error & ) { default_name_check_threw = true; }
83  BOOST_CHECK( default_name_check_threw );
84  BOOST_CHECK( path::default_name_check() == fs::portable_name );
85
86
87  path p1( "fe/fi/fo/fum" );
88  path p2( p1 );
89  path p3;
90  BOOST_CHECK( p1.string() != p3.string() );
91  p3 = p2;
92
93//  p1.branch_path() = p2; // should fail
94//  *p1.begin() = ""; // should fail
95
96  // These verify various overloads don't cause compiler errors
97  fs::exists( "foo" );
98  fs::exists( std::string( "foo" ) );
99  fs::exists( p1 );
100  fs::exists( "foo" / p1 );
101  fs::exists( std::string( "foo" ) / p1 );
102
103  BOOST_CHECK( p1.string() == p2.string() );
104  BOOST_CHECK( p1.string() == p3.string() );
105  BOOST_CHECK( path( "foo" ).leaf() == "foo" );
106  BOOST_CHECK( path( "foo" ).branch_path().string() == "" );
107  BOOST_CHECK( p1.leaf() == "fum" );
108  BOOST_CHECK( p1.branch_path().string() == "fe/fi/fo" );
109  BOOST_CHECK( path( "" ).empty() == true );
110  BOOST_CHECK( path( "foo" ).empty() == false );
111
112  PATH_CHECK( "", "" );
113
114  PATH_CHECK( "foo", "foo" );
115  PATH_CHECK( "f", "f" );
116  PATH_CHECK( "foo/", "foo" );
117  PATH_CHECK( path("foo/").normalize(), "foo" );
118  PATH_CHECK( "f/", "f" );
119  PATH_CHECK( path("f/").normalize(), "f" );
120  PATH_CHECK( path("") / "foo", "foo" );
121  PATH_CHECK( path("foo") / "", "foo" );
122  PATH_CHECK( path( "/" ), "/" );
123  PATH_CHECK( path( "/" ) / "", "/" );
124  PATH_CHECK( path( "/f" ), "/f" );
125  PATH_CHECK( path( "/foo" ).normalize(), "/foo" );
126
127  PATH_CHECK( "/foo", "/foo" );
128  PATH_CHECK( path("") / "/foo", "/foo" );
129  PATH_CHECK( path("/foo") / "", "/foo" );
130
131  PATH_CHECK( "foo/", "foo" );
132  PATH_CHECK( path("") / "foo/", "foo" );
133  PATH_CHECK( path("foo") / "/", "foo" );
134
135  PATH_CHECK( "foo/bar", "foo/bar" );
136  PATH_CHECK( path( "foo/bar" ).normalize(), "foo/bar" );
137  PATH_CHECK( path("foo") / path("bar"), "foo/bar" ); // path arg
138  PATH_CHECK( path("foo") / "bar", "foo/bar" );       // const char * arg
139  PATH_CHECK( path("foo") / path("woo/bar").leaf(), "foo/bar" ); // const std::string & arg
140  PATH_CHECK( "foo" / path("bar"), "foo/bar" );
141
142  PATH_CHECK( "a/b", "a/b" );  // probe for length effects
143  PATH_CHECK( path("a") / "b", "a/b" );
144
145  PATH_CHECK( "..", ".." );
146  PATH_CHECK( path("..").normalize(), ".." );
147  PATH_CHECK( path("..") / "", ".." );
148  PATH_CHECK( path("") / "..", ".." );
149
150  PATH_CHECK( "../..", "../.." );
151  PATH_CHECK( path("../..").normalize(), "../.." );
152  PATH_CHECK( path("..") / ".." , "../.." );
153
154  PATH_CHECK( "/..", "/" );
155  PATH_CHECK( path("/..").normalize(), "/" );
156  PATH_CHECK( path("/") / ".." , "/" );
157
158  PATH_CHECK( "/../..", "/" );
159  PATH_CHECK( path("/../..").normalize(), "/" );
160  PATH_CHECK( path("/..") / ".." , "/" );
161
162  PATH_CHECK( "../foo", "../foo" );
163  PATH_CHECK( path("../foo").normalize(), "../foo" );
164  PATH_CHECK( path("..") / "foo" , "../foo" );
165
166  PATH_CHECK( "foo/..", "foo/.." );
167  PATH_CHECK( path("foo") / ".." , "foo/.." );
168  PATH_CHECK( path("foo/..").normalize(), "." );
169  PATH_CHECK( (path("foo") / "..").normalize() , "." );
170  PATH_CHECK( path( "foo/..bar", fs::no_check ), "foo/..bar" );
171  PATH_CHECK( path("foo/..bar", fs::no_check ).normalize(), "foo/..bar" );
172
173  PATH_CHECK( "../f", "../f" );
174  PATH_CHECK( path("../f").normalize(), "../f" );
175  PATH_CHECK( path("..") / "f" , "../f" );
176
177  PATH_CHECK( "/../f", "/f" );
178  PATH_CHECK( path("/../f").normalize(), "/f" );
179  PATH_CHECK( path("/..") / "f" , "/f" );
180
181  PATH_CHECK( "f/..", "f/.." );
182  PATH_CHECK( path("f") / ".." , "f/.." );
183  PATH_CHECK( path("f/..").normalize(), "." );
184  PATH_CHECK( (path("f") / "..").normalize() , "." );
185
186  PATH_CHECK( "foo/../..", "foo/../.." );
187  PATH_CHECK( path("foo/../..").normalize(), ".." );
188  PATH_CHECK( path("foo") / ".." / ".." , "foo/../.." );
189
190  PATH_CHECK( "foo/../../..", "foo/../../.." );
191  PATH_CHECK( path("foo/../../..").normalize(), "../.." );
192  PATH_CHECK( path("foo") / ".." / ".." / ".." , "foo/../../.." );
193
194  PATH_CHECK( "foo/../bar", "foo/../bar" );
195  PATH_CHECK( path("foo/../bar").normalize(), "bar" );
196  PATH_CHECK( path("foo") / ".." / "bar" , "foo/../bar" );
197
198  PATH_CHECK( "foo/bar/..", "foo/bar/.." );
199  PATH_CHECK( path("foo/bar/..").normalize(), "foo" );
200  PATH_CHECK( path("foo") / "bar" / ".." , "foo/bar/.." );
201
202  PATH_CHECK( "foo/bar/../..", "foo/bar/../.." );
203  PATH_CHECK( path("foo/bar/../..").normalize(), "." );
204  PATH_CHECK( path("foo") / "bar" / ".." / "..", "foo/bar/../.." );
205
206  PATH_CHECK( "foo/bar/../blah", "foo/bar/../blah" );
207  PATH_CHECK( path("foo/bar/../blah").normalize(), "foo/blah" );
208  PATH_CHECK( path("foo") / "bar" / ".." / "blah", "foo/bar/../blah" );
209
210  PATH_CHECK( "f/../b", "f/../b" );
211  PATH_CHECK( path("f/../b").normalize(), "b" );
212  PATH_CHECK( path("f") / ".." / "b" , "f/../b" );
213
214  PATH_CHECK( "f/b/..", "f/b/.." );
215  PATH_CHECK( path("f/b/..").normalize(), "f" );
216  PATH_CHECK( path("f") / "b" / ".." , "f/b/.." );
217
218  PATH_CHECK( "f/b/../a", "f/b/../a" );
219  PATH_CHECK( path("f/b/../a").normalize(), "f/a" );
220  PATH_CHECK( path("f") / "b" / ".." / "a", "f/b/../a" );
221
222  PATH_CHECK( "foo/bar/blah/../..", "foo/bar/blah/../.." );
223  PATH_CHECK( path("foo/bar/blah/../..").normalize(), "foo" );
224  PATH_CHECK( path("foo") / "bar" / "blah" / ".." / "..", "foo/bar/blah/../.." );
225
226  PATH_CHECK( "foo/bar/blah/../../bletch", "foo/bar/blah/../../bletch" );
227  PATH_CHECK( path("foo/bar/blah/../../bletch").normalize(), "foo/bletch" );
228  PATH_CHECK( path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo/bar/blah/../../bletch" );
229
230  PATH_CHECK( path("...", fs::portable_posix_name ), "..." );
231  PATH_CHECK( path("....", fs::portable_posix_name ), "...." );
232  PATH_CHECK( path("foo/...", fs::portable_posix_name ), "foo/..." );
233  PATH_CHECK( path("foo/...", fs::portable_posix_name ).normalize(), "foo/..." );
234  PATH_CHECK( path("abc.", fs::portable_posix_name ), "abc." );
235  PATH_CHECK( path("abc..", fs::portable_posix_name ), "abc.." );
236  PATH_CHECK( path("foo/abc.", fs::portable_posix_name ), "foo/abc." );
237  PATH_CHECK( path("foo/abc..", fs::portable_posix_name ), "foo/abc.." );
238
239  PATH_CHECK( path(".abc", fs::no_check), ".abc" );
240  PATH_CHECK( "a.c", "a.c" );
241  PATH_CHECK( path("..abc", fs::no_check), "..abc" );
242  PATH_CHECK( "a..c", "a..c" );
243  PATH_CHECK( path("foo/.abc", fs::no_check), "foo/.abc" );
244  PATH_CHECK( "foo/a.c", "foo/a.c" );
245  PATH_CHECK( path("foo/..abc", fs::no_check), "foo/..abc" );
246  PATH_CHECK( path("foo/..abc", fs::no_check).normalize(), "foo/..abc" );
247  PATH_CHECK( "foo/a..c", "foo/a..c" );
248
249  PATH_CHECK( ".", "." );
250  PATH_CHECK( path("") / ".", "." );
251  PATH_CHECK( "./foo", "foo" );
252  PATH_CHECK( path(".") / "foo", "foo" );
253  PATH_CHECK( "./..", ".." );
254  PATH_CHECK( path(".") / "..", ".." );
255  PATH_CHECK( "./../foo", "../foo" );
256  PATH_CHECK( "foo/.", "foo" );
257  PATH_CHECK( path("foo") / ".", "foo" );
258  PATH_CHECK( "../.", ".." );
259  PATH_CHECK( path("..") / ".", ".." );
260  PATH_CHECK( "./.", "." );
261  PATH_CHECK( path(".") / ".", "." );
262  PATH_CHECK( "././.", "." );
263  PATH_CHECK( path(".") / "." / ".", "." );
264  PATH_CHECK( "./foo/.", "foo" );
265  PATH_CHECK( path(".") / "foo" / ".", "foo" );
266  PATH_CHECK( "foo/./bar", "foo/bar" );
267  PATH_CHECK( path("foo") / "." / "bar", "foo/bar" );
268  PATH_CHECK( "foo/./.", "foo" );
269  PATH_CHECK( path("foo") / "." / ".", "foo" );
270  PATH_CHECK( "foo/./..", "foo/.." );
271  PATH_CHECK( path("foo") / "." / "..", "foo/.." );
272  PATH_CHECK( "foo/./../bar", "foo/../bar" );
273  PATH_CHECK( "foo/../.", "foo/.." );
274  PATH_CHECK( path(".") / "." / "..", ".." );
275  PATH_CHECK( "././..", ".." );
276  PATH_CHECK( path(".") / "." / "..", ".." );
277  PATH_CHECK( "./../.", ".." );
278  PATH_CHECK( path(".") / ".." / ".", ".." );
279  PATH_CHECK( ".././.", ".." );
280  PATH_CHECK( path("..") / "." / ".", ".." );
281
282  BOOST_CHECK( path("foo\\bar", fs::no_check).leaf() == "foo\\bar" );
283 
284  BOOST_CHECK( fs::portable_posix_name(".") );
285  BOOST_CHECK( fs::portable_posix_name("..") );
286  BOOST_CHECK( fs::portable_posix_name("...") );
287  BOOST_CHECK( fs::portable_posix_name("....") );
288  BOOST_CHECK( fs::portable_posix_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
289  BOOST_CHECK( !fs::portable_posix_name("F$O") );
290
291  BOOST_CHECK( fs::portable_name(".") );
292  BOOST_CHECK( fs::portable_name("..") );
293  BOOST_CHECK( fs::portable_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
294  BOOST_CHECK( !fs::portable_name("A.") );
295  BOOST_CHECK( fs::portable_name("A-") );
296  BOOST_CHECK( !fs::portable_name(".A") );
297  BOOST_CHECK( !fs::portable_name("-A") );
298  BOOST_CHECK( !fs::portable_name("F$O") );
299
300
301  BOOST_CHECK( fs::portable_file_name(".") );
302  BOOST_CHECK( fs::portable_file_name("..") );
303  BOOST_CHECK( fs::portable_file_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
304  BOOST_CHECK( fs::portable_file_name("0123456789.-_") );
305  BOOST_CHECK( fs::portable_file_name("1234567890123456789012345678901") );
306  BOOST_CHECK( !fs::portable_file_name("a.") );
307  BOOST_CHECK( !fs::portable_file_name("a..b") );
308  BOOST_CHECK( !fs::portable_file_name("a.bcde") );
309  BOOST_CHECK( !fs::portable_file_name("a..cde") );
310  BOOST_CHECK( !fs::portable_file_name("a.c.de") );
311  BOOST_CHECK( !fs::portable_file_name("a.cd.e") );
312  BOOST_CHECK( fs::portable_file_name("a.b") );
313  BOOST_CHECK( fs::portable_file_name("a.bc") );
314  BOOST_CHECK( fs::portable_file_name("a.bcd") );
315  BOOST_CHECK( !fs::portable_file_name("A.") );
316  BOOST_CHECK( fs::portable_file_name("A-") );
317  BOOST_CHECK( !fs::portable_file_name(".A") );
318  BOOST_CHECK( !fs::portable_file_name("-A") );
319  BOOST_CHECK( !fs::portable_file_name("F$O") );
320
321  BOOST_CHECK( fs::portable_directory_name(".") );
322  BOOST_CHECK( fs::portable_directory_name("..") );
323  BOOST_CHECK( fs::portable_directory_name("ABCDEFGHIJKLMNOPQRSTUVWXYZ") );
324  BOOST_CHECK( fs::portable_directory_name("abcdefghijklmnopqrstuvwxyz") );
325  BOOST_CHECK( fs::portable_directory_name("0123456789-_") );
326  BOOST_CHECK( fs::portable_directory_name("1234567890123456789012345678901") );
327  BOOST_CHECK( !fs::portable_directory_name("a.") );
328  BOOST_CHECK( !fs::portable_directory_name("a.bcde") );
329  BOOST_CHECK( !fs::portable_directory_name("a..cde") );
330  BOOST_CHECK( !fs::portable_directory_name("a.c.de") );
331  BOOST_CHECK( !fs::portable_directory_name("a.cd.e") );
332  BOOST_CHECK( !fs::portable_directory_name("a.b") );
333  BOOST_CHECK( !fs::portable_directory_name("a.bc") );
334  BOOST_CHECK( !fs::portable_directory_name("a.bcd") );
335  BOOST_CHECK( !fs::portable_directory_name("A.") );
336  BOOST_CHECK( fs::portable_directory_name("A-") );
337  BOOST_CHECK( !fs::portable_directory_name(".A") );
338  BOOST_CHECK( !fs::portable_directory_name("-A") );
339  BOOST_CHECK( !fs::portable_directory_name("F$O") );
340
341  check_throw( "foo//bar" );
342  check_throw( "foo\\bar" );
343  check_throw( " " );
344  check_throw( " foo" );
345  check_throw( "foo " );
346  check_throw( ">" );
347  check_throw( "<" );
348  check_throw( ":" );
349  check_throw( "\"" );
350  check_throw( "|" );
351
352  check_throw( "c:" );
353  check_throw( "c:/" );
354  check_throw( "//share" );
355  check_throw( "prn:" );
356
357  path itr_ck( "/foo/bar" );
358  path::iterator itr( itr_ck.begin() );
359  BOOST_CHECK( *itr == std::string( "/" ) );
360  BOOST_CHECK( *++itr == std::string( "foo" ) );
361  BOOST_CHECK( *++itr == std::string( "bar" ) );
362  BOOST_CHECK( ++itr == itr_ck.end() );
363  BOOST_CHECK( *--itr == std::string( "bar" ) );
364  BOOST_CHECK( *--itr == std::string( "foo" ) );
365  BOOST_CHECK( *--itr == std::string( "/" ) );
366
367  itr_ck = "";
368  BOOST_CHECK( itr_ck.begin() == itr_ck.end() );
369
370  itr_ck = path( "/" );
371  BOOST_CHECK( *itr_ck.begin() == std::string( "/" ) );
372  BOOST_CHECK( next(itr_ck.begin()) == itr_ck.end() );
373  BOOST_CHECK( *prior(itr_ck.end()) == std::string( "/" ) );
374  BOOST_CHECK( prior(itr_ck.end()) == itr_ck.begin() );
375
376  itr_ck = path( "/foo" );
377  BOOST_CHECK( *itr_ck.begin() == std::string( "/" ) );
378  BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "foo" ) );
379  BOOST_CHECK( next(next( itr_ck.begin() )) == itr_ck.end() );
380  BOOST_CHECK( next( itr_ck.begin() ) == prior( itr_ck.end() ) );
381  BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
382  BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "/" ) );
383  BOOST_CHECK( prior(prior( itr_ck.end() )) == itr_ck.begin() );
384
385  itr_ck = "foo";
386  BOOST_CHECK( *itr_ck.begin() == std::string( "foo" ) );
387  BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
388  BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
389  BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
390
391  path p;
392
393  p = "";
394  BOOST_CHECK( p.relative_path().string() == "" );
395  BOOST_CHECK( p.branch_path().string() == "" );
396  BOOST_CHECK( p.leaf() == "" );
397  BOOST_CHECK( p.root_name() == "" );
398  BOOST_CHECK( p.root_directory() == "" );
399  BOOST_CHECK( p.root_path().string() == "" );
400  BOOST_CHECK( !p.has_root_path() );
401  BOOST_CHECK( !p.has_root_name() );
402  BOOST_CHECK( !p.has_root_directory() );
403  BOOST_CHECK( !p.has_relative_path() );
404  BOOST_CHECK( !p.has_leaf() );
405  BOOST_CHECK( !p.has_branch_path() );
406  BOOST_CHECK( !p.is_complete() );
407
408  p = "/";
409  BOOST_CHECK( p.relative_path().string() == "" );
410  BOOST_CHECK( p.branch_path().string() == "" );
411  BOOST_CHECK( p.leaf() == "/" );
412  BOOST_CHECK( p.root_name() == "" );
413  BOOST_CHECK( p.root_directory() == "/" );
414  BOOST_CHECK( p.root_path().string() == "/" );
415  BOOST_CHECK( p.has_root_path() );
416  BOOST_CHECK( !p.has_root_name() );
417  BOOST_CHECK( p.has_root_directory() );
418  BOOST_CHECK( !p.has_relative_path() );
419  BOOST_CHECK( p.has_leaf() );
420  BOOST_CHECK( !p.has_branch_path() );
421  if ( platform == "POSIX" )
422    BOOST_CHECK( p.is_complete() );
423  else
424    BOOST_CHECK( !p.is_complete() );
425
426  p = ".";
427  BOOST_CHECK( p.relative_path().string() == "." );
428  BOOST_CHECK( p.branch_path().string() == "" );
429  BOOST_CHECK( p.leaf() == "." );
430  BOOST_CHECK( p.root_name() == "" );
431  BOOST_CHECK( p.root_directory() == "" );
432  BOOST_CHECK( p.root_path().string() == "" );
433  BOOST_CHECK( !p.has_root_path() );
434  BOOST_CHECK( !p.has_root_name() );
435  BOOST_CHECK( !p.has_root_directory() );
436  BOOST_CHECK( p.has_relative_path() );
437  BOOST_CHECK( p.has_leaf() );
438  BOOST_CHECK( !p.has_branch_path() );
439  BOOST_CHECK( !p.is_complete() );
440
441  p = "..";
442  BOOST_CHECK( p.relative_path().string() == ".." );
443  BOOST_CHECK( p.branch_path().string() == "" );
444  BOOST_CHECK( p.leaf() == ".." );
445  BOOST_CHECK( p.root_name() == "" );
446  BOOST_CHECK( p.root_directory() == "" );
447  BOOST_CHECK( p.root_path().string() == "" );
448  BOOST_CHECK( !p.has_root_path() );
449  BOOST_CHECK( !p.has_root_name() );
450  BOOST_CHECK( !p.has_root_directory() );
451  BOOST_CHECK( p.has_relative_path() );
452  BOOST_CHECK( p.has_leaf() );
453  BOOST_CHECK( !p.has_branch_path() );
454  BOOST_CHECK( !p.is_complete() );
455
456  p = "foo";
457  BOOST_CHECK( p.relative_path().string() == "foo" );
458  BOOST_CHECK( p.branch_path().string() == "" );
459  BOOST_CHECK( p.leaf() == "foo" );
460  BOOST_CHECK( p.root_name() == "" );
461  BOOST_CHECK( p.root_directory() == "" );
462  BOOST_CHECK( p.root_path().string() == "" );
463  BOOST_CHECK( !p.has_root_path() );
464  BOOST_CHECK( !p.has_root_name() );
465  BOOST_CHECK( !p.has_root_directory() );
466  BOOST_CHECK( p.has_relative_path() );
467  BOOST_CHECK( p.has_leaf() );
468  BOOST_CHECK( !p.has_branch_path() );
469  BOOST_CHECK( !p.is_complete() );
470
471  p = "/foo";
472  BOOST_CHECK( p.relative_path().string() == "foo" );
473  BOOST_CHECK( p.branch_path().string() == "/" );
474  BOOST_CHECK( p.leaf() == "foo" );
475  BOOST_CHECK( p.root_name() == "" );
476  BOOST_CHECK( p.root_directory() == "/" );
477  BOOST_CHECK( p.root_path().string() == "/" );
478  BOOST_CHECK( p.has_root_path() );
479  BOOST_CHECK( !p.has_root_name() );
480  BOOST_CHECK( p.has_root_directory() );
481  BOOST_CHECK( p.has_relative_path() );
482  BOOST_CHECK( p.has_leaf() );
483  BOOST_CHECK( p.has_branch_path() );
484  if ( platform == "POSIX" )
485    BOOST_CHECK( p.is_complete() );
486  else
487    BOOST_CHECK( !p.is_complete() );
488
489  p = "foo/bar";
490  BOOST_CHECK( p.relative_path().string() == "foo/bar" );
491  BOOST_CHECK( p.branch_path().string() == "foo" );
492  BOOST_CHECK( p.leaf() == "bar" );
493  BOOST_CHECK( p.root_name() == "" );
494  BOOST_CHECK( p.root_directory() == "" );
495  BOOST_CHECK( p.root_path().string() == "" );
496  BOOST_CHECK( !p.has_root_path() );
497  BOOST_CHECK( !p.has_root_name() );
498  BOOST_CHECK( !p.has_root_directory() );
499  BOOST_CHECK( p.has_relative_path() );
500  BOOST_CHECK( p.has_leaf() );
501  BOOST_CHECK( p.has_branch_path() );
502  BOOST_CHECK( !p.is_complete() );
503
504  p = "../foo";
505  BOOST_CHECK( p.relative_path().string() == "../foo" );
506  BOOST_CHECK( p.branch_path().string() == ".." );
507  BOOST_CHECK( p.leaf() == "foo" );
508  BOOST_CHECK( p.root_name() == "" );
509  BOOST_CHECK( p.root_directory() == "" );
510  BOOST_CHECK( p.root_path().string() == "" );
511  BOOST_CHECK( !p.has_root_path() );
512  BOOST_CHECK( !p.has_root_name() );
513  BOOST_CHECK( !p.has_root_directory() );
514  BOOST_CHECK( p.has_relative_path() );
515  BOOST_CHECK( p.has_leaf() );
516  BOOST_CHECK( p.has_branch_path() );
517  BOOST_CHECK( !p.is_complete() );
518
519  p = "/foo/bar";
520  BOOST_CHECK( p.relative_path().string() == "foo/bar" );
521  BOOST_CHECK( p.branch_path().string() == "/foo" );
522  BOOST_CHECK( p.leaf() == "bar" );
523  BOOST_CHECK( p.root_name() == "" );
524  BOOST_CHECK( p.root_directory() == "/" );
525  BOOST_CHECK( p.root_path().string() == "/" );
526  BOOST_CHECK( p.has_root_path() );
527  BOOST_CHECK( !p.has_root_name() );
528  BOOST_CHECK( p.has_root_directory() );
529  BOOST_CHECK( p.has_relative_path() );
530  BOOST_CHECK( p.has_leaf() );
531  BOOST_CHECK( p.has_branch_path() );
532  if ( platform == "POSIX" )
533    BOOST_CHECK( p.is_complete() );
534  else
535    BOOST_CHECK( !p.is_complete() );
536
537  // decomposition and query functions must work even for paths which
538  // do not pass the default name_check
539  p = path( "/</>", fs::no_check );
540  BOOST_CHECK( p.relative_path().string() == "</>" );
541  BOOST_CHECK( p.branch_path().string() == "/<" );
542  BOOST_CHECK( p.leaf() == ">" );
543  BOOST_CHECK( p.root_name() == "" );
544  BOOST_CHECK( p.root_directory() == "/" );
545  BOOST_CHECK( p.root_path().string() == "/" );
546  BOOST_CHECK( p.has_root_path() );
547  BOOST_CHECK( !p.has_root_name() );
548  BOOST_CHECK( p.has_root_directory() );
549  BOOST_CHECK( p.has_relative_path() );
550  BOOST_CHECK( p.has_leaf() );
551  BOOST_CHECK( p.has_branch_path() );
552  if ( platform == "POSIX" )
553    BOOST_CHECK( p.is_complete() );
554  else
555    BOOST_CHECK( !p.is_complete() );
556
557  if ( platform == "Windows" )
558  {
559    PATH_CHECK( path( "\\", fs::native ), "/" );
560    PATH_CHECK( path( "\\f", fs::native ), "/f" );
561    PATH_CHECK( path( "\\foo", fs::native ), "/foo" );
562    PATH_CHECK( path( "foo\\bar", fs::native ), "foo/bar" );
563    PATH_CHECK( path( "foo bar", fs::native ), "foo bar" );
564    PATH_CHECK( path( "c:", fs::native ), "c:" );
565    PATH_CHECK( path( "c:/", fs::native ), "c:/" );
566    PATH_CHECK( path( "c:.", fs::native ), "c:" );
567    PATH_CHECK( path( "c:./foo", fs::native ), "c:foo" );
568    PATH_CHECK( path( "c:.\\foo", fs::native ), "c:foo" );
569    PATH_CHECK( path( "c:..", fs::native ), "c:.." );
570    PATH_CHECK( path( "c:..", fs::native ).normalize(), "c:.." );
571    PATH_CHECK( path( "c:/.", fs::native ), "c:/" );
572    PATH_CHECK( path( "c:/..", fs::native ), "c:/" );
573    PATH_CHECK( path( "c:/..", fs::native ).normalize(), "c:/" );
574    PATH_CHECK( path( "c:/../", fs::native ), "c:/" );
575    PATH_CHECK( path( "c:\\..\\", fs::native ), "c:/" );
576    PATH_CHECK( path( "c:/../", fs::native ).normalize(), "c:/" );
577    PATH_CHECK( path( "c:/../..", fs::native ), "c:/" );
578    PATH_CHECK( path( "c:/../..", fs::native ).normalize(), "c:/" );
579    PATH_CHECK( path( "c:/../foo", fs::native ), "c:/foo" );
580    PATH_CHECK( path( "c:\\..\\foo", fs::native ), "c:/foo" );
581    PATH_CHECK( path( "c:../foo", fs::native ), "c:../foo" );
582    PATH_CHECK( path( "c:..\\foo", fs::native ), "c:../foo" );
583    PATH_CHECK( path( "c:/../foo", fs::native ).normalize(), "c:/foo" );
584    PATH_CHECK( path( "c:/../../foo", fs::native ), "c:/foo" );
585    PATH_CHECK( path( "c:\\..\\..\\foo", fs::native ), "c:/foo" );
586    PATH_CHECK( path( "c:/../../foo", fs::native ).normalize(), "c:/foo" );
587    PATH_CHECK( path( "c:foo/..", fs::native ), "c:foo/.." );
588    PATH_CHECK( path( "c:foo/..", fs::native ).normalize(), "c:" );
589    PATH_CHECK( path( "c:/foo/..", fs::native ), "c:/foo/.." );
590    PATH_CHECK( path( "c:/foo/..", fs::native ).normalize(), "c:/" );
591    PATH_CHECK( path( "c:/..foo", fs::native ), "c:/..foo" );
592    PATH_CHECK( path( "c:/..foo", fs::native ).normalize(), "c:/..foo" );
593    PATH_CHECK( path( "c:foo", fs::native ), "c:foo" );
594    PATH_CHECK( path( "c:/foo", fs::native ), "c:/foo" );
595    PATH_CHECK( path( "c++", fs::native ), "c++" );
596    PATH_CHECK( path( "//share", fs::native ), "//share" );
597    PATH_CHECK( path( "//share/", fs::native ), "//share/" );
598    PATH_CHECK( path( "//share/foo", fs::native ), "//share/foo" );
599    PATH_CHECK( path( "\\\\share", fs::native ), "//share" );
600    PATH_CHECK( path( "\\\\share\\", fs::native ), "//share/" );
601    PATH_CHECK( path( "\\\\share\\foo", fs::native ), "//share/foo" );
602    PATH_CHECK( path( "c:/foo", fs::native ), "c:/foo" );
603    PATH_CHECK( path( "prn:", fs::native ), "prn:" );
604
605    p = path( "c:", fs::native );
606    BOOST_CHECK( p.relative_path().string() == "" );
607    BOOST_CHECK( p.branch_path().string() == "" );
608    BOOST_CHECK( p.leaf() == "c:" );
609    BOOST_CHECK( p.root_name() == "c:" );
610    BOOST_CHECK( p.root_directory() == "" );
611    BOOST_CHECK( p.root_path().string() == "c:" );
612    BOOST_CHECK( p.has_root_path() );
613    BOOST_CHECK( p.has_root_name() );
614    BOOST_CHECK( !p.has_root_directory() );
615    BOOST_CHECK( !p.has_relative_path() );
616    BOOST_CHECK( p.has_leaf() );
617    BOOST_CHECK( !p.has_branch_path() );
618    BOOST_CHECK( !p.is_complete() );
619
620    p = path( "c:foo", fs::native );
621    BOOST_CHECK( p.relative_path().string() == "foo" );
622    BOOST_CHECK( p.branch_path().string() == "c:" );
623    BOOST_CHECK( p.leaf() == "foo" );
624    BOOST_CHECK( p.root_name() == "c:" );
625    BOOST_CHECK( p.root_directory() == "" );
626    BOOST_CHECK( p.root_path().string() == "c:" );
627    BOOST_CHECK( p.has_root_path() );
628    BOOST_CHECK( p.has_root_name() );
629    BOOST_CHECK( !p.has_root_directory() );
630    BOOST_CHECK( p.has_relative_path() );
631    BOOST_CHECK( p.has_leaf() );
632    BOOST_CHECK( p.has_branch_path() );
633    BOOST_CHECK( !p.is_complete() );
634 
635    p = path( "c:/", fs::native );
636    BOOST_CHECK( p.relative_path().string() == "" );
637    BOOST_CHECK( p.branch_path().string() == "c:" );
638    BOOST_CHECK( p.leaf() == "/" );
639    BOOST_CHECK( p.root_name() == "c:" );
640    BOOST_CHECK( p.root_directory() == "/" );
641    BOOST_CHECK( p.root_path().string() == "c:/" );
642    BOOST_CHECK( p.has_root_path() );
643    BOOST_CHECK( p.has_root_name() );
644    BOOST_CHECK( p.has_root_directory() );
645    BOOST_CHECK( !p.has_relative_path() );
646    BOOST_CHECK( p.has_leaf() );
647    BOOST_CHECK( p.has_branch_path() );
648    BOOST_CHECK( p.is_complete() );
649
650    p = path( "c:..", fs::native );
651    BOOST_CHECK( p.relative_path().string() == ".." );
652    BOOST_CHECK( p.branch_path().string() == "c:" );
653    BOOST_CHECK( p.leaf() == ".." );
654    BOOST_CHECK( p.root_name() == "c:" );
655    BOOST_CHECK( p.root_directory() == "" );
656    BOOST_CHECK( p.root_path().string() == "c:" );
657    BOOST_CHECK( p.has_root_path() );
658    BOOST_CHECK( p.has_root_name() );
659    BOOST_CHECK( !p.has_root_directory() );
660    BOOST_CHECK( p.has_relative_path() );
661    BOOST_CHECK( p.has_leaf() );
662    BOOST_CHECK( p.has_branch_path() );
663    BOOST_CHECK( !p.is_complete() );
664
665    p = path( "c:/foo", fs::native );
666    BOOST_CHECK( p.relative_path().string() == "foo" );
667    BOOST_CHECK( p.branch_path().string() == "c:/" );
668    BOOST_CHECK( p.leaf() == "foo" );
669    BOOST_CHECK( p.root_name() == "c:" );
670    BOOST_CHECK( p.root_directory() == "/" );
671    BOOST_CHECK( p.root_path().string() == "c:/" );
672    BOOST_CHECK( p.has_root_path() );
673    BOOST_CHECK( p.has_root_name() );
674    BOOST_CHECK( p.has_root_directory() );
675    BOOST_CHECK( p.has_relative_path() );
676    BOOST_CHECK( p.has_leaf() );
677    BOOST_CHECK( p.has_branch_path() );
678    BOOST_CHECK( p.is_complete() );
679
680/* Commented out until the semantics of //share are clearer.
681
682    p = path( "//share", fs::native );
683    BOOST_CHECK( p.string() == "//share" );
684    BOOST_CHECK( p.relative_path().string() == "" );
685    BOOST_CHECK( p.branch_path().string() == "" );
686    BOOST_CHECK( p.leaf() == "//share" );
687    BOOST_CHECK( p.root_name() == "//share" );
688    BOOST_CHECK( p.root_directory() == "/" );
689    BOOST_CHECK( p.root_path().string() == "//share/" );
690    BOOST_CHECK( p.has_root_path() );
691    BOOST_CHECK( p.has_root_name() );
692    BOOST_CHECK( !p.has_root_directory() );
693    BOOST_CHECK( !p.has_relative_path() );
694    BOOST_CHECK( p.has_leaf() );
695    BOOST_CHECK( !p.has_branch_path() );
696    BOOST_CHECK( !p.is_complete() );
697*/
698    p = path( "//share/", fs::native );
699    BOOST_CHECK( p.relative_path().string() == "" );
700    BOOST_CHECK( p.branch_path().string() == "//share" );
701    BOOST_CHECK( p.leaf() == "/" );
702    BOOST_CHECK( p.root_name() == "//share" );
703    BOOST_CHECK( p.root_directory() == "/" );
704    BOOST_CHECK( p.root_path().string() == "//share/" );
705    BOOST_CHECK( p.has_root_path() );
706    BOOST_CHECK( p.has_root_name() );
707    BOOST_CHECK( p.has_root_directory() );
708    BOOST_CHECK( !p.has_relative_path() );
709    BOOST_CHECK( p.has_leaf() );
710    BOOST_CHECK( p.has_branch_path() );
711    BOOST_CHECK( p.is_complete() );
712
713    p = path( "//share/foo", fs::native );
714    BOOST_CHECK( p.relative_path().string() == "foo" );
715    BOOST_CHECK( p.branch_path().string() == "//share/" );
716    BOOST_CHECK( p.leaf() == "foo" );
717    BOOST_CHECK( p.root_name() == "//share" );
718    BOOST_CHECK( p.root_directory() == "/" );
719    BOOST_CHECK( p.root_path().string() == "//share/" );
720    BOOST_CHECK( p.has_root_path() );
721    BOOST_CHECK( p.has_root_name() );
722    BOOST_CHECK( p.has_root_directory() );
723    BOOST_CHECK( p.has_relative_path() );
724    BOOST_CHECK( p.has_leaf() );
725    BOOST_CHECK( p.has_branch_path() );
726    BOOST_CHECK( p.is_complete() );
727
728    p = path( "prn:", fs::native );
729    BOOST_CHECK( p.relative_path().string() == "" );
730    BOOST_CHECK( p.branch_path().string() == "" );
731    BOOST_CHECK( p.leaf() == "prn:" );
732    BOOST_CHECK( p.root_name() == "prn:" );
733    BOOST_CHECK( p.root_directory() == "" );
734    BOOST_CHECK( p.root_path().string() == "prn:" );
735    BOOST_CHECK( p.has_root_path() );
736    BOOST_CHECK( p.has_root_name() );
737    BOOST_CHECK( !p.has_root_directory() );
738    BOOST_CHECK( !p.has_relative_path() );
739    BOOST_CHECK( p.has_leaf() );
740    BOOST_CHECK( !p.has_branch_path() );
741    BOOST_CHECK( p.is_complete() );
742
743    itr_ck = path( "c:", fs::native );
744    BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
745    BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
746    BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
747    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "c:" ) );
748
749    itr_ck = path( "c:/", fs::native );
750    BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
751    BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
752    BOOST_CHECK( next( next( itr_ck.begin() )) == itr_ck.end() );
753    BOOST_CHECK( prior( prior( itr_ck.end() )) == itr_ck.begin() );
754    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "/" ) );
755    BOOST_CHECK( *prior( prior( itr_ck.end() )) == std::string( "c:" ) );
756
757    itr_ck = path( "c:foo", fs::native );
758    BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
759    BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "foo" ) );
760    BOOST_CHECK( next(next( itr_ck.begin() )) == itr_ck.end() );
761    BOOST_CHECK( prior(prior( itr_ck.end() )) == itr_ck.begin() );
762    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
763    BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "c:" ) );
764
765    itr_ck = path( "c:/foo", fs::native );
766    BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
767    BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
768    BOOST_CHECK( *next( next( itr_ck.begin() )) == std::string( "foo" ) );
769    BOOST_CHECK( next( next( next( itr_ck.begin() ))) == itr_ck.end() );
770    BOOST_CHECK( prior( prior( prior( itr_ck.end() ))) == itr_ck.begin() );
771    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
772    BOOST_CHECK( *prior( prior( itr_ck.end() )) == std::string( "/" ) );
773    BOOST_CHECK( *prior( prior( prior( itr_ck.end() ))) == std::string( "c:" ) );
774
775    itr_ck = path( "//share", fs::native );
776    BOOST_CHECK( *itr_ck.begin() == std::string( "//share" ) );
777    BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
778    BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
779    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "//share" ) );
780
781    itr_ck = path( "//share/", fs::native );
782    BOOST_CHECK( *itr_ck.begin() == std::string( "//share" ) );
783    BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
784    BOOST_CHECK( next(next( itr_ck.begin() )) == itr_ck.end() );
785    BOOST_CHECK( prior(prior( itr_ck.end() )) == itr_ck.begin() );
786    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "/" ) );
787    BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "//share" ) );
788
789    itr_ck = path( "//share/foo", fs::native );
790    BOOST_CHECK( *itr_ck.begin() == std::string( "//share" ) );
791    BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
792    BOOST_CHECK( *next(next( itr_ck.begin() )) == std::string( "foo" ) );
793    BOOST_CHECK( next(next(next( itr_ck.begin() ))) == itr_ck.end() );
794    BOOST_CHECK( prior(prior(prior( itr_ck.end() ))) == itr_ck.begin() );
795    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
796    BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "/" ) );
797    BOOST_CHECK( *prior(prior(prior( itr_ck.end() ))) == std::string( "//share" ) );
798
799    itr_ck = path( "prn:", fs::native );
800    BOOST_CHECK( *itr_ck.begin() == std::string( "prn:" ) );
801    BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
802    BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
803    BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "prn:" ) );
804  } // Windows
805
806  else
807  { // POSIX
808    p = path( "/usr/local/bin:/usr/bin:/bin", fs::no_check );
809    BOOST_CHECK( p.native_file_string() == "/usr/local/bin:/usr/bin:/bin" );
810  } // POSIX
811
812  // test relational operators
813                                                             
814  path e, e2;
815  path a( "a" );
816  path a2( "a" );
817  path b( "b" );
818
819  // probe operator <
820  BOOST_CHECK( !(e < e2) );
821  BOOST_CHECK( e < a );
822  BOOST_CHECK( a < b );
823  BOOST_CHECK( !(a < a2) );
824
825  // reality check character set is as expected
826  BOOST_CHECK( std::string("a.b") < std::string("a/b") );
827  // verify compare is actually lexicographical
828  BOOST_CHECK( path("a/b") < path("a.b") );
829
830  // make sure the derivative operators also work
831  BOOST_CHECK( a == a2 );
832  BOOST_CHECK( a != b );
833  BOOST_CHECK( a <= b );
834  BOOST_CHECK( a <= a2 );
835  BOOST_CHECK( b >= a );
836  BOOST_CHECK( a2 >= a );
837
838//  std::cout << errors << " errors detected\n";
839 
840  return errors;
841}
Note: See TracBrowser for help on using the repository browser.