libcxx/test/support/filesystem_test_helper.h

   1 #ifndef FILESYSTEM_TEST_HELPER_H
   2 #define FILESYSTEM_TEST_HELPER_H
   3
   4 #include <filesystem>
   5
   6 #include <sys/stat.h> // for stat, mkdir, mkfifo
   7 #ifndef _WIN32
   8 #include <unistd.h> // for ftruncate, link, symlink, getcwd, chdir
   9 #include <sys/statvfs.h>
  10 #else
  11 #include <io.h>
  12 #include <direct.h>
  13 #include <windows.h> // for CreateSymbolicLink, CreateHardLink
  14 #endif
  15
  16 #include <cassert>
  17 #include <cerrno>
  18 #include <chrono>
  19 #include <cstdint>
  20 #include <cstdio> // for printf
  21 #include <string>
  22 #include <system_error>
  23 #include <type_traits>
  24 #include <vector>
  25
  26 #include "assert_macros.h"
  27 #include "make_string.h"
  28 #include "test_macros.h"
  29 #include "format_string.h"
  30
  31 // For creating socket files
  32 #if !defined(__FreeBSD__) && !defined(__APPLE__) && !defined(_WIN32)
  33 # include <sys/socket.h>
  34 # include <sys/un.h>
  35 #endif
  36 namespace fs = std::filesystem;
  37
  38 namespace utils {
  39 #ifdef _WIN32
  40     inline int mkdir(const char* path, int mode) { (void)mode; return ::_mkdir(path); }
  41     inline int symlink(const char* oldname, const char* newname, bool is_dir) {
  42         DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
  43         if (CreateSymbolicLinkA(newname, oldname,
  44                                 flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE))
  45           return 0;
  46         if (GetLastError() != ERROR_INVALID_PARAMETER)
  47           return 1;
  48         return !CreateSymbolicLinkA(newname, oldname, flags);
  49     }
  50     inline int link(const char *oldname, const char* newname) {
  51         return !CreateHardLinkA(newname, oldname, NULL);
  52     }
  53     inline int setenv(const char *var, const char *val, int overwrite) {
  54         (void)overwrite;
  55         return ::_putenv((std::string(var) + "=" + std::string(val)).c_str());
  56     }
  57     inline int unsetenv(const char *var) {
  58         return ::_putenv((std::string(var) + "=").c_str());
  59     }
  60     inline bool space(std::string path, std::uintmax_t &capacity,
  61                       std::uintmax_t &free, std::uintmax_t &avail) {
  62         ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes,
  63                        TotalNumberOfFreeBytes;
  64         if (!GetDiskFreeSpaceExA(path.c_str(), &FreeBytesAvailableToCaller,
  65                                  &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
  66           return false;
  67         capacity = TotalNumberOfBytes.QuadPart;
  68         free = TotalNumberOfFreeBytes.QuadPart;
  69         avail = FreeBytesAvailableToCaller.QuadPart;
  70         assert(capacity > 0);
  71         assert(free > 0);
  72         assert(avail > 0);
  73         return true;
  74     }
  75 #else
  76     using ::mkdir;
  77     inline int symlink(const char* oldname, const char* newname, bool is_dir) { (void)is_dir; return ::symlink(oldname, newname); }
  78     using ::link;
  79     using ::setenv;
  80     using ::unsetenv;
  81     inline bool space(std::string path, std::uintmax_t &capacity,
  82                       std::uintmax_t &free, std::uintmax_t &avail) {
  83         struct statvfs expect;
  84         if (::statvfs(path.c_str(), &expect) == -1)
  85           return false;
  86         assert(expect.f_bavail > 0);
  87         assert(expect.f_bfree > 0);
  88         assert(expect.f_bsize > 0);
  89         assert(expect.f_blocks > 0);
  90         assert(expect.f_frsize > 0);
  91         auto do_mult = [&](std::uintmax_t val) {
  92             std::uintmax_t fsize = expect.f_frsize;
  93             std::uintmax_t new_val = val * fsize;
  94             assert(new_val / fsize == val); // Test for overflow
  95             return new_val;
  96         };
  97         capacity = do_mult(expect.f_blocks);
  98         free = do_mult(expect.f_bfree);
  99         avail = do_mult(expect.f_bavail);
 100         return true;
 101     }
 102 #endif
 103
 104     // N.B. libc might define some of the foo[64] identifiers using macros from
 105     // foo64 -> foo or vice versa.
 106 #if defined(_WIN32)
 107     using off64_t = std::int64_t;
 108 #elif defined(__MVS__) || defined(__LP64__)
 109     using off64_t = ::off_t;
 110 #else
 111     using ::off64_t;
 112 #endif
 113
 114     inline FILE* fopen64(const char* pathname, const char* mode) {
 115         // Bionic does not distinguish between fopen and fopen64, but fopen64
 116         // wasn't added until API 24.
 117 #if defined(_WIN32) || defined(__MVS__) || defined(__LP64__) || defined(__BIONIC__)
 118         return ::fopen(pathname, mode);
 119 #else
 120         return ::fopen64(pathname, mode);
 121 #endif
 122     }
 123
 124     inline int ftruncate64(int fd, off64_t length) {
 125 #if defined(_WIN32)
 126         // _chsize_s sets errno on failure and also returns the error number.
 127         return ::_chsize_s(fd, length) ? -1 : 0;
 128 #elif defined(__MVS__) || defined(__LP64__)
 129         return ::ftruncate(fd, length);
 130 #else
 131         return ::ftruncate64(fd, length);
 132 #endif
 133     }
 134
 135     inline std::string getcwd() {
 136         // Assume that path lengths are not greater than this.
 137         // This should be fine for testing purposes.
 138         char buf[4096];
 139         char* ret = ::getcwd(buf, sizeof(buf));
 140         assert(ret && "getcwd failed");
 141         return std::string(ret);
 142     }
 143
 144     inline bool exists(std::string const& path) {
 145         struct ::stat tmp;
 146         return ::stat(path.c_str(), &tmp) == 0;
 147     }
 148 } // end namespace utils
 149
 150 struct scoped_test_env
 151 {
 152     scoped_test_env() : test_root(available_cwd_path()) {
 153 #ifdef _WIN32
 154         // Windows mkdir can create multiple recursive directories
 155         // if needed.
 156         std::string cmd = "mkdir " + test_root.string();
 157 #else
 158         std::string cmd = "mkdir -p " + test_root.string();
 159 #endif
 160         int ret = std::system(cmd.c_str());
 161         assert(ret == 0);
 162
 163         // Ensure that the root_path is fully resolved, i.e. it contains no
 164         // symlinks. The filesystem tests depend on that. We do this after
 165         // creating the root_path, because `fs::canonical` requires the
 166         // path to exist.
 167         test_root = fs::canonical(test_root);
 168     }
 169
 170     ~scoped_test_env() {
 171 #ifdef _WIN32
 172         std::string cmd = "rmdir /s /q " + test_root.string();
 173         int ret = std::system(cmd.c_str());
 174         assert(ret == 0);
 175 #else
 176 #if defined(__MVS__)
 177         // The behaviour of chmod -R on z/OS prevents recursive
 178         // permission change for directories that do not have read permission.
 179         std::string cmd = "find  " + test_root.string() + " -exec chmod 777 {} \\;";
 180 #else
 181         std::string cmd = "chmod -R 777 " + test_root.string();
 182 #endif // defined(__MVS__)
 183         int ret = std::system(cmd.c_str());
 184 #  if !defined(_AIX) && !defined(__ANDROID__)
 185         // On AIX the chmod command will return non-zero when trying to set
 186         // the permissions on a directory that contains a bad symlink. This triggers
 187         // the assert, despite being able to delete everything with the following
 188         // `rm -r` command.
 189         //
 190         // Android's chmod was buggy in old OSs, but skipping this assert is
 191         // sufficient to ensure that the `rm -rf` succeeds for almost all tests:
 192         //  - Android L: chmod aborts after one error
 193         //  - Android L and M: chmod -R tries to set permissions of a symlink
 194         //    target.
 195         // LIBCXX-ANDROID-FIXME: Other fixes to consider: place a toybox chmod
 196         // onto old devices, re-enable this assert for devices running Android N
 197         // and up, rewrite this chmod+rm in C or C++.
 198         assert(ret == 0);
 199 #  endif
 200
 201         cmd = "rm -rf " + test_root.string();
 202         ret = std::system(cmd.c_str());
 203         assert(ret == 0);
 204 #endif
 205     }
 206
 207     scoped_test_env(scoped_test_env const &) = delete;
 208     scoped_test_env & operator=(scoped_test_env const &) = delete;
 209
 210     fs::path make_env_path(std::string p) { return sanitize_path(p); }
 211
 212     std::string sanitize_path(std::string raw) {
 213         assert(raw.find("..") == std::string::npos);
 214         std::string root = test_root.string();
 215         if (root.compare(0, root.size(), raw, 0, root.size()) != 0) {
 216             assert(raw.front() != '\\');
 217             fs::path tmp(test_root);
 218             tmp /= raw;
 219             return tmp.string();
 220         }
 221         return raw;
 222     }
 223
 224     // Purposefully using a size potentially larger than off_t here so we can
 225     // test the behavior of libc++fs when it is built with _FILE_OFFSET_BITS=64
 226     // but the caller is not (std::filesystem also uses uintmax_t rather than
 227     // off_t). On a 32-bit system this allows us to create a file larger than
 228     // 2GB.
 229     std::string create_file(fs::path filename_path, std::uintmax_t size = 0) {
 230         std::string filename = sanitize_path(filename_path.string());
 231
 232         if (size >
 233             static_cast<typename std::make_unsigned<utils::off64_t>::type>(
 234                 std::numeric_limits<utils::off64_t>::max())) {
 235             fprintf(stderr, "create_file(%s, %ju) too large\n",
 236                     filename.c_str(), size);
 237             abort();
 238         }
 239
 240 #if defined(_WIN32) || defined(__MVS__)
 241 #  define FOPEN_CLOEXEC_FLAG ""
 242 #else
 243 #  define FOPEN_CLOEXEC_FLAG "e"
 244 #endif
 245         FILE* file = utils::fopen64(filename.c_str(), "w" FOPEN_CLOEXEC_FLAG);
 246         if (file == nullptr) {
 247             fprintf(stderr, "fopen %s failed: %s\n", filename.c_str(),
 248                     strerror(errno));
 249             abort();
 250         }
 251
 252         if (utils::ftruncate64(
 253                 fileno(file), static_cast<utils::off64_t>(size)) == -1) {
 254             fprintf(stderr, "ftruncate %s %ju failed: %s\n", filename.c_str(),
 255                     size, strerror(errno));
 256             fclose(file);
 257             abort();
 258         }
 259
 260         fclose(file);
 261         return filename;
 262     }
 263
 264     std::string create_dir(fs::path filename_path) {
 265         std::string filename = filename_path.string();
 266         filename = sanitize_path(std::move(filename));
 267         int ret = utils::mkdir(filename.c_str(), 0777); // rwxrwxrwx mode
 268         assert(ret == 0);
 269         return filename;
 270     }
 271
 272     std::string create_file_dir_symlink(fs::path source_path,
 273                                         fs::path to_path,
 274                                         bool sanitize_source = true,
 275                                         bool is_dir = false) {
 276         std::string source = source_path.string();
 277         std::string to = to_path.string();
 278         if (sanitize_source)
 279             source = sanitize_path(std::move(source));
 280         to = sanitize_path(std::move(to));
 281         int ret = utils::symlink(source.c_str(), to.c_str(), is_dir);
 282         assert(ret == 0);
 283         return to;
 284     }
 285
 286     std::string create_symlink(fs::path source_path,
 287                                fs::path to_path,
 288                                bool sanitize_source = true) {
 289         return create_file_dir_symlink(source_path, to_path, sanitize_source,
 290                                        false);
 291     }
 292
 293     std::string create_directory_symlink(fs::path source_path,
 294                                          fs::path to_path,
 295                                          bool sanitize_source = true) {
 296         return create_file_dir_symlink(source_path, to_path, sanitize_source,
 297                                        true);
 298     }
 299
 300     std::string create_hardlink(fs::path source_path, fs::path to_path) {
 301         std::string source = source_path.string();
 302         std::string to = to_path.string();
 303         source = sanitize_path(std::move(source));
 304         to = sanitize_path(std::move(to));
 305         int ret = utils::link(source.c_str(), to.c_str());
 306         assert(ret == 0);
 307         return to;
 308     }
 309
 310 #ifndef _WIN32
 311     std::string create_fifo(std::string file) {
 312         file = sanitize_path(std::move(file));
 313         int ret = ::mkfifo(file.c_str(), 0666); // rw-rw-rw- mode
 314         assert(ret == 0);
 315         return file;
 316     }
 317 #endif
 318
 319   // Some platforms doesn't support socket files so we shouldn't even
 320   // allow tests to call this unguarded.
 321 #if !defined(__FreeBSD__) && !defined(__APPLE__) && !defined(_WIN32)
 322     std::string create_socket(std::string file) {
 323       file = sanitize_path(std::move(file));
 324
 325       ::sockaddr_un address;
 326       address.sun_family = AF_UNIX;
 327
 328 // If file.size() is too big, try to create a file directly inside
 329 // /tmp to make sure file path is short enough.
 330 // Android platform warns about tmpnam, since the problem does not appear
 331 // on Android, let's not apply it for Android.
 332 #  if !defined(__ANDROID__)
 333     if (file.size() > sizeof(address.sun_path)) {
 334       file = std::tmpnam(nullptr);
 335     }
 336 #  endif
 337     assert(file.size() <= sizeof(address.sun_path));
 338     ::strncpy(address.sun_path, file.c_str(), sizeof(address.sun_path));
 339     int fd = ::socket(AF_UNIX, SOCK_STREAM, 0);
 340     assert(::bind(fd, reinterpret_cast<::sockaddr*>(&address), sizeof(address)) == 0);
 341     return file;
 342   }
 343 #endif
 344
 345     fs::path test_root;
 346
 347 private:
 348     // This could potentially introduce a filesystem race if multiple
 349     // scoped_test_envs were created concurrently in the same test (hence
 350     // sharing the same cwd). However, it is fairly unlikely to happen as
 351     // we generally don't use scoped_test_env from multiple threads, so
 352     // this is deemed acceptable.
 353     // The cwd.filename() itself isn't unique across all tests in the suite,
 354     // so start the numbering from a hash of the full cwd, to avoid
 355     // different tests interfering with each other.
 356     static inline fs::path available_cwd_path() {
 357         fs::path const cwd = utils::getcwd();
 358         fs::path const tmp = fs::temp_directory_path();
 359         std::string base = cwd.filename().string();
 360         std::size_t i = std::hash<std::string>()(cwd.string());
 361         fs::path p = tmp / (base + "-static_env." + std::to_string(i));
 362         while (utils::exists(p.string())) {
 363             p = tmp / (base + "-static_env." + std::to_string(++i));
 364         }
 365         return p;
 366     }
 367 };
 368
 369 /// This class generates the following tree:
 370 ///
 371 ///     static_test_env
 372 ///     |-- bad_symlink -> dne
 373 ///     |-- dir1
 374 ///     |   |-- dir2
 375 ///     |   |   |-- afile3
 376 ///     |   |   |-- dir3
 377 ///     |   |   |   `-- file5
 378 ///     |   |   |-- file4
 379 ///     |   |   `-- symlink_to_dir3 -> dir3
 380 ///     |   `-- file1
 381 ///     |   `-- file2
 382 ///     |-- empty_file
 383 ///     |-- non_empty_file
 384 ///     |-- symlink_to_dir -> dir1
 385 ///     `-- symlink_to_empty_file -> empty_file
 386 ///
 387 class static_test_env {
 388     scoped_test_env env_;
 389 public:
 390     static_test_env() {
 391         env_.create_symlink("dne", "bad_symlink", false);
 392         env_.create_dir("dir1");
 393         env_.create_dir("dir1/dir2");
 394         env_.create_file("dir1/dir2/afile3");
 395         env_.create_dir("dir1/dir2/dir3");
 396         env_.create_file("dir1/dir2/dir3/file5");
 397         env_.create_file("dir1/dir2/file4");
 398         env_.create_directory_symlink("dir3", "dir1/dir2/symlink_to_dir3", false);
 399         env_.create_file("dir1/file1");
 400         env_.create_file("dir1/file2", 42);
 401         env_.create_file("empty_file");
 402         env_.create_file("non_empty_file", 42);
 403         env_.create_directory_symlink("dir1", "symlink_to_dir", false);
 404         env_.create_symlink("empty_file", "symlink_to_empty_file", false);
 405     }
 406
 407     const fs::path Root = env_.test_root;
 408
 409     fs::path makePath(fs::path const& p) const {
 410         // env_path is expected not to contain symlinks.
 411         fs::path const& env_path = Root;
 412         return env_path / p;
 413     }
 414
 415     const std::vector<fs::path> TestFileList = {
 416         makePath("empty_file"),
 417         makePath("non_empty_file"),
 418         makePath("dir1/file1"),
 419         makePath("dir1/file2")
 420     };
 421
 422     const std::vector<fs::path> TestDirList = {
 423         makePath("dir1"),
 424         makePath("dir1/dir2"),
 425         makePath("dir1/dir2/dir3")
 426     };
 427
 428     const fs::path File          = TestFileList[0];
 429     const fs::path Dir           = TestDirList[0];
 430     const fs::path Dir2          = TestDirList[1];
 431     const fs::path Dir3          = TestDirList[2];
 432     const fs::path SymlinkToFile = makePath("symlink_to_empty_file");
 433     const fs::path SymlinkToDir  = makePath("symlink_to_dir");
 434     const fs::path BadSymlink    = makePath("bad_symlink");
 435     const fs::path DNE           = makePath("DNE");
 436     const fs::path EmptyFile     = TestFileList[0];
 437     const fs::path NonEmptyFile  = TestFileList[1];
 438     const fs::path CharFile      = "/dev/null"; // Hopefully this exists
 439
 440     const std::vector<fs::path> DirIterationList = {
 441         makePath("dir1/dir2"),
 442         makePath("dir1/file1"),
 443         makePath("dir1/file2")
 444     };
 445
 446     const std::vector<fs::path> DirIterationListDepth1 = {
 447         makePath("dir1/dir2/afile3"),
 448         makePath("dir1/dir2/dir3"),
 449         makePath("dir1/dir2/symlink_to_dir3"),
 450         makePath("dir1/dir2/file4"),
 451     };
 452
 453     const std::vector<fs::path> RecDirIterationList = {
 454         makePath("dir1/dir2"),
 455         makePath("dir1/file1"),
 456         makePath("dir1/file2"),
 457         makePath("dir1/dir2/afile3"),
 458         makePath("dir1/dir2/dir3"),
 459         makePath("dir1/dir2/symlink_to_dir3"),
 460         makePath("dir1/dir2/file4"),
 461         makePath("dir1/dir2/dir3/file5")
 462     };
 463
 464     const std::vector<fs::path> RecDirFollowSymlinksIterationList = {
 465         makePath("dir1/dir2"),
 466         makePath("dir1/file1"),
 467         makePath("dir1/file2"),
 468         makePath("dir1/dir2/afile3"),
 469         makePath("dir1/dir2/dir3"),
 470         makePath("dir1/dir2/file4"),
 471         makePath("dir1/dir2/dir3/file5"),
 472         makePath("dir1/dir2/symlink_to_dir3"),
 473         makePath("dir1/dir2/symlink_to_dir3/file5"),
 474     };
 475 };
 476
 477 struct CWDGuard {
 478   std::string oldCwd_;
 479   CWDGuard() : oldCwd_(utils::getcwd()) { }
 480   ~CWDGuard() {
 481     int ret = ::chdir(oldCwd_.c_str());
 482     assert(ret == 0 && "chdir failed");
 483   }
 484
 485   CWDGuard(CWDGuard const&) = delete;
 486   CWDGuard& operator=(CWDGuard const&) = delete;
 487 };
 488
 489 // We often need to test that the error_code was cleared if no error occurs
 490 // this function returns an error_code which is set to an error that will
 491 // never be returned by the filesystem functions.
 492 inline std::error_code GetTestEC(unsigned Idx = 0) {
 493   using std::errc;
 494   auto GetErrc = [&]() {
 495     switch (Idx) {
 496     case 0:
 497       return errc::address_family_not_supported;
 498     case 1:
 499       return errc::address_not_available;
 500     case 2:
 501       return errc::address_in_use;
 502     case 3:
 503       return errc::argument_list_too_long;
 504     default:
 505       assert(false && "Idx out of range");
 506       std::abort();
 507     }
 508   };
 509   return std::make_error_code(GetErrc());
 510 }
 511
 512 inline bool ErrorIsImp(const std::error_code& ec,
 513                        std::vector<std::errc> const& errors) {
 514   std::error_condition cond = ec.default_error_condition();
 515   for (auto errc : errors) {
 516     if (cond.value() == static_cast<int>(errc))
 517       return true;
 518   }
 519   return false;
 520 }
 521
 522 template <class... ErrcT>
 523 inline bool ErrorIs(const std::error_code& ec, std::errc First, ErrcT... Rest) {
 524   std::vector<std::errc> errors = {First, Rest...};
 525   return ErrorIsImp(ec, errors);
 526 }
 527
 528 // Provide our own Sleep routine since std::this_thread::sleep_for is not
 529 // available in single-threaded mode.
 530 template <class Dur> void SleepFor(Dur dur) {
 531     using namespace std::chrono;
 532 #if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
 533     using Clock = system_clock;
 534 #else
 535     using Clock = steady_clock;
 536 #endif
 537     const auto wake_time = Clock::now() + dur;
 538     while (Clock::now() < wake_time)
 539         ;
 540 }
 541
 542 inline fs::perms NormalizeExpectedPerms(fs::perms P) {
 543 #ifdef _WIN32
 544   // On Windows, fs::perms only maps down to one bit stored in the filesystem,
 545   // a boolean readonly flag.
 546   // Normalize permissions to the format it gets returned; all fs entries are
 547   // read+exec for all users; writable ones also have the write bit set for
 548   // all users.
 549   P |= fs::perms::owner_read | fs::perms::group_read | fs::perms::others_read;
 550   P |= fs::perms::owner_exec | fs::perms::group_exec | fs::perms::others_exec;
 551   fs::perms Write =
 552       fs::perms::owner_write | fs::perms::group_write | fs::perms::others_write;
 553   if ((P & Write) != fs::perms::none)
 554     P |= Write;
 555 #endif
 556   return P;
 557 }
 558
 559 struct ExceptionChecker {
 560   std::errc expected_err;
 561   fs::path expected_path1;
 562   fs::path expected_path2;
 563   unsigned num_paths;
 564   const char* func_name;
 565   std::string opt_message;
 566
 567   explicit ExceptionChecker(std::errc first_err, const char* fun_name,
 568                             std::string opt_msg = {})
 569       : expected_err{first_err}, num_paths(0), func_name(fun_name),
 570         opt_message(opt_msg) {}
 571   explicit ExceptionChecker(fs::path p, std::errc first_err,
 572                             const char* fun_name, std::string opt_msg = {})
 573       : expected_err(first_err), expected_path1(p), num_paths(1),
 574         func_name(fun_name), opt_message(opt_msg) {}
 575
 576   explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
 577                             const char* fun_name, std::string opt_msg = {})
 578       : expected_err(first_err), expected_path1(p1), expected_path2(p2),
 579         num_paths(2), func_name(fun_name), opt_message(opt_msg) {}
 580
 581   void operator()(fs::filesystem_error const& Err) {
 582     assert(ErrorIsImp(Err.code(), {expected_err}));
 583     assert(Err.path1() == expected_path1);
 584     assert(Err.path2() == expected_path2);
 585     LIBCPP_ONLY(check_libcxx_string(Err));
 586   }
 587
 588   void check_libcxx_string(fs::filesystem_error const& Err) {
 589     std::string message = std::make_error_code(expected_err).message();
 590
 591     std::string additional_msg = "";
 592     if (!opt_message.empty()) {
 593       additional_msg = opt_message + ": ";
 594     }
 595     auto transform_path = [](const fs::path& p) {
 596       return "\"" + p.string() + "\"";
 597     };
 598     std::string format = [&]() -> std::string {
 599       switch (num_paths) {
 600       case 0:
 601         return format_string("filesystem error: in %s: %s%s", func_name,
 602                              additional_msg, message);
 603       case 1:
 604         return format_string("filesystem error: in %s: %s%s [%s]", func_name,
 605                              additional_msg, message,
 606                              transform_path(expected_path1).c_str());
 607       case 2:
 608         return format_string("filesystem error: in %s: %s%s [%s] [%s]",
 609                              func_name, additional_msg, message,
 610                              transform_path(expected_path1).c_str(),
 611                              transform_path(expected_path2).c_str());
 612       default:
 613         TEST_FAIL("unexpected case");
 614         return "";
 615       }
 616     }();
 617     assert(format == Err.what());
 618     if (format != Err.what()) {
 619       fprintf(stderr,
 620               "filesystem_error::what() does not match expected output:\n");
 621       fprintf(stderr, "  expected: \"%s\"\n", format.c_str());
 622       fprintf(stderr, "  actual:   \"%s\"\n\n", Err.what());
 623     }
 624   }
 625
 626   ExceptionChecker(ExceptionChecker const&) = delete;
 627   ExceptionChecker& operator=(ExceptionChecker const&) = delete;
 628
 629 };
 630
 631 inline fs::path GetWindowsInaccessibleDir() {
 632   // Only makes sense on windows, but the code can be compiled for
 633   // any platform.
 634   const fs::path dir("C:\\System Volume Information");
 635   std::error_code ec;
 636   const fs::path root("C:\\");
 637   for (const auto &ent : fs::directory_iterator(root, ec)) {
 638     if (ent != dir)
 639       continue;
 640     // Basic sanity checks on the directory_entry
 641     if (!ent.exists() || !ent.is_directory()) {
 642       fprintf(stderr, "The expected inaccessible directory \"%s\" was found "
 643                       "but doesn't behave as expected, skipping tests "
 644                       "regarding it\n", dir.string().c_str());
 645       return fs::path();
 646     }
 647     // Check that it indeed is inaccessible as expected
 648     (void)fs::exists(ent, ec);
 649     if (!ec) {
 650       fprintf(stderr, "The expected inaccessible directory \"%s\" was found "
 651                       "but seems to be accessible, skipping tests "
 652                       "regarding it\n", dir.string().c_str());
 653       return fs::path();
 654     }
 655     return ent;
 656   }
 657   fprintf(stderr, "No inaccessible directory \"%s\" found, skipping tests "
 658                   "regarding it\n", dir.string().c_str());
 659   return fs::path();
 660 }
 661
 662 #endif /* FILESYSTEM_TEST_HELPER_H */