[libc++] [test] Generate static_test_env on the fly

[broadwaylamb]

Summary

Instead of storing static_test_env (with all the symlinks) in the repo, we create it on the fly to be cross-toolchain-friendly. The primary use case for this are Windows-hosted cross-toolchains. Windows doesn't really have a concept of symlinks. So, when the monorepo is cloned, those symlinks turn to ordinary text files. Previously, if we cross-compiled libc++ for some symlink-friendly system (e. g. Linux) and ran tests on the target system, some tests would fail. This patch makes them pass.

I'm not sure though about the need to create the RAII object in each test case that relies on static_test_env being present. Maybe a global would be better. Please let me know what you think.

[broadwaylamb]

Or maybe we'd rather generate the whole tree of static_test_env, not just symlinks?

[ldionne]

I kind of think that we should do away with the static test env entirely, and always create it on the fly when we need it. It seems like this would be cleaner, and if we made .Root a member variable of static_test_env, it would be impossible to forget to create it. Right now, it's not really obvious how the static test env is created, and with this patch it's possible to forget to create it properly altogether.

My preference would be that static_test_env sets up the whole static test environment in the current directory, and that tests that need it create the environment as a local variable. We could also remove it from // FILE_DEPENDENCIES lines in the relevant tests. WDYT?

libcxx/test/support/filesystem_test_helper.h

46–53

I normally love comments, but I don't think the explanation part of why we're doing it this way now belongs in that comment. This is for the git history to tell instead.

57

range-based for loop?

61

What about the bad symlink -- won't it fail here?

[ldionne]

In D78200#1983649, @broadwaylamb wrote:

Or maybe we'd rather generate the whole tree of static_test_env, not just symlinks?

I saw your comment after I had typed mine. But if that wasn't clear, that's basically what my comment meant.

[EricWF]

The entire point of the static test environment is that it's /static/.
Meaning it's checked in and not created on the fly.

[broadwaylamb]

Generate all static_test_env on the fly, not just symlinks

[ldionne]

In D78200#1987067, @EricWF wrote:

The entire point of the static test environment is that it's /static/.
Meaning it's checked in and not created on the fly.

Do you have an idea to deal with the problem described on Windows? Would you prefer if we only created symlinks on the fly (like the first version of this patch does)?

[broadwaylamb]

ping

[broadwaylamb]

@ldionne @EricWF am I getting it right that this patch is the wrong direction? How the described Windows issue could be resolved otherwise?

[ldionne]

In D78200#2017911, @broadwaylamb wrote:

@ldionne @EricWF am I getting it right that this patch is the wrong direction? How the described Windows issue could be resolved otherwise?

I personally think it's the right direction. I believe Eric's point is that creating the static environment *statically* has the benefit that we know exactly what input our tests are running on, whereas we don't when we create the environment on the fly (e.g. there could be a bug in how we generate the env). However, given the difficulty with Windows, I'm OK with that.

Unless we can find another way to solve this problem, I believe we should move forward with this patch so as to enable Filesystem testing from a Windows host.

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

54–56

Just to confirm, you add the guard here because we change the current directory, but the directory is then removed so the test would fail if we didn't go back to the previous cwd at the end?

[broadwaylamb]

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

54–56

This test wouldn't fail, but other tests would. Otherwise yes, exactly as you said.

[EricWF]

When I initially wrote the filesystem tests, I had divided them between "static" and "dynamic"; that is, tests which modified the target filesystem and those which did not.

I was concerned that some targets supported by libc++ wouldn't have the runtime dependencies for "dynamic" tests available. I didn't want these targets to have no filesystem tests,
I tried to write a minimal subset of tests which were "static".

I don't know that my initial concerned panned out, so I have reserved support for removing it if needed. That said, I don't understand how this patch makes these tests pass on Windows.
If Windows doesn't support symlinks, how does dynamically creating them make a difference?

Because this change unknowingly broke tests, I'm going to revert it.
We can recommit it after ensuring there are no other accidental changes.

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

65–66

This test is no longer correct.
I assume this change broke or changed the meaning of other tests as well.

If we're creating the static test env using a RAII guard,
that RAII guard should be the only way to name the members of the static environment
and the old StaticEnv::Foo variables should be removed.

[EricWF]

Unless I'm mistaken, this change is racy. Tests in different files are run in parallel.
One test could be tearing down the static environment while another in trying to construct it.

[broadwaylamb]

Update the diff to reflect the committed changes

[broadwaylamb]

I'm sorry, I've messed up. I first committed this as rG645ad5badbabdeca31de5c98ea8135c5a6e7d710, but then realized that I've committed the previous version of this patch. So I reverted it and recommitted as 52cc8bac7780dbfb90dcc8cfe24696618eeaa06e.

In D78200#2021841, @EricWF wrote:

That said, I don't understand how this patch makes these tests pass on Windows.
If Windows doesn't support symlinks, how does dynamically creating them make a difference?

This patch is not about making them pass on Windows, but rather about making them pass on Linux in the case when we cross-compile them on Windows.

Because this change unknowingly broke tests, I'm going to revert it.
We can recommit it after ensuring there are no other accidental changes.

Could you please point me to the test failures? I didn't receive any e-mails.

Unless I'm mistaken, this change is racy. Tests in different files are run in parallel.
One test could be tearing down the static environment while another in trying to construct it.

This is not the case as of 52cc8bac7780dbfb90dcc8cfe24696618eeaa06e. Each RAII object creates a new temporary directory using mktemps (more precisely, it uses scoped_test_env under the hood).

Again, my apologies for messing up the diff here.

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

65–66

Now it should be fine.

[EricWF]

In D78200#2022470, @broadwaylamb wrote:

I'm sorry, I've messed up. I first committed this as rG645ad5badbabdeca31de5c98ea8135c5a6e7d710, but then realized that I've committed the previous version of this patch. So I reverted it and recommitted as 52cc8bac7780dbfb90dcc8cfe24696618eeaa06e.

In D78200#2021841, @EricWF wrote:

That said, I don't understand how this patch makes these tests pass on Windows.
If Windows doesn't support symlinks, how does dynamically creating them make a difference?

This patch is not about making them pass on Windows, but rather about making them pass on Linux in the case when we cross-compile them on Windows.

In that case, would it not be sufficient to have the source tree checked out on the target system, and specify that location while compiling on the host?
I don't see why a change of this size is needed to solve that particular problem.

Because this change unknowingly broke tests, I'm going to revert it.
We can recommit it after ensuring there are no other accidental changes.

Could you please point me to the test failures? I didn't receive any e-mails.

The test I left that comment on was broken. It still passed, but it changed meaning.
It was checking that exists on a broken symlink returned false, but your change
turned a broken symlink into a file that didn't exist. So the test continued to pass,
but for the wrong reasons.

Unless I'm mistaken, this change is racy. Tests in different files are run in parallel.
One test could be tearing down the static environment while another in trying to construct it.

This is not the case as of 52cc8bac7780dbfb90dcc8cfe24696618eeaa06e. Each RAII object creates a new temporary directory using mktemps (more precisely, it uses scoped_test_env under the hood).

I don't see how that's possible since the static environment was still being referenced via the StaticEnv globals, but maybe I didn't look hard enough.

Again, my apologies for messing up the diff here.

[EricWF]

If we don't want the static env, we should remove it entirely.
Meaning, we should convert each of these tests to use dynamic_test_env and setup the required files like the remainder of the tests do.

libcxx/test/support/filesystem_test_helper.h

306

I'm not OK with changing the tests working directory during the test.

[EricWF]

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

54–56

You are now using current_path in the setup for the current_path tests.
This is not OK. You cannot use the entity under test in said entities tests.

Please revert the patch.

[ldionne]

@EricWF I understand your concern about using function foo() in the setup for testing function foo(). However, the flipside is that we have to reimplement e.g. current_path() ourselves in filesystem_helper.h, which entails basically copy-pasting it from the libc++ sources. And that's not much better IMO. Previously, we worked around that by using Python to do these things, but that assumes Python on the target, and we can't assume that.

If we had another way of solving the problem on Windows, we would not need this patch and everything would be much simpler. So let me ask again what I asked above:

Do you (or anyone else) have an idea to deal with the problem described on Windows? Would you prefer if we only created symlinks on the fly (like the first version of this patch does)?

For context, here's what the problem is:

Windows doesn't really have a concept of symlinks. So, when the monorepo is cloned, those symlinks turn to ordinary text files. Previously, if we cross-compiled libc++ for some symlink-friendly system (e. g. Linux) and ran tests on the target system, some tests would fail.

If we can solve this problem differently, I'm all for it. One possibility would be to store a tarball of the static environment in the source tree, and then automatically untar it only when on the target system -- this way Windows would never see any symlinks. Thoughts?

libcxx/test/support/filesystem_test_helper.h

306

Some tests already do this. This is just moving CwdGuard from canonical.pass.cpp to this header so it can be reused.

[broadwaylamb]

I've reverted the commit.

In D78200#2023484, @EricWF wrote:

In that case, would it not be sufficient to have the source tree checked out on the target system, and specify that location while compiling on the host?
I don't see why a change of this size is needed to solve that particular problem.

Checking out the source tree on the target machine is not an option simply because the size of the monorepo checkout is close to the size of the remaining disk space on our board.

I don't see how that's possible since the static environment was still being referenced via the StaticEnv globals, but maybe I didn't look hard enough.

I've completely removed the StaticEnv namespace, so I'm pretty sure those globals are not referenced anymore.

If we don't want the static env, we should remove it entirely.
Meaning, we should convert each of these tests to use dynamic_test_env and setup the required files like the remainder of the tests do.

Would you be OK with this solution?

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

54–56

Good point.

Would it be okay to use POSIX functions in the CWDGuard implementation instead?

libcxx/test/support/filesystem_test_helper.h

306

I'm not sure I understand what you mean. Some tests that test the current_path() function would inevitably change the working directory, it's just that we want to set it back so they don't affect other tests.

And if we're going to use dynamic_test_env, this will still be the case.

[broadwaylamb]

In D78200#2023574, @ldionne wrote:

If we can solve this problem differently, I'm all for it. One possibility would be to store a tarball of the static environment in the source tree, and then automatically untar it only when on the target system -- this way Windows would never see any symlinks. Thoughts?

I like this!

[smeenai]

Sorry for jumping in without context, but wanted to chime in on one thing.

Windows doesn't really have a concept of symlinks. So, when the monorepo is cloned, those symlinks turn to ordinary text files. Previously, if we cross-compiled libc++ for some symlink-friendly system (e. g. Linux) and ran tests on the target system, some tests would fail.

This isn't right. Windows has supported symbolic links since Vista. The big limitation was that you needed to be in an elevated process to be able to create symbolic links. Windows 10 lifted that limitation in Developer Mode starting with the April 2017 release (https://blogs.windows.com/windowsdeveloper/2016/12/02/symlinks-windows-10/). If git for Windows isn't creating symbolic links properly, that's a git issue and not a Windows issue (although I recognize it doesn't make much difference for the end user). Some searching suggests that you should be able to configure Git on Windows to handle symlinks correctly (https://github.com/libgit2/libgit2/pull/4713, and https://github.community/t5/How-to-use-Git-and-GitHub/git-bash-symbolic-links-on-windows/m-p/11488#M3732 shows an option to enable symbolic links when running the setup).

[broadwaylamb]

In D78200#2023624, @smeenai wrote:

Sorry for jumping in without context, but wanted to chime in on one thing.

Windows doesn't really have a concept of symlinks. So, when the monorepo is cloned, those symlinks turn to ordinary text files. Previously, if we cross-compiled libc++ for some symlink-friendly system (e. g. Linux) and ran tests on the target system, some tests would fail.

This isn't right. Windows has supported symbolic links since Vista. The big limitation was that you needed to be in an elevated process to be able to create symbolic links. Windows 10 lifted that limitation in Developer Mode starting with the April 2017 release (https://blogs.windows.com/windowsdeveloper/2016/12/02/symlinks-windows-10/). If git for Windows isn't creating symbolic links properly, that's a git issue and not a Windows issue (although I recognize it doesn't make much difference for the end user). Some searching suggests that you should be able to configure Git on Windows to handle symlinks correctly (https://github.com/libgit2/libgit2/pull/4713, and https://github.community/t5/How-to-use-Git-and-GitHub/git-bash-symbolic-links-on-windows/m-p/11488#M3732 shows an option to enable symbolic links when running the setup).

I am aware of this, and I even had some success turning on support for symlinks on Windows. Which gives me the right to say that this process requires a little more involvement than it should :-)

However, things are even more complicated on the buildbot (which is the main purpose of this effort). Namely, there are some limitations of the buildbot platform that won't allow passing custom flags to Git when cloning the repo.

(But yeah, my wording could be more precise here.)

[EricWF]

In D78200#2023637, @broadwaylamb wrote:

In D78200#2023624, @smeenai wrote:

Sorry for jumping in without context, but wanted to chime in on one thing.

Windows doesn't really have a concept of symlinks. So, when the monorepo is cloned, those symlinks turn to ordinary text files. Previously, if we cross-compiled libc++ for some symlink-friendly system (e. g. Linux) and ran tests on the target system, some tests would fail.

This isn't right. Windows has supported symbolic links since Vista. The big limitation was that you needed to be in an elevated process to be able to create symbolic links. Windows 10 lifted that limitation in Developer Mode starting with the April 2017 release (https://blogs.windows.com/windowsdeveloper/2016/12/02/symlinks-windows-10/). If git for Windows isn't creating symbolic links properly, that's a git issue and not a Windows issue (although I recognize it doesn't make much difference for the end user). Some searching suggests that you should be able to configure Git on Windows to handle symlinks correctly (https://github.com/libgit2/libgit2/pull/4713, and https://github.community/t5/How-to-use-Git-and-GitHub/git-bash-symbolic-links-on-windows/m-p/11488#M3732 shows an option to enable symbolic links when running the setup).

I am aware of this, and I even had some success turning on support for symlinks on Windows. Which gives me the right to say that this process requires a little more involvement than it should :-)

However, things are even more complicated on the buildbot (which is the main purpose of this effort). Namely, there are some limitations of the buildbot platform that won't allow passing custom flags to Git when cloning the repo.

Buildbot's Git module allows you to pass in a config object, so I don't understand the problem.
http://docs.buildbot.net/0.8.9/manual/cfg-buildsteps.html#git

Are you using an even older version of Buildbot?
If so you can always insert the symlink config option by putting it in a .gitconfig file.

(But yeah, my wording could be more precise here.)

[broadwaylamb]

In D78200#2025807, @EricWF wrote:

Buildbot's Git module allows you to pass in a config object, so I don't understand the problem.
http://docs.buildbot.net/0.8.9/manual/cfg-buildsteps.html#git

Are you using an even older version of Buildbot?
If so you can always insert the symlink config option by putting it in a .gitconfig file.

I didn't know about this, thanks.

However, the question is whether we want to depend on the presence of this filesystem feature on the host machine. I personally was surprised to see test failures caused by this, when everything else was in place. We could document that whoever wants to run libc++ tests in this setup will need to do some extra work setting up their environment and even re-cloning the whole monorepo (which takes some time). But I think it is too much to ask the user to do.

Besides, @danalbert has mentioned that Android would also benefit from this.

[broadwaylamb]

Reimplement CWDGuard using POSIX functions.

[ldionne]

With the updated CWDGuard, I don't think we had any remaining major objections. Like we noted in our offline discussions, we would like to have more consistency between the static env and the dynamic env, but this patch seems like an OK stepping stone.

libcxx/test/std/input.output/filesystems/Inputs/static_test_env/bad_symlink

-dne
 

libcxx/test/std/input.output/filesystems/Inputs/static_test_env/dir1/dir2/symlink_to_dir3

-dir3
 

libcxx/test/std/input.output/filesystems/Inputs/static_test_env/dir1/file2

-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 

libcxx/test/std/input.output/filesystems/Inputs/static_test_env/non_empty_file

-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 

libcxx/test/std/input.output/filesystems/Inputs/static_test_env/symlink_to_dir

-dir1
 

libcxx/test/std/input.output/filesystems/Inputs/static_test_env/symlink_to_empty_file

-empty_file
 

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_entry
 
 // explicit directory_entry(const path);
 // directory_entry(const path&, error_code& ec);
TEST_CASE(path_ctor) {
   {
     const path p("foo/bar/baz");
     const directory_entry e(p);
     TEST_CHECK(e.path() == p);
   }
 }
 
 TEST_CASE(path_ec_ctor) {
+  static_test_env static_env;
   using namespace fs;
   {
     static_assert(
         std::is_constructible<directory_entry, const path&,
                               std::error_code&>::value,
         "directory_entry must be constructible from path and error_code");
     static_assert(!std::is_nothrow_constructible<directory_entry, const path&,
                                                  std::error_code&>::value,
                   "directory_entry constructor should not be noexcept");
     static_assert(
         test_convertible<directory_entry, const path&, std::error_code&>(),
         "directory_entry constructor should not be explicit");
   }
   {
     std::error_code ec = GetTestEC();
-    const directory_entry e(StaticEnv::File, ec);
-    TEST_CHECK(e.path() == StaticEnv::File);
+    const directory_entry e(static_env.File, ec);
+    TEST_CHECK(e.path() == static_env.File);
     TEST_CHECK(!ec);
   }
   {
     const path p("foo/bar/baz");
     std::error_code ec = GetTestEC();
     const directory_entry e(p, ec);
     TEST_CHECK(e.path() == p);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
env.create_file("dir/file", 101);
     TEST_CHECK(ent.file_size() == 101);
     TEST_CHECK(ent_ec.file_size() == 101);
   }
 }
 
 TEST_CASE(path_ctor_dne) {
   using namespace fs;
 
+  static_test_env static_env;
+
   {
     std::error_code ec = GetTestEC();
-    directory_entry ent(StaticEnv::DNE, ec);
+    directory_entry ent(static_env.DNE, ec);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
-    TEST_CHECK(ent.path() == StaticEnv::DNE);
+    TEST_CHECK(ent.path() == static_env.DNE);
   }
   // don't report dead symlinks as an error.
   {
     std::error_code ec = GetTestEC();
-    directory_entry ent(StaticEnv::BadSymlink, ec);
+    directory_entry ent(static_env.BadSymlink, ec);
     TEST_CHECK(!ec);
-    TEST_CHECK(ent.path() == StaticEnv::BadSymlink);
+    TEST_CHECK(ent.path() == static_env.BadSymlink);
   }
   // DNE does not cause the constructor to throw
   {
-    directory_entry ent(StaticEnv::DNE);
-    TEST_CHECK(ent.path() == StaticEnv::DNE);
+    directory_entry ent(static_env.DNE);
+    TEST_CHECK(ent.path() == static_env.DNE);
 
-    directory_entry ent_two(StaticEnv::BadSymlink);
-    TEST_CHECK(ent_two.path() == StaticEnv::BadSymlink);
+    directory_entry ent_two(static_env.BadSymlink);
+    TEST_CHECK(ent_two.path() == static_env.BadSymlink);
   }
 }
 
 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);

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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_entry
 
 // directory_entry& operator=(directory_entry const&) = default;
 // directory_entry& operator=(directory_entry&&) noexcept = default;
using namespace fs;
     e.replace_filename(replace);
     TEST_CHECK(e.path() == expect);
   }
 }
 
 TEST_CASE(test_replace_filename_ec_method) {
   using namespace fs;
 
+  static_test_env static_env;
   {
     directory_entry e;
     path replace;
     std::error_code ec;
     static_assert(noexcept(e.replace_filename(replace, ec)) == false,
                   "operation cannot be noexcept");
     static_assert(
         std::is_same<decltype(e.replace_filename(replace, ec)), void>::value,
         "operation must return void");
   }
   {
     const path p("/path/to/foo.exe");
     const path replace("bar.out");
     const path expect("/path/to/bar.out");
     directory_entry e(p);
     TEST_CHECK(e.path() == p);
     std::error_code ec = GetTestEC();
     e.replace_filename(replace, ec);
     TEST_CHECK(e.path() == expect);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
   }
   {
-    const path p = StaticEnv::EmptyFile;
-    const path expect = StaticEnv::NonEmptyFile;
-    const path replace = StaticEnv::NonEmptyFile.filename();
+    const path p = static_env.EmptyFile;
+    const path expect = static_env.NonEmptyFile;
+    const path replace = static_env.NonEmptyFile.filename();
     TEST_REQUIRE(expect.parent_path() == p.parent_path());
     directory_entry e(p);
     TEST_CHECK(e.path() == p);
     std::error_code ec = GetTestEC();
     e.replace_filename(replace, ec);
     TEST_CHECK(e.path() == expect);
     TEST_CHECK(!ec);
   }

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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_entry
 
 // uintmax_t file_size() const;
 // uintmax_t file_size(error_code const&) const noexcept;
for (auto const& TC : TestCases) {
     ExceptionChecker Checker(p, TC.expected_err, "directory_entry::file_size");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
   }
 }
 
 TEST_CASE(error_reporting) {
   using namespace fs;
 
+  static_test_env static_env;
   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");
 
   const perms old_perms = status(dir).permissions();
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    ent.assign(StaticEnv::DNE, ec);
-    TEST_REQUIRE(ent.path() == StaticEnv::DNE);
+    ent.assign(static_env.DNE, ec);
+    TEST_REQUIRE(ent.path() == static_env.DNE);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    ExceptionChecker Checker(StaticEnv::DNE,
+    ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::file_size");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    uintmax_t expect_bad = file_size(StaticEnv::BadSymlink, ec);
+    uintmax_t expect_bad = file_size(static_env.BadSymlink, ec);
     TEST_CHECK(expect_bad == uintmax_t(-1));
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    ent.assign(StaticEnv::BadSymlink, ec);
-    TEST_REQUIRE(ent.path() == StaticEnv::BadSymlink);
+    ent.assign(static_env.BadSymlink, ec);
+    TEST_REQUIRE(ent.path() == static_env.BadSymlink);
     TEST_CHECK(!ec);
 
     ec = GetTestEC();
     TEST_CHECK(ent.file_size(ec) == expect_bad);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    ExceptionChecker Checker(StaticEnv::BadSymlink,
+    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());
   }
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = file_size(file);

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

TEST_CASE(test_with_ec) {
   }
 }
 
 TEST_CASE(test_with_ec_dne) {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
-
-  for (auto p : {StaticEnv::DNE, StaticEnv::BadSymlink}) {
+  static_test_env static_env;
+  for (auto p : {static_env.DNE, static_env.BadSymlink}) {
 
     directory_entry e(p);
     std::error_code status_ec = GetTestEC();
     std::error_code sym_status_ec = GetTestEC(1);
     file_status st = status(p, status_ec);
     file_status sym_st = symlink_status(p, sym_status_ec);
     std::error_code ec = GetTestEC(2);
     auto CheckEC = [&](std::error_code const& other_ec) {

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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_entry
 
 // uintmax_t hard_link_count() const;
 // uintmax_t hard_link_count(error_code const&) const noexcept;
for (auto p : {dir2, fifo, sym_to_fifo}) {
     TEST_CHECK(!ec);
     TEST_CHECK_NO_THROW(ent.hard_link_count());
   }
 }
 
 TEST_CASE(error_reporting) {
   using namespace fs;
 
+  static_test_env static_env;
   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");
 
   const perms old_perms = status(dir).permissions();
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    ent.assign(StaticEnv::DNE, ec);
+    ent.assign(static_env.DNE, ec);
     TEST_CHECK(ec);
-    TEST_REQUIRE(ent.path() == StaticEnv::DNE);
+    TEST_REQUIRE(ent.path() == static_env.DNE);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1));
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    ExceptionChecker Checker(StaticEnv::DNE,
+    ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::hard_link_count");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    uintmax_t expect_bad = hard_link_count(StaticEnv::BadSymlink, ec);
+    uintmax_t expect_bad = hard_link_count(static_env.BadSymlink, ec);
     TEST_CHECK(expect_bad == uintmax_t(-1));
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    ent.assign(StaticEnv::BadSymlink, ec);
-    TEST_REQUIRE(ent.path() == StaticEnv::BadSymlink);
+    ent.assign(static_env.BadSymlink, ec);
+    TEST_REQUIRE(ent.path() == static_env.BadSymlink);
     TEST_CHECK(!ec);
 
     ec = GetTestEC();
     TEST_CHECK(ent.hard_link_count(ec) == expect_bad);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    ExceptionChecker Checker(StaticEnv::BadSymlink,
+    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());
   }
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = hard_link_count(file);

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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_entry
 
 // file_time_type last_write_time() const;
 // file_time_type last_write_time(error_code const&) const noexcept;
env.create_file("file", 99);
     TEST_CHECK(ent.last_write_time(ec) == expect);
     TEST_CHECK(!ec);
   }
 }
 
 TEST_CASE(error_reporting) {
   using namespace fs;
 
+  static_test_env static_env;
   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");
 
   const perms old_perms = status(dir).permissions();
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    ent.assign(StaticEnv::DNE, ec);
-    TEST_REQUIRE(ent.path() == StaticEnv::DNE);
+    ent.assign(static_env.DNE, ec);
+    TEST_REQUIRE(ent.path() == static_env.DNE);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     TEST_CHECK(ent.last_write_time(ec) == file_time_type::min());
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    ExceptionChecker Checker(StaticEnv::DNE,
+    ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::last_write_time");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    file_time_type expect_bad = last_write_time(StaticEnv::BadSymlink, ec);
+    file_time_type expect_bad = last_write_time(static_env.BadSymlink, ec);
     TEST_CHECK(expect_bad == file_time_type::min());
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    ent.assign(StaticEnv::BadSymlink, ec);
-    TEST_REQUIRE(ent.path() == StaticEnv::BadSymlink);
+    ent.assign(static_env.BadSymlink, ec);
+    TEST_REQUIRE(ent.path() == static_env.BadSymlink);
     TEST_CHECK(!ec);
 
     ec = GetTestEC();
     TEST_CHECK(ent.last_write_time(ec) == expect_bad);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    ExceptionChecker Checker(StaticEnv::BadSymlink,
+    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());
   }
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     file_time_type expect_good = last_write_time(file);

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

 #include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
 TEST_SUITE(directory_entry_status_testsuite)
 
 TEST_CASE(test_basic) {
   using namespace fs;
+  static_test_env static_env;
   {
     const fs::directory_entry e("foo");
     std::error_code ec;
     static_assert(std::is_same<decltype(e.status()), fs::file_status>::value, "");
     static_assert(std::is_same<decltype(e.status(ec)), fs::file_status>::value, "");
     static_assert(noexcept(e.status()) == false, "");
     static_assert(noexcept(e.status(ec)) == true, "");
   }
-  path TestCases[] = {StaticEnv::File, StaticEnv::Dir, StaticEnv::SymlinkToFile,
-                      StaticEnv::DNE};
+  path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
+                      static_env.DNE};
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     std::error_code pec = GetTestEC(), eec = GetTestEC(1);
     file_status ps = fs::status(p, pec);
     file_status es = e.status(eec);
     TEST_CHECK(ps.type() == es.type());
     TEST_CHECK(ps.permissions() == es.permissions());
     TEST_CHECK(pec == eec);

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

 #include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
 TEST_SUITE(directory_entry_obs_suite)
 
 TEST_CASE(test_signature) {
   using namespace fs;
+  static_test_env static_env;
   {
     const directory_entry e("foo");
     std::error_code ec;
     static_assert(std::is_same<decltype(e.symlink_status()), file_status>::value, "");
     static_assert(std::is_same<decltype(e.symlink_status(ec)), file_status>::value, "");
     static_assert(noexcept(e.symlink_status()) == false, "");
     static_assert(noexcept(e.symlink_status(ec)) == true, "");
   }
-  path TestCases[] = {StaticEnv::File, StaticEnv::Dir, StaticEnv::SymlinkToFile,
-                      StaticEnv::DNE};
+  path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
+                      static_env.DNE};
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     std::error_code pec = GetTestEC(), eec = GetTestEC(1);
     file_status ps = fs::symlink_status(p, pec);
     file_status es = e.symlink_status(eec);
     TEST_CHECK(ps.type() == es.type());
     TEST_CHECK(ps.permissions() == es.permissions());
     TEST_CHECK(pec == eec);

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator(directory_iterator const&);
 

 {
     const directory_iterator endIt;
     directory_iterator it(endIt);
     TEST_CHECK(it == endIt);
 }
 
 TEST_CASE(test_copy_valid_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     const directory_iterator it(testDir);
     TEST_REQUIRE(it != endIt);
     const path entry = *it;
 
     const directory_iterator it2(it);
     TEST_REQUIRE(it2 == it);
     TEST_CHECK(*it2 == entry);
     TEST_CHECK(*it == entry);
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator& operator=(directory_iterator const&);
 

 TEST_CASE(test_assignment_signature)
 {
     using D = directory_iterator;
     static_assert(std::is_copy_assignable<D>::value, "");
 }
 
 TEST_CASE(test_copy_to_end_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
 
     const directory_iterator from(testDir);
     TEST_REQUIRE(from != directory_iterator{});
     const path entry = *from;
 
     directory_iterator to{};
     to = from;
     TEST_REQUIRE(to == from);
     TEST_CHECK(*to == entry);
     TEST_CHECK(*from == entry);
 }
 
 
 TEST_CASE(test_copy_from_end_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
 
     const directory_iterator from{};
 
     directory_iterator to(testDir);
     TEST_REQUIRE(to != directory_iterator{});
 
     to = from;
     TEST_REQUIRE(to == from);
     TEST_CHECK(to == directory_iterator{});
 }
 
 TEST_CASE(test_copy_valid_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     directory_iterator it_obj(testDir);
     const directory_iterator& it = it_obj;
     TEST_REQUIRE(it != endIt);
     ++it_obj;
     TEST_REQUIRE(it != endIt);
     const path entry = *it;

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // explicit directory_iterator(const path& p);
 // directory_iterator(const path& p, directory_options options);
static_assert(std::is_constructible<D, path, directory_options,
         std::error_code&>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options,
         std::error_code&>::value, "");
 
 }
 
 TEST_CASE(test_construction_from_bad_path)
 {
+    static_test_env static_env;
     std::error_code ec;
     directory_options opts = directory_options::none;
     const directory_iterator endIt;
 
-    const path testPaths[] = { StaticEnv::DNE, StaticEnv::BadSymlink };
+    const path testPaths[] = { static_env.DNE, static_env.BadSymlink };
     for (path const& testPath : testPaths)
     {
         {
             directory_iterator it(testPath, ec);
             TEST_CHECK(ec);
             TEST_CHECK(it == endIt);
         }
         {
TEST_CASE(test_open_on_empty_directory_equals_end)
     {
         directory_iterator it(testDir);
         TEST_CHECK(it == endIt);
     }
 }
 
 TEST_CASE(test_open_on_directory_succeeds)
 {
-    const path testDir = StaticEnv::Dir;
-    std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
-                                std::end(  StaticEnv::DirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    std::set<path> dir_contents(static_env.DirIterationList.begin(),
+                                static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     {
         std::error_code ec;
         directory_iterator it(testDir, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(it != endIt);
         TEST_CHECK(dir_contents.count(*it));
     }
     {
         directory_iterator it(testDir);
         TEST_CHECK(it != endIt);
         TEST_CHECK(dir_contents.count(*it));
     }
 }
 
 TEST_CASE(test_open_on_file_fails)
 {
-    const path testFile = StaticEnv::File;
+    static_test_env static_env;
+    const path testFile = static_env.File;
     const directory_iterator endIt{};
     {
         std::error_code ec;
         directory_iterator it(testFile, ec);
         TEST_REQUIRE(ec);
         TEST_CHECK(it == endIt);
     }
     {
TEST_CASE(test_open_on_dot_dir)
 
     std::error_code ec;
     directory_iterator it(testPath, ec);
     TEST_CHECK(!ec);
 }
 
 TEST_CASE(test_open_on_symlink)
 {
-    const path symlinkToDir = StaticEnv::SymlinkToDir;
+    static_test_env static_env;
+    const path symlinkToDir = static_env.SymlinkToDir;
     std::set<path> dir_contents;
-    for (path const& p : StaticEnv::DirIterationList) {
+    for (path const& p : static_env.DirIterationList) {
         dir_contents.insert(p.filename());
     }
     const directory_iterator endIt{};
 
     {
         std::error_code ec;
         directory_iterator it(symlinkToDir, ec);
         TEST_REQUIRE(!ec);

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator& operator++();
 // directory_iterator& increment(error_code& ec);
TEST_CASE(test_increment_signatures)
     ASSERT_NOT_NOEXCEPT(++d);
 
     ASSERT_SAME_TYPE(decltype(d.increment(ec)), directory_iterator&);
     ASSERT_NOT_NOEXCEPT(d.increment(ec));
 }
 
 TEST_CASE(test_prefix_increment)
 {
-    const path testDir = StaticEnv::Dir;
-    const std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
-                                      std::end(  StaticEnv::DirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const std::set<path> dir_contents(static_env.DirIterationList.begin(),
+                                      static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
         TEST_REQUIRE(it != endIt);
         const path entry = *it;
         TEST_REQUIRE(unseen_entries.erase(entry) == 1);
         directory_iterator& it_ref = ++it;
         TEST_CHECK(&it_ref == &it);
     }
 
     TEST_CHECK(it == endIt);
 }
 
 TEST_CASE(test_postfix_increment)
 {
-    const path testDir = StaticEnv::Dir;
-    const std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
-                                      std::end(  StaticEnv::DirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const std::set<path> dir_contents(static_env.DirIterationList.begin(),
+                                      static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
         TEST_REQUIRE(it != endIt);
         const path entry = *it;
         TEST_REQUIRE(unseen_entries.erase(entry) == 1);
         const path entry2 = *it++;
         TEST_CHECK(entry2 == entry);
     }
 
     TEST_CHECK(it == endIt);
 }
 
 
 TEST_CASE(test_increment_method)
 {
-    const path testDir = StaticEnv::Dir;
-    const std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
-                                      std::end(  StaticEnv::DirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const std::set<path> dir_contents(static_env.DirIterationList.begin(),
+                                      static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator(directory_iterator&&) noexcept;
 
TEST_CASE(test_move_end_iterator)
 
     directory_iterator it(std::move(endIt2));
     TEST_CHECK(it == endIt);
     TEST_CHECK(endIt2 == endIt);
 }
 
 TEST_CASE(test_move_valid_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     directory_iterator it(testDir);
     TEST_REQUIRE(it != endIt);
     const path entry = *it;
 
     const directory_iterator it2(std::move(it));
     TEST_CHECK(*it2 == entry);
 
     TEST_CHECK(it == it2 || it == endIt);
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator& operator=(directory_iterator const&);
 

 TEST_CASE(test_assignment_signature)
 {
     using D = directory_iterator;
     static_assert(std::is_nothrow_move_assignable<D>::value, "");
 }
 
 TEST_CASE(test_move_to_end_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
 
     directory_iterator from(testDir);
     TEST_REQUIRE(from != directory_iterator{});
     const path entry = *from;
 
     directory_iterator to{};
     to = std::move(from);
     TEST_REQUIRE(to != directory_iterator{});
     TEST_CHECK(*to == entry);
 }
 
 
 TEST_CASE(test_move_from_end_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
 
     directory_iterator from{};
 
     directory_iterator to(testDir);
     TEST_REQUIRE(to != from);
 
     to = std::move(from);
     TEST_REQUIRE(to == directory_iterator{});
     TEST_REQUIRE(from == directory_iterator{});
 }
 
 TEST_CASE(test_move_valid_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     directory_iterator it(testDir);
     TEST_REQUIRE(it != endIt);
     ++it;
     TEST_REQUIRE(it != endIt);
     const path entry = *it;
 
TEST_CASE(test_returns_reference_to_self)
     directory_iterator it2;
     directory_iterator& ref = (it2 = it);
     TEST_CHECK(&ref == &it2);
 }
 
 
 TEST_CASE(test_self_move)
 {
+    static_test_env static_env;
     // Create two non-equal iterators that have exactly the same state.
-    directory_iterator it(StaticEnv::Dir);
-    directory_iterator it2(StaticEnv::Dir);
+    directory_iterator it(static_env.Dir);
+    directory_iterator it2(static_env.Dir);
     ++it; ++it2;
     TEST_CHECK(it != it2);
     TEST_CHECK(*it2 == *it);
 
     it = std::move(it);
     TEST_CHECK(*it2 == *it);
 }
 
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator begin(directory_iterator iter) noexcept;
 // directory_iterator end(directory_iterator iter) noexcept;
TEST_CASE(test_function_signatures)
     ASSERT_NOEXCEPT(begin(std::move(d)));
 
     ASSERT_SAME_TYPE(decltype(end(d)), directory_iterator);
     ASSERT_NOEXCEPT(end(std::move(d)));
 }
 
 TEST_CASE(test_ranged_for_loop)
 {
-    const path testDir = StaticEnv::Dir;
-    std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
-                                      std::end(  StaticEnv::DirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    std::set<path> dir_contents(static_env.DirIterationList.begin(),
+                                static_env.DirIterationList.end());
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     for (auto& elem : it) {
         TEST_CHECK(dir_contents.erase(elem) == 1);
     }
     TEST_CHECK(dir_contents.empty());
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&);
 

 {
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(endIt);
     TEST_CHECK(it == endIt);
 }
 
 TEST_CASE(test_copy_valid_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt{};
 
     // build 'it' up with "interesting" non-default state so we can test
     // that it gets copied. We want to get 'it' into a state such that:
     //  it.options() != directory_options::none
     //  it.depth() != 0
     //  it.recursion_pending() != true
     const directory_options opts = directory_options::skip_permission_denied;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 TEST_SUITE(recursive_directory_iterator_copy_assign_tests)
 
-recursive_directory_iterator createInterestingIterator()
+recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::skip_permission_denied
     //   it.depth() == 1
     //   it.recursion_pending() == true
 {
-    const path testDir = StaticEnv::Dir;
+    const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::skip_permission_denied);
     TEST_ASSERT(it != endIt);
     while (it.depth() != 1) {
         ++it;
         TEST_ASSERT(it != endIt);
     }
     TEST_ASSERT(it.depth() == 1);
     it.disable_recursion_pending();
     return it;
 }
 
 
-recursive_directory_iterator createDifferentInterestingIterator()
+recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::follow_directory_symlink
     //   it.depth() == 2
     //   it.recursion_pending() == false
 {
-    const path testDir = StaticEnv::Dir;
+    const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::follow_directory_symlink);
     TEST_ASSERT(it != endIt);
     while (it.depth() != 2) {
         ++it;
         TEST_ASSERT(it != endIt);
     }
     TEST_ASSERT(it.depth() == 2);
     return it;
 }
 
 TEST_CASE(test_assignment_signature) {
     using D = recursive_directory_iterator;
     static_assert(std::is_copy_assignable<D>::value, "");
 }
 
 TEST_CASE(test_copy_to_end_iterator)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt;
 
-    const recursive_directory_iterator from = createInterestingIterator();
+    const recursive_directory_iterator from = createInterestingIterator(static_env);
     const path entry = *from;
 
     recursive_directory_iterator to;
     to = from;
     TEST_REQUIRE(to == from);
     TEST_CHECK(*to == entry);
     TEST_CHECK(to.options() == from.options());
     TEST_CHECK(to.depth() == from.depth());
     TEST_CHECK(to.recursion_pending() == from.recursion_pending());
 }
 
 
 TEST_CASE(test_copy_from_end_iterator)
 {
+    static_test_env static_env;
     const recursive_directory_iterator from;
-    recursive_directory_iterator to = createInterestingIterator();
+    recursive_directory_iterator to = createInterestingIterator(static_env);
 
     to = from;
     TEST_REQUIRE(to == from);
     TEST_CHECK(to == recursive_directory_iterator{});
 }
 
 TEST_CASE(test_copy_valid_iterator)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt;
 
-    const recursive_directory_iterator it = createInterestingIterator();
+    const recursive_directory_iterator it = createInterestingIterator(static_env);
     const path entry = *it;
 
-    recursive_directory_iterator it2 = createDifferentInterestingIterator();
+    recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
     TEST_REQUIRE(it2                   != it);
     TEST_CHECK(it2.options()           != it.options());
     TEST_CHECK(it2.depth()             != it.depth());
     TEST_CHECK(it2.recursion_pending() != it.recursion_pending());
     TEST_CHECK(*it2                    != entry);
 
     it2 = it;
     TEST_REQUIRE(it2                   == it);
     TEST_CHECK(it2.options()           == it.options());
     TEST_CHECK(it2.depth()             == it.depth());
     TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
     TEST_CHECK(*it2                    == entry);
 }
 
 TEST_CASE(test_returns_reference_to_self)
 {
     const recursive_directory_iterator it;
     recursive_directory_iterator it2;
     recursive_directory_iterator& ref = (it2 = it);
     TEST_CHECK(&ref == &it2);
 }
 
 TEST_CASE(test_self_copy)
 {
+    static_test_env static_env;
     // Create two non-equal iterators that have exactly the same state.
-    recursive_directory_iterator it = createInterestingIterator();
-    recursive_directory_iterator it2 = createInterestingIterator();
+    recursive_directory_iterator it = createInterestingIterator(static_env);
+    recursive_directory_iterator it2 = createInterestingIterator(static_env);
     TEST_CHECK(it != it2);
     TEST_CHECK(it2.options()           == it.options());
     TEST_CHECK(it2.depth()             == it.depth());
     TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
     TEST_CHECK(*it2 == *it);
 
     // perform a self-copy and check that the state still matches the
     // other unmodified iterator.

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class directory_iterator
 
 //
 // explicit recursive_directory_iterator(const path& p);
TEST_CASE(test_constructor_signatures)
 
     // directory_iterator(path const&, directory_options, error_code&)
     static_assert(std::is_constructible<D, path, directory_options, std::error_code&>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, "");
 }
 
 TEST_CASE(test_construction_from_bad_path)
 {
+    static_test_env static_env;
     std::error_code ec;
     directory_options opts = directory_options::none;
     const RDI endIt;
 
-    const path testPaths[] = { StaticEnv::DNE, StaticEnv::BadSymlink };
+    const path testPaths[] = { static_env.DNE, static_env.BadSymlink };
     for (path const& testPath : testPaths)
     {
         {
             RDI it(testPath, ec);
             TEST_CHECK(ec);
             TEST_CHECK(it == endIt);
         }
         {
TEST_CASE(test_open_on_empty_directory_equals_end)
     {
         RDI it(testDir);
         TEST_CHECK(it == endIt);
     }
 }
 
 TEST_CASE(test_open_on_directory_succeeds)
 {
-    const path testDir = StaticEnv::Dir;
-    std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
-                                std::end(  StaticEnv::DirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    std::set<path> dir_contents(static_env.DirIterationList.begin(),
+                                static_env.DirIterationList.end());
     const RDI endIt{};
 
     {
         std::error_code ec;
         RDI it(testDir, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(it != endIt);
         TEST_CHECK(dir_contents.count(*it));
     }
     {
         RDI it(testDir);
         TEST_CHECK(it != endIt);
         TEST_CHECK(dir_contents.count(*it));
     }
 }
 
 TEST_CASE(test_open_on_file_fails)
 {
-    const path testFile = StaticEnv::File;
+    static_test_env static_env;
+    const path testFile = static_env.File;
     const RDI endIt{};
     {
         std::error_code ec;
         RDI it(testFile, ec);
         TEST_REQUIRE(ec);
         TEST_CHECK(it == endIt);
     }
     {
         TEST_CHECK_THROW(filesystem_error, RDI(testFile));
     }
 }
 
 TEST_CASE(test_options_post_conditions)
 {
-    const path goodDir = StaticEnv::Dir;
-    const path badDir = StaticEnv::DNE;
+    static_test_env static_env;
+    const path goodDir = static_env.Dir;
+    const path badDir = static_env.DNE;
 
     {
         std::error_code ec;
 
         RDI it1(goodDir, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(it1.options() == directory_options::none);
 

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // int depth() const
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 TEST_SUITE(recursive_directory_iterator_depth_tests)
 
 TEST_CASE(test_depth)
 {
-    const path testDir = StaticEnv::Dir;
-    const path DirDepth1 = StaticEnv::Dir2;
-    const path DirDepth2 = StaticEnv::Dir3;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const path DirDepth1 = static_env.Dir2;
+    const path DirDepth2 = static_env.Dir3;
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
     TEST_CHECK(it.depth() == 0);
 
     bool seen_d1, seen_d2;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // void disable_recursion_pending();
 

 using namespace fs;
 
 TEST_SUITE(recursive_directory_iterator_disable_recursion_pending_tests)
 
 // NOTE: The main semantics of disable_recursion_pending are tested
 // in the 'recursion_pending()' tests.
 TEST_CASE(basic_test)
 {
-    recursive_directory_iterator it(StaticEnv::Dir);
+    static_test_env static_env;
+    recursive_directory_iterator it(static_env.Dir);
     TEST_REQUIRE(it.recursion_pending() == true);
     it.disable_recursion_pending();
     TEST_CHECK(it.recursion_pending() == false);
     it.disable_recursion_pending();
     TEST_CHECK(it.recursion_pending() == false);
 }
 
 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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator++();
 // recursive_directory_iterator& increment(error_code& ec) noexcept;
TEST_CASE(test_increment_signatures)
     ASSERT_NOT_NOEXCEPT(++d);
 
     ASSERT_SAME_TYPE(decltype(d.increment(ec)), recursive_directory_iterator&);
     ASSERT_NOT_NOEXCEPT(d.increment(ec));
 }
 
 TEST_CASE(test_prefix_increment)
 {
-    const path testDir = StaticEnv::Dir;
-    const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
-                                      std::end(  StaticEnv::RecDirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
+                                      static_env.RecDirIterationList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
         TEST_REQUIRE(it != endIt);
         const path entry = *it;
         TEST_REQUIRE(unseen_entries.erase(entry) == 1);
         recursive_directory_iterator& it_ref = ++it;
         TEST_CHECK(&it_ref == &it);
     }
 
     TEST_CHECK(it == endIt);
 }
 
 TEST_CASE(test_postfix_increment)
 {
-    const path testDir = StaticEnv::Dir;
-    const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
-                                      std::end(  StaticEnv::RecDirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
+                                      static_env.RecDirIterationList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
         TEST_REQUIRE(it != endIt);
         const path entry = *it;
         TEST_REQUIRE(unseen_entries.erase(entry) == 1);
         const path entry2 = *it++;
         TEST_CHECK(entry2 == entry);
     }
     TEST_CHECK(it == endIt);
 }
 
 
 TEST_CASE(test_increment_method)
 {
-    const path testDir = StaticEnv::Dir;
-    const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
-                                      std::end(  StaticEnv::RecDirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
+                                      static_env.RecDirIterationList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
         TEST_REQUIRE(it != endIt);
         const path entry = *it;
         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);
 }
 
 TEST_CASE(test_follow_symlinks)
 {
-    const path testDir = StaticEnv::Dir;
-    auto const& IterList = StaticEnv::RecDirFollowSymlinksIterationList;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    auto const& IterList = static_env.RecDirFollowSymlinksIterationList;
 
-    const std::set<path> dir_contents(std::begin(IterList), std::end(IterList));
+    const std::set<path> dir_contents(IterList.begin(), IterList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir,
                               directory_options::follow_directory_symlink, ec);
     TEST_REQUIRE(!ec);
 
     std::set<path> unseen_entries = dir_contents;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator(recursive_directory_iterator&&) noexcept;
 
TEST_CASE(test_move_end_iterator)
 
     recursive_directory_iterator it(std::move(endIt2));
     TEST_CHECK(it == endIt);
     TEST_CHECK(endIt2 == endIt);
 }
 
 TEST_CASE(test_move_valid_iterator)
 {
-    const path testDir = StaticEnv::Dir;
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt{};
 
     // build 'it' up with "interesting" non-default state so we can test
     // that it gets copied. We want to get 'it' into a state such that:
     //  it.options() != directory_options::none
     //  it.depth() != 0
     //  it.recursion_pending() != true
     const directory_options opts = directory_options::skip_permission_denied;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
 

 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wself-move"
 #endif
 
 using namespace fs;
 
 TEST_SUITE(recursive_directory_iterator_move_assign_tests)
 
-recursive_directory_iterator createInterestingIterator()
+recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::skip_permission_denied
     //   it.depth() == 1
     //   it.recursion_pending() == true
 {
-    const path testDir = StaticEnv::Dir;
+    const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::skip_permission_denied);
     TEST_ASSERT(it != endIt);
     while (it.depth() != 1) {
         ++it;
         TEST_ASSERT(it != endIt);
     }
     TEST_ASSERT(it.depth() == 1);
     it.disable_recursion_pending();
     return it;
 }
 
-recursive_directory_iterator createDifferentInterestingIterator()
+recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::follow_directory_symlink
     //   it.depth() == 2
     //   it.recursion_pending() == false
 {
-    const path testDir = StaticEnv::Dir;
+    const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::follow_directory_symlink);
     TEST_ASSERT(it != endIt);
     while (it.depth() != 2) {
         ++it;
         TEST_ASSERT(it != endIt);
     }
     TEST_ASSERT(it.depth() == 2);
     return it;
 }
 
 
 TEST_CASE(test_assignment_signature)
 {
     using D = recursive_directory_iterator;
     static_assert(std::is_nothrow_move_assignable<D>::value, "");
 }
 
 
 TEST_CASE(test_move_to_end_iterator)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt;
 
-    recursive_directory_iterator from = createInterestingIterator();
+    recursive_directory_iterator from = createInterestingIterator(static_env);
     const recursive_directory_iterator from_copy(from);
     const path entry = *from;
 
     recursive_directory_iterator to;
     to = std::move(from);
     TEST_REQUIRE(to != endIt);
     TEST_CHECK(*to == entry);
     TEST_CHECK(to.options() == from_copy.options());
     TEST_CHECK(to.depth() == from_copy.depth());
     TEST_CHECK(to.recursion_pending() == from_copy.recursion_pending());
     TEST_CHECK(from == endIt || from == to);
 }
 
 
 TEST_CASE(test_move_from_end_iterator)
 {
+    static_test_env static_env;
     recursive_directory_iterator from;
-    recursive_directory_iterator to = createInterestingIterator();
+    recursive_directory_iterator to = createInterestingIterator(static_env);
 
     to = std::move(from);
     TEST_REQUIRE(to == from);
     TEST_CHECK(to == recursive_directory_iterator{});
 }
 
 TEST_CASE(test_move_valid_iterator)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt;
 
-    recursive_directory_iterator it = createInterestingIterator();
+    recursive_directory_iterator it = createInterestingIterator(static_env);
     const recursive_directory_iterator it_copy(it);
     const path entry = *it;
 
-    recursive_directory_iterator it2 = createDifferentInterestingIterator();
+    recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
     const recursive_directory_iterator it2_copy(it2);
     TEST_REQUIRE(it2 != it);
     TEST_CHECK(it2.options() != it.options());
     TEST_CHECK(it2.depth() != it.depth());
     TEST_CHECK(it2.recursion_pending() != it.recursion_pending());
     TEST_CHECK(*it2 != entry);
 
     it2 = std::move(it);
TEST_CASE(test_returns_reference_to_self)
     recursive_directory_iterator it;
     recursive_directory_iterator it2;
     recursive_directory_iterator& ref = (it2 = std::move(it));
     TEST_CHECK(&ref == &it2);
 }
 
 TEST_CASE(test_self_move)
 {
+    static_test_env static_env;
     // Create two non-equal iterators that have exactly the same state.
-    recursive_directory_iterator it = createInterestingIterator();
-    recursive_directory_iterator it2 = createInterestingIterator();
+    recursive_directory_iterator it = createInterestingIterator(static_env);
+    recursive_directory_iterator it2 = createInterestingIterator(static_env);
     TEST_CHECK(it != it2);
     TEST_CHECK(it2.options()           == it.options());
     TEST_CHECK(it2.depth()             == it.depth());
     TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
     TEST_CHECK(*it2 == *it);
 
     it = std::move(it);
     TEST_CHECK(it2.options()           == it.options());
     TEST_CHECK(it2.depth()             == it.depth());
     TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
     TEST_CHECK(*it2 == *it);
 }
 
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // void pop();
 // void pop(error_code& ec);
TEST_CASE(signature_tests)
     ASSERT_NOT_NOEXCEPT(it.pop());
     ASSERT_NOT_NOEXCEPT(it.pop(ec)); // may require allocation or other things
 }
 
 // NOTE: Since the order of iteration is unspecified we use a list of
 // seen files at each depth to determine the new depth after a 'pop()' operation.
 TEST_CASE(test_depth)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt{};
 
-    auto& DE0 = StaticEnv::DirIterationList;
-    std::set<path> notSeenDepth0(std::begin(DE0), std::end(DE0));
+    auto& DE0 = static_env.DirIterationList;
+    std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
 
-    auto& DE1 = StaticEnv::DirIterationListDepth1;
-    std::set<path> notSeenDepth1(std::begin(DE1), std::end(DE1));
+    auto& DE1 = static_env.DirIterationListDepth1;
+    std::set<path> notSeenDepth1(DE1.begin(), DE1.end());
 
     std::error_code ec;
-    recursive_directory_iterator it(StaticEnv::Dir, ec);
+    recursive_directory_iterator it(static_env.Dir, ec);
     TEST_REQUIRE(it != endIt);
     TEST_CHECK(it.depth() == 0);
 
     while (it.depth() != 2) {
         if (it.depth() == 0)
             notSeenDepth0.erase(it->path());
         else
             notSeenDepth1.erase(it->path());

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // bool recursion_pending() const;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 TEST_SUITE(recursive_directory_iterator_recursion_pending_tests)
 
 TEST_CASE(initial_value_test)
 {
-    recursive_directory_iterator it(StaticEnv::Dir);
+    static_test_env static_env;
+    recursive_directory_iterator it(static_env.Dir);
     TEST_REQUIRE(it.recursion_pending() == true);
 }
 
 TEST_CASE(value_after_copy_construction_and_assignment_test)
 {
-    recursive_directory_iterator rec_pending_it(StaticEnv::Dir);
-    recursive_directory_iterator no_rec_pending_it(StaticEnv::Dir);
+    static_test_env static_env;
+    recursive_directory_iterator rec_pending_it(static_env.Dir);
+    recursive_directory_iterator no_rec_pending_it(static_env.Dir);
     no_rec_pending_it.disable_recursion_pending();
 
     { // copy construction
         recursive_directory_iterator it(rec_pending_it);
         TEST_CHECK(it.recursion_pending() == true);
         it.disable_recursion_pending();
         TEST_REQUIRE(rec_pending_it.recursion_pending() == true);
 
         recursive_directory_iterator it2(no_rec_pending_it);
         TEST_CHECK(it2.recursion_pending() == false);
     }
     { // copy assignment
-        recursive_directory_iterator it(StaticEnv::Dir);
+        recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         it = rec_pending_it;
         TEST_CHECK(it.recursion_pending() == true);
         it.disable_recursion_pending();
         TEST_REQUIRE(rec_pending_it.recursion_pending() == true);
 
-        recursive_directory_iterator it2(StaticEnv::Dir);
+        recursive_directory_iterator it2(static_env.Dir);
         it2 = no_rec_pending_it;
         TEST_CHECK(it2.recursion_pending() == false);
     }
     TEST_CHECK(rec_pending_it.recursion_pending() == true);
     TEST_CHECK(no_rec_pending_it.recursion_pending() == false);
 }
 
 
 TEST_CASE(value_after_move_construction_and_assignment_test)
 {
-    recursive_directory_iterator rec_pending_it(StaticEnv::Dir);
-    recursive_directory_iterator no_rec_pending_it(StaticEnv::Dir);
+    static_test_env static_env;
+    recursive_directory_iterator rec_pending_it(static_env.Dir);
+    recursive_directory_iterator no_rec_pending_it(static_env.Dir);
     no_rec_pending_it.disable_recursion_pending();
 
     { // move construction
         recursive_directory_iterator it_cp(rec_pending_it);
         recursive_directory_iterator it(std::move(it_cp));
         TEST_CHECK(it.recursion_pending() == true);
 
         recursive_directory_iterator it_cp2(no_rec_pending_it);
         recursive_directory_iterator it2(std::move(it_cp2));
         TEST_CHECK(it2.recursion_pending() == false);
     }
     { // copy assignment
-        recursive_directory_iterator it(StaticEnv::Dir);
+        recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         recursive_directory_iterator it_cp(rec_pending_it);
         it = std::move(it_cp);
         TEST_CHECK(it.recursion_pending() == true);
 
-        recursive_directory_iterator it2(StaticEnv::Dir);
+        recursive_directory_iterator it2(static_env.Dir);
         recursive_directory_iterator it_cp2(no_rec_pending_it);
         it2 = std::move(it_cp2);
         TEST_CHECK(it2.recursion_pending() == false);
     }
     TEST_CHECK(rec_pending_it.recursion_pending() == true);
     TEST_CHECK(no_rec_pending_it.recursion_pending() == false);
 }
 
 TEST_CASE(increment_resets_value)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt;
     {
-        recursive_directory_iterator it(StaticEnv::Dir);
+        recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         TEST_CHECK(it.recursion_pending() == false);
         ++it;
         TEST_CHECK(it.recursion_pending() == true);
         TEST_CHECK(it.depth() == 0);
     }
     {
-        recursive_directory_iterator it(StaticEnv::Dir);
+        recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         TEST_CHECK(it.recursion_pending() == false);
         it++;
         TEST_CHECK(it.recursion_pending() == true);
         TEST_CHECK(it.depth() == 0);
     }
     {
-        recursive_directory_iterator it(StaticEnv::Dir);
+        recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         TEST_CHECK(it.recursion_pending() == false);
         std::error_code ec;
         it.increment(ec);
         TEST_CHECK(it.recursion_pending() == true);
         TEST_CHECK(it.depth() == 0);
     }
 }
 
 TEST_CASE(pop_does_not_reset_value)
 {
+    static_test_env static_env;
     const recursive_directory_iterator endIt;
 
-    auto& DE0 = StaticEnv::DirIterationList;
-    std::set<path> notSeenDepth0(std::begin(DE0), std::end(DE0));
+    auto& DE0 = static_env.DirIterationList;
+    std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
 
-    recursive_directory_iterator it(StaticEnv::Dir);
+    recursive_directory_iterator it(static_env.Dir);
     TEST_REQUIRE(it != endIt);
 
     while (it.depth() == 0) {
         notSeenDepth0.erase(it->path());
         ++it;
         TEST_REQUIRE(it != endIt);
     }
     TEST_REQUIRE(it.depth() == 1);

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
 // recursive_directory_iterator end(recursive_directory_iterator iter) noexcept;
TEST_CASE(test_function_signatures)
     ASSERT_NOEXCEPT(begin(std::move(d)));
 
     ASSERT_SAME_TYPE(decltype(end(d)), recursive_directory_iterator);
     ASSERT_NOEXCEPT(end(std::move(d)));
 }
 
 TEST_CASE(test_ranged_for_loop)
 {
-    const path testDir = StaticEnv::Dir;
-    std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
-                                std::end(  StaticEnv::RecDirIterationList));
+    static_test_env static_env;
+    const path testDir = static_env.Dir;
+    std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
+                                static_env.RecDirIterationList.end());
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
     TEST_REQUIRE(!ec);
 
     for (auto& elem : it) {
         TEST_CHECK(dir_contents.erase(elem) == 1);
     }
     TEST_CHECK(dir_contents.empty());
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // uintmax_t hard_link_count(const path& p);
 // uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
TEST_CASE(signature_test)
     ASSERT_SAME_TYPE(decltype(hard_link_count(p)), uintmax_t);
     ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), uintmax_t);
     ASSERT_NOT_NOEXCEPT(hard_link_count(p));
     ASSERT_NOEXCEPT(hard_link_count(p, ec));
 }
 
 TEST_CASE(hard_link_count_for_file)
 {
-    TEST_CHECK(hard_link_count(StaticEnv::File) == 1);
+    static_test_env static_env;
+    TEST_CHECK(hard_link_count(static_env.File) == 1);
     std::error_code ec;
-    TEST_CHECK(hard_link_count(StaticEnv::File, ec) == 1);
+    TEST_CHECK(hard_link_count(static_env.File, ec) == 1);
 }
 
 TEST_CASE(hard_link_count_for_directory)
 {
+    static_test_env static_env;
     uintmax_t DirExpect = 3; // hard link from . .. and Dir2
     uintmax_t Dir3Expect = 2; // hard link from . ..
     uintmax_t DirExpectAlt = DirExpect;
     uintmax_t Dir3ExpectAlt = Dir3Expect;
 #if defined(__APPLE__)
     // Filesystems formatted with case sensitive hfs+ behave unixish as
     // expected. Normal hfs+ filesystems report the number of directory
     // entries instead.
     DirExpectAlt = 5; // .  ..  Dir2  file1  file2
     Dir3Expect = 3; // .  ..  file5
 #endif
-    TEST_CHECK(hard_link_count(StaticEnv::Dir) == DirExpect ||
-               hard_link_count(StaticEnv::Dir) == DirExpectAlt ||
-               hard_link_count(StaticEnv::Dir) == 1);
-    TEST_CHECK(hard_link_count(StaticEnv::Dir3) == Dir3Expect ||
-               hard_link_count(StaticEnv::Dir3) == Dir3ExpectAlt ||
-               hard_link_count(StaticEnv::Dir3) == 1);
+    TEST_CHECK(hard_link_count(static_env.Dir) == DirExpect ||
+               hard_link_count(static_env.Dir) == DirExpectAlt ||
+               hard_link_count(static_env.Dir) == 1);
+    TEST_CHECK(hard_link_count(static_env.Dir3) == Dir3Expect ||
+               hard_link_count(static_env.Dir3) == Dir3ExpectAlt ||
+               hard_link_count(static_env.Dir3) == 1);
 
     std::error_code ec;
-    TEST_CHECK(hard_link_count(StaticEnv::Dir, ec) == DirExpect ||
-               hard_link_count(StaticEnv::Dir, ec) == DirExpectAlt ||
-               hard_link_count(StaticEnv::Dir) == 1);
-    TEST_CHECK(hard_link_count(StaticEnv::Dir3, ec) == Dir3Expect ||
-               hard_link_count(StaticEnv::Dir3, ec) == Dir3ExpectAlt ||
-               hard_link_count(StaticEnv::Dir3) == 1);
+    TEST_CHECK(hard_link_count(static_env.Dir, ec) == DirExpect ||
+               hard_link_count(static_env.Dir, ec) == DirExpectAlt ||
+               hard_link_count(static_env.Dir) == 1);
+    TEST_CHECK(hard_link_count(static_env.Dir3, ec) == Dir3Expect ||
+               hard_link_count(static_env.Dir3, ec) == Dir3ExpectAlt ||
+               hard_link_count(static_env.Dir3) == 1);
 }
 TEST_CASE(hard_link_count_increments_test)
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     TEST_CHECK(hard_link_count(file) == 1);
 
     env.create_hardlink(file, "file_hl");
     TEST_CHECK(hard_link_count(file) == 2);
 }
 
 
 TEST_CASE(hard_link_count_error_cases)
 {
+    static_test_env static_env;
     const path testCases[] = {
-        StaticEnv::BadSymlink,
-        StaticEnv::DNE
+        static_env.BadSymlink,
+        static_env.DNE
     };
     const uintmax_t expect = static_cast<uintmax_t>(-1);
     for (auto& TC : testCases) {
         std::error_code ec;
         TEST_CHECK(hard_link_count(TC, ec) == expect);
         TEST_CHECK(ec);
     }
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // path canonical(const path& p);
 // path canonical(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-struct CWDGuard {
-  path OldCWD;
-  CWDGuard() : OldCWD(fs::current_path()) { }
-  ~CWDGuard() { fs::current_path(OldCWD); }
-
-  CWDGuard(CWDGuard const&) = delete;
-  CWDGuard& operator=(CWDGuard const&) = delete;
-};
-
 TEST_SUITE(filesystem_canonical_path_test_suite)
 
 TEST_CASE(signature_test)
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(canonical(p));
     ASSERT_NOT_NOEXCEPT(canonical(p, ec));
 }
 
 // There are 4 cases is the proposal for absolute path.
 // Each scope tests one of the cases.
 TEST_CASE(test_canonical)
 {
+    static_test_env static_env;
     CWDGuard guard;
     // has_root_name() && has_root_directory()
-    const path Root = StaticEnv::Root;
+    const path Root = static_env.Root;
     const path RootName = Root.filename();
-    const path DirName = StaticEnv::Dir.filename();
-    const path SymlinkName = StaticEnv::SymlinkToFile.filename();
+    const path DirName = static_env.Dir.filename();
+    const path SymlinkName = static_env.SymlinkToFile.filename();
     struct TestCase {
         path p;
         path expect;
         path base;
-        TestCase(path p1, path e, path b = StaticEnv::Root)
+        TestCase(path p1, path e, path b)
             : p(p1), expect(e), base(b) {}
     };
     const TestCase testCases[] = {
-        { ".", Root, Root},
-        { DirName / ".." / "." / DirName, StaticEnv::Dir, Root},
-        { StaticEnv::Dir2 / "..",    StaticEnv::Dir },
-        { StaticEnv::Dir3 / "../..", StaticEnv::Dir },
-        { StaticEnv::Dir / ".",      StaticEnv::Dir },
-        { Root / "." / DirName / ".." / DirName, StaticEnv::Dir},
-        { path("..") / "." / RootName / DirName / ".." / DirName, StaticEnv::Dir, Root},
-        { StaticEnv::SymlinkToFile,  StaticEnv::File },
-        { SymlinkName, StaticEnv::File, StaticEnv::Root}
+        { ".", Root, Root },
+        { DirName / ".." / "." / DirName, static_env.Dir, Root },
+        { static_env.Dir2 / "..",    static_env.Dir, Root },
+        { static_env.Dir3 / "../..", static_env.Dir, Root },
+        { static_env.Dir / ".",      static_env.Dir, Root },
+        { Root / "." / DirName / ".." / DirName, static_env.Dir, Root },
+        { path("..") / "." / RootName / DirName / ".." / DirName,
+          static_env.Dir,
+          Root },
+        { static_env.SymlinkToFile,  static_env.File, Root },
+        { SymlinkName, static_env.File, Root}
     };
     for (auto& TC : testCases) {
         std::error_code ec = GetTestEC();
         fs::current_path(TC.base);
         const path ret = canonical(TC.p, ec);
         TEST_REQUIRE(!ec);
         const path ret2 = canonical(TC.p);
         TEST_CHECK(PathEq(ret, TC.expect));
         TEST_CHECK(PathEq(ret, ret2));
         TEST_CHECK(ret.is_absolute());
     }
 }
 
 TEST_CASE(test_dne_path)
 {
+    static_test_env static_env;
     std::error_code ec = GetTestEC();
     {
-        const path ret = canonical(StaticEnv::DNE, ec);
+        const path ret = canonical(static_env.DNE, ec);
         TEST_CHECK(ec != GetTestEC());
         TEST_REQUIRE(ec);
         TEST_CHECK(ret == path{});
     }
     {
-        TEST_CHECK_THROW(filesystem_error, canonical(StaticEnv::DNE));
+        TEST_CHECK_THROW(filesystem_error, canonical(static_env.DNE));
     }
 }
 
 TEST_CASE(test_exception_contains_paths)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
+    static_test_env static_env;
     CWDGuard guard;
     const path p = "blabla/dne";
     try {
         canonical(p);
         TEST_REQUIRE(false);
     } catch (filesystem_error const& err) {
         TEST_CHECK(err.path1() == p);
         // libc++ provides the current path as the second path in the exception
         LIBCPP_ONLY(TEST_CHECK(err.path2() == current_path()));
     }
-    fs::current_path(StaticEnv::Dir);
+    fs::current_path(static_env.Dir);
     try {
         canonical(p);
         TEST_REQUIRE(false);
     } catch (filesystem_error const& err) {
         TEST_CHECK(err.path1() == p);
-        LIBCPP_ONLY(TEST_CHECK(err.path2() == StaticEnv::Dir));
+        LIBCPP_ONLY(TEST_CHECK(err.path2() == static_env.Dir));
     }
 #endif
 }
 
 TEST_SUITE_END()

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

#ifndef TEST_HAS_NO_EXCEPTIONS
                 && err.code() == ec;
         }
 #else
         ((void)f); ((void)t); ((void)ec);
         return true;
 #endif
     };
 
+    static_test_env static_env;
     scoped_test_env env;
     const path file = env.create_file("file1", 42);
     const path dir = env.create_dir("dir");
     const path fifo = env.create_fifo("fifo");
     TEST_REQUIRE(is_other(fifo));
 
     const auto test_ec = GetTestEC();
 
     // !exists(f)
     {
         std::error_code ec = test_ec;
-        const path f = StaticEnv::DNE;
+        const path f = static_env.DNE;
         const path t = env.test_root;
         fs::copy(f, t, ec);
         TEST_REQUIRE(ec);
         TEST_REQUIRE(ec != test_ec);
         TEST_CHECK(checkThrow(f, t, ec));
     }
     { // equivalent(f, t) == true
         std::error_code ec = test_ec;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // path current_path();
 // path current_path(error_code& ec);
 // void current_path(path const&);
 // void current_path(path const&, std::error_code& ec) noexcept;
TEST_CASE(current_path_test)
     TEST_CHECK(is_directory(p));
 
     const path p2 = current_path();
     TEST_CHECK(p2 == p);
 }
 
 TEST_CASE(current_path_after_change_test)
 {
-    const path new_path = StaticEnv::Dir;
+    CWDGuard guard;
+    static_test_env static_env;
+    const path new_path = static_env.Dir;
     current_path(new_path);
     TEST_CHECK(current_path() == new_path);
 }
 
 TEST_CASE(current_path_is_file_test)
 {
-    const path p = StaticEnv::File;
+    CWDGuard guard;
+    static_test_env static_env;
+    const path p = static_env.File;
     std::error_code ec;
     const path old_p = current_path();
     current_path(p, ec);
     TEST_CHECK(ec);
     TEST_CHECK(old_p == current_path());
 }
 
 TEST_CASE(set_to_non_absolute_path)
 {
-    const path base = StaticEnv::Dir;
+    CWDGuard guard;
+    static_test_env static_env;
+    const path base = static_env.Dir;
     current_path(base);
-    const path p = StaticEnv::Dir2.filename();
+    const path p = static_env.Dir2.filename();
     std::error_code ec;
     current_path(p, ec);
     TEST_CHECK(!ec);
     const path new_cwd = current_path();
-    TEST_CHECK(new_cwd == StaticEnv::Dir2);
+    TEST_CHECK(new_cwd == static_env.Dir2);
     TEST_CHECK(new_cwd.is_absolute());
 }
 
 TEST_CASE(set_to_empty)
 {
     const path p = "";
     std::error_code ec;
     const path old_p = current_path();
     current_path(p, ec);
     TEST_CHECK(ec);
     TEST_CHECK(old_p == current_path());
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // bool equivalent(path const& lhs, path const& rhs);
 // bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
TEST_CASE(signature_test) {
   ((void)p);
   std::error_code ec;
   ((void)ec);
   ASSERT_NOEXCEPT(equivalent(p, p, ec));
   ASSERT_NOT_NOEXCEPT(equivalent(p, p));
 }
 
 TEST_CASE(equivalent_test) {
+  static_test_env static_env;
   struct TestCase {
     path lhs;
     path rhs;
     bool expect;
   };
   const TestCase testCases[] = {
-      {StaticEnv::Dir, StaticEnv::Dir, true},
-      {StaticEnv::File, StaticEnv::Dir, false},
-      {StaticEnv::Dir, StaticEnv::SymlinkToDir, true},
-      {StaticEnv::Dir, StaticEnv::SymlinkToFile, false},
-      {StaticEnv::File, StaticEnv::File, true},
-      {StaticEnv::File, StaticEnv::SymlinkToFile, true},
+      {static_env.Dir, static_env.Dir, true},
+      {static_env.File, static_env.Dir, false},
+      {static_env.Dir, static_env.SymlinkToDir, true},
+      {static_env.Dir, static_env.SymlinkToFile, false},
+      {static_env.File, static_env.File, true},
+      {static_env.File, static_env.SymlinkToFile, true},
   };
   for (auto& TC : testCases) {
     std::error_code ec;
     TEST_CHECK(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
     TEST_CHECK(!ec);
   }
 }
 
 TEST_CASE(equivalent_reports_error_if_input_dne) {
-  const path E = StaticEnv::File;
-  const path DNE = StaticEnv::DNE;
+  static_test_env static_env;
+  const path E = static_env.File;
+  const path DNE = static_env.DNE;
   { // Test that an error is reported when either of the paths don't exist
     std::error_code ec = GetTestEC();
     TEST_CHECK(equivalent(E, DNE, ec) == false);
     TEST_CHECK(ec);
     TEST_CHECK(ec != GetTestEC());
   }
   {
     std::error_code ec = GetTestEC();

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

TEST_CASE(exists_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(exists(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    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);
 }
 
 TEST_CASE(test_exists_fails)

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // uintmax_t file_size(const path& p);
 // uintmax_t file_size(const path& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
TEST_CASE(signature_test)
     ASSERT_SAME_TYPE(decltype(file_size(p)), uintmax_t);
     ASSERT_SAME_TYPE(decltype(file_size(p, ec)), uintmax_t);
     ASSERT_NOT_NOEXCEPT(file_size(p));
     ASSERT_NOEXCEPT(file_size(p, ec));
 }
 
 TEST_CASE(file_size_empty_test)
 {
-    const path p = StaticEnv::EmptyFile;
+    static_test_env static_env;
+    const path p = static_env.EmptyFile;
     TEST_CHECK(file_size(p) == 0);
     std::error_code ec;
     TEST_CHECK(file_size(p, ec) == 0);
 }
 
 TEST_CASE(file_size_non_empty)
 {
     scoped_test_env env;
     const path p = env.create_file("file", 42);
     TEST_CHECK(file_size(p) == 42);
     std::error_code ec;
     TEST_CHECK(file_size(p, ec) == 42);
 }
 
 TEST_CASE(symlink_test_case)
 {
-    const path p = StaticEnv::File;
-    const path p2 = StaticEnv::SymlinkToFile;
+    static_test_env static_env;
+    const path p = static_env.File;
+    const path p2 = static_env.SymlinkToFile;
     TEST_CHECK(file_size(p) == file_size(p2));
 }
 
 TEST_CASE(file_size_error_cases)
 {
+  static_test_env static_env;
   struct {
     path p;
     std::errc expected_err;
   } TestCases[] = {
-      {StaticEnv::Dir, std::errc::is_a_directory},
-      {StaticEnv::SymlinkToDir, std::errc::is_a_directory},
-      {StaticEnv::BadSymlink, std::errc::no_such_file_or_directory},
-      {StaticEnv::DNE, std::errc::no_such_file_or_directory},
+      {static_env.Dir, std::errc::is_a_directory},
+      {static_env.SymlinkToDir, std::errc::is_a_directory},
+      {static_env.BadSymlink, std::errc::no_such_file_or_directory},
+      {static_env.DNE, std::errc::no_such_file_or_directory},
       {"", std::errc::no_such_file_or_directory}};
     const uintmax_t expect = static_cast<uintmax_t>(-1);
     for (auto& TC : TestCases) {
       std::error_code ec = GetTestEC();
       TEST_CHECK(file_size(TC.p, ec) == expect);
       TEST_CHECK(ErrorIs(ec, TC.expected_err));
 
       ExceptionChecker Checker(TC.p, TC.expected_err, "file_size");
       TEST_CHECK_THROW_RESULT(filesystem_error, Checker, file_size(TC.p));
     }
 }
 
 TEST_SUITE_END()

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

TEST_CASE(is_block_file_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_block_file(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     TEST_CHECK(is_block_file(p) == false);
 }
 
 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);

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

TEST_CASE(is_character_file_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_character_file(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     TEST_CHECK(is_character_file(p) == false);
 }
 
 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);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // bool is_directory(file_status s) noexcept
 // bool is_directory(path const& p);
 // bool is_directory(path const& p, std::error_code& ec) noexcept;
 
TEST_CASE(is_directory_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_directory(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     TEST_CHECK(is_directory(p) == false);
 }
 
 TEST_CASE(static_env_test)
 {
-    TEST_CHECK(is_directory(StaticEnv::Dir));
-    TEST_CHECK(is_directory(StaticEnv::SymlinkToDir));
-    TEST_CHECK(!is_directory(StaticEnv::File));
+    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));
 }
 
 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);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // bool is_empty(path const& p);
 // bool is_empty(path const& p, std::error_code& ec);
 
 #include "filesystem_include.h"
TEST_CASE(signature_test)
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(is_empty(p, ec));
     ASSERT_NOT_NOEXCEPT(is_empty(p));
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     std::error_code ec;
     TEST_CHECK(is_empty(p, ec) == false);
     TEST_CHECK(ec);
     TEST_CHECK_THROW(filesystem_error, is_empty(p));
 }
 
 TEST_CASE(test_is_empty_directory)
 {
-    TEST_CHECK(!is_empty(StaticEnv::Dir));
-    TEST_CHECK(!is_empty(StaticEnv::SymlinkToDir));
+    static_test_env static_env;
+    TEST_CHECK(!is_empty(static_env.Dir));
+    TEST_CHECK(!is_empty(static_env.SymlinkToDir));
 }
 
 TEST_CASE(test_is_empty_directory_dynamic)
 {
     scoped_test_env env;
     TEST_CHECK(is_empty(env.test_root));
     env.create_file("foo", 42);
     TEST_CHECK(!is_empty(env.test_root));
 }
 
 TEST_CASE(test_is_empty_file)
 {
-    TEST_CHECK(is_empty(StaticEnv::EmptyFile));
-    TEST_CHECK(!is_empty(StaticEnv::NonEmptyFile));
+    static_test_env static_env;
+    TEST_CHECK(is_empty(static_env.EmptyFile));
+    TEST_CHECK(!is_empty(static_env.NonEmptyFile));
 }
 
 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);

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

TEST_CASE(is_fifo_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_fifo(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     TEST_CHECK(is_fifo(p) == false);
 }
 
 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);

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

TEST_CASE(is_other_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_other(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     TEST_CHECK(is_other(p) == false);
 }
 
 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);

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

TEST_CASE(is_regular_file_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_regular_file(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    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);
 }
 
 TEST_CASE(test_is_regular_file_fails)
 {

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

TEST_CASE(is_socket_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_socket(s) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    static_test_env static_env;
+    const path p = static_env.DNE;
     TEST_CHECK(is_socket(p) == false);
 }
 
 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);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // bool is_symlink(file_status s) noexcept
 // bool is_symlink(path const& p);
 // bool is_symlink(path const& p, std::error_code& ec) noexcept;
 
TEST_CASE(is_symlink_status_test)
     for (auto& TC : testCases) {
         file_status s(TC.type);
         TEST_CHECK(is_symlink(s) == TC.expect);
     }
 }
 
 TEST_CASE(static_env_test)
 {
+    static_test_env static_env;
     struct TestCase {
         path p;
         bool expect;
     };
     const TestCase testCases[] = {
-        {StaticEnv::File, false},
-        {StaticEnv::Dir, false},
-        {StaticEnv::SymlinkToFile, true},
-        {StaticEnv::SymlinkToDir, true},
-        {StaticEnv::BadSymlink, true}
+        {static_env.File, false},
+        {static_env.Dir, false},
+        {static_env.SymlinkToFile, true},
+        {static_env.SymlinkToDir, true},
+        {static_env.BadSymlink, true}
     };
     for (auto& TC : testCases) {
         TEST_CHECK(is_symlink(TC.p) == TC.expect);
     }
 }
 
 TEST_CASE(test_exist_not_found)
 {
-    const path p = StaticEnv::DNE;
+    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);
 }
 
 TEST_CASE(test_is_symlink_fails)
 {

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // file_time_type last_write_time(const path& p);
 // file_time_type last_write_time(const path& p, std::error_code& ec) noexcept;
 // void last_write_time(const path& p, file_time_type new_time);
 // void last_write_time(const path& p, file_time_type new_type,
TEST_CASE(signature_test)
     ASSERT_NOT_NOEXCEPT(last_write_time(p));
     ASSERT_NOT_NOEXCEPT(last_write_time(p, t));
     ASSERT_NOEXCEPT(last_write_time(p, ec));
     ASSERT_NOEXCEPT(last_write_time(p, t, ec));
 }
 
 TEST_CASE(read_last_write_time_static_env_test)
 {
+    static_test_env static_env;
     using C = file_time_type::clock;
     file_time_type min = file_time_type::min();
     {
-        file_time_type ret = last_write_time(StaticEnv::File);
+        file_time_type ret = last_write_time(static_env.File);
         TEST_CHECK(ret != min);
         TEST_CHECK(ret < C::now());
-        TEST_CHECK(CompareTime(ret, LastWriteTime(StaticEnv::File)));
+        TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.File)));
 
-        file_time_type ret2 = last_write_time(StaticEnv::SymlinkToFile);
+        file_time_type ret2 = last_write_time(static_env.SymlinkToFile);
         TEST_CHECK(CompareTime(ret, ret2));
-        TEST_CHECK(CompareTime(ret2, LastWriteTime(StaticEnv::SymlinkToFile)));
+        TEST_CHECK(CompareTime(ret2, LastWriteTime(static_env.SymlinkToFile)));
     }
     {
-        file_time_type ret = last_write_time(StaticEnv::Dir);
+        file_time_type ret = last_write_time(static_env.Dir);
         TEST_CHECK(ret != min);
         TEST_CHECK(ret < C::now());
-        TEST_CHECK(CompareTime(ret, LastWriteTime(StaticEnv::Dir)));
+        TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.Dir)));
 
-        file_time_type ret2 = last_write_time(StaticEnv::SymlinkToDir);
+        file_time_type ret2 = last_write_time(static_env.SymlinkToDir);
         TEST_CHECK(CompareTime(ret, ret2));
-        TEST_CHECK(CompareTime(ret2, LastWriteTime(StaticEnv::SymlinkToDir)));
+        TEST_CHECK(CompareTime(ret2, LastWriteTime(static_env.SymlinkToDir)));
     }
 }
 
 TEST_CASE(get_last_write_time_dynamic_env_test)
 {
     using Clock = file_time_type::clock;
     using Sec = std::chrono::seconds;
     scoped_test_env env;
TEST_CASE(test_write_max_time) {
   } else {
     TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
     TEST_CHECK(tt == old_time);
   }
 }
 
 TEST_CASE(test_value_on_failure)
 {
-    const path p = StaticEnv::DNE;
+    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));
 }
 
 TEST_CASE(test_exists_fails)
 {
     scoped_test_env env;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // path proximate(const path& p, error_code &ec)
 // path proximate(const path& p, const path& base = current_path())
 // path proximate(const path& p, const path& base, error_code& ec);
 

 
 TEST_CASE(test_signature_1) {
   fs::path p(".");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(fs::current_path()));
 }
 
 TEST_CASE(test_signature_2) {
-  fs::path p(StaticEnv::File);
+  static_test_env static_env;
+  fs::path p(static_env.File);
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::File));
+  TEST_CHECK(output == std::string(static_env.File));
 }
 
 TEST_CASE(test_signature_3) {
-  fs::path p(StaticEnv::Dir);
+  static_test_env static_env;
+  fs::path p(static_env.Dir);
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir));
+  TEST_CHECK(output == std::string(static_env.Dir));
 }
 
 TEST_CASE(test_signature_4) {
-  fs::path p(StaticEnv::SymlinkToDir);
+  static_test_env static_env;
+  fs::path p(static_env.SymlinkToDir);
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir));
+  TEST_CHECK(output == std::string(static_env.Dir));
 }
 
 TEST_CASE(test_signature_5) {
-  fs::path p(StaticEnv::SymlinkToDir / "dir2/.");
+  static_test_env static_env;
+  fs::path p(static_env.SymlinkToDir / "dir2/.");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2"));
+  TEST_CHECK(output == std::string(static_env.Dir / "dir2"));
 }
 
 TEST_CASE(test_signature_6) {
+  static_test_env static_env;
   // FIXME? If the trailing separator occurs in a part of the path that exists,
   // it is omitted. Otherwise it is added to the end of the result.
-  fs::path p(StaticEnv::SymlinkToDir / "dir2/./");
+  fs::path p(static_env.SymlinkToDir / "dir2/./");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2"));
+  TEST_CHECK(output == std::string(static_env.Dir / "dir2"));
 }
 
 TEST_CASE(test_signature_7) {
-  fs::path p(StaticEnv::SymlinkToDir / "dir2/DNE/./");
+  static_test_env static_env;
+  fs::path p(static_env.SymlinkToDir / "dir2/DNE/./");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2/DNE/"));
+  TEST_CHECK(output == std::string(static_env.Dir / "dir2/DNE/"));
 }
 
 TEST_CASE(test_signature_8) {
-  fs::path p(StaticEnv::SymlinkToDir / "dir2");
+  static_test_env static_env;
+  fs::path p(static_env.SymlinkToDir / "dir2");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir2));
+  TEST_CHECK(output == std::string(static_env.Dir2));
 }
 
 TEST_CASE(test_signature_9) {
-  fs::path p(StaticEnv::SymlinkToDir / "dir2/../dir2/DNE/..");
+  static_test_env static_env;
+  fs::path p(static_env.SymlinkToDir / "dir2/../dir2/DNE/..");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir2 / ""));
+  TEST_CHECK(output == std::string(static_env.Dir2 / ""));
 }
 
 TEST_CASE(test_signature_10) {
-  fs::path p(StaticEnv::SymlinkToDir / "dir2/dir3/../DNE/DNE2");
+  static_test_env static_env;
+  fs::path p(static_env.SymlinkToDir / "dir2/dir3/../DNE/DNE2");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir2 / "DNE/DNE2"));
+  TEST_CHECK(output == std::string(static_env.Dir2 / "DNE/DNE2"));
 }
 
 TEST_CASE(test_signature_11) {
-  fs::path p(StaticEnv::Dir / "../dir1");
+  static_test_env static_env;
+  fs::path p(static_env.Dir / "../dir1");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir));
+  TEST_CHECK(output == std::string(static_env.Dir));
 }
 
 TEST_CASE(test_signature_12) {
-  fs::path p(StaticEnv::Dir / "./.");
+  static_test_env static_env;
+  fs::path p(static_env.Dir / "./.");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir));
+  TEST_CHECK(output == std::string(static_env.Dir));
 }
 
 TEST_CASE(test_signature_13) {
-  fs::path p(StaticEnv::Dir / "DNE/../foo");
+  static_test_env static_env;
+  fs::path p(static_env.Dir / "DNE/../foo");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == std::string(StaticEnv::Dir / "foo"));
+  TEST_CHECK(output == std::string(static_env.Dir / "foo"));
 }
 
 TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // space_info space(const path& p);
 // space_info space(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
TEST_CASE(signature_test)
     ASSERT_SAME_TYPE(decltype(space(p)), space_info);
     ASSERT_SAME_TYPE(decltype(space(p, ec)), space_info);
     ASSERT_NOT_NOEXCEPT(space(p));
     ASSERT_NOEXCEPT(space(p, ec));
 }
 
 TEST_CASE(test_error_reporting)
 {
+    static_test_env static_env;
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             space(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
     };
     const path cases[] = {
         "",
-        StaticEnv::DNE,
-        StaticEnv::BadSymlink
+        static_env.DNE,
+        static_env.BadSymlink
     };
     for (auto& p : cases) {
         const auto expect = static_cast<std::uintmax_t>(-1);
         std::error_code ec;
         space_info info = space(p, ec);
         TEST_CHECK(ec);
         TEST_CHECK(info.capacity == expect);
         TEST_CHECK(info.free == expect);
         TEST_CHECK(info.available == expect);
         TEST_CHECK(checkThrow(p, ec));
     }
 }
 
 TEST_CASE(basic_space_test)
 {
+    static_test_env static_env;
+
     // All the test cases should reside on the same filesystem and therefore
     // should have the same expected result. Compute this expected result
     // one and check that it looks semi-sane.
     struct statvfs expect;
-    TEST_REQUIRE(::statvfs(StaticEnv::Dir.c_str(), &expect) != -1);
+    TEST_REQUIRE(::statvfs(static_env.Dir.c_str(), &expect) != -1);
     TEST_CHECK(expect.f_bavail > 0);
     TEST_CHECK(expect.f_bfree > 0);
     TEST_CHECK(expect.f_bsize > 0);
     TEST_CHECK(expect.f_blocks > 0);
     TEST_REQUIRE(expect.f_frsize > 0);
     auto do_mult = [&](std::uintmax_t val) {
         std::uintmax_t fsize = expect.f_frsize;
         std::uintmax_t new_val = val * fsize;
         TEST_CHECK(new_val / fsize == val); // Test for overflow
         return new_val;
     };
     const std::uintmax_t bad_value = static_cast<std::uintmax_t>(-1);
     const std::uintmax_t expect_capacity = do_mult(expect.f_blocks);
     const std::uintmax_t expect_free = do_mult(expect.f_bfree);
     const std::uintmax_t expect_avail = do_mult(expect.f_bavail);
 
     // Other processes running on the operating system may have changed
     // the amount of space available. Check that these are within tolerances.
     // Currently 5% of capacity
     const std::uintmax_t delta = expect_capacity / 20;
     const path cases[] = {
-        StaticEnv::File,
-        StaticEnv::Dir,
-        StaticEnv::Dir2,
-        StaticEnv::SymlinkToFile,
-        StaticEnv::SymlinkToDir
+        static_env.File,
+        static_env.Dir,
+        static_env.Dir2,
+        static_env.SymlinkToFile,
+        static_env.SymlinkToDir
     };
     for (auto& p : cases) {
         std::error_code ec = GetTestEC();
         space_info info = space(p, ec);
         TEST_CHECK(!ec);
         TEST_CHECK(info.capacity != bad_value);
         TEST_CHECK(expect_capacity == info.capacity);
         TEST_CHECK(info.free != bad_value);
         TEST_CHECK(EqualDelta(expect_free, info.free, delta));
         TEST_CHECK(info.available != bad_value);
         TEST_CHECK(EqualDelta(expect_avail, info.available, delta));
     }
 }
 
 TEST_SUITE_END()

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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // file_status status(const path& p);
 // file_status status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
TEST_CASE(signature_test)
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(status(p));
     ASSERT_NOEXCEPT(status(p, ec));
 }
 
 TEST_CASE(test_status_not_found)
 {
+    static_test_env static_env;
     const std::error_code expect_ec =
         std::make_error_code(std::errc::no_such_file_or_directory);
     const path cases[] {
-        StaticEnv::DNE,
-        StaticEnv::BadSymlink
+        static_env.DNE,
+        static_env.BadSymlink
     };
     for (auto& p : cases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         // test non-throwing overload.
         file_status st = status(p, ec);
         TEST_CHECK(ec == expect_ec);
         TEST_CHECK(st.type() == file_type::not_found);
         TEST_CHECK(st.permissions() == perms::unknown);
#ifndef TEST_HAS_NO_EXCEPTIONS
             }
         }
 #endif
     }
 }
 
 TEST_CASE(status_file_types_test)
 {
+    static_test_env static_env;
     scoped_test_env env;
     struct TestCase {
       path p;
       file_type expect_type;
     } cases[] = {
-        {StaticEnv::File, file_type::regular},
-        {StaticEnv::SymlinkToFile, file_type::regular},
-        {StaticEnv::Dir, file_type::directory},
-        {StaticEnv::SymlinkToDir, file_type::directory},
+        {static_env.File, file_type::regular},
+        {static_env.SymlinkToFile, file_type::regular},
+        {static_env.Dir, file_type::directory},
+        {static_env.SymlinkToDir, file_type::directory},
         // Block files tested elsewhere
-        {StaticEnv::CharFile, file_type::character},
+        {static_env.CharFile, file_type::character},
 #if !defined(__APPLE__) && !defined(__FreeBSD__) // No support for domain sockets
         {env.create_socket("socket"), file_type::socket},
 #endif
         {env.create_fifo("fifo"), file_type::fifo}
     };
     for (const auto& TC : cases) {
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);

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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // file_status symlink_status(const path& p);
 // file_status symlink_status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
TEST_CASE(signature_test)
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(symlink_status(p));
     ASSERT_NOEXCEPT(symlink_status(p, ec));
 }
 
 TEST_CASE(test_symlink_status_not_found)
 {
+    static_test_env static_env;
     const std::error_code expect_ec =
         std::make_error_code(std::errc::no_such_file_or_directory);
     const path cases[] {
-        StaticEnv::DNE
+        static_env.DNE
     };
     for (auto& p : cases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         // test non-throwing overload.
         file_status st = symlink_status(p, ec);
         TEST_CHECK(ec == expect_ec);
         TEST_CHECK(st.type() == file_type::not_found);
         TEST_CHECK(st.permissions() == perms::unknown);
// can be stat-ed using symlink_status
         TEST_CHECK(st.type() == file_type::symlink);
         TEST_CHECK(st.permissions() != perms::unknown);
     }
 }
 
 
 TEST_CASE(symlink_status_file_types_test)
 {
+    static_test_env static_env;
     scoped_test_env env;
     struct TestCase {
       path p;
       file_type expect_type;
     } cases[] = {
-        {StaticEnv::BadSymlink, file_type::symlink},
-        {StaticEnv::File, file_type::regular},
-        {StaticEnv::SymlinkToFile, file_type::symlink},
-        {StaticEnv::Dir, file_type::directory},
-        {StaticEnv::SymlinkToDir, file_type::symlink},
+        {static_env.BadSymlink, file_type::symlink},
+        {static_env.File, file_type::regular},
+        {static_env.SymlinkToFile, file_type::symlink},
+        {static_env.Dir, file_type::directory},
+        {static_env.SymlinkToDir, file_type::symlink},
         // Block files tested elsewhere
-        {StaticEnv::CharFile, file_type::character},
+        {static_env.CharFile, file_type::character},
 #if !defined(__APPLE__) && !defined(__FreeBSD__) // No support for domain sockets
         {env.create_socket("socket"), file_type::socket},
 #endif
         {env.create_fifo("fifo"), file_type::fifo}
     };
     for (const auto& TC : cases) {
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: ../../Inputs/static_test_env
 // UNSUPPORTED: c++98, c++03
 
 // <filesystem>
 
 // path weakly_canonical(const path& p);
 // path weakly_canonical(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <vector>
 #include <iostream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
 
 
 int main(int, char**) {
+
+  static_test_env static_env;
+
   // clang-format off
   struct {
     std::string input;
     std::string expect;
   } TestCases[] = {
       {"", fs::current_path()},
       {".", fs::current_path()},
       {"/", "/"},
       {"/foo", "/foo"},
       {"/.", "/"},
       {"/./", "/"},
       {"a/b", fs::current_path() / "a/b"},
       {"a", fs::current_path() / "a"},
       {"a/b/", fs::current_path() / "a/b/"},
-      {StaticEnv::File, StaticEnv::File},
-      {StaticEnv::Dir, StaticEnv::Dir},
-      {StaticEnv::SymlinkToDir, StaticEnv::Dir},
-      {StaticEnv::SymlinkToDir / "dir2/.", StaticEnv::Dir / "dir2"},
+      {static_env.File, static_env.File},
+      {static_env.Dir, static_env.Dir},
+      {static_env.SymlinkToDir, static_env.Dir},
+      {static_env.SymlinkToDir / "dir2/.", static_env.Dir / "dir2"},
       // FIXME? If the trailing separator occurs in a part of the path that exists,
       // it is omitted. Otherwise it is added to the end of the result.
-      {StaticEnv::SymlinkToDir / "dir2/./", StaticEnv::Dir / "dir2"},
-      {StaticEnv::SymlinkToDir / "dir2/DNE/./", StaticEnv::Dir / "dir2/DNE/"},
-      {StaticEnv::SymlinkToDir / "dir2", StaticEnv::Dir2},
-      {StaticEnv::SymlinkToDir / "dir2/../dir2/DNE/..", StaticEnv::Dir2 / ""},
-      {StaticEnv::SymlinkToDir / "dir2/dir3/../DNE/DNE2", StaticEnv::Dir2 / "DNE/DNE2"},
-      {StaticEnv::Dir / "../dir1", StaticEnv::Dir},
-      {StaticEnv::Dir / "./.", StaticEnv::Dir},
-      {StaticEnv::Dir / "DNE/../foo", StaticEnv::Dir / "foo"}
+      {static_env.SymlinkToDir / "dir2/./", static_env.Dir / "dir2"},
+      {static_env.SymlinkToDir / "dir2/DNE/./", static_env.Dir / "dir2/DNE/"},
+      {static_env.SymlinkToDir / "dir2", static_env.Dir2},
+      {static_env.SymlinkToDir / "dir2/../dir2/DNE/..", static_env.Dir2 / ""},
+      {static_env.SymlinkToDir / "dir2/dir3/../DNE/DNE2", static_env.Dir2 / "DNE/DNE2"},
+      {static_env.Dir / "../dir1", static_env.Dir},
+      {static_env.Dir / "./.", static_env.Dir},
+      {static_env.Dir / "DNE/../foo", static_env.Dir / "foo"}
   };
   // clang-format on
   int ID = 0;
   bool Failed = false;
   for (auto& TC : TestCases) {
     ++ID;
     fs::path p(TC.input);
     const fs::path output = fs::weakly_canonical(p);

libcxx/test/support/filesystem_test_helper.h

 #ifndef FILESYSTEM_TEST_HELPER_H
 #define FILESYSTEM_TEST_HELPER_H
 
 #include "filesystem_include.h"
 
-#include <unistd.h> // for ftruncate
+#include <sys/stat.h> // for mkdir, mkfifo
+#include <unistd.h> // for ftruncate, link, symlink, getcwd, chdir
 
 #include <cassert>
 #include <cstdio> // for printf
 #include <string>
 #include <fstream>
 #include <random>
 #include <chrono>
 #include <vector>
 #include <regex>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "format_string.h"
 
 // For creating socket files
 #if !defined(__FreeBSD__) && !defined(__APPLE__)
 # include <sys/socket.h>
 # include <sys/un.h>
 #endif
 
-// static test helpers
-
-namespace StaticEnv {
-
-// Tests that use these utilities should add '<...>/Inputs/static_test_env'
-// to their FILE_DEPENDENCIES, to make sure the directory is made available
-// to the test. Assuming that, the 'static_test_env' will be available in the
-// directory where the test is run.
-static const fs::path Root = fs::current_path() / "static_test_env";
-
-inline fs::path makePath(fs::path const& p) {
-    // env_path is expected not to contain symlinks.
-    fs::path const& env_path = Root;
-    return env_path / p;
-}
-
-static const fs::path TestFileList[] = {
-        makePath("empty_file"),
-        makePath("non_empty_file"),
-        makePath("dir1/file1"),
-        makePath("dir1/file2")
-};
-const std::size_t TestFileListSize = sizeof(TestFileList) / sizeof(fs::path);
-
-static const fs::path TestDirList[] = {
-        makePath("dir1"),
-        makePath("dir1/dir2"),
-        makePath("dir1/dir2/dir3")
-};
-const std::size_t TestDirListSize = sizeof(TestDirList) / sizeof(fs::path);
-
-static const fs::path File          = TestFileList[0];
-static const fs::path Dir           = TestDirList[0];
-static const fs::path Dir2          = TestDirList[1];
-static const fs::path Dir3          = TestDirList[2];
-static const fs::path SymlinkToFile = makePath("symlink_to_empty_file");
-static const fs::path SymlinkToDir  = makePath("symlink_to_dir");
-static const fs::path BadSymlink    = makePath("bad_symlink");
-static const fs::path DNE           = makePath("DNE");
-static const fs::path EmptyFile     = TestFileList[0];
-static const fs::path NonEmptyFile  = TestFileList[1];
-static const fs::path CharFile      = "/dev/null"; // Hopefully this exists
-
-static const fs::path DirIterationList[] = {
-    makePath("dir1/dir2"),
-    makePath("dir1/file1"),
-    makePath("dir1/file2")
-};
-const std::size_t DirIterationListSize = sizeof(DirIterationList)
-                                        / sizeof(fs::path);
-
-static const fs::path DirIterationListDepth1[] = {
-    makePath("dir1/dir2/afile3"),
-    makePath("dir1/dir2/dir3"),
-    makePath("dir1/dir2/symlink_to_dir3"),
-    makePath("dir1/dir2/file4"),
-};
-
-static const fs::path RecDirIterationList[] = {
-    makePath("dir1/dir2"),
-    makePath("dir1/file1"),
-    makePath("dir1/file2"),
-    makePath("dir1/dir2/afile3"),
-    makePath("dir1/dir2/dir3"),
-    makePath("dir1/dir2/symlink_to_dir3"),
-    makePath("dir1/dir2/file4"),
-    makePath("dir1/dir2/dir3/file5")
-};
-
-static const fs::path RecDirFollowSymlinksIterationList[] = {
-    makePath("dir1/dir2"),
-    makePath("dir1/file1"),
-    makePath("dir1/file2"),
-    makePath("dir1/dir2/afile3"),
-    makePath("dir1/dir2/dir3"),
-    makePath("dir1/dir2/file4"),
-    makePath("dir1/dir2/dir3/file5"),
-    makePath("dir1/dir2/symlink_to_dir3"),
-    makePath("dir1/dir2/symlink_to_dir3/file5"),
-};
-
-} // namespace StaticEnv
-
 namespace random_utils {
 inline char to_hex(int ch) {
   return ch < 10 ? static_cast<char>('0' + ch)
                  : static_cast<char>('a' + (ch - 10));
 }
 
 inline char random_hex_char() {
   static std::mt19937 rd{std::random_device{}()};
   static std::uniform_int_distribution<int> mrand{0, 15};
   return to_hex(mrand(rd));
 }
 
 } // namespace random_utils
 
 struct scoped_test_env
 {
     scoped_test_env() : test_root(random_path()) {
         std::string cmd = "mkdir -p " + test_root.native();
         int ret = std::system(cmd.c_str());
         assert(ret == 0);
 
         // Ensure that the root_path is fully resolved, i.e. it contains no
         // symlinks. The filesystem tests depend on that. We do this after
         // creating the root_path, because `fs::canonical` requires the
         // path to exist.
         test_root = fs::canonical(test_root);
     }
 
     ~scoped_test_env() {
         std::string cmd = "chmod -R 777 " + test_root.native();
         int ret = std::system(cmd.c_str());
         assert(ret == 0);
 
         cmd = "rm -r " + test_root.native();
         ret = std::system(cmd.c_str());
         assert(ret == 0);
     }
 
     scoped_test_env(scoped_test_env const &) = delete;
     scoped_test_env & operator=(scoped_test_env const &) = delete;
 
     fs::path make_env_path(std::string p) { return sanitize_path(p); }
#endif
         }
 
         fclose(file);
         return filename;
     }
 
     std::string create_dir(std::string filename) {
         filename = sanitize_path(std::move(filename));
-        std::string cmd = "mkdir " + filename;
-        int ret = std::system(cmd.c_str());
+        int ret = ::mkdir(filename.c_str(), 0777); // rwxrwxrwx mode
         assert(ret == 0);
         return filename;
     }
 
-    std::string create_symlink(std::string source, std::string to) {
+    std::string create_symlink(std::string source,
+                               std::string to,
+                               bool sanitize_source = true) {
+        if (sanitize_source)
             source = sanitize_path(std::move(source));
         to = sanitize_path(std::move(to));
-        std::string cmd = "ln -s " + source + ' ' + to;
-        int ret = std::system(cmd.c_str());
+        int ret = ::symlink(source.c_str(), to.c_str());
         assert(ret == 0);
         return to;
     }
 
     std::string create_hardlink(std::string source, std::string to) {
         source = sanitize_path(std::move(source));
         to = sanitize_path(std::move(to));
-        std::string cmd = "ln " + source + ' ' + to;
-        int ret = std::system(cmd.c_str());
+        int ret = ::link(source.c_str(), to.c_str());
         assert(ret == 0);
         return to;
     }
 
     std::string create_fifo(std::string file) {
         file = sanitize_path(std::move(file));
-        std::string cmd = "mkfifo " + file;
-        int ret = std::system(cmd.c_str());
+        int ret = ::mkfifo(file.c_str(), 0666); // rw-rw-rw- mode
         assert(ret == 0);
         return file;
     }
 
   // OS X and FreeBSD doesn't support socket files so we shouldn't even
   // allow tests to call this unguarded.
 #if !defined(__FreeBSD__) && !defined(__APPLE__)
     std::string create_socket(std::string file) {
private:
     // running at the same time, but oh well, it's just test code.
     static inline fs::path random_path() {
         fs::path tmp = fs::temp_directory_path();
         fs::path p = fs::path(tmp) / unique_path_suffix();
         return p;
     }
 };
 
+/// This class generates the following tree:
+///
+///     static_test_env
+///     ├── bad_symlink -> dne
+///     ├── dir1
+///     │!! ├── dir2
+///     │!! │!! ├── afile3
+///     │!! │!! ├── dir3
+///     │!! │!! │!! └── file5
+///     │!! │!! ├── file4
+///     │!! │!! └── symlink_to_dir3 -> dir3
+///     │!! ├── file1
+///     │!! └── file2
+///     ├── empty_file
+///     ├── non_empty_file
+///     ├── symlink_to_dir -> dir1
+///     └── symlink_to_empty_file -> empty_file
+///
+class static_test_env {
+    scoped_test_env env_;
+public:
+    static_test_env() {
+        env_.create_symlink("dne", "bad_symlink", false);
+        env_.create_dir("dir1");
+        env_.create_dir("dir1/dir2");
+        env_.create_file("dir1/dir2/afile3");
+        env_.create_dir("dir1/dir2/dir3");
+        env_.create_file("dir1/dir2/dir3/file5");
+        env_.create_file("dir1/dir2/file4");
+        env_.create_symlink("dir3", "dir1/dir2/symlink_to_dir3", false);
+        env_.create_file("dir1/file1");
+        env_.create_file("dir1/file2", 42);
+        env_.create_file("empty_file");
+        env_.create_file("non_empty_file", 42);
+        env_.create_symlink("dir1", "symlink_to_dir", false);
+        env_.create_symlink("empty_file", "symlink_to_empty_file", false);
+    }
+
+    const fs::path Root = env_.test_root;
+
+    fs::path makePath(fs::path const& p) const {
+        // env_path is expected not to contain symlinks.
+        fs::path const& env_path = Root;
+        return env_path / p;
+    }
+
+    const std::vector<fs::path> TestFileList = {
+        makePath("empty_file"),
+        makePath("non_empty_file"),
+        makePath("dir1/file1"),
+        makePath("dir1/file2")
+    };
+
+    const std::vector<fs::path> TestDirList = {
+        makePath("dir1"),
+        makePath("dir1/dir2"),
+        makePath("dir1/dir2/dir3")
+    };
+
+    const fs::path File          = TestFileList[0];
+    const fs::path Dir           = TestDirList[0];
+    const fs::path Dir2          = TestDirList[1];
+    const fs::path Dir3          = TestDirList[2];
+    const fs::path SymlinkToFile = makePath("symlink_to_empty_file");
+    const fs::path SymlinkToDir  = makePath("symlink_to_dir");
+    const fs::path BadSymlink    = makePath("bad_symlink");
+    const fs::path DNE           = makePath("DNE");
+    const fs::path EmptyFile     = TestFileList[0];
+    const fs::path NonEmptyFile  = TestFileList[1];
+    const fs::path CharFile      = "/dev/null"; // Hopefully this exists
+
+    const std::vector<fs::path> DirIterationList = {
+        makePath("dir1/dir2"),
+        makePath("dir1/file1"),
+        makePath("dir1/file2")
+    };
+
+    const std::vector<fs::path> DirIterationListDepth1 = {
+        makePath("dir1/dir2/afile3"),
+        makePath("dir1/dir2/dir3"),
+        makePath("dir1/dir2/symlink_to_dir3"),
+        makePath("dir1/dir2/file4"),
+    };
+
+    const std::vector<fs::path> RecDirIterationList = {
+        makePath("dir1/dir2"),
+        makePath("dir1/file1"),
+        makePath("dir1/file2"),
+        makePath("dir1/dir2/afile3"),
+        makePath("dir1/dir2/dir3"),
+        makePath("dir1/dir2/symlink_to_dir3"),
+        makePath("dir1/dir2/file4"),
+        makePath("dir1/dir2/dir3/file5")
+    };
+
+    const std::vector<fs::path> RecDirFollowSymlinksIterationList = {
+        makePath("dir1/dir2"),
+        makePath("dir1/file1"),
+        makePath("dir1/file2"),
+        makePath("dir1/dir2/afile3"),
+        makePath("dir1/dir2/dir3"),
+        makePath("dir1/dir2/file4"),
+        makePath("dir1/dir2/dir3/file5"),
+        makePath("dir1/dir2/symlink_to_dir3"),
+        makePath("dir1/dir2/symlink_to_dir3/file5"),
+    };
+};
+
+struct CWDGuard {
+  // Assume that path lengths are not greater than this.
+  // This should be fine for testing purposes.
+  char OldCWD[4096];
+  CWDGuard() {
+    char* ret = ::getcwd(OldCWD, sizeof(OldCWD));
+    assert(ret && "getcwd failed");
+  }
+  ~CWDGuard() { 
+    int ret = ::chdir(OldCWD);
+    assert(ret == 0 && "chdir failed");
+  }
+
+  CWDGuard(CWDGuard const&) = delete;
+  CWDGuard& operator=(CWDGuard const&) = delete;
+};
+
 // Misc test types
 
 #define MKSTR(Str) {Str, TEST_CONCAT(L, Str), TEST_CONCAT(u, Str), TEST_CONCAT(U, Str)}
 
 struct MultiStringType {
   const char* s;
   const wchar_t* w;
   const char16_t* u16;