ceph/src/boost/libs/filesystem/test/operations_unit_test.cpp

   1 //  operations_unit_test.cpp  ----------------------------------------------------------//
   2
   3 //  Copyright Beman Dawes 2008, 2009, 2015
   4
   5 //  Distributed under the Boost Software License, Version 1.0.
   6 //  See http://www.boost.org/LICENSE_1_0.txt
   7
   8 //  Library home page: http://www.boost.org/libs/filesystem
   9
  10 //  ------------------------------------------------------------------------------------//
  11
  12 //  This program is misnamed - it is really a smoke test rather than a unit test
  13
  14 //  ------------------------------------------------------------------------------------//
  15
  16
  17 #include <boost/config/warning_disable.hpp>
  18
  19 //  See deprecated_test for tests of deprecated features
  20 #ifndef BOOST_FILESYSTEM_NO_DEPRECATED
  21 #  define BOOST_FILESYSTEM_NO_DEPRECATED
  22 #endif
  23 #ifndef BOOST_SYSTEM_NO_DEPRECATED
  24 #  define BOOST_SYSTEM_NO_DEPRECATED
  25 #endif
  26
  27 #include <boost/filesystem.hpp>   // make sure filesystem.hpp works
  28
  29 #include <boost/config.hpp>
  30 # if defined( BOOST_NO_STD_WSTRING )
  31 #   error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support
  32 # endif
  33
  34 #include <boost/system/error_code.hpp>
  35 #include <boost/detail/lightweight_test.hpp>
  36 #include <boost/detail/lightweight_main.hpp>
  37 #include <iostream>
  38
  39 using namespace boost::filesystem;
  40 using namespace boost::system;
  41 using std::cout;
  42 using std::endl;
  43 using std::string;
  44
  45 #define CHECK(x) check(x, __FILE__, __LINE__)
  46
  47 namespace
  48 {
  49   bool cleanup = true;
  50
  51   void check(bool ok, const char* file, int line)
  52   {
  53     if (ok) return;
  54
  55     ++::boost::detail::test_errors();
  56
  57     cout << file << '(' << line << "): test failed\n";
  58   }
  59
  60   //  file_status_test  ----------------------------------------------------------------//
  61
  62   void file_status_test()
  63   {
  64     cout << "file_status test..." << endl;
  65
  66     file_status s = status(".");
  67     int v = s.permissions();
  68     cout << "  status(\".\") permissions are "
  69       << std::oct << (v & 0777) << std::dec << endl;
  70     CHECK((v & 0400) == 0400);
  71
  72     s = symlink_status(".");
  73     v = s.permissions();
  74     cout << "  symlink_status(\".\") permissions are "
  75       << std::oct << (v & 0777) << std::dec << endl;
  76     CHECK((v & 0400) == 0400);
  77   }
  78
  79   //  query_test  ----------------------------------------------------------------------//
  80
  81   void query_test()
  82   {
  83     cout << "query test..." << endl;
  84
  85     error_code ec;
  86
  87     CHECK(file_size("no-such-file", ec) == static_cast<boost::uintmax_t>(-1));
  88     CHECK(ec == errc::no_such_file_or_directory);
  89
  90     CHECK(status("no-such-file") == file_status(file_not_found, no_perms));
  91
  92     CHECK(exists("/"));
  93     CHECK(is_directory("/"));
  94     CHECK(!exists("no-such-file"));
  95
  96     exists("/", ec);
  97     if (ec)
  98     {
  99       cout << "exists(\"/\", ec) resulted in non-zero ec.value()" << endl;
 100       cout << "ec value: " << ec.value() << ", message: "<< ec.message() << endl;
 101     }
 102     CHECK(!ec);
 103
 104     CHECK(exists("/"));
 105     CHECK(is_directory("/"));
 106     CHECK(!is_regular_file("/"));
 107     CHECK(!boost::filesystem::is_empty("/"));
 108     CHECK(!is_other("/"));
 109   }
 110
 111   //  directory_iterator_test  -----------------------------------------------//
 112
 113   void directory_iterator_test()
 114   {
 115     cout << "directory_iterator_test..." << endl;
 116
 117     directory_iterator end;
 118
 119     directory_iterator it(".");
 120
 121     CHECK(!it->path().empty());
 122
 123     if (is_regular_file(it->status()))
 124     {
 125       CHECK(is_regular_file(it->symlink_status()));
 126       CHECK(!is_directory(it->status()));
 127       CHECK(!is_symlink(it->status()));
 128       CHECK(!is_directory(it->symlink_status()));
 129       CHECK(!is_symlink(it->symlink_status()));
 130     }
 131     else
 132     {
 133       CHECK(is_directory(it->status()));
 134       CHECK(is_directory(it->symlink_status()));
 135       CHECK(!is_regular_file(it->status()));
 136       CHECK(!is_regular_file(it->symlink_status()));
 137       CHECK(!is_symlink(it->status()));
 138       CHECK(!is_symlink(it->symlink_status()));
 139     }
 140
 141     for (; it != end; ++it)
 142     {
 143       //cout << "  " << it->path() << "\n";
 144     }
 145
 146     CHECK(directory_iterator(".") != directory_iterator());
 147     CHECK(directory_iterator() == end);
 148
 149 #ifndef BOOST_NO_CXX11_RANGE_BASED_FOR
 150     for (directory_entry& x : directory_iterator("."))
 151     {
 152       CHECK(!x.path().empty());
 153        //cout << "  " << x.path() << "\n";
 154     }
 155     const directory_iterator dir_itr(".");
 156     for (directory_entry& x : dir_itr)
 157     {
 158       CHECK(!x.path().empty());
 159       //cout << "  " << x.path() << "\n";
 160     }
 161 #endif
 162
 163     for (directory_iterator itr("."); itr != directory_iterator(); ++itr)
 164     {
 165       CHECK(!itr->path().empty());
 166       //cout << "  " << itr->path() << "\n";
 167     }
 168
 169     cout << "directory_iterator_test complete" << endl;
 170   }
 171
 172   //  recursive_directory_iterator_test  -----------------------------------------------//
 173
 174   void recursive_directory_iterator_test()
 175   {
 176     cout << "recursive_directory_iterator_test..." << endl;
 177
 178     recursive_directory_iterator end;
 179
 180     recursive_directory_iterator it(".");
 181
 182     CHECK(!it->path().empty());
 183
 184     if (is_regular_file(it->status()))
 185     {
 186       CHECK(is_regular_file(it->symlink_status()));
 187       CHECK(!is_directory(it->status()));
 188       CHECK(!is_symlink(it->status()));
 189       CHECK(!is_directory(it->symlink_status()));
 190       CHECK(!is_symlink(it->symlink_status()));
 191     }
 192     else
 193     {
 194       CHECK(is_directory(it->status()));
 195       CHECK(is_directory(it->symlink_status()));
 196       CHECK(!is_regular_file(it->status()));
 197       CHECK(!is_regular_file(it->symlink_status()));
 198       CHECK(!is_symlink(it->status()));
 199       CHECK(!is_symlink(it->symlink_status()));
 200     }
 201
 202     for (; it != end; ++it)
 203     {
 204       //cout << "  " << it->path() << "\n";
 205     }
 206
 207     CHECK(recursive_directory_iterator(".") != recursive_directory_iterator());
 208     CHECK(recursive_directory_iterator() == end);
 209
 210 #ifndef BOOST_NO_CXX11_RANGE_BASED_FOR
 211     for (directory_entry& x : recursive_directory_iterator("."))
 212     {
 213       CHECK(!x.path().empty());
 214       //cout << "  " << x.path() << "\n";
 215     }
 216     const recursive_directory_iterator dir_itr(".");
 217     for (directory_entry& x : dir_itr)
 218     {
 219       CHECK(!x.path().empty());
 220       //cout << "  " << x.path() << "\n";
 221     }
 222 #endif
 223
 224     for (recursive_directory_iterator itr(".");
 225       itr != recursive_directory_iterator(); ++itr)
 226     {
 227       CHECK(!itr->path().empty());
 228       //cout << "  " << itr->path() << "\n";
 229     }
 230
 231     cout << "recursive_directory_iterator_test complete" << endl;
 232   }
 233
 234   //  operations_test  -------------------------------------------------------//
 235
 236   void operations_test()
 237   {
 238     cout << "operations test..." << endl;
 239
 240     error_code ec;
 241
 242     CHECK(!create_directory("/", ec));
 243
 244     CHECK(!boost::filesystem::remove("no-such-file-or-directory"));
 245     CHECK(!remove_all("no-such-file-or-directory"));
 246
 247     space_info info = space("/");
 248
 249     CHECK(info.available <= info.capacity);
 250
 251     CHECK(equivalent("/", "/"));
 252     CHECK(!equivalent("/", "."));
 253
 254     std::time_t ft = last_write_time(".");
 255     ft = -1;
 256     last_write_time(".", ft, ec);
 257   }
 258
 259   //  directory_entry_test  ------------------------------------------------------------//
 260
 261   void directory_entry_test()
 262   {
 263     cout << "directory_entry test..." << endl;
 264
 265     directory_entry de("foo.bar",
 266       file_status(regular_file, owner_all), file_status(directory_file, group_all));
 267
 268     CHECK(de.path() == "foo.bar");
 269     CHECK(de.status() == file_status(regular_file, owner_all));
 270     CHECK(de.symlink_status() == file_status(directory_file, group_all));
 271     CHECK(de < directory_entry("goo.bar"));
 272     CHECK(de == directory_entry("foo.bar"));
 273     CHECK(de != directory_entry("goo.bar"));
 274     de.replace_filename("bar.foo");
 275     CHECK(de.path() == "bar.foo");
 276   }
 277
 278   //  directory_entry_overload_test  ---------------------------------------------------//
 279
 280   void directory_entry_overload_test()
 281   {
 282     cout << "directory_entry overload test..." << endl;
 283
 284     directory_iterator it(".");
 285     path p(*it);
 286   }
 287
 288   //  error_handling_test  -------------------------------------------------------------//
 289
 290   void error_handling_test()
 291   {
 292     cout << "error handling test..." << endl;
 293
 294     bool threw(false);
 295     try
 296     {
 297       file_size("no-such-file");
 298     }
 299     catch (const boost::filesystem::filesystem_error & ex)
 300     {
 301       threw = true;
 302       cout << "\nas expected, attempt to get size of non-existent file threw a filesystem_error\n"
 303         "what() returns " << ex.what() << "\n";
 304     }
 305     catch (...)
 306     {
 307       cout << "\nunexpected exception type caught" << endl;
 308     }
 309
 310     CHECK(threw);
 311
 312     error_code ec;
 313     CHECK(!create_directory("/", ec));
 314   }
 315
 316   //  string_file_tests  ---------------------------------------------------------------//
 317
 318   void string_file_tests(const path& temp_dir)
 319   {
 320     cout << "string_file_tests..." << endl;
 321     std::string contents("0123456789");
 322     path p(temp_dir / "string_file");
 323     save_string_file(p, contents);
 324     save_string_file(p, contents);
 325     BOOST_TEST_EQ(file_size(p), 10u);
 326     std::string round_trip;
 327     load_string_file(p, round_trip);
 328     BOOST_TEST_EQ(contents, round_trip);
 329   }
 330
 331 }  // unnamed namespace
 332
 333 //--------------------------------------------------------------------------------------//
 334 //                                                                                      //
 335 //                                    main                                              //
 336 //                                                                                      //
 337 //--------------------------------------------------------------------------------------//
 338
 339 int cpp_main(int argc, char* argv[])
 340 {
 341 // document state of critical macros
 342 #ifdef BOOST_POSIX_API
 343   cout << "BOOST_POSIX_API is defined\n";
 344 #endif
 345 #ifdef BOOST_WINDOWS_API
 346   cout << "BOOST_WINDOWS_API is defined\n";
 347 #endif
 348   cout << "BOOST_FILESYSTEM_DECL" << BOOST_STRINGIZE(=BOOST_FILESYSTEM_DECL) << "\n";
 349   cout << "BOOST_SYMBOL_VISIBLE" << BOOST_STRINGIZE(=BOOST_SYMBOL_VISIBLE) << "\n";
 350
 351   cout << "current_path() is " << current_path().string() << endl;
 352
 353   if (argc >= 2)
 354   {
 355     cout << "argv[1] is '" << argv[1] << "', changing current_path() to it" << endl;
 356
 357     error_code ec;
 358     current_path( argv[1], ec );
 359
 360     if (ec)
 361     {
 362       cout << "current_path('" << argv[1] << "') failed: " << ec << ": " << ec.message() << endl;
 363     }
 364
 365     cout << "current_path() is " << current_path().string() << endl;
 366   }
 367
 368   const path temp_dir(current_path() / ".." / unique_path("op-unit_test-%%%%-%%%%-%%%%"));
 369   cout << "temp_dir is " << temp_dir.string() << endl;
 370
 371   create_directory(temp_dir);
 372
 373   file_status_test();
 374   query_test();
 375   directory_iterator_test();
 376   recursive_directory_iterator_test();
 377   operations_test();
 378   directory_entry_test();
 379   directory_entry_overload_test();
 380   error_handling_test();
 381   string_file_tests(temp_dir);
 382
 383   cout << unique_path() << endl;
 384   cout << unique_path("foo-%%%%%-%%%%%-bar") << endl;
 385   cout << unique_path("foo-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-%%%%-bar") << endl;
 386   cout << unique_path("foo-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-%%%%%-bar") << endl;
 387
 388   cout << "testing complete" << endl;
 389
 390   // post-test cleanup
 391   if (cleanup)
 392   {
 393     cout << "post-test removal of " << temp_dir << endl;
 394     BOOST_TEST(remove_all(temp_dir) != 0);
 395     // above was added just to simplify testing, but it ended up detecting
 396     // a bug (failure to close an internal search handle).
 397     cout << "post-test removal complete" << endl;
 398 //    BOOST_TEST(!fs::exists(dir));  // nice test, but doesn't play well with TortoiseGit cache
 399   }
 400
 401   return ::boost::report_errors();
 402 }