[libcxx] [test] Use GetWindowsInaccessibleDir() in a couple more tests

[curdeius]

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

114

Just thinking out loud, if you used nested_dir = dir on Windows, wouldn't that provoke permission_denied error?

[mstorsjo]

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

114

That's true, why didn't I just go with that? Updating...

[mstorsjo]

Simplify the modification in temp_directory_path

[curdeius]

LGTM apart from the comment.

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

108

I'd like a small comment here about the difference on Windows, as we cannot create any file inside the inaccessible directory so we cannot test the same thing.

[mstorsjo]

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

108

Ok, amended it locally with this comment:

// We can't create files in the directory we use as inaccessible directory
// for tests on Windows, so this doesn't test exactly the same as the
// code below.

[curdeius]

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

108

+1

[mstorsjo]

Ping @Mordante (who reviewed a similar patch earlier) for second approval

[mstorsjo]

Amended to remove xfails and to allow the dir to be missing. Has 1 approval from earlier, but the temp_dir_path test is modified a bit differently then all the others so it might warrant another look.

[curdeius]

Still LGTM.

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.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", 101);
     TEST_CHECK(ent.is_symlink());
     TEST_CHECK(ent.is_regular_file());
   }
 }
 
 TEST_CASE(test_assign_propagates_error) {
   using namespace fs;
   scoped_test_env env;
+#ifdef _WIN32
+  // Windows doesn't support setting perms::none to trigger failures
+  // reading directories; test using a special inaccessible directory
+  // instead.
+  const path dir = GetWindowsInaccessibleDir();
+  if (dir.empty())
+    TEST_UNSUPPORTED();
+  const path file = dir / "inaccessible_file";
+  // We can't create files in the inaccessible directory, so this doesn't
+  // test exactly the same as the code below.
+  const path sym_out_of_dir = env.create_symlink(file, "sym");
+  {
+    directory_entry ent;
+    std::error_code ec = GetTestEC();
+    ent.assign(file, ec);
+    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+  }
+#else
   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");
 
   permissions(dir, perms::none);
 
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
     TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
   }
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
     TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
   }
+#endif
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
     TEST_CHECK(!ec);
   }
 }
 
 TEST_SUITE_END()

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

// 'skip_permissions_denied' is given.
         TEST_CHECK(it == RDI{});
     }
 }
 
 
 TEST_CASE(access_denied_to_file_test_case)
 {
     using namespace fs;
+#ifdef _WIN32
+    // Windows doesn't support setting perms::none to trigger failures
+    // reading directories; test using a special inaccessible directory
+    // instead.
+    const path testDir = GetWindowsInaccessibleDir();
+    if (testDir.empty())
+        TEST_UNSUPPORTED();
+    path const testFile = testDir / "inaccessible_file";
+#else
     scoped_test_env env;
     path const testFile = env.make_env_path("file1");
     env.create_file(testFile, 42);
 
     // Change the permissions so we can no longer iterate
     permissions(testFile, perms::none);
+#endif
 
     // Check that the construction fails when skip_permissions_denied is
     // not given.
     {
         std::error_code ec;
         RDI it(testFile, ec);
         TEST_REQUIRE(ec);
         TEST_CHECK(it == RDI{});

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.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>
 
 // path temp_directory_path();
 // path temp_directory_path(error_code& ec);
 
 #include "filesystem_include.h"
 #include <memory>
 #include <cstdlib>
TEST_CASE(signature_test)
     ASSERT_NOT_NOEXCEPT(temp_directory_path(ec));
 }
 
 TEST_CASE(basic_tests)
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path file = env.create_file("file", 42);
+#ifdef _WIN32
+    // Windows doesn't support setting perms::none to trigger failures
+    // reading directories; test using a special inaccessible directory
+    // instead.
+    const path inaccessible_dir = GetWindowsInaccessibleDir();
+#else
     const path dir_perms = env.create_dir("bad_perms_dir");
-    const path nested_dir = env.create_dir("bad_perms_dir/nested");
+    const path inaccessible_dir = env.create_dir("bad_perms_dir/nested");
     permissions(dir_perms, perms::none);
+#endif
     LIBCPP_ONLY(const std::errc expect_errc = std::errc::not_a_directory);
     struct TestCase {
       std::string name;
       path p;
     } cases[] = {
 #ifdef _WIN32
         {"TMP", env.create_dir("dir1")},
         {"TEMP", env.create_dir("dir2")},
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 == "");
 
+        if (!inaccessible_dir.empty()) {
             // Set the env variable to point to a dir we can't access
-        PutEnv(TC.name, nested_dir);
+            PutEnv(TC.name, inaccessible_dir);
             ec = GetTestEC();
             ret = temp_directory_path(ec);
             TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
             TEST_CHECK(ret == "");
+        }
 
         // 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 == "");