mirror of
https://github.com/boostorg/filesystem.git
synced 2025-05-12 13:41:47 +00:00
Replaced BOOST_TEST
[SVN r27048]
This commit is contained in:
Stefan Slapeta
parent
53b3c9404c
commit
4c75d616cf
@ -44,61 +44,61 @@ int test_main( int, char*[] )
|
||||
|
||||
// create_directories() tests ----------------------------------------------//
|
||||
|
||||
BOOST_TEST( !fs::create_directories( "" ) ); // should be harmless
|
||||
BOOST_TEST( !fs::create_directories( "/" ) ); // ditto
|
||||
BOOST_CHECK( !fs::create_directories( "" ) ); // should be harmless
|
||||
BOOST_CHECK( !fs::create_directories( "/" ) ); // ditto
|
||||
|
||||
fs::remove_all( "xx" ); // make sure slate is blank
|
||||
BOOST_TEST( !fs::exists( "xx" ) ); // reality check
|
||||
BOOST_CHECK( !fs::exists( "xx" ) ); // reality check
|
||||
|
||||
BOOST_TEST( fs::create_directories( "xx" ) );
|
||||
BOOST_TEST( fs::exists( "xx" ) );
|
||||
BOOST_TEST( fs::is_directory( "xx" ) );
|
||||
BOOST_CHECK( fs::create_directories( "xx" ) );
|
||||
BOOST_CHECK( fs::exists( "xx" ) );
|
||||
BOOST_CHECK( fs::is_directory( "xx" ) );
|
||||
|
||||
BOOST_TEST( fs::create_directories( "xx/ww/zz" ) );
|
||||
BOOST_TEST( fs::exists( "xx" ) );
|
||||
BOOST_TEST( fs::exists( "xx/ww" ) );
|
||||
BOOST_TEST( fs::exists( "xx/ww/zz" ) );
|
||||
BOOST_TEST( fs::is_directory( "xx" ) );
|
||||
BOOST_TEST( fs::is_directory( "xx/ww" ) );
|
||||
BOOST_TEST( fs::is_directory( "xx/ww/zz" ) );
|
||||
BOOST_CHECK( fs::create_directories( "xx/ww/zz" ) );
|
||||
BOOST_CHECK( fs::exists( "xx" ) );
|
||||
BOOST_CHECK( fs::exists( "xx/ww" ) );
|
||||
BOOST_CHECK( fs::exists( "xx/ww/zz" ) );
|
||||
BOOST_CHECK( fs::is_directory( "xx" ) );
|
||||
BOOST_CHECK( fs::is_directory( "xx/ww" ) );
|
||||
BOOST_CHECK( fs::is_directory( "xx/ww/zz" ) );
|
||||
|
||||
path is_a_file( "xx/uu" );
|
||||
{
|
||||
std::ofstream f( is_a_file.native_file_string().c_str() );
|
||||
BOOST_TEST( !!f );
|
||||
BOOST_CHECK( !!f );
|
||||
}
|
||||
BOOST_TEST(
|
||||
BOOST_CHECK(
|
||||
throws_fs_error( boost::bind( fs::create_directories, is_a_file ) ) );
|
||||
BOOST_TEST(
|
||||
BOOST_CHECK(
|
||||
throws_fs_error( boost::bind( fs::create_directories, is_a_file / "aa" ) ) );
|
||||
|
||||
// extension() tests ----------------------------------------------------------//
|
||||
|
||||
BOOST_TEST( fs::extension("a/b") == "" );
|
||||
BOOST_TEST( fs::extension("a/b.txt") == ".txt" );
|
||||
BOOST_TEST( fs::extension("a/b.") == "." );
|
||||
BOOST_TEST( fs::extension("a.b.c") == ".c" );
|
||||
BOOST_TEST( fs::extension("a.b.c.") == "." );
|
||||
BOOST_TEST( fs::extension("") == "" );
|
||||
BOOST_TEST( fs::extension("a/") == "" );
|
||||
BOOST_CHECK( fs::extension("a/b") == "" );
|
||||
BOOST_CHECK( fs::extension("a/b.txt") == ".txt" );
|
||||
BOOST_CHECK( fs::extension("a/b.") == "." );
|
||||
BOOST_CHECK( fs::extension("a.b.c") == ".c" );
|
||||
BOOST_CHECK( fs::extension("a.b.c.") == "." );
|
||||
BOOST_CHECK( fs::extension("") == "" );
|
||||
BOOST_CHECK( fs::extension("a/") == "" );
|
||||
|
||||
// basename() tests ----------------------------------------------------------//
|
||||
|
||||
BOOST_TEST( fs::basename("b") == "b" );
|
||||
BOOST_TEST( fs::basename("a/b.txt") == "b" );
|
||||
BOOST_TEST( fs::basename("a/b.") == "b" );
|
||||
BOOST_TEST( fs::basename("a.b.c") == "a.b" );
|
||||
BOOST_TEST( fs::basename("a.b.c.") == "a.b.c" );
|
||||
BOOST_TEST( fs::basename("") == "" );
|
||||
BOOST_CHECK( fs::basename("b") == "b" );
|
||||
BOOST_CHECK( fs::basename("a/b.txt") == "b" );
|
||||
BOOST_CHECK( fs::basename("a/b.") == "b" );
|
||||
BOOST_CHECK( fs::basename("a.b.c") == "a.b" );
|
||||
BOOST_CHECK( fs::basename("a.b.c.") == "a.b.c" );
|
||||
BOOST_CHECK( fs::basename("") == "" );
|
||||
|
||||
// change_extension tests ---------------------------------------------------//
|
||||
|
||||
BOOST_TEST( fs::change_extension("a.txt", ".tex").string() == "a.tex" );
|
||||
BOOST_TEST( fs::change_extension("a.", ".tex").string() == "a.tex" );
|
||||
BOOST_TEST( fs::change_extension("a", ".txt").string() == "a.txt" );
|
||||
BOOST_TEST( fs::change_extension("a.b.txt", ".tex").string() == "a.b.tex" );
|
||||
BOOST_CHECK( fs::change_extension("a.txt", ".tex").string() == "a.tex" );
|
||||
BOOST_CHECK( fs::change_extension("a.", ".tex").string() == "a.tex" );
|
||||
BOOST_CHECK( fs::change_extension("a", ".txt").string() == "a.txt" );
|
||||
BOOST_CHECK( fs::change_extension("a.b.txt", ".tex").string() == "a.b.tex" );
|
||||
// see the rationale in html docs for explanation why this works
|
||||
BOOST_TEST( fs::change_extension("", ".png").string() == ".png" );
|
||||
BOOST_CHECK( fs::change_extension("", ".png").string() == ".png" );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -17,10 +17,10 @@ using boost::filesystem::path;
|
||||
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
BOOST_TEST( path::default_name_check_writable() );
|
||||
BOOST_CHECK( path::default_name_check_writable() );
|
||||
path::default_name_check( fs::no_check );
|
||||
BOOST_TEST( !path::default_name_check_writable() );
|
||||
BOOST_TEST( path::default_name_check() == fs::no_check );
|
||||
BOOST_CHECK( !path::default_name_check_writable() );
|
||||
BOOST_CHECK( path::default_name_check() == fs::no_check );
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -45,8 +45,8 @@ int test_main( int, char*[] )
|
||||
fs::basic_ofstream<char> bofs( "fstream_test_bfoo" );
|
||||
fs::ofstream cofs( "fstream_test_cfoo" );
|
||||
|
||||
BOOST_TEST( bofs.is_open() );
|
||||
BOOST_TEST( cofs.is_open() );
|
||||
BOOST_CHECK( bofs.is_open() );
|
||||
BOOST_CHECK( cofs.is_open() );
|
||||
|
||||
bofs << "fstream_test_bfoo";
|
||||
cofs << "fstream_test_cfoo";
|
||||
@ -57,7 +57,7 @@ int test_main( int, char*[] )
|
||||
|
||||
# ifndef BOOST_NO_STD_WSTRING
|
||||
fs::wofstream wofs( "fstream_test_wfoo" );
|
||||
BOOST_TEST( wofs.is_open() );
|
||||
BOOST_CHECK( wofs.is_open() );
|
||||
wofs << L"fstream_test_wfoo";
|
||||
wofs.open( "fstream_test_wfoo" ); // expected to fail
|
||||
# endif
|
||||
@ -67,8 +67,8 @@ int test_main( int, char*[] )
|
||||
fs::basic_ifstream<char> bifs( "fstream_test_bfoo" );
|
||||
fs::ifstream cifs( "fstream_test_cfoo" );
|
||||
|
||||
BOOST_TEST( bifs.is_open() );
|
||||
BOOST_TEST( cifs.is_open() );
|
||||
BOOST_CHECK( bifs.is_open() );
|
||||
BOOST_CHECK( cifs.is_open() );
|
||||
|
||||
std::string b;
|
||||
std::string c;
|
||||
@ -76,8 +76,8 @@ int test_main( int, char*[] )
|
||||
bifs >> b;
|
||||
cifs >> c;
|
||||
|
||||
BOOST_TEST( b == "fstream_test_bfoo" );
|
||||
BOOST_TEST( c == "fstream_test_cfoo" );
|
||||
BOOST_CHECK( b == "fstream_test_bfoo" );
|
||||
BOOST_CHECK( c == "fstream_test_cfoo" );
|
||||
|
||||
// these will fail, but they still test the interface
|
||||
bifs.open( "fstream_test_bfoo" );
|
||||
@ -85,10 +85,10 @@ int test_main( int, char*[] )
|
||||
|
||||
# ifndef BOOST_NO_STD_WSTRING
|
||||
fs::wifstream wifs( "fstream_test_wfoo" );
|
||||
BOOST_TEST( wifs.is_open() );
|
||||
BOOST_CHECK( wifs.is_open() );
|
||||
std::wstring w;
|
||||
wifs >> w;
|
||||
BOOST_TEST( w == L"fstream_test_wfoo" );
|
||||
BOOST_CHECK( w == L"fstream_test_wfoo" );
|
||||
wifs.open( "fstream_test_wfoo" ); // expected to fail
|
||||
# endif
|
||||
}
|
||||
@ -97,8 +97,8 @@ int test_main( int, char*[] )
|
||||
fs::basic_fstream<char> bfs( "fstream_test_bfoo" );
|
||||
fs::fstream cfs( "fstream_test_cfoo" );
|
||||
|
||||
BOOST_TEST( bfs.is_open() );
|
||||
BOOST_TEST( cfs.is_open() );
|
||||
BOOST_CHECK( bfs.is_open() );
|
||||
BOOST_CHECK( cfs.is_open() );
|
||||
|
||||
std::string b;
|
||||
std::string c;
|
||||
@ -106,8 +106,8 @@ int test_main( int, char*[] )
|
||||
bfs >> b;
|
||||
cfs >> c;
|
||||
|
||||
BOOST_TEST( b == "fstream_test_bfoo" );
|
||||
BOOST_TEST( c == "fstream_test_cfoo" );
|
||||
BOOST_CHECK( b == "fstream_test_bfoo" );
|
||||
BOOST_CHECK( c == "fstream_test_cfoo" );
|
||||
|
||||
// these will fail, but they still test the interface
|
||||
bfs.open( "fstream_test_bfoo" );
|
||||
@ -115,10 +115,10 @@ int test_main( int, char*[] )
|
||||
|
||||
# ifndef BOOST_NO_STD_WSTRING
|
||||
fs::wfstream wfs( "fstream_test_wfoo" );
|
||||
BOOST_TEST( wfs.is_open() );
|
||||
BOOST_CHECK( wfs.is_open() );
|
||||
std::wstring w;
|
||||
wfs >> w;
|
||||
BOOST_TEST( w == L"fstream_test_wfoo" );
|
||||
BOOST_CHECK( w == L"fstream_test_wfoo" );
|
||||
wfs.open( "fstream_test_wfoo" ); // expected to fail
|
||||
# endif
|
||||
}
|
||||
|
||||
@ -105,16 +105,16 @@ int test_main( int argc, char * argv[] )
|
||||
<< fs::initial_path().native_file_string()
|
||||
<< "\"\n";
|
||||
|
||||
BOOST_TEST( fs::initial_path().is_complete() );
|
||||
BOOST_TEST( fs::current_path().is_complete() );
|
||||
BOOST_TEST( fs::initial_path().string() == fs::current_path().string() );
|
||||
BOOST_CHECK( fs::initial_path().is_complete() );
|
||||
BOOST_CHECK( fs::current_path().is_complete() );
|
||||
BOOST_CHECK( fs::initial_path().string() == fs::current_path().string() );
|
||||
|
||||
BOOST_TEST( fs::complete( "" ).empty() );
|
||||
BOOST_TEST( fs::complete( "/" ).string()
|
||||
BOOST_CHECK( fs::complete( "" ).empty() );
|
||||
BOOST_CHECK( fs::complete( "/" ).string()
|
||||
== fs::initial_path().root_path().string() );
|
||||
BOOST_TEST( fs::complete( "foo" ).string()
|
||||
BOOST_CHECK( fs::complete( "foo" ).string()
|
||||
== fs::initial_path().string()+"/foo" );
|
||||
BOOST_TEST( fs::complete( "/foo" ).string()
|
||||
BOOST_CHECK( fs::complete( "/foo" ).string()
|
||||
== fs::initial_path().root_path().string()+"foo" );
|
||||
|
||||
fs::path dir( fs::initial_path() / "temp_fs_test_directory" );
|
||||
@ -122,155 +122,155 @@ int test_main( int argc, char * argv[] )
|
||||
// Windows only tests
|
||||
if ( platform == "Windows" )
|
||||
{
|
||||
BOOST_TEST( !fs::exists( fs::path( "//share-not/foo", fs::native ) ) );
|
||||
BOOST_TEST( dir.string().size() > 1
|
||||
BOOST_CHECK( !fs::exists( fs::path( "//share-not/foo", fs::native ) ) );
|
||||
BOOST_CHECK( dir.string().size() > 1
|
||||
&& dir.string()[1] == ':' ); // verify path includes drive
|
||||
|
||||
BOOST_TEST( fs::system_complete( "" ).empty() );
|
||||
BOOST_TEST( fs::system_complete( "/" ).string()
|
||||
BOOST_CHECK( fs::system_complete( "" ).empty() );
|
||||
BOOST_CHECK( fs::system_complete( "/" ).string()
|
||||
== fs::initial_path().root_path().string() );
|
||||
BOOST_TEST( fs::system_complete( "foo" ).string()
|
||||
BOOST_CHECK( fs::system_complete( "foo" ).string()
|
||||
== fs::initial_path().string()+"/foo" );
|
||||
BOOST_TEST( fs::system_complete( "/foo" ).string()
|
||||
BOOST_CHECK( fs::system_complete( "/foo" ).string()
|
||||
== fs::initial_path().root_path().string()+"foo" );
|
||||
|
||||
// BOOST_TEST( fs::complete( fs::path( "c:", fs::native ) ).string()
|
||||
// BOOST_CHECK( fs::complete( fs::path( "c:", fs::native ) ).string()
|
||||
// == fs::initial_path().string() );
|
||||
// BOOST_TEST( fs::complete( fs::path( "c:foo", fs::native ) ).string()
|
||||
// BOOST_CHECK( fs::complete( fs::path( "c:foo", fs::native ) ).string()
|
||||
// == fs::initial_path().string()+"/foo" );
|
||||
BOOST_TEST( fs::complete( fs::path( "c:/", fs::native ) ).string()
|
||||
BOOST_CHECK( fs::complete( fs::path( "c:/", fs::native ) ).string()
|
||||
== "c:/" );
|
||||
BOOST_TEST( fs::complete( fs::path( "c:/foo", fs::native ) ).string()
|
||||
BOOST_CHECK( fs::complete( fs::path( "c:/foo", fs::native ) ).string()
|
||||
== "c:/foo" );
|
||||
BOOST_TEST( fs::complete( fs::path( "//share", fs::native ) ).string()
|
||||
BOOST_CHECK( fs::complete( fs::path( "//share", fs::native ) ).string()
|
||||
== "//share" );
|
||||
|
||||
BOOST_TEST( fs::system_complete( fs::path( fs::initial_path().root_name(),
|
||||
BOOST_CHECK( fs::system_complete( fs::path( fs::initial_path().root_name(),
|
||||
fs::native ) ).string() == fs::initial_path().string() );
|
||||
BOOST_TEST( fs::system_complete( fs::path( fs::initial_path().root_name()
|
||||
BOOST_CHECK( fs::system_complete( fs::path( fs::initial_path().root_name()
|
||||
+ "foo", fs::native ) ).string() == fs::initial_path().string()+"/foo" );
|
||||
BOOST_TEST( fs::system_complete( fs::path( "c:/", fs::native ) ).string()
|
||||
BOOST_CHECK( fs::system_complete( fs::path( "c:/", fs::native ) ).string()
|
||||
== "c:/" );
|
||||
BOOST_TEST( fs::system_complete( fs::path( "c:/foo", fs::native ) ).string()
|
||||
BOOST_CHECK( fs::system_complete( fs::path( "c:/foo", fs::native ) ).string()
|
||||
== "c:/foo" );
|
||||
BOOST_TEST( fs::system_complete( fs::path( "//share", fs::native ) ).string()
|
||||
BOOST_CHECK( fs::system_complete( fs::path( "//share", fs::native ) ).string()
|
||||
== "//share" );
|
||||
}
|
||||
|
||||
else if ( platform == "POSIX" )
|
||||
{
|
||||
BOOST_TEST( fs::system_complete( "" ).empty() );
|
||||
BOOST_TEST( fs::initial_path().root_path().string() == "/" );
|
||||
BOOST_TEST( fs::system_complete( "/" ).string() == "/" );
|
||||
BOOST_TEST( fs::system_complete( "foo" ).string()
|
||||
BOOST_CHECK( fs::system_complete( "" ).empty() );
|
||||
BOOST_CHECK( fs::initial_path().root_path().string() == "/" );
|
||||
BOOST_CHECK( fs::system_complete( "/" ).string() == "/" );
|
||||
BOOST_CHECK( fs::system_complete( "foo" ).string()
|
||||
== fs::initial_path().string()+"/foo" );
|
||||
BOOST_TEST( fs::system_complete( "/foo" ).string()
|
||||
BOOST_CHECK( fs::system_complete( "/foo" ).string()
|
||||
== fs::initial_path().root_path().string()+"foo" );
|
||||
}
|
||||
|
||||
fs::path ng( " no-way, Jose", fs::native );
|
||||
|
||||
fs::remove_all( dir ); // in case residue from prior failed tests
|
||||
BOOST_TEST( !fs::exists( dir ) );
|
||||
BOOST_CHECK( !fs::exists( dir ) );
|
||||
|
||||
// the bound functions should throw, so throws_fs_error() should return true
|
||||
BOOST_TEST( throws_fs_error( bind( fs::is_directory, ng ), fs::not_found_error ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::file_size, ng ), fs::not_found_error ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::is_directory, dir ) ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::_is_empty, dir ) ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::is_directory, ng ), fs::not_found_error ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::file_size, ng ), fs::not_found_error ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::is_directory, dir ) ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::_is_empty, dir ) ) );
|
||||
|
||||
// test path::exception members
|
||||
try { fs::is_directory( ng ); } // will throw
|
||||
|
||||
catch ( const fs::filesystem_error & ex )
|
||||
{
|
||||
BOOST_TEST( ex.who() == "boost::filesystem::is_directory" );
|
||||
BOOST_TEST( ex.path1().string() == " no-way, Jose" );
|
||||
BOOST_CHECK( ex.who() == "boost::filesystem::is_directory" );
|
||||
BOOST_CHECK( ex.path1().string() == " no-way, Jose" );
|
||||
}
|
||||
|
||||
BOOST_TEST( fs::create_directory( dir ) );
|
||||
BOOST_CHECK( fs::create_directory( dir ) );
|
||||
|
||||
BOOST_TEST( fs::exists( dir ) );
|
||||
BOOST_TEST( fs::_is_empty( dir ) );
|
||||
BOOST_TEST( fs::is_directory( dir ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::file_size, dir ),
|
||||
BOOST_CHECK( fs::exists( dir ) );
|
||||
BOOST_CHECK( fs::_is_empty( dir ) );
|
||||
BOOST_CHECK( fs::is_directory( dir ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::file_size, dir ),
|
||||
fs::is_directory_error ) );
|
||||
BOOST_TEST( !fs::create_directory( dir ) );
|
||||
BOOST_CHECK( !fs::create_directory( dir ) );
|
||||
|
||||
BOOST_TEST( !fs::symbolic_link_exists( dir ) );
|
||||
BOOST_TEST( !fs::symbolic_link_exists( "nosuchfileordirectory" ) );
|
||||
BOOST_CHECK( !fs::symbolic_link_exists( dir ) );
|
||||
BOOST_CHECK( !fs::symbolic_link_exists( "nosuchfileordirectory" ) );
|
||||
|
||||
fs::path d1( dir / "d1" );
|
||||
BOOST_TEST( fs::create_directory( d1 ) );
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( fs::is_directory( d1 ) );
|
||||
BOOST_TEST( fs::_is_empty( d1 ) );
|
||||
BOOST_CHECK( fs::create_directory( d1 ) );
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::is_directory( d1 ) );
|
||||
BOOST_CHECK( fs::_is_empty( d1 ) );
|
||||
|
||||
boost::function_requires< boost::InputIteratorConcept< fs::directory_iterator > >();
|
||||
|
||||
{
|
||||
fs::directory_iterator dir_itr( dir );
|
||||
BOOST_TEST( dir_itr->leaf() == "d1" );
|
||||
BOOST_CHECK( dir_itr->leaf() == "d1" );
|
||||
}
|
||||
|
||||
// create a second directory named d2
|
||||
fs::path d2( dir / "d2" );
|
||||
fs::create_directory(d2 );
|
||||
BOOST_TEST( fs::exists( d2 ) );
|
||||
BOOST_TEST( fs::is_directory( d2 ) );
|
||||
BOOST_CHECK( fs::exists( d2 ) );
|
||||
BOOST_CHECK( fs::is_directory( d2 ) );
|
||||
|
||||
// test the basic operation of directory_iterators, and test that
|
||||
// stepping one iterator doesn't affect a different iterator.
|
||||
{
|
||||
fs::directory_iterator dir_itr( dir );
|
||||
fs::directory_iterator dir_itr2( dir );
|
||||
BOOST_TEST( dir_itr->leaf() == "d1" || dir_itr->leaf() == "d2" );
|
||||
BOOST_TEST( dir_itr2->leaf() == "d1" || dir_itr2->leaf() == "d2" );
|
||||
BOOST_CHECK( dir_itr->leaf() == "d1" || dir_itr->leaf() == "d2" );
|
||||
BOOST_CHECK( dir_itr2->leaf() == "d1" || dir_itr2->leaf() == "d2" );
|
||||
if ( dir_itr->leaf() == "d1" )
|
||||
{
|
||||
BOOST_TEST( (++dir_itr)->leaf() == "d2" );
|
||||
BOOST_TEST( dir_itr2->leaf() == "d1" );
|
||||
BOOST_TEST( (++dir_itr2)->leaf() == "d2" );
|
||||
BOOST_CHECK( (++dir_itr)->leaf() == "d2" );
|
||||
BOOST_CHECK( dir_itr2->leaf() == "d1" );
|
||||
BOOST_CHECK( (++dir_itr2)->leaf() == "d2" );
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_TEST( (dir_itr)->leaf() == "d2" );
|
||||
BOOST_TEST( (++dir_itr)->leaf() == "d1" );
|
||||
BOOST_TEST( dir_itr2->leaf() == "d2" );
|
||||
BOOST_TEST( (++dir_itr2)->leaf() == "d1" );
|
||||
BOOST_CHECK( (dir_itr)->leaf() == "d2" );
|
||||
BOOST_CHECK( (++dir_itr)->leaf() == "d1" );
|
||||
BOOST_CHECK( dir_itr2->leaf() == "d2" );
|
||||
BOOST_CHECK( (++dir_itr2)->leaf() == "d1" );
|
||||
}
|
||||
BOOST_TEST( ++dir_itr == fs::directory_iterator() );
|
||||
BOOST_TEST( dir_itr2 != fs::directory_iterator() );
|
||||
BOOST_TEST( ++dir_itr2 == fs::directory_iterator() );
|
||||
BOOST_CHECK( ++dir_itr == fs::directory_iterator() );
|
||||
BOOST_CHECK( dir_itr2 != fs::directory_iterator() );
|
||||
BOOST_CHECK( ++dir_itr2 == fs::directory_iterator() );
|
||||
}
|
||||
|
||||
{ // *i++ must work to meet the standard's InputIterator requirements
|
||||
fs::directory_iterator dir_itr( dir );
|
||||
BOOST_TEST( dir_itr->leaf() == "d1" || dir_itr->leaf() == "d2" );
|
||||
BOOST_CHECK( dir_itr->leaf() == "d1" || dir_itr->leaf() == "d2" );
|
||||
if ( dir_itr->leaf() == "d1" )
|
||||
{
|
||||
BOOST_TEST( (*dir_itr++).leaf() == "d1" );
|
||||
BOOST_TEST( dir_itr->leaf() == "d2" );
|
||||
BOOST_CHECK( (*dir_itr++).leaf() == "d1" );
|
||||
BOOST_CHECK( dir_itr->leaf() == "d2" );
|
||||
}
|
||||
else
|
||||
{
|
||||
// Check C++98 input iterator requirements
|
||||
BOOST_TEST( (*dir_itr++).leaf() == "d1" );
|
||||
BOOST_CHECK( (*dir_itr++).leaf() == "d1" );
|
||||
// input iterator requirements in the current WP would require this check:
|
||||
// BOOST_TEST( implicit_cast<std::string const&>(*dir_itr++).leaf() == "d1" );
|
||||
// BOOST_CHECK( implicit_cast<std::string const&>(*dir_itr++).leaf() == "d1" );
|
||||
|
||||
BOOST_TEST( dir_itr->leaf() == "d1" );
|
||||
BOOST_CHECK( dir_itr->leaf() == "d1" );
|
||||
}
|
||||
}
|
||||
|
||||
// create an empty file named "f0"
|
||||
fs::path file_ph( dir / "f0");
|
||||
create_file( file_ph, "" );
|
||||
BOOST_TEST( fs::exists( file_ph ) );
|
||||
BOOST_TEST( !fs::is_directory( file_ph ) );
|
||||
BOOST_TEST( fs::_is_empty( file_ph ) );
|
||||
BOOST_TEST( fs::file_size( file_ph ) == 0 );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::create_directory, file_ph ),
|
||||
BOOST_CHECK( fs::exists( file_ph ) );
|
||||
BOOST_CHECK( !fs::is_directory( file_ph ) );
|
||||
BOOST_CHECK( fs::_is_empty( file_ph ) );
|
||||
BOOST_CHECK( fs::file_size( file_ph ) == 0 );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::create_directory, file_ph ),
|
||||
fs::not_directory_error ) );
|
||||
|
||||
// create a file named "f1"
|
||||
@ -279,16 +279,16 @@ int test_main( int argc, char * argv[] )
|
||||
|
||||
// equivalence tests
|
||||
fs::path ng2("does_not_exist2");
|
||||
BOOST_TEST( throws_fs_error( bind( fs::equivalent, ng, ng2 ) ) );
|
||||
BOOST_TEST( fs::equivalent( file_ph, dir / "f1" ) );
|
||||
BOOST_TEST( fs::equivalent( dir, d1 / ".." ) );
|
||||
BOOST_TEST( !fs::equivalent( file_ph, dir ) );
|
||||
BOOST_TEST( !fs::equivalent( dir, file_ph ) );
|
||||
BOOST_TEST( !fs::equivalent( d1, d2 ) );
|
||||
BOOST_TEST( !fs::equivalent( dir, ng ) );
|
||||
BOOST_TEST( !fs::equivalent( ng, dir ) );
|
||||
BOOST_TEST( !fs::equivalent( file_ph, ng ) );
|
||||
BOOST_TEST( !fs::equivalent( ng, file_ph ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::equivalent, ng, ng2 ) ) );
|
||||
BOOST_CHECK( fs::equivalent( file_ph, dir / "f1" ) );
|
||||
BOOST_CHECK( fs::equivalent( dir, d1 / ".." ) );
|
||||
BOOST_CHECK( !fs::equivalent( file_ph, dir ) );
|
||||
BOOST_CHECK( !fs::equivalent( dir, file_ph ) );
|
||||
BOOST_CHECK( !fs::equivalent( d1, d2 ) );
|
||||
BOOST_CHECK( !fs::equivalent( dir, ng ) );
|
||||
BOOST_CHECK( !fs::equivalent( ng, dir ) );
|
||||
BOOST_CHECK( !fs::equivalent( file_ph, ng ) );
|
||||
BOOST_CHECK( !fs::equivalent( ng, file_ph ) );
|
||||
|
||||
std::time_t ft = fs::last_write_time( file_ph );
|
||||
std::cout << "UTC should currently be about " << std::asctime(std::gmtime(&ft)) << "\n";
|
||||
@ -297,11 +297,11 @@ int test_main( int argc, char * argv[] )
|
||||
// hard to test time exactly, but except under the most unusual circumstances,
|
||||
// time since file creation should be no more than one minute, I'm hoping.
|
||||
double time_diff = std::difftime( std::time(0), fs::last_write_time( file_ph ) );
|
||||
BOOST_TEST( time_diff > -60.0 && time_diff < 60.0 );
|
||||
BOOST_CHECK( time_diff > -60.0 && time_diff < 60.0 );
|
||||
|
||||
BOOST_TEST( fs::exists( file_ph ) );
|
||||
BOOST_TEST( !fs::is_directory( file_ph ) );
|
||||
BOOST_TEST( fs::file_size( file_ph ) == 7 );
|
||||
BOOST_CHECK( fs::exists( file_ph ) );
|
||||
BOOST_CHECK( !fs::is_directory( file_ph ) );
|
||||
BOOST_CHECK( fs::file_size( file_ph ) == 7 );
|
||||
verify_file( file_ph, "foobar1" );
|
||||
|
||||
std::tm * tmp = std::localtime( &ft );
|
||||
@ -315,12 +315,12 @@ int test_main( int argc, char * argv[] )
|
||||
std::cout << "Now get time difference" << std::endl;
|
||||
time_diff = std::difftime( std::time(0), fs::last_write_time( file_ph ) );
|
||||
std::cout << "Time difference is : " << time_diff << std::endl;
|
||||
BOOST_TEST( time_diff >= 365*24*3600.0 && time_diff < (366*24*3600.0 + 60.0) );
|
||||
BOOST_CHECK( time_diff >= 365*24*3600.0 && time_diff < (366*24*3600.0 + 60.0) );
|
||||
std::cout << "Reset to current time" << std::endl;
|
||||
fs::last_write_time( file_ph, std::time(0) );
|
||||
std::cout << "And check that" << std::endl;
|
||||
time_diff = std::difftime( std::time(0), fs::last_write_time( file_ph ) );
|
||||
BOOST_TEST( time_diff >= -60.0 && time_diff < 60.0 );
|
||||
BOOST_CHECK( time_diff >= -60.0 && time_diff < 60.0 );
|
||||
ft = fs::last_write_time( file_ph );
|
||||
std::cout << "Local time should currently be about " << std::asctime(std::localtime(&ft)) << "\n";
|
||||
|
||||
@ -329,128 +329,128 @@ int test_main( int argc, char * argv[] )
|
||||
{
|
||||
fs::directory_iterator di;
|
||||
{ di = fs::directory_iterator( dir ); }
|
||||
BOOST_TEST( ++di != fs::directory_iterator() );
|
||||
BOOST_CHECK( ++di != fs::directory_iterator() );
|
||||
}
|
||||
|
||||
// copy_file() tests
|
||||
fs::copy_file( file_ph, d1 / "f2" );
|
||||
BOOST_TEST( fs::exists( file_ph ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( !fs::is_directory( d1 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( file_ph ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( !fs::is_directory( d1 / "f2" ) );
|
||||
verify_file( d1 / "f2", "foobar1" );
|
||||
|
||||
// rename() test case numbers refer to operations.htm#rename table
|
||||
|
||||
// [case 1] make sure can't rename() a non-existent file
|
||||
BOOST_TEST( !fs::exists( d1 / "f99" ) );
|
||||
BOOST_TEST( !fs::exists( d1 / "f98" ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, d1 / "f99", d1 / "f98" ),
|
||||
BOOST_CHECK( !fs::exists( d1 / "f99" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 / "f98" ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, d1 / "f99", d1 / "f98" ),
|
||||
fs::not_found_error ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, fs::path(""), d1 / "f98" ),
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, fs::path(""), d1 / "f98" ),
|
||||
fs::not_found_error ) );
|
||||
|
||||
// [case 2] rename() target.empty()
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, file_ph, "" ),
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, file_ph, "" ),
|
||||
fs::not_found_error ) );
|
||||
|
||||
// [case 3] make sure can't rename() to an existent file or directory
|
||||
BOOST_TEST( fs::exists( dir / "f1" ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, dir / "f1", d1 / "f2" ) ) );
|
||||
BOOST_CHECK( fs::exists( dir / "f1" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, dir / "f1", d1 / "f2" ) ) );
|
||||
// several POSIX implementations (cygwin, openBSD) report ENOENT instead of EEXIST,
|
||||
// so we don't verify error type on the above test.
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, dir, d1 ) ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, dir, d1 ) ) );
|
||||
|
||||
// [case 4A] can't rename() file to a nonexistent parent directory
|
||||
BOOST_TEST( !fs::is_directory( dir / "f1" ) );
|
||||
BOOST_TEST( !fs::exists( dir / "d3/f3" ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, dir / "f1", dir / "d3/f3" ),
|
||||
BOOST_CHECK( !fs::is_directory( dir / "f1" ) );
|
||||
BOOST_CHECK( !fs::exists( dir / "d3/f3" ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, dir / "f1", dir / "d3/f3" ),
|
||||
fs::not_found_error ) );
|
||||
|
||||
// [case 4B] rename() file in same directory
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( !fs::exists( d1 / "f50" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 / "f50" ) );
|
||||
fs::rename( d1 / "f2", d1 / "f50" );
|
||||
BOOST_TEST( !fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f50" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f50" ) );
|
||||
fs::rename( d1 / "f50", d1 / "f2" );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( !fs::exists( d1 / "f50" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 / "f50" ) );
|
||||
|
||||
// [case 4C] rename() file d1/f2 to d2/f3
|
||||
fs::rename( d1 / "f2", d2 / "f3" );
|
||||
BOOST_TEST( !fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( !fs::exists( d2 / "f2" ) );
|
||||
BOOST_TEST( fs::exists( d2 / "f3" ) );
|
||||
BOOST_TEST( !fs::is_directory( d2 / "f3" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d2 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( d2 / "f3" ) );
|
||||
BOOST_CHECK( !fs::is_directory( d2 / "f3" ) );
|
||||
verify_file( d2 / "f3", "foobar1" );
|
||||
fs::rename( d2 / "f3", d1 / "f2" );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
|
||||
// [case 5A] rename() directory to nonexistent parent directory
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( !fs::exists( dir / "d3/d5" ) );
|
||||
BOOST_TEST( !fs::exists( dir / "d3" ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::rename, d1, dir / "d3/d5" ),
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( !fs::exists( dir / "d3/d5" ) );
|
||||
BOOST_CHECK( !fs::exists( dir / "d3" ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::rename, d1, dir / "d3/d5" ),
|
||||
fs::not_found_error ) );
|
||||
|
||||
// [case 5B] rename() on directory
|
||||
fs::path d3( dir / "d3" );
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( !fs::exists( d3 ) );
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d3 ) );
|
||||
fs::rename( d1, d3 );
|
||||
BOOST_TEST( !fs::exists( d1 ) );
|
||||
BOOST_TEST( fs::exists( d3 ) );
|
||||
BOOST_TEST( fs::is_directory( d3 ) );
|
||||
BOOST_TEST( !fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( fs::exists( d3 / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::exists( d3 ) );
|
||||
BOOST_CHECK( fs::is_directory( d3 ) );
|
||||
BOOST_CHECK( !fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( d3 / "f2" ) );
|
||||
fs::rename( d3, d1 );
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_TEST( !fs::exists( d3 ) );
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d3 ) );
|
||||
|
||||
// [case 5C] rename() rename and move d1 to d2 / "d20"
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( !fs::exists( d2 / "d20" ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( !fs::exists( d2 / "d20" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
fs::rename( d1, d2 / "d20" );
|
||||
BOOST_TEST( !fs::exists( d1 ) );
|
||||
BOOST_TEST( fs::exists( d2 / "d20" ) );
|
||||
BOOST_TEST( fs::exists( d2 / "d20" / "f2" ) );
|
||||
BOOST_CHECK( !fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::exists( d2 / "d20" ) );
|
||||
BOOST_CHECK( fs::exists( d2 / "d20" / "f2" ) );
|
||||
fs::rename( d2 / "d20", d1 );
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( !fs::exists( d2 / "d20" ) );
|
||||
BOOST_TEST( fs::exists( d1 / "f2" ) );
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( !fs::exists( d2 / "d20" ) );
|
||||
BOOST_CHECK( fs::exists( d1 / "f2" ) );
|
||||
|
||||
// remove() tests on file
|
||||
file_ph = dir / "shortlife";
|
||||
BOOST_TEST( !fs::exists( file_ph ) );
|
||||
BOOST_CHECK( !fs::exists( file_ph ) );
|
||||
create_file( file_ph, "" );
|
||||
BOOST_TEST( fs::exists( file_ph ) );
|
||||
BOOST_TEST( !fs::is_directory( file_ph ) );
|
||||
BOOST_TEST( fs::remove( file_ph ) );
|
||||
BOOST_TEST( !fs::exists( file_ph ) );
|
||||
BOOST_TEST( !fs::remove( "no-such-file" ) );
|
||||
BOOST_TEST( !fs::remove( "no-such-directory/no-such-file" ) );
|
||||
BOOST_CHECK( fs::exists( file_ph ) );
|
||||
BOOST_CHECK( !fs::is_directory( file_ph ) );
|
||||
BOOST_CHECK( fs::remove( file_ph ) );
|
||||
BOOST_CHECK( !fs::exists( file_ph ) );
|
||||
BOOST_CHECK( !fs::remove( "no-such-file" ) );
|
||||
BOOST_CHECK( !fs::remove( "no-such-directory/no-such-file" ) );
|
||||
|
||||
// remove() test on directory
|
||||
d1 = dir / "shortlife_dir";
|
||||
BOOST_TEST( !fs::exists( d1 ) );
|
||||
BOOST_CHECK( !fs::exists( d1 ) );
|
||||
fs::create_directory( d1 );
|
||||
BOOST_TEST( fs::exists( d1 ) );
|
||||
BOOST_TEST( fs::is_directory( d1 ) );
|
||||
BOOST_TEST( fs::_is_empty( d1 ) );
|
||||
BOOST_TEST( throws_fs_error( bind( fs::remove, dir ), fs::not_empty_error ) );
|
||||
BOOST_TEST( fs::remove( d1 ) );
|
||||
BOOST_TEST( !fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::exists( d1 ) );
|
||||
BOOST_CHECK( fs::is_directory( d1 ) );
|
||||
BOOST_CHECK( fs::_is_empty( d1 ) );
|
||||
BOOST_CHECK( throws_fs_error( bind( fs::remove, dir ), fs::not_empty_error ) );
|
||||
BOOST_CHECK( fs::remove( d1 ) );
|
||||
BOOST_CHECK( !fs::exists( d1 ) );
|
||||
|
||||
// post-test cleanup
|
||||
BOOST_TEST( fs::remove_all( dir ) != 0 );
|
||||
BOOST_CHECK( fs::remove_all( dir ) != 0 );
|
||||
// above was added just to simplify testing, but it ended up detecting
|
||||
// a bug (failure to close an internal search handle).
|
||||
BOOST_TEST( !fs::exists( dir ) );
|
||||
BOOST_TEST( fs::remove_all( dir ) == 0 );
|
||||
BOOST_CHECK( !fs::exists( dir ) );
|
||||
BOOST_CHECK( fs::remove_all( dir ) == 0 );
|
||||
|
||||
return 0;
|
||||
} // main
|
||||
|
||||
@ -74,20 +74,20 @@ int test_main( int, char*[] )
|
||||
# endif
|
||||
std::cout << "Platform is " << platform << '\n';
|
||||
|
||||
BOOST_TEST( path::default_name_check_writable() );
|
||||
BOOST_TEST( path::default_name_check() == fs::portable_name );
|
||||
BOOST_TEST( !path::default_name_check_writable() );
|
||||
BOOST_CHECK( path::default_name_check_writable() );
|
||||
BOOST_CHECK( path::default_name_check() == fs::portable_name );
|
||||
BOOST_CHECK( !path::default_name_check_writable() );
|
||||
bool default_name_check_threw = false;
|
||||
try { path::default_name_check( fs::no_check ); }
|
||||
catch ( const fs::filesystem_error & ) { default_name_check_threw = true; }
|
||||
BOOST_TEST( default_name_check_threw );
|
||||
BOOST_TEST( path::default_name_check() == fs::portable_name );
|
||||
BOOST_CHECK( default_name_check_threw );
|
||||
BOOST_CHECK( path::default_name_check() == fs::portable_name );
|
||||
|
||||
|
||||
path p1( "fe/fi/fo/fum" );
|
||||
path p2( p1 );
|
||||
path p3;
|
||||
BOOST_TEST( p1.string() != p3.string() );
|
||||
BOOST_CHECK( p1.string() != p3.string() );
|
||||
p3 = p2;
|
||||
|
||||
// p1.branch_path() = p2; // should fail
|
||||
@ -100,14 +100,14 @@ int test_main( int, char*[] )
|
||||
fs::exists( "foo" / p1 );
|
||||
fs::exists( std::string( "foo" ) / p1 );
|
||||
|
||||
BOOST_TEST( p1.string() == p2.string() );
|
||||
BOOST_TEST( p1.string() == p3.string() );
|
||||
BOOST_TEST( path( "foo" ).leaf() == "foo" );
|
||||
BOOST_TEST( path( "foo" ).branch_path().string() == "" );
|
||||
BOOST_TEST( p1.leaf() == "fum" );
|
||||
BOOST_TEST( p1.branch_path().string() == "fe/fi/fo" );
|
||||
BOOST_TEST( path( "" ).empty() == true );
|
||||
BOOST_TEST( path( "foo" ).empty() == false );
|
||||
BOOST_CHECK( p1.string() == p2.string() );
|
||||
BOOST_CHECK( p1.string() == p3.string() );
|
||||
BOOST_CHECK( path( "foo" ).leaf() == "foo" );
|
||||
BOOST_CHECK( path( "foo" ).branch_path().string() == "" );
|
||||
BOOST_CHECK( p1.leaf() == "fum" );
|
||||
BOOST_CHECK( p1.branch_path().string() == "fe/fi/fo" );
|
||||
BOOST_CHECK( path( "" ).empty() == true );
|
||||
BOOST_CHECK( path( "foo" ).empty() == false );
|
||||
|
||||
PATH_CHECK( "", "" );
|
||||
|
||||
@ -279,64 +279,64 @@ int test_main( int, char*[] )
|
||||
PATH_CHECK( ".././.", ".." );
|
||||
PATH_CHECK( path("..") / "." / ".", ".." );
|
||||
|
||||
BOOST_TEST( path("foo\\bar", fs::no_check).leaf() == "foo\\bar" );
|
||||
BOOST_CHECK( path("foo\\bar", fs::no_check).leaf() == "foo\\bar" );
|
||||
|
||||
BOOST_TEST( fs::portable_posix_name(".") );
|
||||
BOOST_TEST( fs::portable_posix_name("..") );
|
||||
BOOST_TEST( fs::portable_posix_name("...") );
|
||||
BOOST_TEST( fs::portable_posix_name("....") );
|
||||
BOOST_TEST( fs::portable_posix_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
|
||||
BOOST_TEST( !fs::portable_posix_name("F$O") );
|
||||
BOOST_CHECK( fs::portable_posix_name(".") );
|
||||
BOOST_CHECK( fs::portable_posix_name("..") );
|
||||
BOOST_CHECK( fs::portable_posix_name("...") );
|
||||
BOOST_CHECK( fs::portable_posix_name("....") );
|
||||
BOOST_CHECK( fs::portable_posix_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
|
||||
BOOST_CHECK( !fs::portable_posix_name("F$O") );
|
||||
|
||||
BOOST_TEST( fs::portable_name(".") );
|
||||
BOOST_TEST( fs::portable_name("..") );
|
||||
BOOST_TEST( fs::portable_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
|
||||
BOOST_TEST( !fs::portable_name("A.") );
|
||||
BOOST_TEST( fs::portable_name("A-") );
|
||||
BOOST_TEST( !fs::portable_name(".A") );
|
||||
BOOST_TEST( !fs::portable_name("-A") );
|
||||
BOOST_TEST( !fs::portable_name("F$O") );
|
||||
BOOST_CHECK( fs::portable_name(".") );
|
||||
BOOST_CHECK( fs::portable_name("..") );
|
||||
BOOST_CHECK( fs::portable_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
|
||||
BOOST_CHECK( !fs::portable_name("A.") );
|
||||
BOOST_CHECK( fs::portable_name("A-") );
|
||||
BOOST_CHECK( !fs::portable_name(".A") );
|
||||
BOOST_CHECK( !fs::portable_name("-A") );
|
||||
BOOST_CHECK( !fs::portable_name("F$O") );
|
||||
|
||||
|
||||
BOOST_TEST( fs::portable_file_name(".") );
|
||||
BOOST_TEST( fs::portable_file_name("..") );
|
||||
BOOST_TEST( fs::portable_file_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
|
||||
BOOST_TEST( fs::portable_file_name("0123456789.-_") );
|
||||
BOOST_TEST( fs::portable_file_name("1234567890123456789012345678901") );
|
||||
BOOST_TEST( !fs::portable_file_name("a.") );
|
||||
BOOST_TEST( !fs::portable_file_name("a..b") );
|
||||
BOOST_TEST( !fs::portable_file_name("a.bcde") );
|
||||
BOOST_TEST( !fs::portable_file_name("a..cde") );
|
||||
BOOST_TEST( !fs::portable_file_name("a.c.de") );
|
||||
BOOST_TEST( !fs::portable_file_name("a.cd.e") );
|
||||
BOOST_TEST( fs::portable_file_name("a.b") );
|
||||
BOOST_TEST( fs::portable_file_name("a.bc") );
|
||||
BOOST_TEST( fs::portable_file_name("a.bcd") );
|
||||
BOOST_TEST( !fs::portable_file_name("A.") );
|
||||
BOOST_TEST( fs::portable_file_name("A-") );
|
||||
BOOST_TEST( !fs::portable_file_name(".A") );
|
||||
BOOST_TEST( !fs::portable_file_name("-A") );
|
||||
BOOST_TEST( !fs::portable_file_name("F$O") );
|
||||
BOOST_CHECK( fs::portable_file_name(".") );
|
||||
BOOST_CHECK( fs::portable_file_name("..") );
|
||||
BOOST_CHECK( fs::portable_file_name("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_") );
|
||||
BOOST_CHECK( fs::portable_file_name("0123456789.-_") );
|
||||
BOOST_CHECK( fs::portable_file_name("1234567890123456789012345678901") );
|
||||
BOOST_CHECK( !fs::portable_file_name("a.") );
|
||||
BOOST_CHECK( !fs::portable_file_name("a..b") );
|
||||
BOOST_CHECK( !fs::portable_file_name("a.bcde") );
|
||||
BOOST_CHECK( !fs::portable_file_name("a..cde") );
|
||||
BOOST_CHECK( !fs::portable_file_name("a.c.de") );
|
||||
BOOST_CHECK( !fs::portable_file_name("a.cd.e") );
|
||||
BOOST_CHECK( fs::portable_file_name("a.b") );
|
||||
BOOST_CHECK( fs::portable_file_name("a.bc") );
|
||||
BOOST_CHECK( fs::portable_file_name("a.bcd") );
|
||||
BOOST_CHECK( !fs::portable_file_name("A.") );
|
||||
BOOST_CHECK( fs::portable_file_name("A-") );
|
||||
BOOST_CHECK( !fs::portable_file_name(".A") );
|
||||
BOOST_CHECK( !fs::portable_file_name("-A") );
|
||||
BOOST_CHECK( !fs::portable_file_name("F$O") );
|
||||
|
||||
BOOST_TEST( fs::portable_directory_name(".") );
|
||||
BOOST_TEST( fs::portable_directory_name("..") );
|
||||
BOOST_TEST( fs::portable_directory_name("ABCDEFGHIJKLMNOPQRSTUVWXYZ") );
|
||||
BOOST_TEST( fs::portable_directory_name("abcdefghijklmnopqrstuvwxyz") );
|
||||
BOOST_TEST( fs::portable_directory_name("0123456789-_") );
|
||||
BOOST_TEST( fs::portable_directory_name("1234567890123456789012345678901") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.bcde") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a..cde") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.c.de") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.cd.e") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.b") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.bc") );
|
||||
BOOST_TEST( !fs::portable_directory_name("a.bcd") );
|
||||
BOOST_TEST( !fs::portable_directory_name("A.") );
|
||||
BOOST_TEST( fs::portable_directory_name("A-") );
|
||||
BOOST_TEST( !fs::portable_directory_name(".A") );
|
||||
BOOST_TEST( !fs::portable_directory_name("-A") );
|
||||
BOOST_TEST( !fs::portable_directory_name("F$O") );
|
||||
BOOST_CHECK( fs::portable_directory_name(".") );
|
||||
BOOST_CHECK( fs::portable_directory_name("..") );
|
||||
BOOST_CHECK( fs::portable_directory_name("ABCDEFGHIJKLMNOPQRSTUVWXYZ") );
|
||||
BOOST_CHECK( fs::portable_directory_name("abcdefghijklmnopqrstuvwxyz") );
|
||||
BOOST_CHECK( fs::portable_directory_name("0123456789-_") );
|
||||
BOOST_CHECK( fs::portable_directory_name("1234567890123456789012345678901") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.bcde") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a..cde") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.c.de") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.cd.e") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.b") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.bc") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("a.bcd") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("A.") );
|
||||
BOOST_CHECK( fs::portable_directory_name("A-") );
|
||||
BOOST_CHECK( !fs::portable_directory_name(".A") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("-A") );
|
||||
BOOST_CHECK( !fs::portable_directory_name("F$O") );
|
||||
|
||||
check_throw( "foo//bar" );
|
||||
check_throw( "foo\\bar" );
|
||||
@ -356,203 +356,203 @@ int test_main( int, char*[] )
|
||||
|
||||
path itr_ck( "/foo/bar" );
|
||||
path::iterator itr( itr_ck.begin() );
|
||||
BOOST_TEST( *itr == std::string( "/" ) );
|
||||
BOOST_TEST( *++itr == std::string( "foo" ) );
|
||||
BOOST_TEST( *++itr == std::string( "bar" ) );
|
||||
BOOST_TEST( ++itr == itr_ck.end() );
|
||||
BOOST_TEST( *--itr == std::string( "bar" ) );
|
||||
BOOST_TEST( *--itr == std::string( "foo" ) );
|
||||
BOOST_TEST( *--itr == std::string( "/" ) );
|
||||
BOOST_CHECK( *itr == std::string( "/" ) );
|
||||
BOOST_CHECK( *++itr == std::string( "foo" ) );
|
||||
BOOST_CHECK( *++itr == std::string( "bar" ) );
|
||||
BOOST_CHECK( ++itr == itr_ck.end() );
|
||||
BOOST_CHECK( *--itr == std::string( "bar" ) );
|
||||
BOOST_CHECK( *--itr == std::string( "foo" ) );
|
||||
BOOST_CHECK( *--itr == std::string( "/" ) );
|
||||
|
||||
itr_ck = "";
|
||||
BOOST_TEST( itr_ck.begin() == itr_ck.end() );
|
||||
BOOST_CHECK( itr_ck.begin() == itr_ck.end() );
|
||||
|
||||
itr_ck = path( "/" );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "/" ) );
|
||||
BOOST_TEST( next(itr_ck.begin()) == itr_ck.end() );
|
||||
BOOST_TEST( *prior(itr_ck.end()) == std::string( "/" ) );
|
||||
BOOST_TEST( prior(itr_ck.end()) == itr_ck.begin() );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "/" ) );
|
||||
BOOST_CHECK( next(itr_ck.begin()) == itr_ck.end() );
|
||||
BOOST_CHECK( *prior(itr_ck.end()) == std::string( "/" ) );
|
||||
BOOST_CHECK( prior(itr_ck.end()) == itr_ck.begin() );
|
||||
|
||||
itr_ck = path( "/foo" );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "/" ) );
|
||||
BOOST_TEST( *next( itr_ck.begin() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( next(next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_TEST( next( itr_ck.begin() ) == prior( itr_ck.end() ) );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( *prior(prior( itr_ck.end() )) == std::string( "/" ) );
|
||||
BOOST_TEST( prior(prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "/" ) );
|
||||
BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( next(next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_CHECK( next( itr_ck.begin() ) == prior( itr_ck.end() ) );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "/" ) );
|
||||
BOOST_CHECK( prior(prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
|
||||
itr_ck = "foo";
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "foo" ) );
|
||||
BOOST_TEST( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "foo" ) );
|
||||
BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
|
||||
path p;
|
||||
|
||||
p = "";
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "" );
|
||||
BOOST_TEST( !p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( !p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "" );
|
||||
BOOST_CHECK( !p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( !p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "/";
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "/" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "/" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
if ( platform == "POSIX" )
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
else
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = ".";
|
||||
BOOST_TEST( p.relative_path().string() == "." );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "." );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "" );
|
||||
BOOST_TEST( !p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "." );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "." );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "" );
|
||||
BOOST_CHECK( !p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "..";
|
||||
BOOST_TEST( p.relative_path().string() == ".." );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == ".." );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "" );
|
||||
BOOST_TEST( !p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == ".." );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == ".." );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "" );
|
||||
BOOST_CHECK( !p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "foo";
|
||||
BOOST_TEST( p.relative_path().string() == "foo" );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "foo" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "" );
|
||||
BOOST_TEST( !p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo" );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "foo" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "" );
|
||||
BOOST_CHECK( !p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "/foo";
|
||||
BOOST_TEST( p.relative_path().string() == "foo" );
|
||||
BOOST_TEST( p.branch_path().string() == "/" );
|
||||
BOOST_TEST( p.leaf() == "foo" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo" );
|
||||
BOOST_CHECK( p.branch_path().string() == "/" );
|
||||
BOOST_CHECK( p.leaf() == "foo" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
if ( platform == "POSIX" )
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
else
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "foo/bar";
|
||||
BOOST_TEST( p.relative_path().string() == "foo/bar" );
|
||||
BOOST_TEST( p.branch_path().string() == "foo" );
|
||||
BOOST_TEST( p.leaf() == "bar" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "" );
|
||||
BOOST_TEST( !p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo/bar" );
|
||||
BOOST_CHECK( p.branch_path().string() == "foo" );
|
||||
BOOST_CHECK( p.leaf() == "bar" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "" );
|
||||
BOOST_CHECK( !p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "../foo";
|
||||
BOOST_TEST( p.relative_path().string() == "../foo" );
|
||||
BOOST_TEST( p.branch_path().string() == ".." );
|
||||
BOOST_TEST( p.leaf() == "foo" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "" );
|
||||
BOOST_TEST( !p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "../foo" );
|
||||
BOOST_CHECK( p.branch_path().string() == ".." );
|
||||
BOOST_CHECK( p.leaf() == "foo" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "" );
|
||||
BOOST_CHECK( !p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = "/foo/bar";
|
||||
BOOST_TEST( p.relative_path().string() == "foo/bar" );
|
||||
BOOST_TEST( p.branch_path().string() == "/foo" );
|
||||
BOOST_TEST( p.leaf() == "bar" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo/bar" );
|
||||
BOOST_CHECK( p.branch_path().string() == "/foo" );
|
||||
BOOST_CHECK( p.leaf() == "bar" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
if ( platform == "POSIX" )
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
else
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
// decomposition and query functions must work even for paths which
|
||||
// do not pass the default name_check
|
||||
p = path( "/</>", fs::no_check );
|
||||
BOOST_TEST( p.relative_path().string() == "</>" );
|
||||
BOOST_TEST( p.branch_path().string() == "/<" );
|
||||
BOOST_TEST( p.leaf() == ">" );
|
||||
BOOST_TEST( p.root_name() == "" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( !p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_CHECK( p.relative_path().string() == "</>" );
|
||||
BOOST_CHECK( p.branch_path().string() == "/<" );
|
||||
BOOST_CHECK( p.leaf() == ">" );
|
||||
BOOST_CHECK( p.root_name() == "" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( !p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
if ( platform == "POSIX" )
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
else
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
if ( platform == "Windows" )
|
||||
{
|
||||
@ -602,210 +602,210 @@ int test_main( int, char*[] )
|
||||
PATH_CHECK( path( "prn:", fs::native ), "prn:" );
|
||||
|
||||
p = path( "c:", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "c:" );
|
||||
BOOST_TEST( p.root_name() == "c:" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "c:" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "c:" );
|
||||
BOOST_CHECK( p.root_name() == "c:" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "c:" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = path( "c:foo", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "foo" );
|
||||
BOOST_TEST( p.branch_path().string() == "c:" );
|
||||
BOOST_TEST( p.leaf() == "foo" );
|
||||
BOOST_TEST( p.root_name() == "c:" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "c:" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo" );
|
||||
BOOST_CHECK( p.branch_path().string() == "c:" );
|
||||
BOOST_CHECK( p.leaf() == "foo" );
|
||||
BOOST_CHECK( p.root_name() == "c:" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "c:" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = path( "c:/", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "c:" );
|
||||
BOOST_TEST( p.leaf() == "/" );
|
||||
BOOST_TEST( p.root_name() == "c:" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "c:/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "c:" );
|
||||
BOOST_CHECK( p.leaf() == "/" );
|
||||
BOOST_CHECK( p.root_name() == "c:" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "c:/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
|
||||
p = path( "c:..", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == ".." );
|
||||
BOOST_TEST( p.branch_path().string() == "c:" );
|
||||
BOOST_TEST( p.leaf() == ".." );
|
||||
BOOST_TEST( p.root_name() == "c:" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "c:" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == ".." );
|
||||
BOOST_CHECK( p.branch_path().string() == "c:" );
|
||||
BOOST_CHECK( p.leaf() == ".." );
|
||||
BOOST_CHECK( p.root_name() == "c:" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "c:" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
|
||||
p = path( "c:/foo", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "foo" );
|
||||
BOOST_TEST( p.branch_path().string() == "c:/" );
|
||||
BOOST_TEST( p.leaf() == "foo" );
|
||||
BOOST_TEST( p.root_name() == "c:" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "c:/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo" );
|
||||
BOOST_CHECK( p.branch_path().string() == "c:/" );
|
||||
BOOST_CHECK( p.leaf() == "foo" );
|
||||
BOOST_CHECK( p.root_name() == "c:" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "c:/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
|
||||
/* Commented out until the semantics of //share are clearer.
|
||||
|
||||
p = path( "//share", fs::native );
|
||||
BOOST_TEST( p.string() == "//share" );
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "//share" );
|
||||
BOOST_TEST( p.root_name() == "//share" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "//share/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( !p.is_complete() );
|
||||
BOOST_CHECK( p.string() == "//share" );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "//share" );
|
||||
BOOST_CHECK( p.root_name() == "//share" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "//share/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( !p.is_complete() );
|
||||
*/
|
||||
p = path( "//share/", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "//share" );
|
||||
BOOST_TEST( p.leaf() == "/" );
|
||||
BOOST_TEST( p.root_name() == "//share" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "//share/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "//share" );
|
||||
BOOST_CHECK( p.leaf() == "/" );
|
||||
BOOST_CHECK( p.root_name() == "//share" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "//share/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
|
||||
p = path( "//share/foo", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "foo" );
|
||||
BOOST_TEST( p.branch_path().string() == "//share/" );
|
||||
BOOST_TEST( p.leaf() == "foo" );
|
||||
BOOST_TEST( p.root_name() == "//share" );
|
||||
BOOST_TEST( p.root_directory() == "/" );
|
||||
BOOST_TEST( p.root_path().string() == "//share/" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( p.has_root_directory() );
|
||||
BOOST_TEST( p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( p.has_branch_path() );
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "foo" );
|
||||
BOOST_CHECK( p.branch_path().string() == "//share/" );
|
||||
BOOST_CHECK( p.leaf() == "foo" );
|
||||
BOOST_CHECK( p.root_name() == "//share" );
|
||||
BOOST_CHECK( p.root_directory() == "/" );
|
||||
BOOST_CHECK( p.root_path().string() == "//share/" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( p.has_root_directory() );
|
||||
BOOST_CHECK( p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( p.has_branch_path() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
|
||||
p = path( "prn:", fs::native );
|
||||
BOOST_TEST( p.relative_path().string() == "" );
|
||||
BOOST_TEST( p.branch_path().string() == "" );
|
||||
BOOST_TEST( p.leaf() == "prn:" );
|
||||
BOOST_TEST( p.root_name() == "prn:" );
|
||||
BOOST_TEST( p.root_directory() == "" );
|
||||
BOOST_TEST( p.root_path().string() == "prn:" );
|
||||
BOOST_TEST( p.has_root_path() );
|
||||
BOOST_TEST( p.has_root_name() );
|
||||
BOOST_TEST( !p.has_root_directory() );
|
||||
BOOST_TEST( !p.has_relative_path() );
|
||||
BOOST_TEST( p.has_leaf() );
|
||||
BOOST_TEST( !p.has_branch_path() );
|
||||
BOOST_TEST( p.is_complete() );
|
||||
BOOST_CHECK( p.relative_path().string() == "" );
|
||||
BOOST_CHECK( p.branch_path().string() == "" );
|
||||
BOOST_CHECK( p.leaf() == "prn:" );
|
||||
BOOST_CHECK( p.root_name() == "prn:" );
|
||||
BOOST_CHECK( p.root_directory() == "" );
|
||||
BOOST_CHECK( p.root_path().string() == "prn:" );
|
||||
BOOST_CHECK( p.has_root_path() );
|
||||
BOOST_CHECK( p.has_root_name() );
|
||||
BOOST_CHECK( !p.has_root_directory() );
|
||||
BOOST_CHECK( !p.has_relative_path() );
|
||||
BOOST_CHECK( p.has_leaf() );
|
||||
BOOST_CHECK( !p.has_branch_path() );
|
||||
BOOST_CHECK( p.is_complete() );
|
||||
|
||||
itr_ck = path( "c:", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_TEST( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_TEST( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "c:" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "c:" ) );
|
||||
|
||||
itr_ck = path( "c:/", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_TEST( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_TEST( next( next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_TEST( prior( prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "/" ) );
|
||||
BOOST_TEST( *prior( prior( itr_ck.end() )) == std::string( "c:" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_CHECK( next( next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_CHECK( prior( prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "/" ) );
|
||||
BOOST_CHECK( *prior( prior( itr_ck.end() )) == std::string( "c:" ) );
|
||||
|
||||
itr_ck = path( "c:foo", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_TEST( *next( itr_ck.begin() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( next(next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_TEST( prior(prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( *prior(prior( itr_ck.end() )) == std::string( "c:" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( next(next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_CHECK( prior(prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "c:" ) );
|
||||
|
||||
itr_ck = path( "c:/foo", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_TEST( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_TEST( *next( next( itr_ck.begin() )) == std::string( "foo" ) );
|
||||
BOOST_TEST( next( next( next( itr_ck.begin() ))) == itr_ck.end() );
|
||||
BOOST_TEST( prior( prior( prior( itr_ck.end() ))) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( *prior( prior( itr_ck.end() )) == std::string( "/" ) );
|
||||
BOOST_TEST( *prior( prior( prior( itr_ck.end() ))) == std::string( "c:" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "c:" ) );
|
||||
BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_CHECK( *next( next( itr_ck.begin() )) == std::string( "foo" ) );
|
||||
BOOST_CHECK( next( next( next( itr_ck.begin() ))) == itr_ck.end() );
|
||||
BOOST_CHECK( prior( prior( prior( itr_ck.end() ))) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( *prior( prior( itr_ck.end() )) == std::string( "/" ) );
|
||||
BOOST_CHECK( *prior( prior( prior( itr_ck.end() ))) == std::string( "c:" ) );
|
||||
|
||||
itr_ck = path( "//share", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "//share" ) );
|
||||
BOOST_TEST( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_TEST( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "//share" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "//share" ) );
|
||||
BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "//share" ) );
|
||||
|
||||
itr_ck = path( "//share/", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "//share" ) );
|
||||
BOOST_TEST( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_TEST( next(next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_TEST( prior(prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "/" ) );
|
||||
BOOST_TEST( *prior(prior( itr_ck.end() )) == std::string( "//share" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "//share" ) );
|
||||
BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_CHECK( next(next( itr_ck.begin() )) == itr_ck.end() );
|
||||
BOOST_CHECK( prior(prior( itr_ck.end() )) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "/" ) );
|
||||
BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "//share" ) );
|
||||
|
||||
itr_ck = path( "//share/foo", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "//share" ) );
|
||||
BOOST_TEST( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_TEST( *next(next( itr_ck.begin() )) == std::string( "foo" ) );
|
||||
BOOST_TEST( next(next(next( itr_ck.begin() ))) == itr_ck.end() );
|
||||
BOOST_TEST( prior(prior(prior( itr_ck.end() ))) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_TEST( *prior(prior( itr_ck.end() )) == std::string( "/" ) );
|
||||
BOOST_TEST( *prior(prior(prior( itr_ck.end() ))) == std::string( "//share" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "//share" ) );
|
||||
BOOST_CHECK( *next( itr_ck.begin() ) == std::string( "/" ) );
|
||||
BOOST_CHECK( *next(next( itr_ck.begin() )) == std::string( "foo" ) );
|
||||
BOOST_CHECK( next(next(next( itr_ck.begin() ))) == itr_ck.end() );
|
||||
BOOST_CHECK( prior(prior(prior( itr_ck.end() ))) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "foo" ) );
|
||||
BOOST_CHECK( *prior(prior( itr_ck.end() )) == std::string( "/" ) );
|
||||
BOOST_CHECK( *prior(prior(prior( itr_ck.end() ))) == std::string( "//share" ) );
|
||||
|
||||
itr_ck = path( "prn:", fs::native );
|
||||
BOOST_TEST( *itr_ck.begin() == std::string( "prn:" ) );
|
||||
BOOST_TEST( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_TEST( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_TEST( *prior( itr_ck.end() ) == std::string( "prn:" ) );
|
||||
BOOST_CHECK( *itr_ck.begin() == std::string( "prn:" ) );
|
||||
BOOST_CHECK( next( itr_ck.begin() ) == itr_ck.end() );
|
||||
BOOST_CHECK( prior( itr_ck.end() ) == itr_ck.begin() );
|
||||
BOOST_CHECK( *prior( itr_ck.end() ) == std::string( "prn:" ) );
|
||||
} // Windows
|
||||
|
||||
else
|
||||
{ // POSIX
|
||||
p = path( "/usr/local/bin:/usr/bin:/bin", fs::no_check );
|
||||
BOOST_TEST( p.native_file_string() == "/usr/local/bin:/usr/bin:/bin" );
|
||||
BOOST_CHECK( p.native_file_string() == "/usr/local/bin:/usr/bin:/bin" );
|
||||
} // POSIX
|
||||
|
||||
// test relational operators
|
||||
@ -816,23 +816,23 @@ int test_main( int, char*[] )
|
||||
path b( "b" );
|
||||
|
||||
// probe operator <
|
||||
BOOST_TEST( !(e < e2) );
|
||||
BOOST_TEST( e < a );
|
||||
BOOST_TEST( a < b );
|
||||
BOOST_TEST( !(a < a2) );
|
||||
BOOST_CHECK( !(e < e2) );
|
||||
BOOST_CHECK( e < a );
|
||||
BOOST_CHECK( a < b );
|
||||
BOOST_CHECK( !(a < a2) );
|
||||
|
||||
// reality check character set is as expected
|
||||
BOOST_TEST( std::string("a.b") < std::string("a/b") );
|
||||
BOOST_CHECK( std::string("a.b") < std::string("a/b") );
|
||||
// verify compare is actually lexicographical
|
||||
BOOST_TEST( path("a/b") < path("a.b") );
|
||||
BOOST_CHECK( path("a/b") < path("a.b") );
|
||||
|
||||
// make sure the derivative operators also work
|
||||
BOOST_TEST( a == a2 );
|
||||
BOOST_TEST( a != b );
|
||||
BOOST_TEST( a <= b );
|
||||
BOOST_TEST( a <= a2 );
|
||||
BOOST_TEST( b >= a );
|
||||
BOOST_TEST( a2 >= a );
|
||||
BOOST_CHECK( a == a2 );
|
||||
BOOST_CHECK( a != b );
|
||||
BOOST_CHECK( a <= b );
|
||||
BOOST_CHECK( a <= a2 );
|
||||
BOOST_CHECK( b >= a );
|
||||
BOOST_CHECK( a2 >= a );
|
||||
|
||||
// std::cout << errors << " errors detected\n";
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user