operations_test.cpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

  verify_file( file_ph, "foobar1" );

  // equivalence tests
  BOOST_CHECK( CHECK_EXCEPTION( bad_equivalent, ENOENT ) );
  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 ) );
  
  // hard link tests
  fs::path from_ph( dir / "f3" );
  BOOST_CHECK( !fs::exists( from_ph ) );
  BOOST_CHECK( fs::exists( file_ph ) );
  bool create_hard_link_ok(true);
  try { fs::create_hard_link( file_ph, from_ph ); }
  catch ( const fs::filesystem_error & ex )
  {
    create_hard_link_ok = false;
    std::cout
      << "create_hard_link() attempt failed\n"
      << "filesystem_error.what() reports: " << ex.what() << '\n'
      << "create_hard_link() may not be supported on this file system\n";
  }

  if ( create_hard_link_ok )
  {
    std::cout << "create_hard_link() succeeded\n";
    BOOST_CHECK( fs::exists( from_ph ) );
    BOOST_CHECK( fs::exists( file_ph ) );
    BOOST_CHECK( fs::equivalent( from_ph, file_ph ) );
  }

  error_code ec;
  BOOST_CHECK( fs::create_hard_link( fs::path("doesnotexist"),
    fs::path("shouldnotwork"), ec ) );
  BOOST_CHECK( ec );

  // symbolic link tests
  from_ph = dir / "f4";
  BOOST_CHECK( !fs::exists( from_ph ) );
  BOOST_CHECK( fs::exists( file_ph ) );
  bool create_symlink_ok(true);
  try { fs::create_symlink( file_ph, from_ph ); }
  catch ( const fs::filesystem_error & ex )
  {
    create_symlink_ok = false;
    std::cout
      << "create_symlink() attempt failed\n"
      << "filesystem_error.what() reports: " << ex.what() << '\n'
      << "create_symlink() may not be supported on this file system\n";
  }

  if ( create_symlink_ok )
  {
    std::cout << "create_symlink() succeeded\n";
    BOOST_CHECK( fs::exists( from_ph ) );
    BOOST_CHECK( fs::is_symlink( from_ph ) );
    BOOST_CHECK( fs::exists( file_ph ) );
    BOOST_CHECK( fs::equivalent( from_ph, file_ph ) );
    stat = fs::symlink_status( from_ph );
    BOOST_CHECK( fs::exists( stat ) );
    BOOST_CHECK( !fs::is_directory( stat ) );
    BOOST_CHECK( !fs::is_regular_file( stat ) );
    BOOST_CHECK( !fs::is_other( stat ) );
    BOOST_CHECK( fs::is_symlink( stat ) );
  }

  ec = error_code();
  BOOST_CHECK( fs::create_symlink( "doesnotexist", "", ec ) );
  BOOST_CHECK( ec );

  // 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_CHECK( ++di != fs::directory_iterator() );
  }

  // copy_file() tests
  std::cout << "begin copy_file test..." << std::endl;
  fs::copy_file( file_ph, d1 / "f2" );
  std::cout << "copying complete" << std::endl;
  BOOST_CHECK( fs::exists( file_ph ) );
  BOOST_CHECK( fs::exists( d1 / "f2" ) );
  BOOST_CHECK( !fs::is_directory( d1 / "f2" ) );
  verify_file( d1 / "f2", "foobar1" );
  std::cout << "copy_file test complete" << std::endl;

  // rename() test case numbers refer to operations.htm#rename table

  // [case 1] make sure can't rename() a non-existent file
  BOOST_CHECK( !fs::exists( d1 / "f99" ) );
  BOOST_CHECK( !fs::exists( d1 / "f98" ) );
  renamer n1a( d1 / "f99", d1 / "f98" );
  BOOST_CHECK( CHECK_EXCEPTION( n1a, ENOENT ) );
  renamer n1b( fs::path(""), d1 / "f98" );
  BOOST_CHECK( CHECK_EXCEPTION( n1b, ENOENT ) );

  // [case 2] rename() target.empty()
  renamer n2( file_ph, "" );
  BOOST_CHECK( CHECK_EXCEPTION( n2, ENOENT ) );

  // [case 3] make sure can't rename() to an existent file or directory
  BOOST_CHECK( fs::exists( dir / "f1" ) );
  BOOST_CHECK( fs::exists( d1 / "f2" ) );
  renamer n3a( dir / "f1", d1 / "f2" );
  BOOST_CHECK( CHECK_EXCEPTION( n3a, EEXIST ) );
  // several POSIX implementations (cygwin, openBSD) report ENOENT instead of EEXIST,
  // so we don't verify error type on the above test.
  renamer n3b( dir, d1 );
  BOOST_CHECK( CHECK_EXCEPTION( n3b, 0 ) );

  // [case 4A] can't rename() file to a nonexistent parent directory
  BOOST_CHECK( !fs::is_directory( dir / "f1" ) );
  BOOST_CHECK( !fs::exists( dir / "d3/f3" ) );
  renamer n4a( dir / "f1", dir / "d3/f3" );
  BOOST_CHECK( CHECK_EXCEPTION( n4a, ENOENT ) );

  // [case 4B] rename() file in same directory
  BOOST_CHECK( fs::exists( d1 / "f2" ) );
  BOOST_CHECK( !fs::exists( d1 / "f50" ) );
  fs::rename( d1 / "f2", d1 / "f50" );
  BOOST_CHECK( !fs::exists( d1 / "f2" ) );
  BOOST_CHECK( fs::exists( d1 / "f50" ) );
  fs::rename( d1 / "f50", d1 / "f2" );
  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_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_CHECK( fs::exists( d1 / "f2" ) );

  // [case 5A] rename() directory to nonexistent parent directory
  BOOST_CHECK( fs::exists( d1 ) );
  BOOST_CHECK( !fs::exists( dir / "d3/d5" ) );
  BOOST_CHECK( !fs::exists( dir / "d3" ) );
  renamer n5a( d1, dir / "d3/d5" );
  BOOST_CHECK( CHECK_EXCEPTION( n5a, ENOENT ) );

  // [case 5B] rename() on directory
  fs::path d3( dir / "d3" );
  BOOST_CHECK( fs::exists( d1 ) );
  BOOST_CHECK( fs::exists( d1 / "f2" ) );
  BOOST_CHECK( !fs::exists( d3 ) );
  fs::rename( d1, d3 );
  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_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_CHECK( fs::exists( d1 ) );
  BOOST_CHECK( !fs::exists( d2 / "d20" ) );
  BOOST_CHECK( fs::exists( d1 / "f2" ) );
  fs::rename( d1, d2 / "d20" );
  BOOST_CHECK( !fs::exists( d1 ) );
  BOOST_CHECK( fs::exists( d2 / "d20" ) );
  BOOST_CHECK( fs::exists( d2 / "d20" / "f2" ) );
  fs::rename( d2 / "d20", d1 );
  BOOST_CHECK( fs::exists( d1 ) );
  BOOST_CHECK( !fs::exists( d2 / "d20" ) );
  BOOST_CHECK( fs::exists( d1 / "f2" ) );

  // remove() file
  file_ph = dir / "shortlife";
  BOOST_CHECK( !fs::exists( file_ph ) );
  create_file( file_ph, "" );
  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() directory
  d1 = dir / "shortlife_dir";
  BOOST_CHECK( !fs::exists( d1 ) );
  fs::create_directory( d1 );
  BOOST_CHECK( fs::exists( d1 ) );
  BOOST_CHECK( fs::is_directory( d1 ) );
  BOOST_CHECK( BOOST_FS_IS_EMPTY( d1 ) );
  bad_remove_dir = dir;
  BOOST_CHECK( CHECK_EXCEPTION( bad_remove, ENOTEMPTY ) );
  BOOST_CHECK( fs::remove( d1 ) );
  BOOST_CHECK( !fs::exists( d1 ) );

  if ( create_symlink_ok )  // only if symlinks supported
  {
    // remove() dangling symbolic link
    fs::path link( "dangling_link" );
    fs::remove( link );  // remove any residue from past tests
    BOOST_CHECK( !fs::is_symlink( link ) );
    BOOST_CHECK( !fs::exists( link ) );
    fs::create_symlink( "nowhere", link );
    BOOST_CHECK( !fs::exists( link ) );
    BOOST_CHECK( fs::is_symlink( link ) );
    BOOST_CHECK( fs::remove( link ) );
    BOOST_CHECK( !fs::is_symlink( link ) );

    // remove() self-refering symbolic link
    link = "link_to_self";
    fs::remove( link );  // remove any residue from past tests
    BOOST_CHECK( !fs::is_symlink( link ) );
    BOOST_CHECK( !fs::exists( link ) );
    fs::create_symlink( link, link );
    BOOST_CHECK( fs::remove( link ) );
    BOOST_CHECK( !fs::exists( link ) );
    BOOST_CHECK( !fs::is_symlink( link ) );

    // remove() cyclic symbolic link
    link = "link_to_a";
    fs::path link2( "link_to_b" );
    fs::remove( link );   // remove any residue from past tests
    fs::remove( link2 );  // remove any residue from past tests
    BOOST_CHECK( !fs::is_symlink( link ) );
    BOOST_CHECK( !fs::exists( link ) );
    fs::create_symlink( link, link2 );
    fs::create_symlink( link2, link );
    BOOST_CHECK( fs::remove( link ) );
    BOOST_CHECK( fs::remove( link2 ) );
    BOOST_CHECK( !fs::exists( link ) );
    BOOST_CHECK( !fs::exists( link2 ) );
    BOOST_CHECK( !fs::is_symlink( link ) );

    // remove() symbolic link to file
    file_ph = "link_target";
    fs::remove( file_ph );  // remove any residue from past tests
    BOOST_CHECK( !fs::exists( file_ph ) );
    create_file( file_ph, "" );
    BOOST_CHECK( fs::exists( file_ph ) );
    BOOST_CHECK( !fs::is_directory( file_ph ) );
    BOOST_CHECK( fs::is_regular_file( file_ph ) );
    link = "non_dangling_link";
    fs::create_symlink( file_ph, link );
    BOOST_CHECK( fs::exists( link ) );
    BOOST_CHECK( !fs::is_directory( link ) );
    BOOST_CHECK( fs::is_regular_file( link ) );
    BOOST_CHECK( fs::is_symlink( link ) );
    BOOST_CHECK( fs::remove( link ) );
    BOOST_CHECK( fs::exists( file_ph ) );
    BOOST_CHECK( !fs::exists( link ) );
    BOOST_CHECK( !fs::is_symlink( link ) );
    BOOST_CHECK( fs::remove( file_ph ) );
    BOOST_CHECK( !fs::exists( file_ph ) );
  }

  // write time tests

  file_ph = dir / "foobar2";
  create_file( file_ph, "foobar2" );
  BOOST_CHECK( fs::exists( file_ph ) );
  BOOST_CHECK( !fs::is_directory( file_ph ) );
  BOOST_CHECK( fs::is_regular_file( file_ph ) );
  BOOST_CHECK( fs::file_size( file_ph ) == 7 );
  verify_file( file_ph, "foobar2" );

  // Some file system report last write time as local (FAT), while
  // others (NTFS) report it as UTC. The C standard does not specify
  // if time_t is local or UTC. 

  std::time_t ft = fs::last_write_time( file_ph );
  std::cout << "\nUTC last_write_time() for a file just created is "
    << std::asctime(std::gmtime(&ft)) << std::endl;

  std::tm * tmp = std::localtime( &ft );
  std::cout << "\nYear is " << tmp->tm_year << std::endl;
  --tmp->tm_year;
  std::cout << "Change year to " << tmp->tm_year << std::endl;
  fs::last_write_time( file_ph, std::mktime( tmp ) );
  std::time_t ft2 = fs::last_write_time( file_ph );
  std::cout << "last_write_time() for the file is now "
    << std::asctime(std::gmtime(&ft2)) << std::endl;
  BOOST_CHECK( ft != fs::last_write_time( file_ph ) );


  std::cout << "\nReset to current time" << std::endl;
  fs::last_write_time( file_ph, ft );
  double time_diff = std::difftime( ft, fs::last_write_time( file_ph ) );
  std::cout 
    << "original last_write_time() - current last_write_time() is "
    << time_diff << " seconds" << std::endl;
  BOOST_CHECK( time_diff >= -60.0 && time_diff <= 60.0 );

  // post-test cleanup
  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_CHECK( !fs::exists( dir ) );
  BOOST_CHECK( fs::remove_all( dir ) == 0 );
  return 0;
} // main