[libcxx] [test] Ifdef out tests that rely on perms::none on directories for triggering errors

[mstorsjo]

Summary

On windows, one can't use perms::none on a directory to trigger failures to read the directory entries.

This fixes 23 tests on windows.

[ldionne]

So actually, I think those tests are the same that fail when we run under sudo. I believe it would be useful to find an alternative way to trigger those failures. This would allow us to both run the tests on Windows and also would remove this weird quirk about running under sudo (which is useful e.g. when running in a Docker image).

Can you think of another way to do this? Could we change the owner of the directory?

[mstorsjo]

Tagging @curdeius and @amccarth for input and ideas

In D97538#2597651, @ldionne wrote:

So actually, I think those tests are the same that fail when we run under sudo. I believe it would be useful to find an alternative way to trigger those failures. This would allow us to both run the tests on Windows and also would remove this weird quirk about running under sudo (which is useful e.g. when running in a Docker image).

Can you think of another way to do this? Could we change the owner of the directory?

If a process running as root can iterate over a directory even after chmod 000, I don't think changing the owner would help. Dunno about windows - on the API level we operate so far, permissions only consist of a boolean readonly flag, not much more. On some other level, windows filesystems have full ACLs for controlling access though.

[mstorsjo]

@curdeius Any ideas on this one? There's lots of tests that test the error cases when unable to read a directory, by giving those directories perms::none, which doesn't stop them from being read on windows. (On windows, the perms we have available essentially is only a binary readonly-flag.) And if I understand things right, these tests also fail if running the tests as root or in sudo, as one apparently ends up able to read the directories regardless, in those cases.

[amccarth]

In D97538#2597729, @mstorsjo wrote:

Tagging @curdeius and @amccarth for input and ideas
If a process running as root can iterate over a directory even after chmod 000, I don't think changing the owner would help. Dunno about windows - on the API level we operate so far, permissions only consist of a boolean readonly flag, not much more. On some other level, windows filesystems have full ACLs for controlling access though.

I can't think of a way to trigger a permission denied error with anything less than an ACL. And it might be hard for the owner that just created the directory to then lock itself out. And if it succeeded, then the test might have trouble cleaning up afterwards.

I having a hard time even thinking of a Windows directory that would block permission to list contents. The best I can come up with is C:\Users\SomebodyElse, but that's not guaranteed to exist on any other machine, and you couldn't temporarily change the permissions to set up the rest of the scenario being tested.

I tried thinking of something other than an access problem that would temporarily interfere with iterating directory contents, but I'm not coming up with any good options.

[curdeius]

Unfortunately I haven't found anything really satisfying that will provoke this or similar behaviour on Windows without, as Adrian noted, accessing other user's folder or changing ACLs.
Funnily, I had the very same problem in one of my projects just last week.

Anyway, speaking of C:\Users\SomebodyElse and stuff. That's not really nice to do some setup using a different user.
But if we used an already existing directory to which a normal user does not have access rights?
E.g. a normal user cannot write to C:\Users\Default.
Also, one cannot traverse nor read the contents of C:\System Volume Information and this folder always exists (at least for Windows 7+, Server 2012+, probably even Server 2008). Maybe this would make the trick, at least for some tests?

[mstorsjo]

In D97538#2610559, @curdeius wrote:

Unfortunately I haven't found anything really satisfying that will provoke this or similar behaviour on Windows without, as Adrian noted, accessing other user's folder or changing ACLs.
Funnily, I had the very same problem in one of my projects just last week.

Anyway, speaking of C:\Users\SomebodyElse and stuff. That's not really nice to do some setup using a different user.
But if we used an already existing directory to which a normal user does not have access rights?
E.g. a normal user cannot write to C:\Users\Default.
Also, one cannot traverse nor read the contents of C:\System Volume Information and this folder always exists (at least for Windows 7+, Server 2012+, probably even Server 2008). Maybe this would make the trick, at least for some tests?

Thanks! That does indeed seem to work. Ideally I'd like to first check that it exists before proceeding with a test that assumes its existence and behaviour, but exists("C:\System Volume Information") fails as we don't really have access to access the directory much at all. We can iterate over C:\ and see that it's listed as one of the entries there though.

Converting all these instances to use that does feel like overkill, and most of these tests are kinda redundant with other tests, but there's at least a few instances where it can make sense to use this. And this did uncover a bug regarding the handling of the skip_permission_denied flag. I'll post a separate patch for that and a few tests to use that dir, and then we can update this one to ifdef out other cases that are less necessary.

[mstorsjo]

Updated after splitting out changes that use GetWindowsInaccessibleDir().

These remaining tests can't use GetWindowsInaccessibleDir() sensibly, e.g. for tests that rely on toggling accessibility back and forth during the test, or where the semantics of the dir provided by GetWindowsInaccessibleDir() doesn't allow for running the ifdeffed tests meaningfully.

[mstorsjo]

@curdeius - WDYT about the rest of this?

[curdeius]

No objection from my side. @ldionne?

[mstorsjo]

Ping for second approval

[mstorsjo]

@ldionne - TL;DR: Nobody has so far come up with a reliable crossplatform way of making those tests work under sudo. For windows, there's a special directory with suitable characteristics that work for some tests. (If it turns out the special dir doesn't exist or doesn't behave as we need it to, we use TEST_UNSUPPORTED() to bail out of that particular test - maybe such an approach could be used to waive failures when run under sudo, too? That's a separate effort anyway.) This patch now ifdefs out the remaining few cases where the special dir couldn't be used (e.g. where the test requires changing permissions back and forth during the test).

[ldionne]

This LGTM, but can we perhaps define a macro like TEST_WIN_NO_FAILURES_WITH_PERMISSIONS defined when _WIN32 is defined (pick a better name) and use that instead? Just to avoid sprinkling naked _WIN32's in the test suite if we can. No need for review either way, but please consider my suggestion.

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp

// DNE does not cause the constructor to throw
     directory_entry ent(static_env.DNE);
     TEST_CHECK(ent.path() == static_env.DNE);
 
     directory_entry ent_two(static_env.BadSymlink);
     TEST_CHECK(ent_two.path() == static_env.BadSymlink);
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(path_ctor_cannot_resolve) {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file1", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("dir/file1", "dir/sym2");
permissions(dir, perms::none);
     TEST_CHECK(ent.path() == sym_out_of_dir);
   }
   {
     TEST_CHECK_NO_THROW(directory_entry(file));
     TEST_CHECK_NO_THROW(directory_entry(sym_in_dir));
     TEST_CHECK_NO_THROW(directory_entry(sym_out_of_dir));
   }
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp

env.create_file("dir/file", 101);
     LIBCPP_ONLY(remove(file));
     LIBCPP_ONLY(remove(sym));
 
     TEST_CHECK(ent.is_symlink());
     TEST_CHECK(ent.is_regular_file());
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(test_assign_propagates_error) {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path file_out_of_dir = env.create_file("file1");
   const path sym_in_dir = env.create_symlink("file1", "dir/sym1");
TEST_CASE(test_assign_propagates_error) {
   }
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
     TEST_CHECK(!ec);
   }
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp

TEST_CASE(test_refresh_ec_method) {
   {
     directory_entry e;
     std::error_code ec = GetTestEC();
     e.refresh(ec);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(refresh_on_file_dne) {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
 
   const perms old_perms = status(dir).permissions();
 
env.create_file("dir/file", 101);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     permissions(dir, perms::none);
     TEST_CHECK(!ent.exists());
   }
 }
+#endif
 
 void remove_if_exists(const fs::path& p) {
   std::error_code ec;
   remove(p, ec);
 }
 
 TEST_CASE(refresh_on_bad_symlink) {
   using namespace fs;
// test file doesn't exist
     TEST_CHECK(ent.is_regular_file());
     TEST_CHECK(ent.exists());
 
     remove_if_exists(file);
     ent.refresh();
 
     LIBCPP_ONLY(permissions(dir, perms::none));
     TEST_CHECK(ent.is_symlink());
+#ifndef _WIN32
     TEST_CHECK(!ent.is_regular_file());
     TEST_CHECK(!ent.exists());
+#endif
   }
   permissions(dir, old_perms);
   env.create_file("dir/file", 101);
   {
     directory_entry ent(sym);
     LIBCPP_ONLY(remove(file));
     TEST_CHECK(ent.is_symlink());
     TEST_CHECK(ent.is_regular_file());
     TEST_CHECK(ent.exists());
 
     remove_if_exists(file);
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     TEST_CHECK(!ec); // we don't report bad symlinks as an error.
 
     LIBCPP_ONLY(permissions(dir, perms::none));
+#ifndef _WIN32
     TEST_CHECK(!ent.exists());
+#endif
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(refresh_cannot_resolve) {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file1", 99);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file1", "dir/sym1");
permissions(dir, old_perms);
     ((void)ent_file);
     ((void)ent_sym);
 
     TEST_CHECK_THROW(filesystem_error, ent_file.refresh());
     TEST_CHECK_THROW(filesystem_error, ent_sym.refresh());
     TEST_CHECK_NO_THROW(ent_sym2);
   }
 }
+#endif
 
 TEST_CASE(refresh_doesnt_throw_on_dne_but_reports_it) {
   using namespace fs;
   scoped_test_env env;
 
   const path file = env.create_file("file1", 42);
   const path sym = env.create_symlink("file1", "sym");
 
env.create_file("file1", 99);
     ec = GetTestEC();
     TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     TEST_CHECK_THROW(filesystem_error, ent.file_size());
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(access_cache_after_refresh_fails) {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file1", 101);
   const path sym = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("dir/file", "dir/sym2");
permissions(dir, old_perms);
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_regular_file, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
     CHECK_ACCESS(hard_link_count, uintmax_t(-1));
   }
 #undef CHECK_ACCESS
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp

env.create_file("dir/file_two", 99);
     LIBCPP_ONLY(remove(sym_two));
 
     TEST_CHECK(ent.is_symlink());
     TEST_CHECK(ent.is_regular_file());
     TEST_CHECK(ent.file_size() == 99);
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(test_replace_filename_propagates_error) {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_two = env.create_file("dir/file_two", 99);
   const path file_out_of_dir = env.create_file("file_three", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
permissions(dir, old_perms);
     ent.replace_filename(sym_out_of_dir_two.filename(), ec);
     TEST_CHECK(!ec);
     TEST_CHECK(ent.is_symlink());
     ec = GetTestEC();
     TEST_CHECK(!ent.exists(ec));
     TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
   }
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp

TEST_CASE(error_reporting) {
   scoped_test_env env;
 
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
 
+#ifndef _WIN32
   const perms old_perms = status(dir).permissions();
+#endif
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
     TEST_REQUIRE(ent.path() == static_env.DNE);
// test a dead symlink
     TEST_CHECK(ent.file_size(ec) == expect_bad);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::file_size");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
   }
+  // Windows doesn't support setting perms::none to trigger failures
+  // reading directories.
+#ifndef _WIN32
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = file_size(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
// test a symlink to a file w/o appropriate permissions
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     TEST_CHECK(ent.file_size(ec) == expect_good);
     TEST_CHECK(!ec);
     TEST_CHECK_NO_THROW(ent.file_size());
   }
+#endif
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp

for (auto p : {static_env.DNE, static_env.BadSymlink}) {
     TEST_CHECK(e.is_socket(ec) == is_socket(st));
     TEST_CHECK(CheckEC(status_ec));
 
     TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st));
     TEST_CHECK(CheckEC(sym_status_ec));
   }
 }
 
+#ifndef _WIN32
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
 TEST_CASE(test_with_ec_cannot_resolve) {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
 
   scoped_test_env env;
   const path dir = env.create_dir("dir");
for (auto p : {file, sym}) {
 
     TEST_CHECK(e.is_socket(ec) == is_socket(st));
     TEST_CHECK(CheckEC(status_ec));
 
     TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st));
     TEST_CHECK(CheckEC(sym_status_ec));
   }
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp

TEST_CASE(error_reporting) {
   scoped_test_env env;
 
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
 
+#ifndef _WIN32
   const perms old_perms = status(dir).permissions();
+#endif
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
     TEST_CHECK(ec);
// test a dead symlink
     TEST_CHECK(ent.hard_link_count(ec) == expect_bad);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::hard_link_count");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
   }
+  // Windows doesn't support setting perms::none to trigger failures
+  // reading directories.
+#ifndef _WIN32
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = hard_link_count(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
// test a symlink to a file w/o appropriate permissions
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     TEST_CHECK(ent.hard_link_count(ec) == expect_good);
     TEST_CHECK(!ec);
     TEST_CHECK_NO_THROW(ent.hard_link_count());
   }
+#endif
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp

TEST_CASE(error_reporting) {
   scoped_test_env env;
 
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
 
+#ifndef _WIN32
   const perms old_perms = status(dir).permissions();
+#endif
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
     TEST_REQUIRE(ent.path() == static_env.DNE);
// test a dead symlink
     TEST_CHECK(ent.last_write_time(ec) == expect_bad);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::last_write_time");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
   }
+  // Windows doesn't support setting perms::none to trigger failures
+  // reading directories.
+#ifndef _WIN32
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     file_time_type expect_good = last_write_time(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
// test a symlink to a file w/o appropriate permissions
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     TEST_CHECK(ent.last_write_time(ec) == expect_good);
     TEST_CHECK(!ec);
     TEST_CHECK_NO_THROW(ent.last_write_time());
   }
+#endif
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp

for (path const& testPath : testPaths)
         }
         {
             TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath));
             TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath, opts));
         }
     }
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(access_denied_test_case)
 {
     using namespace fs;
     scoped_test_env env;
     path const testDir = env.make_env_path("dir1");
     path const testFile = testDir / "testFile";
     env.create_dir(testDir);
     env.create_file(testFile, 42);
TEST_CASE(access_denied_test_case)
     // 'skip_permissions_denied' is given.
     {
         std::error_code ec;
         directory_iterator it(testDir, directory_options::skip_permission_denied, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(it == directory_iterator{});
     }
 }
+#endif
 
 
 TEST_CASE(access_denied_to_file_test_case)
 {
     using namespace fs;
     scoped_test_env env;
     path const testFile = env.make_env_path("file1");
     env.create_file(testFile, 42);

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp

for (path const& testPath : testPaths)
         }
         {
             TEST_CHECK_THROW(filesystem_error, RDI(testPath));
             TEST_CHECK_THROW(filesystem_error, RDI(testPath, opts));
         }
     }
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(access_denied_test_case)
 {
     using namespace fs;
     scoped_test_env env;
     path const testDir = env.make_env_path("dir1");
     path const testFile = testDir / "testFile";
     env.create_dir(testDir);
     env.create_file(testFile, 42);
TEST_CASE(access_denied_to_file_test_case)
     // because we tried to open a file and not a directory.
     {
         std::error_code ec;
         RDI it(testFile, directory_options::skip_permission_denied, ec);
         TEST_REQUIRE(ec);
         TEST_CHECK(it == RDI{});
     }
 }
+#endif
 
 TEST_CASE(test_open_on_empty_directory_equals_end)
 {
     scoped_test_env env;
     const path testDir = env.make_env_path("dir1");
     env.create_dir(testDir);
 
     const RDI endIt;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp

while (!unseen_entries.empty()) {
         TEST_REQUIRE(unseen_entries.erase(entry) == 1);
         recursive_directory_iterator& it_ref = it.increment(ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(&it_ref == &it);
     }
     TEST_CHECK(it == endIt);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(access_denied_on_recursion_test_case)
 {
     using namespace fs;
     scoped_test_env env;
     const path testFiles[] = {
         env.create_dir("dir1"),
         env.create_dir("dir1/dir2"),
         env.create_file("dir1/dir2/file1"),
for (auto TC : TestCases){
         TEST_CHECK(it == EndIt);
       } else {
         TEST_CHECK(ec);
         TEST_CHECK(ErrorIs(ec, eacess));
         TEST_CHECK(it == EndIt);
       }
     }
 }
+#endif
 
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp

TEST_CASE(create_existing_directory)
 
     // Check that the permissions were unchanged
     TEST_CHECK(orig_p == status(dir).permissions());
 
     // Test throwing version
     TEST_CHECK(fs::create_directory(dir, dir2) == false);
 }
 
+// Windows doesn't have the concept of perms::none on directories.
+#ifndef _WIN32
 TEST_CASE(create_directory_one_level)
 {
     scoped_test_env env;
     // Remove setgid which mkdir would inherit
     permissions(env.test_root, perms::set_gid, perm_options::remove);
 
     const path dir = env.make_env_path("dir1");
     const path attr_dir = env.create_dir("dir2");
     permissions(attr_dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == true);
     TEST_CHECK(!ec);
     TEST_CHECK(is_directory(dir));
 
     // Check that the new directory has the same permissions as attr_dir
     auto st = status(dir);
     TEST_CHECK(st.permissions() == perms::none);
 }
+#endif
 
 TEST_CASE(create_directory_multi_level)
 {
     scoped_test_env env;
     const path dir = env.make_env_path("dir1/dir2");
     const path dir1 = env.make_env_path("dir1");
     const path attr_dir = env.create_dir("attr_dir");
     std::error_code ec = GetTestEC();

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp

TEST_CASE(test_exist_not_found)
     const path p = static_env.DNE;
     TEST_CHECK(exists(p) == false);
 
     std::error_code ec = GetTestEC();
     TEST_CHECK(exists(p, ec) == false);
     TEST_CHECK(!ec);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_exists_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(exists(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, exists(file));
 }
+#endif
 
 TEST_CASE(test_name_too_long) {
     std::string long_name(2500, 'a');
     const path file(long_name);
 
     std::error_code ec;
     TEST_CHECK(exists(file, ec) == false);
     TEST_CHECK(ec);
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp

 
 TEST_CASE(test_exist_not_found)
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_block_file(p) == false);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_block_file_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_block_file(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_block_file(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp

 
 TEST_CASE(test_exist_not_found)
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_character_file(p) == false);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_character_file_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_character_file(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_character_file(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp

 TEST_CASE(static_env_test)
 {
     static_test_env static_env;
     TEST_CHECK(is_directory(static_env.Dir));
     TEST_CHECK(is_directory(static_env.SymlinkToDir));
     TEST_CHECK(!is_directory(static_env.File));
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_directory_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dir2 = env.create_dir("dir/dir2");
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_directory(dir2, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_directory(dir2));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp

 
 TEST_CASE(test_is_empty_file)
 {
     static_test_env static_env;
     TEST_CHECK(is_empty(static_env.EmptyFile));
     TEST_CHECK(!is_empty(static_env.NonEmptyFile));
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_empty_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dir2 = env.create_dir("dir/dir2");
     permissions(dir, perms::none);
 
     std::error_code ec;
TEST_CASE(test_directory_access_denied)
 
     std::error_code ec = GetTestEC();
     TEST_CHECK(is_empty(dir, ec) == false);
     TEST_CHECK(ec);
     TEST_CHECK(ec != GetTestEC());
 
     TEST_CHECK_THROW(filesystem_error, is_empty(dir));
 }
-
+#endif
 
 #ifndef _WIN32
 TEST_CASE(test_fifo_fails)
 {
     scoped_test_env env;
     const path fifo = env.create_fifo("fifo");
 
     std::error_code ec = GetTestEC();

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp

 
 TEST_CASE(test_exist_not_found)
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_fifo(p) == false);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_fifo_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_fifo(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_fifo(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp

 
 TEST_CASE(test_exist_not_found)
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_other(p) == false);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_other_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_other(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_other(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp

TEST_CASE(test_exist_not_found)
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_regular_file(p) == false);
     std::error_code ec;
     TEST_CHECK(is_regular_file(p, ec) == false);
     TEST_CHECK(ec);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_regular_file_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_regular_file(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_regular_file(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp

 
 TEST_CASE(test_exist_not_found)
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_socket(p) == false);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_socket_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_socket(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_socket(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp

TEST_CASE(test_exist_not_found)
     static_test_env static_env;
     const path p = static_env.DNE;
     TEST_CHECK(is_symlink(p) == false);
     std::error_code ec;
     TEST_CHECK(is_symlink(p, ec) == false);
     TEST_CHECK(ec);
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_is_symlink_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec;
     TEST_CHECK(is_symlink(file, ec) == false);
     TEST_CHECK(ec);
 
     TEST_CHECK_THROW(filesystem_error, is_symlink(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

 {
     static_test_env static_env;
     const path p = static_env.DNE;
     std::error_code ec = GetTestEC();
     TEST_CHECK(last_write_time(p, ec) == file_time_type::min());
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_exists_fails)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     TEST_CHECK(last_write_time(file, ec) == file_time_type::min());
     TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied,
                              "last_write_time");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, last_write_time(file));
 }
+#endif
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp

TEST_CASE(test_signatures)
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::remove(p)), bool);
     ASSERT_SAME_TYPE(decltype(fs::remove(p, ec)), bool);
 
     ASSERT_NOT_NOEXCEPT(fs::remove(p));
     ASSERT_NOEXCEPT(fs::remove(p, ec));
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_error_reporting)
 {
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::remove(f);
             return false;
#endif
 
     for (auto& p : testCasesNonexistant) {
         std::error_code ec;
 
         TEST_CHECK(!fs::remove(p, ec));
         TEST_CHECK(!ec);
     }
 }
+#endif
 
 TEST_CASE(basic_remove_test)
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path link = env.create_symlink(dne, "link");
     const path nested_link = env.make_env_path("nested_link");
     create_symlink(link, nested_link);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp

TEST_CASE(test_signatures)
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::remove_all(p)), std::uintmax_t);
     ASSERT_SAME_TYPE(decltype(fs::remove_all(p, ec)), std::uintmax_t);
 
     ASSERT_NOT_NOEXCEPT(fs::remove_all(p));
     ASSERT_NOT_NOEXCEPT(fs::remove_all(p, ec));
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_error_reporting)
 {
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::remove_all(f);
             return false;
#endif
     };
     for (auto &p : testCasesNonexistant) {
         std::error_code ec;
 
         TEST_CHECK(fs::remove_all(p, ec) == 0);
         TEST_CHECK(!ec);
     }
 }
+#endif
 
 TEST_CASE(basic_remove_all_test)
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path link = env.create_symlink(dne, "link");
     const path nested_link = env.make_env_path("nested_link");
     create_symlink(link, nested_link);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp

for (auto& p : cases) {
         // test throwing overload. It should not throw even though it reports
         // that the file was not found.
         TEST_CHECK_NO_THROW(st = status(p));
         TEST_CHECK(st.type() == file_type::not_found);
         TEST_CHECK(st.permissions() == perms::unknown);
     }
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_status_cannot_resolve)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     const path sym = env.create_symlink("dir/file", "sym");
     permissions(dir, perms::none);
 
#ifndef TEST_HAS_NO_EXCEPTIONS
                 TEST_CHECK(err.path1() == TC.p);
                 TEST_CHECK(err.path2() == "");
                 TEST_CHECK(ErrorIs(err.code(), TC.expect_errc));
             }
         }
 #endif
     }
 }
+#endif
 
 TEST_CASE(status_file_types_test)
 {
     static_test_env static_env;
     scoped_test_env env;
     struct TestCase {
       path p;
       file_type expect_type;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp

for (auto& p : cases) {
         // test throwing overload. It should not throw even though it reports
         // that the file was not found.
         TEST_CHECK_NO_THROW(st = status(p));
         TEST_CHECK(st.type() == file_type::not_found);
         TEST_CHECK(st.permissions() == perms::unknown);
     }
 }
 
+// Windows doesn't support setting perms::none to trigger failures
+// reading directories.
+#ifndef _WIN32
 TEST_CASE(test_symlink_status_cannot_resolve)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file_in_dir = env.create_file("dir/file", 42);
     const path sym_in_dir = env.create_symlink("dir/file", "dir/bad_sym");
     const path sym_points_in_dir = env.create_symlink("dir/file", "sym");
     permissions(dir, perms::none);
// can be stat-ed using symlink_status
         TEST_CHECK(st.type() == file_type::symlink);
         TEST_CHECK(st.permissions() != perms::unknown);
         // test non-throwing version
         TEST_REQUIRE_NO_THROW(st = symlink_status(sym_points_in_dir));
         TEST_CHECK(st.type() == file_type::symlink);
         TEST_CHECK(st.permissions() != perms::unknown);
     }
 }
+#endif
 
 
 TEST_CASE(symlink_status_file_types_test)
 {
     static_test_env static_env;
     scoped_test_env env;
     struct TestCase {
       path p;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp

for (auto& TC : cases) {
         PutEnv(TC.name, file);
         ec = GetTestEC();
         ret = temp_directory_path(ec);
         LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc)));
         TEST_CHECK(ec != GetTestEC());
         TEST_CHECK(ec);
         TEST_CHECK(ret == "");
 
+        // Windows doesn't support setting perms::none to trigger failures
+        // reading directories.
+#ifndef _WIN32
         // Set the env variable to point to a dir we can't access
         PutEnv(TC.name, nested_dir);
         ec = GetTestEC();
         ret = temp_directory_path(ec);
         TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
         TEST_CHECK(ret == "");
+#endif
 
         // Set the env variable to point to a non-existent dir
         PutEnv(TC.name, TC.p / "does_not_exist");
         ec = GetTestEC();
         ret = temp_directory_path(ec);
         TEST_CHECK(ec != GetTestEC());
         TEST_CHECK(ec);
         TEST_CHECK(ret == "");