[libcxx] [test] Fix all remaining issues with fs::path::string_type being wstring

[mstorsjo]

Summary

Use fs::path as variable type instead of std::string, when the input potentially is a path, as they can't be implicitly converted back to string.

[ldionne]

Accepting as long as you extract PutEnv into filesystem_test_helper.h and use it everywhere in the test suite!

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

28–29

This could be in filesystem_test_helper (I proposed adding such a helper in another patch in this series).

[mstorsjo]

In D89674#2338516, @ldionne wrote:

Accepting as long as you extract PutEnv into filesystem_test_helper.h and use it everywhere in the test suite!

Sure, that sounds like a good idea, but I'd rather do that in a separate patch (superseding the one you commented on) and keeping this one as such (as a pure path/string handling fix).

[ldionne]

In D89674#2338529, @mstorsjo wrote:

In D89674#2338516, @ldionne wrote:

Accepting as long as you extract PutEnv into filesystem_test_helper.h and use it everywhere in the test suite!

Sure, that sounds like a good idea, but I'd rather do that in a separate patch (superseding the one you commented on) and keeping this one as such (as a pure path/string handling fix).

Sounds good -- can you open the patch now? I want to make sure we don't accidentally forget to cleanup afterwards :-)

libcxx/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp

void checkIteratorConcepts() {
   {
     It it;
     ASSERT_SAME_TYPE(It&, decltype(++it));
     ASSERT_SAME_TYPE(It, decltype(it++));
     ASSERT_SAME_TYPE(It&, decltype(--it));
     ASSERT_SAME_TYPE(It, decltype(it--));
     ASSERT_SAME_TYPE(Traits::reference, decltype(*it));
     ASSERT_SAME_TYPE(Traits::pointer, decltype(it.operator->()));
+#ifdef _WIN32
+    ASSERT_SAME_TYPE(std::wstring const&, decltype(it->native()));
+#else
     ASSERT_SAME_TYPE(std::string const&, decltype(it->native()));
+#endif
     ASSERT_SAME_TYPE(bool, decltype(it == it));
     ASSERT_SAME_TYPE(bool, decltype(it != it));
   }
   {
     path const p;
     ASSERT_SAME_TYPE(It, decltype(p.begin()));
     ASSERT_SAME_TYPE(It, decltype(p.end()));
     assert(p.begin() == p.end());

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp

 #include "test_macros.h"
 #include "count_new.h"
 
 
 int main(int, char**) {
   using namespace fs;
   path p("abc");
   p = {};
+#ifdef _WIN32
+  assert(p.native() == L"");
+#else
   assert(p.native() == "");
+#endif
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp

 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
 
 
 template <class CharT>
 void RunTestCase(MultiStringType const& MS) {
   using namespace fs;
-  const char* Expect = MS;
+  const fs::path::value_type* Expect = MS;
   const CharT* TestPath = MS;
   const CharT* TestPathEnd = StrEnd(TestPath);
   const std::size_t Size = TestPathEnd - TestPath;
   const std::size_t SSize = StrEnd(Expect) - Expect;
   assert(Size == SSize);
   //////////////////////////////////////////////////////////////////////////////
   // basic_string<Char, Traits, Alloc>
   {
void test_sfinae() {
 
   }
   {
     static_assert(!std::is_assignable<path, int*>::value, "");
     static_assert(!has_assign<int*>(), "");
   }
 }
 
-void RunStringMoveTest(const char* Expect) {
+void RunStringMoveTest(const fs::path::value_type* Expect) {
   using namespace fs;
-  std::string ss(Expect);
+  fs::path::string_type ss(Expect);
   path p;
   {
     DisableAllocationGuard g; ((void)g);
     path& pr = (p = std::move(ss));
     assert(&pr == &p);
   }
   assert(p == Expect);
   {

libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp

 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
 #include "verbose_assert.h"
 
 struct ComparePathExact {
-  bool operator()(std::string const& LHS, std::string const& RHS) const {
-    return LHS == RHS;
+  bool operator()(fs::path const& LHS, std::string const& RHS) const {
+    return LHS.string() == RHS;
   }
 };
 
 struct PathDecomposeTestcase
 {
     std::string raw;
     std::vector<std::string> elements;
     std::string root_path;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp

for (auto& TC : TestCases) {
     fs::path p(TC.input);
     const fs::path output = p.lexically_normal();
     if (!PathEq(output, TC.expect)) {
       Failed = true;
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n",
-        ID, TC.input.c_str(), TC.expect.c_str(), output.native().c_str());
+        ID, TC.input.c_str(), TC.expect.c_str(), output.string().c_str());
     }
   }
   return Failed;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

auto ReportErr = [&](const char* Testing, fs::path const& Output,
       Failed = true;
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Testing: %s\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n",
         ID, Testing, TC.input.c_str(), TC.base.c_str(),
-        Expected.c_str(), Output.native().c_str());
+        Expected.string().c_str(), Output.string().c_str());
     };
     if (!PathEq(output, TC.expect))
       ReportErr("path::lexically_relative", output, TC.expect);
     const fs::path proximate_output = p.lexically_proximate(TC.base);
     // [path.gen] lexically_proximate
     // Returns: If the value of lexically_relative(base) is not an empty path,
     // return it. Otherwise return *this.
     const fs::path proximate_expected = output.native().empty() ? p
         : output;
     if (!PathEq(proximate_expected, proximate_output))
       ReportErr("path::lexically_proximate", proximate_output, proximate_expected);
   }
   return Failed;
 }

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

auto SetupState = [&](bool AllowEAccess, bool& SeenFile3) {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(false, SeenNestedFile);
       TEST_REQUIRE(it != endIt);
       TEST_REQUIRE(*it == nestedDir);
 
       ExceptionChecker Checker(std::errc::permission_denied,
                                "recursive_directory_iterator::operator++()",
                                format_string("attempting recursion into \"%s\"",
-                                             nestedDir.native()));
+                                             nestedDir.string().c_str()));
       TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ++it);
     }
 }
 
 
 // See llvm.org/PR35078
 TEST_CASE(test_PR35078_with_symlink)
 {

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

 }
 
 
 TEST_CASE(basic_test)
 {
     const fs::path cwd = fs::current_path();
     const struct {
       std::string input;
-      std::string expect;
+      fs::path expect;
     } TestCases [] = {
         {"", cwd / ""},
         {"foo", cwd / "foo"},
         {"foo/", cwd / "foo/"},
         {"/already_absolute", "/already_absolute"}
     };
     for (auto& TC : TestCases) {
         std::error_code ec = GetTestEC();
         const path ret = absolute(TC.input, ec);
         TEST_CHECK(!ec);
         TEST_CHECK(ret.is_absolute());
         TEST_CHECK(PathEq(ret, TC.expect));
     }
 }
 
 TEST_SUITE_END()

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

 }
 
 struct Times {
   TimeSpec access, write;
 };
 
 Times GetTimes(path const& p) {
     StatT st;
-    if (::stat(p.c_str(), &st) == -1) {
+    if (::stat(p.string().c_str(), &st) == -1) {
         std::error_code ec(errno, std::generic_category());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         throw ec;
 #else
         std::exit(EXIT_FAILURE);
 #endif
     }
     return {extract_atime(st), extract_mtime(st)};
 }
 
 TimeSpec LastAccessTime(path const& p) { return GetTimes(p).access; }
 
 TimeSpec LastWriteTime(path const& p) { return GetTimes(p).write; }
 
 Times GetSymlinkTimes(path const& p) {
   StatT st;
-  if (::lstat(p.c_str(), &st) == -1) {
+  if (::lstat(p.string().c_str(), &st) == -1) {
     std::error_code ec(errno, std::generic_category());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         throw ec;
 #else
         std::exit(EXIT_FAILURE);
 #endif
     }
     Times res;
TEST_CASE(get_last_write_time_dynamic_env_test)
 
     file_time_type dtime = last_write_time(dir);
     TEST_CHECK(Clock::to_time_t(dtime) == dir_write_time.tv_sec);
     TEST_CHECK(CompareTime(dtime, dir_write_time));
 
     SleepFor(Sec(2));
 
     // update file and add a file to the directory. Make sure the times increase.
-    std::FILE* of = std::fopen(file.c_str(), "a");
+    std::FILE* of = std::fopen(file.string().c_str(), "a");
     std::fwrite("hello", 1, sizeof("hello"), of);
     std::fclose(of);
     env.create_file("dir/file1", 1);
 
     file_time_type ftime2 = last_write_time(file);
     file_time_type dtime2 = last_write_time(dir);
 
     TEST_CHECK(ftime2 > ftime);

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

TEST_CASE(basic_test) {
   TEST_REQUIRE(!cwd.native().empty());
   int cwd_depth = count_path_elems(cwd);
   path dot_dot_to_root;
   for (int i=0; i < cwd_depth; ++i)
     dot_dot_to_root /= "..";
   path relative_cwd = cwd.native().substr(1);
   // clang-format off
   struct {
-    std::string input;
-    std::string base;
-    std::string expect;
+    fs::path input;
+    fs::path base;
+    fs::path expect;
   } TestCases[] = {
       {"", "", "."},
       {cwd, "a", ".."},
       {parent_cwd, "a", "../.."},
       {"a", cwd, "a"},
       {"a", parent_cwd, curdir / "a"},
       {"/", "a", dot_dot_to_root / ".."},
       {"/", "a/b", dot_dot_to_root / "../.."},
for (auto& TC : TestCases) {
     fs::path p(TC.input);
     const fs::path output = fs::proximate(p, TC.base, ec);
     if (ec) {
       TEST_CHECK(!ec);
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n",
-        ID, TC.input.c_str(), TC.base.c_str(), TC.expect.c_str());
+        ID, TC.input.string().c_str(), TC.base.string().c_str(),
+        TC.expect.string().c_str());
     } else if (!PathEq(output, TC.expect)) {
       TEST_CHECK(PathEq(output, TC.expect));
 
       const path canon_input = fs::weakly_canonical(TC.input);
       const path canon_base = fs::weakly_canonical(TC.base);
       const path lexically_p = canon_input.lexically_proximate(canon_base);
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n"
                   "  Lex Prox: '%s'\n"
                   "  Canon Input: '%s'\n"
                   "  Canon Base: '%s'\n",
-        ID, TC.input.c_str(), TC.base.c_str(), TC.expect.c_str(),
-        output.native().c_str(), lexically_p.native().c_str(),
-        canon_input.c_str(), canon_base.c_str());
+        ID, TC.input.string().c_str(), TC.base.string().c_str(),
+        TC.expect.string().c_str(), output.string().c_str(),
+        lexically_p.string().c_str(), canon_input.string().c_str(),
+        canon_base.string().c_str());
     }
   }
 }
 
 TEST_SUITE_END()

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

 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(static_env.Dir.c_str(), &expect) != -1);
+    TEST_REQUIRE(::statvfs(static_env.Dir.string().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;

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

 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-void PutEnv(std::string var, std::string value) {
-    assert(::setenv(var.c_str(), value.c_str(), /* overwrite */ 1) == 0);
+void PutEnv(std::string var, fs::path value) {
+    assert(::setenv(var.c_str(), value.string().c_str(), /* overwrite */ 1) == 0);
 }
 
 void UnsetEnv(std::string var) {
     assert(::unsetenv(var.c_str()) == 0);
 }
 
 TEST_SUITE(filesystem_temp_directory_path_test_suite)
 

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

 
 
 int main(int, char**) {
 
   static_test_env static_env;
 
   // clang-format off
   struct {
-    std::string input;
-    std::string expect;
+    fs::path input;
+    fs::path expect;
   } TestCases[] = {
       {"", fs::current_path()},
       {".", fs::current_path()},
       {"/", "/"},
       {"/foo", "/foo"},
       {"/.", "/"},
       {"/./", "/"},
       {"a/b", fs::current_path() / "a/b"},
for (auto& TC : TestCases) {
     fs::path p(TC.input);
     const fs::path output = fs::weakly_canonical(p);
     if (!PathEq(output, TC.expect)) {
       Failed = true;
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n",
-        ID, TC.input.c_str(), TC.expect.c_str(), output.native().c_str());
+        ID, TC.input.string().c_str(), TC.expect.string().c_str(),
+        output.string().c_str());
     }
   }
   return Failed;
 }