[libcxx] [test] Call create_directory_symlink where relevant

[mstorsjo]

Summary

Tested in a posix build by making create_symlink (both libc++ and the test helper) error out if passed a path that exists and isn't a directory.

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

TEST_CASE(not_regular_file) {
 
   scoped_test_env env;
   struct {
     const path p;
     std::errc expected_err;
   } TestCases[] = {
       {env.create_dir("dir"), std::errc::is_a_directory},
       {env.create_fifo("fifo"), std::errc::not_supported},
-      {env.create_symlink("dir", "sym"), std::errc::is_a_directory}};
+      {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);
 
     std::error_code other_ec = GetTestEC(1);

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

 {
   using namespace fs;
     scoped_test_env env;
     const path testFiles[] = {
         env.create_dir("dir1"),
         env.create_file("dir1/file1"),
         env.create_dir("sym_dir"),
         env.create_dir("sym_dir/nested_sym_dir"),
-        env.create_symlink("sym_dir/nested_sym_dir", "dir1/dir2"),
+        env.create_directory_symlink("sym_dir/nested_sym_dir", "dir1/dir2"),
         env.create_dir("sym_dir/dir1"),
         env.create_dir("sym_dir/dir1/dir2"),
 
     };
    // const unsigned TestFilesSize = sizeof(testFiles) / sizeof(testFiles[0]);
     const path startDir = testFiles[0];
     const path nestedFile = testFiles[1];
     const path permDeniedDir = testFiles[2];

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

 
 TEST_CASE(test_copy_symlinks_to_symlink_dir)
 {
     scoped_test_env env;
     const path file1 = env.create_file("file1", 42);
     const path file2 = env.create_file("file2", 101);
     const path file2_sym = env.create_symlink(file2, "file2_sym");
     const path dir = env.create_dir("dir");
-    const path dir_sym = env.create_symlink(dir, "dir_sym");
+    const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
     {
         std::error_code ec = GetTestEC();
         fs::copy(file1, dir_sym, copy_options::copy_symlinks, ec);
         TEST_CHECK(!ec);
         const path dest = env.make_env_path("dir/file1");
         TEST_CHECK(exists(dest));
         TEST_CHECK(!is_symlink(dest));
         TEST_CHECK(file_size(dest) == 42);

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

const path dne = env.make_env_path("dne");
         TEST_REQUIRE(ec);
     }
 }
 
 TEST_CASE(copy_symlink_basic)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
-    const path dir_sym = env.create_symlink(dir, "dir_sym");
+    const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
     const path file = env.create_file("file", 42);
     const path file_sym = env.create_symlink(file, "file_sym");
     { // test for directory symlinks
         const path dest = env.make_env_path("dest1");
         std::error_code ec;
         fs::copy_symlink(dir_sym, dest, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(is_symlink(dest));

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

TEST_CASE(create_directories_multi_level)
     TEST_CHECK(!ec);
     TEST_CHECK(is_directory(dir));
 }
 
 TEST_CASE(create_directory_symlinks) {
   scoped_test_env env;
   const path root = env.create_dir("dir");
   const path sym_dest_dead = env.make_env_path("dead");
-  const path dead_sym = env.create_symlink(sym_dest_dead, "dir/sym_dir");
+  const path dead_sym = env.create_directory_symlink(sym_dest_dead, "dir/sym_dir");
   const path target = env.make_env_path("dir/sym_dir/foo");
   {
     std::error_code ec = GetTestEC();
     TEST_CHECK(create_directories(target, ec) == false);
     TEST_CHECK(ec);
     TEST_CHECK(!exists(sym_dest_dead));
     TEST_CHECK(!exists(dead_sym));
   }
 }
 
 
 TEST_CASE(create_directory_through_symlinks) {
   scoped_test_env env;
   const path root = env.create_dir("dir");
-  const path sym_dir = env.create_symlink(root, "sym_dir");
+  const path sym_dir = env.create_directory_symlink(root, "sym_dir");
   const path target = env.make_env_path("sym_dir/foo");
   const path resolved_target = env.make_env_path("dir/foo");
   TEST_REQUIRE(is_directory(sym_dir));
   {
     std::error_code ec = GetTestEC();
     TEST_CHECK(create_directories(target, ec) == true);
     TEST_CHECK(!ec);
     TEST_CHECK(is_directory(target));
     TEST_CHECK(is_directory(resolved_target));
   }
 }
 
 TEST_SUITE_END()

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

const path sym = env.create_symlink(file, "sym");
         TEST_REQUIRE(ec);
     }
 }
 
 TEST_CASE(create_directory_symlink_basic)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
-    const path dir_sym = env.create_symlink(dir, "dir_sym");
+    const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
 
     const path dest = env.make_env_path("dest1");
     std::error_code ec;
     fs::create_directory_symlink(dir_sym, dest, ec);
     TEST_REQUIRE(!ec);
     TEST_CHECK(is_symlink(dest));
     TEST_CHECK(equivalent(dest, dir));
 }
 
 
 TEST_SUITE_END()

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

 }
 
 TEST_CASE(create_symlink_basic)
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path file_sym = env.create_symlink(file, "file_sym");
     const path dir = env.create_dir("dir");
-    const path dir_sym = env.create_symlink(dir, "dir_sym");
+    const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
     {
         const path dest = env.make_env_path("dest1");
         std::error_code ec;
         fs::create_symlink(file_sym, dest, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(is_symlink(dest));
         TEST_CHECK(equivalent(dest, file));
     }
     {
         const path dest = env.make_env_path("dest2");
         std::error_code ec;
-        fs::create_symlink(dir_sym, dest, ec);
+        fs::create_directory_symlink(dir_sym, dest, ec);
         TEST_REQUIRE(!ec);
         TEST_CHECK(is_symlink(dest));
         TEST_CHECK(equivalent(dest, dir));
     }
 }
 
 
 TEST_SUITE_END()

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

TEST_CASE(basic_symlink_test)
     const path nested_link = env.make_env_path("nested_link");
     create_symlink(link, nested_link);
     struct TestCase {
       path symlink;
       path expected;
     } testCases[] = {
         {env.create_symlink(dne, "dne_link"), dne},
         {env.create_symlink(file, "file_link"), file},
-        {env.create_symlink(dir, "dir_link"), dir},
+        {env.create_directory_symlink(dir, "dir_link"), dir},
         {nested_link, link}
     };
     for (auto& TC : testCases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         const path ret = read_symlink(TC.symlink, ec);
         TEST_CHECK(!ec);
         TEST_CHECK(ret == TC.expected);
     }
 }
 
 TEST_SUITE_END()

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

TEST_CASE(basic_remove_all_test)
     }
 }
 
 TEST_CASE(symlink_to_dir)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file(dir / "file", 42);
-    const path link = env.create_symlink(dir, "sym");
+    const path link = env.create_directory_symlink(dir, "sym");
 
     {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         TEST_CHECK(remove_all(link, ec) == 1);
         TEST_CHECK(!ec);
         TEST_CHECK(!exists(symlink_status(link)));
         TEST_CHECK(exists(dir));
         TEST_CHECK(exists(file));
     }
 }
 
 
 TEST_CASE(nested_dir)
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dir1 = env.create_dir(dir / "dir1");
     const path out_of_dir_file = env.create_file("file1", 42);
     const path all_files[] = {
         dir, dir1,
         env.create_file(dir / "file1", 42),
         env.create_symlink(out_of_dir_file, dir / "sym1"),
         env.create_file(dir1 / "file2", 42),
-        env.create_symlink(dir, dir1 / "sym2")
+        env.create_directory_symlink(dir, dir1 / "sym2")
     };
     const std::size_t expected_count = sizeof(all_files) / sizeof(all_files[0]);
 
     std::error_code ec = std::make_error_code(std::errc::address_in_use);
     TEST_CHECK(remove_all(dir, ec) == expected_count);
     TEST_CHECK(!ec);
     for (auto const& p : all_files) {
         TEST_CHECK(!exists(symlink_status(p)));
     }
     TEST_CHECK(exists(out_of_dir_file));
 }
 
 TEST_SUITE_END()