[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

135–142

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.

146

range-based for loop?

150

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 ↗

(On Diff #258116)

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 ↗

(On Diff #258116)

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

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

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

429

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 ↗

(On Diff #262344)

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

429

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 ↗

(On Diff #262344)

Good point.

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

libcxx/test/support/filesystem_test_helper.h

429

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/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

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);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
     TEST_CHECK(ent.path() == StaticEnv::DNE);
   }
   // don't report dead symlinks as an error.
   {

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

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");
 

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

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");
 

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

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");
 

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

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 };
     for (path const& testPath : testPaths)
     {
         {
TEST_CASE(test_open_on_empty_directory_equals_end)
     {
         directory_iterator it(testDir);
         TEST_CHECK(it == endIt);
     }
 }
 
 TEST_CASE(test_open_on_directory_succeeds)
 {
+    static_test_env static_env;
     const path testDir = StaticEnv::Dir;
     std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
                                 std::end(  StaticEnv::DirIterationList));
     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)
 {
+    static_test_env static_env;
     const path testFile = StaticEnv::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)
 {
+    static_test_env static_env;
     const path symlinkToDir = StaticEnv::SymlinkToDir;
     std::set<path> dir_contents;
     for (path const& p : StaticEnv::DirIterationList) {
         dir_contents.insert(p.filename());
     }
     const directory_iterator endIt{};
 
     {

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

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)
 {
+    static_test_env static_env;
     const path testDir = StaticEnv::Dir;
     const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
                                       std::end(  StaticEnv::RecDirIterationList));
     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)
 {
+    static_test_env static_env;
     const path testDir = StaticEnv::Dir;
     const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
                                       std::end(  StaticEnv::RecDirIterationList));
     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)
 {
+    static_test_env static_env;
     const path testDir = StaticEnv::Dir;
     const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
                                       std::end(  StaticEnv::RecDirIterationList));
     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)
 {
+    static_test_env static_env;
     const path testDir = StaticEnv::Dir;
     auto const& IterList = StaticEnv::RecDirFollowSymlinksIterationList;
 
     const std::set<path> dir_contents(std::begin(IterList), std::end(IterList));
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir,

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp

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)
 {
+    static_test_env static_env;
     const path testDir = StaticEnv::Dir;
     std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
                                 std::end(  StaticEnv::RecDirIterationList));
 
     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.canonical/canonical.pass.cpp

TEST_CASE(signature_test)
     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 RootName = Root.filename();
     const path DirName = StaticEnv::Dir.filename();
     const path SymlinkName = StaticEnv::SymlinkToFile.filename();
     struct TestCase {
         path p;

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

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},

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

TEST_CASE(file_size_non_empty)
     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)
 {
+    static_test_env static_env;
     const path p = StaticEnv::File;
     const path p2 = StaticEnv::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},

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

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;
     TEST_CHECK(is_directory(p) == false);
 }
 
 TEST_CASE(static_env_test)
 {
+    static_test_env static_env;
     TEST_CHECK(is_directory(StaticEnv::Dir));
     TEST_CHECK(is_directory(StaticEnv::SymlinkToDir));
     TEST_CHECK(!is_directory(StaticEnv::File));
 }
 
 TEST_CASE(test_is_directory_fails)
 {
     scoped_test_env env;

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

TEST_CASE(test_exist_not_found)
     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)
 {
+    static_test_env static_env;
     TEST_CHECK(!is_empty(StaticEnv::Dir));
     TEST_CHECK(!is_empty(StaticEnv::SymlinkToDir));
 }
 
 TEST_CASE(test_is_empty_directory_dynamic)
 {
     scoped_test_env env;
     TEST_CHECK(is_empty(env.test_root));

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

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},

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

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);
         TEST_CHECK(ret != min);
         TEST_CHECK(ret < C::now());
         TEST_CHECK(CompareTime(ret, LastWriteTime(StaticEnv::File)));
 

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

 
 TEST_CASE(test_signature_3) {
   fs::path p(StaticEnv::Dir);
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir));
 }
 
 TEST_CASE(test_signature_4) {
+  static_test_env static_env;
   fs::path p(StaticEnv::SymlinkToDir);
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir));
 }
 
 TEST_CASE(test_signature_5) {
+  static_test_env static_env;
   fs::path p(StaticEnv::SymlinkToDir / "dir2/.");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::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/./");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2"));
 }
 
 TEST_CASE(test_signature_7) {
+  static_test_env static_env;
   fs::path p(StaticEnv::SymlinkToDir / "dir2/DNE/./");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2/DNE/"));
 }
 
 TEST_CASE(test_signature_8) {
+  static_test_env static_env;
   fs::path p(StaticEnv::SymlinkToDir / "dir2");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir2));
 }
 
 TEST_CASE(test_signature_9) {
+  static_test_env static_env;
   fs::path p(StaticEnv::SymlinkToDir / "dir2/../dir2/DNE/..");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir2 / ""));
 }
 
 TEST_CASE(test_signature_10) {
+  static_test_env static_env;
   fs::path p(StaticEnv::SymlinkToDir / "dir2/dir3/../DNE/DNE2");
   const fs::path output = fs::weakly_canonical(p);
   TEST_CHECK(output == std::string(StaticEnv::Dir2 / "DNE/DNE2"));
 }
 
 TEST_CASE(test_signature_11) {
   fs::path p(StaticEnv::Dir / "../dir1");
   const fs::path output = fs::weakly_canonical(p);

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

for (auto& p : cases) {
         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_CHECK(expect.f_bavail > 0);
     TEST_CHECK(expect.f_bfree > 0);
     TEST_CHECK(expect.f_bsize > 0);

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

#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},

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

// 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},

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

 
 #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()},
       {"/", "/"},

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 <unistd.h> // for ftruncate, symlink, unlink
 
 #include <cassert>
 #include <cstdio> // for printf
 #include <string>
 #include <fstream>
 #include <random>
 #include <chrono>
 #include <vector>
static const fs::path RecDirFollowSymlinksIterationList[] = {
     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"),
 };
 
+static const std::pair<fs::path, fs::path> SymlinkList[] = {
+    {"dne",        makePath("bad_symlink")},
+    {"dir1",       makePath("symlink_to_dir")},
+    {"empty_file", makePath("symlink_to_empty_file")},
+    {"dir3",       makePath("dir1/dir2/symlink_to_dir3")}
+};
+
 } // 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
 
+/// A RAII object that prepares the 'static_test_env' directory for usage in
+/// tests.
+///
+/// Namely, it creates some symlinks that tests expect to be present.
+/// We do it here instead of storing them in the repo 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.
+/// If we cross-compiled libc++ for some symlink-friendly system
+/// (e. g. Linux) and ran tests on the target system, some tests would fail.
+/// Instead, we create symlinks here, when a test is already being executed.
+class static_test_env {
+public:
+  static_test_env() {
+    for (const auto *link = std::begin(StaticEnv::SymlinkList);
+         link != std::end(StaticEnv::SymlinkList);
+         ++link) {
+      int ret = ::symlink(link->first.c_str(), link->second.c_str());
+      assert(ret == 0);
+    }
+  }
+
+  ~static_test_env() {
+    for (const auto *link = std::begin(StaticEnv::SymlinkList);
+         link != std::end(StaticEnv::SymlinkList);
+         ++link) {
+      int ret = ::unlink(link->second.c_str());
+      assert(ret == 0);
+    }
+  }
+};
+
 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

 
 
 template <class Iter1, class Iter2>
 bool checkCollectionsEqualBackwards(
     Iter1 const start1, Iter1 end1
   , Iter2 const start2, Iter2 end2
   )
 {
     while (start1 != end1 && start2 != end2) {
         --end1; --end2;
         if (*end1 != *end2) {
             return false;
         }
     }
     return (start1 == end1 && start2 == end2);
 }