mirror of
https://github.com/boostorg/filesystem.git
synced 2026-01-30 20:02:10 +00:00
242 lines
7.4 KiB
C++
242 lines
7.4 KiB
C++
// Boost operations_test.cpp -----------------------------------------------//
|
|
|
|
// (C) Copyright Beman Dawes 2002. Permission to copy,
|
|
// use, modify, sell and distribute this software is granted provided this
|
|
// copyright notice appears in all copies. This software is provided "as is"
|
|
// without express or implied warranty, and with no claim as to its
|
|
// suitability for any purpose.
|
|
|
|
// See http://www.boost.org for most recent version including documentation.
|
|
|
|
#include <boost/filesystem/operations.hpp>
|
|
#include <boost/filesystem/exception.hpp>
|
|
namespace fs = boost::filesystem;
|
|
|
|
#include <boost/test/minimal.hpp>
|
|
#include <boost/concept_check.hpp>
|
|
#include <boost/bind.hpp>
|
|
using boost::bind;
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <cstring>
|
|
|
|
namespace
|
|
{
|
|
fs::directory_iterator end_itr;
|
|
|
|
void create_file( const fs::path & ph, const std::string & contents )
|
|
{
|
|
std::ofstream f( ph.system_specific_file_string().c_str() );
|
|
if ( !f )
|
|
throw fs::filesystem_error( "ofstream(): " + ph.string() );
|
|
if ( !contents.empty() ) f << contents;
|
|
}
|
|
|
|
void verify_file( const fs::path & ph, const std::string & expected )
|
|
{
|
|
std::ifstream f( ph.system_specific_file_string().c_str() );
|
|
if ( !f )
|
|
throw fs::filesystem_error( "ifstream(): " + ph.string() );
|
|
std::string contents;
|
|
f >> contents;
|
|
if ( contents != expected )
|
|
throw fs::filesystem_error("verify_file(): " + ph.string()
|
|
+ " contents \"" + contents
|
|
+ "\" != \"" + expected + "\"" );
|
|
}
|
|
|
|
template< typename F >
|
|
bool throws_fs_error( F func )
|
|
{
|
|
try { func(); }
|
|
|
|
catch ( const fs::filesystem_error & /*ex*/ )
|
|
{
|
|
// std::cout << ex.what() << "\n";
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
} // unnamed namespace
|
|
|
|
// test_main ---------------------------------------------------------------//
|
|
|
|
int test_main( int, char * [] )
|
|
{
|
|
std::cout << "implemenation name: "
|
|
<< fs::detail::implementation_name() << "\n";
|
|
std::cout << "initial_path().string() is\n \""
|
|
<< fs::initial_path().string()
|
|
<< "\"\n";
|
|
std::cout << "initial_path().system_specific_file_string() is\n \""
|
|
<< fs::initial_path().system_specific_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() );
|
|
|
|
fs::path dir( fs::initial_path() / "temp_fs_test_directory" );
|
|
|
|
if ( std::strcmp( fs::detail::implementation_name(), "Windows" ) == 0 )
|
|
{
|
|
BOOST_TEST( dir.string().size() > 1
|
|
&& dir.string()[1] == ':' ); // verify path includes drive
|
|
}
|
|
|
|
fs::path ng( " no-way, Jose ", fs::system_specific );
|
|
|
|
fs::remove_all( dir ); // in case residue from prior failed tests
|
|
BOOST_TEST( !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 ) ) );
|
|
BOOST_TEST( throws_fs_error( bind( fs::is_directory, dir ) ) );
|
|
BOOST_TEST( throws_fs_error( bind( fs::_is_empty, dir ) ) );
|
|
|
|
fs::create_directory( dir );
|
|
|
|
BOOST_TEST( fs::exists( dir ) );
|
|
BOOST_TEST( fs::_is_empty( dir ) );
|
|
|
|
BOOST_TEST( fs::is_directory( dir ) );
|
|
|
|
fs::path d1( dir / "d1" );
|
|
fs::create_directory( d1 );
|
|
BOOST_TEST( fs::exists( d1 ) );
|
|
BOOST_TEST( fs::is_directory( d1 ) );
|
|
BOOST_TEST( fs::_is_empty( d1 ) );
|
|
|
|
boost::function_requires< boost::InputIteratorConcept< fs::directory_iterator > >();
|
|
boost::function_requires< boost::ForwardIteratorConcept< fs::directory_iterator > >();
|
|
|
|
{
|
|
fs::directory_iterator dir_itr( dir );
|
|
BOOST_TEST( 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 ) );
|
|
|
|
{
|
|
fs::directory_iterator dir_itr( dir );
|
|
BOOST_TEST( dir_itr->leaf() == "d1" || dir_itr->leaf() == "d2" );
|
|
if ( dir_itr->leaf() == "d1" )
|
|
{
|
|
BOOST_TEST( (++dir_itr)->leaf() == "d2" );
|
|
}
|
|
else
|
|
{
|
|
BOOST_TEST( (++dir_itr)->leaf() == "d1" );
|
|
}
|
|
}
|
|
|
|
{ // *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" );
|
|
if ( dir_itr->leaf() == "d1" )
|
|
{
|
|
BOOST_TEST( (*dir_itr++).leaf() == "d1" );
|
|
BOOST_TEST( dir_itr->leaf() == "d2" );
|
|
}
|
|
else
|
|
{
|
|
BOOST_TEST( (*dir_itr++).leaf() == "d2" );
|
|
BOOST_TEST( 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 ) );
|
|
|
|
// create a file named "f1"
|
|
file_ph = dir / "f1";
|
|
create_file( file_ph, "foobar1" );
|
|
BOOST_TEST( fs::exists( file_ph ) );
|
|
BOOST_TEST( !fs::is_directory( file_ph ) );
|
|
verify_file( file_ph, "foobar1" );
|
|
|
|
// there was an inital bug in directory_iterator that caused premature
|
|
// close of an OS handle. This block will detect regression.
|
|
{
|
|
fs::directory_iterator di;
|
|
{ di = fs::directory_iterator( dir ); }
|
|
BOOST_TEST( ++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" ) );
|
|
verify_file( d1 / "f2", "foobar1" );
|
|
|
|
// rename() on 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" ) );
|
|
verify_file( d2 / "f3", "foobar1" );
|
|
|
|
// make sure can't rename() a non-existent file
|
|
BOOST_TEST( throws_fs_error( bind( fs::rename, d1 / "f2", d2 / "f4" ) ) );
|
|
|
|
// make sure can't rename() to an existent file
|
|
BOOST_TEST( throws_fs_error( bind( fs::rename, dir / "f1", d2 / "f3" ) ) );
|
|
|
|
// make sure can't rename() to a nonexistent parent directory
|
|
BOOST_TEST( throws_fs_error( bind( fs::rename, dir / "f1", dir / "d3/f3" ) ) );
|
|
|
|
// rename() on directory
|
|
fs::path d3( dir / "d3" );
|
|
fs::rename( d2, d3 );
|
|
BOOST_TEST( !fs::exists( d2 ) );
|
|
BOOST_TEST( fs::exists( d3 ) );
|
|
BOOST_TEST( fs::is_directory( d3 ) );
|
|
BOOST_TEST( !fs::exists( d2 / "f3" ) );
|
|
BOOST_TEST( fs::exists( d3 / "f3" ) );
|
|
|
|
// remove() tests on file
|
|
file_ph = dir / "shortlife";
|
|
BOOST_TEST( !fs::exists( file_ph ) );
|
|
create_file( file_ph, "" );
|
|
BOOST_TEST( fs::exists( file_ph ) );
|
|
BOOST_TEST( !fs::is_directory( file_ph ) );
|
|
fs::remove( file_ph );
|
|
BOOST_TEST( !fs::exists( file_ph ) );
|
|
fs::remove( "no-such-file" ); // should be harmless
|
|
fs::remove( "no-such-directory/no-such-file" ); // ditto
|
|
|
|
// remove test on directory
|
|
d1 = dir / "shortlife_dir";
|
|
BOOST_TEST( !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::remove( d1 );
|
|
BOOST_TEST( !fs::exists( d1 ) );
|
|
|
|
// post-test cleanup
|
|
BOOST_TEST( 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 );
|
|
|
|
return 0;
|
|
} // main
|
|
|