[libcxx] [test] Ifdef out uses of create_fifo on windows

[mstorsjo]

Summary

Restructure code in directory_entry.obs/file_type_obs.pass.cpp and directory_entry.obs/hard_link_count.pass.cpp to reduce the amount of ifdeffery needed.

In file_type_obs.pass.cpp, we can't inline the calls to env.create_* into the lambda calls (e.g. "test_path(env.create_*())"), because the lambda removes the referenced file, and the hardlink must be created while the earlier test file exists.

In hard_link_count.pass.cpp, move restoration of the original directory permissions to the end of the lambda, so that new directory entries can be created after the lambda has run once.

[mstorsjo]

Updated/rebased.

This is probably not ready to go as-is, but serves to point out the cases that need to be disabled in one way or another.

Some of the lists, that currently are in the form {a, b, c, d} might be easier to make conditional if split up over multiple lines with one line per entry.

[ldionne]

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

89–90

As a general pattern, could we instead refactor the body of the loop (which contains the actual tests) into a lambda, and then call it with the appropriate inputs? I think that might make the #ifdefs less awkward. WDYT?

I don't think it makes sense to do that everywhere, but I think it might here.

[mstorsjo]

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

89–90

Sounds good, I'll give that a try later and come back to this patch.

[mstorsjo]

Reworked some ugly cases to use a lambda, as suggested by @ldionne.

[ldionne]

I think this is a net improvement. Thanks!

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

TEST_CASE(not_regular_file) {
   using namespace fs;
 
   scoped_test_env env;
   struct {
     const path p;
     std::errc expected_err;
   } TestCases[] = {
       {env.create_dir("dir"), std::errc::is_a_directory},
+#ifndef _WIN32
       {env.create_fifo("fifo"), std::errc::not_supported},
+#endif
       {env.create_directory_symlink("dir", "sym"), std::errc::is_a_directory}};
 
   for (auto const& TC : TestCases) {
     const path& p = TC.p;
     directory_entry ent(p);
     TEST_CHECK(ent.path() == p);
     std::error_code ec = GetTestEC(0);
 

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

TEST_CASE(test_without_ec) {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
 
   scoped_test_env env;
   path f = env.create_file("foo", 42);
   path d = env.create_dir("dir");
-  path fifo = env.create_fifo("fifo");
   path hl = env.create_hardlink("foo", "hl");
-  for (auto p : {hl, f, d, fifo}) {
+  auto test_path = [=](const path &p) {
     directory_entry e(p);
     file_status st = status(p);
     file_status sym_st = symlink_status(p);
     fs::remove(p);
     TEST_REQUIRE(e.exists());
     TEST_REQUIRE(!exists(p));
     TEST_CHECK(e.exists() == exists(st));
     TEST_CHECK(e.is_block_file() == is_block_file(st));
     TEST_CHECK(e.is_character_file() == is_character_file(st));
     TEST_CHECK(e.is_directory() == is_directory(st));
     TEST_CHECK(e.is_fifo() == is_fifo(st));
     TEST_CHECK(e.is_other() == is_other(st));
     TEST_CHECK(e.is_regular_file() == is_regular_file(st));
     TEST_CHECK(e.is_socket() == is_socket(st));
     TEST_CHECK(e.is_symlink() == is_symlink(sym_st));
-  }
+  };
+  test_path(f);
+  test_path(d);
+  test_path(hl);
+#ifndef _WIN32
+  path fifo = env.create_fifo("fifo");
+  test_path(fifo);
+#endif
 }
 
 TEST_CASE(test_with_ec) {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
 
   scoped_test_env env;
   path f = env.create_file("foo", 42);
   path d = env.create_dir("dir");
-  path fifo = env.create_fifo("fifo");
   path hl = env.create_hardlink("foo", "hl");
-  for (auto p : {hl, f, d, fifo}) {
+  auto test_path = [=](const path &p) {
     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);
     fs::remove(p);
     std::error_code ec = GetTestEC(2);
     auto CheckEC = [&](std::error_code const& other_ec) {
auto test_path = [=](const path &p) {
     TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st));
     TEST_CHECK(CheckEC(status_ec));
 
     TEST_CHECK(e.is_socket(ec) == is_socket(st));
     TEST_CHECK(CheckEC(status_ec));
 
     TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st));
     TEST_CHECK(CheckEC(sym_status_ec));
-  }
+  };
+  test_path(f);
+  test_path(d);
+  test_path(hl);
+#ifndef _WIN32
+  path fifo = env.create_fifo("fifo");
+  test_path(fifo);
+#endif
 }
 
 TEST_CASE(test_with_ec_dne) {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
   static_test_env static_env;

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

 }
 
 TEST_CASE(not_regular_file) {
   using namespace fs;
 
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path dir2 = env.create_dir("dir/dir2");
-  const path fifo = env.create_fifo("dir/fifo");
-  const path sym_to_fifo = env.create_symlink("dir/fifo", "dir/sym");
 
   const perms old_perms = status(dir).permissions();
 
-  for (auto p : {dir2, fifo, sym_to_fifo}) {
-    permissions(dir, old_perms);
+  auto test_path = [=](const path &p) {
     std::error_code dummy_ec = GetTestEC();
     directory_entry ent(p, dummy_ec);
     TEST_CHECK(!dummy_ec);
 
     uintmax_t expect = hard_link_count(p);
 
     LIBCPP_ONLY(permissions(dir, perms::none));
 
     std::error_code ec = GetTestEC();
     TEST_CHECK(ent.hard_link_count(ec) == expect);
     TEST_CHECK(!ec);
     TEST_CHECK_NO_THROW(ent.hard_link_count());
-  }
+    permissions(dir, old_perms);
+  };
+  test_path(dir2);
+#ifndef _WIN32
+  const path fifo = env.create_fifo("dir/fifo");
+  const path sym_to_fifo = env.create_symlink("dir/fifo", "dir/sym");
+  test_path(fifo);
+  test_path(sym_to_fifo);
+#endif
 }
 
 TEST_CASE(error_reporting) {
   using namespace fs;
 
   static_test_env static_env;
   scoped_test_env env;
 

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

#else
         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");
+#ifndef _WIN32
     const path fifo = env.create_fifo("fifo");
     TEST_REQUIRE(is_other(fifo));
+#endif
 
     const auto test_ec = GetTestEC();
 
     // !exists(f)
     {
         std::error_code ec = test_ec;
         const path f = static_env.DNE;
         const path t = env.test_root;
#endif
     }
     { // is_directory(from) && is_file(to)
         std::error_code ec = test_ec;
         fs::copy(dir, file, ec);
         TEST_REQUIRE(ec);
         TEST_REQUIRE(ec != test_ec);
         TEST_CHECK(checkThrow(dir, file, ec));
     }
+#ifndef _WIN32
     { // is_other(from)
         std::error_code ec = test_ec;
         fs::copy(fifo, dir, ec);
         TEST_REQUIRE(ec);
         TEST_REQUIRE(ec != test_ec);
         TEST_CHECK(checkThrow(fifo, dir, ec));
     }
     { // is_other(to)
         std::error_code ec = test_ec;
         fs::copy(file, fifo, ec);
         TEST_REQUIRE(ec);
         TEST_REQUIRE(ec != test_ec);
         TEST_CHECK(checkThrow(file, fifo, ec));
     }
+#endif
 }
 
 TEST_CASE(from_is_symlink)
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path symlink = env.create_symlink(file, "sym");
     const path dne = env.make_env_path("dne");

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

const path file2 = env.create_file("file2", 55);
     TEST_CHECK(fs::copy_file(file, file2, ec) == false);
     TEST_CHECK(ErrorIs(ec, std::errc::file_exists));
     ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file");
     TEST_CHECK_THROW_RESULT(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
 
   }
 }
 
+#ifndef _WIN32
 TEST_CASE(non_regular_file_test) {
   scoped_test_env env;
   const path fifo = env.create_fifo("fifo");
   const path dest = env.make_env_path("dest");
   const path file = env.create_file("file", 42);
 
   {
     std::error_code ec = GetTestEC();
     TEST_REQUIRE(fs::copy_file(fifo, dest, ec) == false);
     TEST_CHECK(ErrorIs(ec, std::errc::not_supported));
     TEST_CHECK(!exists(dest));
   }
   {
     std::error_code ec = GetTestEC();
     TEST_REQUIRE(fs::copy_file(file, fifo, copy_options::overwrite_existing,
                                ec) == false);
     TEST_CHECK(ErrorIs(ec, std::errc::not_supported));
     TEST_CHECK(is_fifo(fifo));
   }
 
 }
+#endif
 
 TEST_CASE(test_attributes_get_copied) {
   scoped_test_env env;
   const path file = env.create_file("file1", 42);
   const path dest = env.make_env_path("file2");
   (void)status(file);
   perms new_perms = perms::owner_read;
   permissions(file, new_perms);

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

TEST_CASE(equivalent_hardlink_succeeds) {
   path const file = env.create_file("file", 42);
   const path hl1 = env.create_hardlink(file, "hl1");
   const path hl2 = env.create_hardlink(file, "hl2");
   TEST_CHECK(equivalent(file, hl1));
   TEST_CHECK(equivalent(file, hl2));
   TEST_CHECK(equivalent(hl1, hl2));
 }
 
+#ifndef _WIN32
 TEST_CASE(equivalent_is_other_succeeds) {
   scoped_test_env env;
   path const file = env.create_file("file", 42);
   const path fifo1 = env.create_fifo("fifo1");
   const path fifo2 = env.create_fifo("fifo2");
   // Required to test behavior for inputs where is_other(p) is true.
   TEST_REQUIRE(is_other(fifo1));
   TEST_CHECK(!equivalent(file, fifo1));
   TEST_CHECK(!equivalent(fifo2, file));
   TEST_CHECK(!equivalent(fifo1, fifo2));
   TEST_CHECK(equivalent(fifo1, fifo1));
 }
+#endif
 
 TEST_SUITE_END()

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

TEST_CASE(test_directory_access_denied)
     TEST_CHECK(is_empty(dir, ec) == false);
     TEST_CHECK(ec);
     TEST_CHECK(ec != GetTestEC());
 
     TEST_CHECK_THROW(filesystem_error, is_empty(dir));
 }
 
 
+#ifndef _WIN32
 TEST_CASE(test_fifo_fails)
 {
     scoped_test_env env;
     const path fifo = env.create_fifo("fifo");
 
     std::error_code ec = GetTestEC();
     TEST_CHECK(is_empty(fifo, ec) == false);
     TEST_CHECK(ec);
     TEST_CHECK(ec != GetTestEC());
 
     TEST_CHECK_THROW(filesystem_error, is_empty(fifo));
 }
+#endif
 
 TEST_SUITE_END()

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

struct TestCase {
         {static_env.SymlinkToFile, file_type::regular},
         {static_env.Dir, file_type::directory},
         {static_env.SymlinkToDir, file_type::directory},
         // Block files tested elsewhere
         {static_env.CharFile, file_type::character},
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(_WIN32) // No support for domain sockets
         {env.create_socket("socket"), file_type::socket},
 #endif
+#ifndef _WIN32
         {env.create_fifo("fifo"), file_type::fifo}
+#endif
     };
     for (const auto& TC : cases) {
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         file_status st = status(TC.p, ec);
         TEST_CHECK(!ec);
         TEST_CHECK(st.type() == TC.expect_type);
         TEST_CHECK(st.permissions() != perms::unknown);

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

struct TestCase {
         {static_env.SymlinkToFile, file_type::symlink},
         {static_env.Dir, file_type::directory},
         {static_env.SymlinkToDir, file_type::symlink},
         // Block files tested elsewhere
         {static_env.CharFile, file_type::character},
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(_WIN32) // No support for domain sockets
         {env.create_socket("socket"), file_type::socket},
 #endif
+#ifndef _WIN32
         {env.create_fifo("fifo"), file_type::fifo}
+#endif
     };
     for (const auto& TC : cases) {
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         file_status st = symlink_status(TC.p, ec);
         TEST_CHECK(!ec);
         TEST_CHECK(st.type() == TC.expect_type);
         TEST_CHECK(st.permissions() != perms::unknown);