[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.mods/refresh.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: with_system_cxx_lib=macosx10.15
 
 // <filesystem>
 
 // class directory_entry
 
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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // class directory_entry
 
 // directory_entry& operator=(directory_entry const&) = default;
 // directory_entry& operator=(directory_entry&&) noexcept = default;
 // void assign(path const&);
 // void replace_filename(path const&);
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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: with_system_cxx_lib=macosx10.15
 
 // <filesystem>
 
 // class directory_entry
 
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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // class directory_entry
 
 // file_status status() const;
 // file_status status(error_code const&) const noexcept;
 
 #include "filesystem_include.h"
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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: with_system_cxx_lib=macosx10.15
 
 // <filesystem>
 
 // class directory_entry
 
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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: with_system_cxx_lib=macosx10.15
 
 // <filesystem>
 
 // class directory_entry
 
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.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator++();
 // recursive_directory_iterator& increment(error_code& ec) noexcept;
 
 #include "filesystem_include.h"
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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // This test requires the dylib support introduced in D92769.
 // XFAIL: with_system_cxx_lib=macosx10.15
 
 // <filesystem>
 
 // bool create_directory(const path& p, const path& attr);
 // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
 
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.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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // bool remove(const path& p);
 // bool remove(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
#endif
     scoped_test_env env;
     const path non_empty_dir = env.create_dir("dir");
     env.create_file(non_empty_dir / "file1", 42);
     const path bad_perms_dir = env.create_dir("bad_dir");
     const path file_in_bad_dir = env.create_file(bad_perms_dir / "file", 42);
     permissions(bad_perms_dir, perms::none);
     const path testCases[] = {
         non_empty_dir,
+#ifndef _WIN32
+        // Windows doesn't support setting perms::none on a directory to
+        // stop it from being accessed. And a fictional file under
+        // GetWindowsInaccessibleDir() doesn't cause fs::remove() to report
+        // errors, it just returns false cleanly.
         file_in_bad_dir,
+#endif
     };
     for (auto& p : testCases) {
         std::error_code ec;
 
         TEST_CHECK(!fs::remove(p, ec));
         TEST_CHECK(ec);
         TEST_CHECK(checkThrow(p, ec));
     }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // uintmax_t remove_all(const path& p);
 // uintmax_t remove_all(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
TEST_CASE(test_signatures)
     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));
 }
 
 TEST_CASE(test_error_reporting)
 {
+    scoped_test_env env;
+    // Windows doesn't support setting perms::none to trigger failures
+    // reading directories.
+#ifndef _WIN32
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::remove_all(f);
             return false;
         } catch (filesystem_error const& err) {
             return err.path1() == f
                 && err.path2() == ""
                 && err.code() == ec;
         }
 #else
         ((void)f); ((void)ec);
         return true;
 #endif
     };
-    scoped_test_env env;
     const path non_empty_dir = env.create_dir("dir");
     env.create_file(non_empty_dir / "file1", 42);
     const path bad_perms_dir = env.create_dir("bad_dir");
     const path file_in_bad_dir = env.create_file(bad_perms_dir / "file", 42);
     permissions(bad_perms_dir, perms::none);
     const path bad_perms_file = env.create_file("file2", 42);
     permissions(bad_perms_file, perms::none);
 
     const path testCases[] = {
         file_in_bad_dir
     };
     const auto BadRet = static_cast<std::uintmax_t>(-1);
     for (auto& p : testCases) {
         std::error_code ec;
 
         TEST_CHECK(fs::remove_all(p, ec) == BadRet);
         TEST_CHECK(ec);
         TEST_CHECK(checkThrow(p, ec));
     }
+#endif
 
     // PR#35780
     const path testCasesNonexistant[] = {
         "",
         env.make_env_path("dne")
     };
     for (auto &p : testCasesNonexistant) {
         std::error_code ec;

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // file_status status(const path& p);
 // file_status status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
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. Imaginary files under GetWindowsInaccessibleDir()
+// produce no_such_file_or_directory, not the error codes this test checks
+// for. Finally, status() for a too long file name doesn't return errors
+// on windows.
+#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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // file_status symlink_status(const path& p);
 // file_status symlink_status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
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. Imaginary files under GetWindowsInaccessibleDir()
+// produce no_such_file_or_directory, not the error codes this test checks
+// for. Finally, status() for a too long file name doesn't return errors
+// on windows.
+#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;