[libcxx] [test] Fix string type handling in a few fairly trivial class.path tests

[mstorsjo]

Summary

Use string() for convenience for testing where possible, but keep using native() for move tests where we want to check that no allocations are made, constructing a reference fs::path::string_type instead.

Use the right value_type in a few places.

Make the synop test check for the right types and for the expected preferred separator.

[ldionne]

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

29

Why don't you create s directly as fs::path::string_type?

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

32

Same

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp

31

Same.

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

29

Same.

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp

31

Same.

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp

28

Just create them as strings from the get go?

[mstorsjo]

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

29

How does one construct a wstring from a non-wide char pointer/literal? Or do you suggest adding a wrapper in some header to wrap the literal, for optionally adding the L prefix?

[ldionne]

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

29

Ah, you're right. That's why I phrased it as "why don't you" :-)

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

 int main(int, char**) {
   using namespace fs;
   static_assert(std::is_copy_assignable<path>::value, "");
   static_assert(!std::is_nothrow_copy_assignable<path>::value, "should not be noexcept");
   const std::string s("foo");
   const path p(s);
   path p2;
   path& pref = (p2 = p);
-  assert(p.native() == s);
-  assert(p2.native() == s);
+  assert(p.string() == s);
+  assert(p2.string() == s);
   assert(&pref == &p2);
 
   return 0;
 }

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

 #include "test_macros.h"
 #include "count_new.h"
 
 
 int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_move_assignable<path>::value, "");
   assert(globalMemCounter.checkOutstandingNewEq(0));
   const std::string s("we really really really really really really really "
                       "really really long string so that we allocate");
+  const fs::path::string_type ps(s.begin(), s.end());
   assert(globalMemCounter.checkOutstandingNewEq(1));
   path p(s);
   {
     DisableAllocationGuard g;
     path p2;
     path& pref = (p2 = std::move(p));
-    assert(p2.native() == s);
-    assert(p.native() != s); // Testing moved from state
+    assert(p2.native() == ps);
+    assert(p.native() != ps); // Testing moved from state
     assert(&pref == &p2);
   }
 
   return 0;
 }

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

 
 int main(int, char**) {
   using namespace fs;
   static_assert(std::is_copy_constructible<path>::value, "");
   static_assert(!std::is_nothrow_copy_constructible<path>::value, "should not be noexcept");
   const std::string s("foo");
   const path p(s);
   path p2(p);
-  assert(p.native() == s);
-  assert(p2.native() == s);
+  assert(p.string() == s);
+  assert(p2.string() == s);
 
   return 0;
 }

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

 
 int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_move_constructible<path>::value, "");
   assert(globalMemCounter.checkOutstandingNewEq(0));
   const std::string s("we really really really really really really really "
                       "really really long string so that we allocate");
   assert(globalMemCounter.checkOutstandingNewEq(1));
+  const fs::path::string_type ps(s.begin(), s.end());
   path p(s);
   {
     DisableAllocationGuard g;
     path p2(std::move(p));
-    assert(p2.native() == s);
-    assert(p.native() != s); // Testing moved from state
+    assert(p2.native() == ps);
+    assert(p.native() != ps); // Testing moved from state
   }
 
   return 0;
 }

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

 #include "test_iterators.h"
 #include "min_allocator.h"
 #include "filesystem_test_helper.h"
 
 
 template <class CharT, class ...Args>
 void RunTestCaseImpl(MultiStringType const& MS, Args... args) {
   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);
   // StringTypes
   {
     const std::basic_string<CharT> S(TestPath);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp

 #include "filesystem_test_helper.h"
 
 
 int main(int, char**)
 {
   using namespace fs;
   const char* const value = "hello world";
   const std::string str_value = value;
+  const fs::path::string_type pathstr_value(str_value.begin(), str_value.end());
   { // Check signature
     path p(value);
     ASSERT_SAME_TYPE(path::value_type const*, decltype(p.c_str()));
     ASSERT_NOEXCEPT(p.c_str());
   }
   {
     path p(value);
-    assert(p.c_str() == str_value);
+    assert(p.c_str() == pathstr_value);
     assert(p.native().c_str() == p.c_str());
   }
 
   return 0;
 }

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

 #include "test_macros.h"
 #include "filesystem_test_helper.h"
 
 
 int main(int, char**)
 {
   using namespace fs;
   const char* const value = "hello world";
+  std::string value_str(value);
+  fs::path::string_type pathstr_value(value_str.begin(), value_str.end());
   { // Check signature
     path p(value);
     ASSERT_SAME_TYPE(path::string_type const&, decltype(p.native()));
     ASSERT_NOEXCEPT(p.native());
   }
   { // native() is tested elsewhere
     path p(value);
-    assert(p.native() == value);
+    assert(p.native() == pathstr_value);
   }
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp

 #include "filesystem_test_helper.h"
 
 
 int main(int, char**)
 {
   using namespace fs;
   using string_type = path::string_type;
   const char* const value = "hello world";
+  std::string value_str(value);
+  fs::path::string_type pathstr_value(value_str.begin(), value_str.end());
   { // Check signature
     path p(value);
     static_assert(std::is_convertible<path, string_type>::value, "");
     static_assert(std::is_constructible<string_type, path>::value, "");
     ASSERT_SAME_TYPE(string_type, decltype(p.operator string_type()));
     ASSERT_NOT_NOEXCEPT(p.operator string_type());
   }
   {
     path p(value);
-    assert(p.native() == value);
+    assert(p.native() == pathstr_value);
     string_type s = p;
-    assert(s == value);
-    assert(p == value);
+    assert(s == pathstr_value);
+    assert(p == pathstr_value);
   }
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp

void doIOTest() {
   { // test output
     auto& ret = (ss << p);
     assert(ss.str() == E);
     assert(&ret == &ss);
   }
   { // test input
     path p_in;
     auto& ret = ss >> p_in;
-    assert(p_in.native() == (const char*)InStr);
+    assert(p_in.native() == (const path::value_type*)InStr);
     assert(&ret == &ss);
   }
 }
 
 namespace impl {
 using namespace fs;
 
 template <class Stream, class Tp, class = decltype(std::declval<Stream&>() << std::declval<Tp&>())>

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp

 #include "count_new.h"
 #include "filesystem_test_helper.h"
 
 
 // NOTE: this is tested in path.members/path.modifiers via the member swap.
 int main(int, char**)
 {
   using namespace fs;
   const char* value1 = "foo/bar/baz";
   const char* value2 = "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG";
   path p1(value1);
   path p2(value2);
+  fs::path::string_type ps1 = p1.native();
+  fs::path::string_type ps2 = p2.native();
   {
     using namespace std; using namespace fs;
     ASSERT_NOEXCEPT(swap(p1, p2));
     ASSERT_SAME_TYPE(void, decltype(swap(p1, p2)));
   }
   {
     DisableAllocationGuard g;
     using namespace std;
     using namespace fs;
     swap(p1, p2);
-    assert(p1.native() == value2);
-    assert(p2.native() == value1);
+    assert(p1.native() == ps2);
+    assert(p2.native() == ps1);
     swap(p1, p2);
-    assert(p1.native() == value1);
-    assert(p2.native() == value2);
+    assert(p1.native() == ps1);
+    assert(p2.native() == ps2);
   }
 
   return 0;
 }

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

 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 
 int main(int, char**) {
   using namespace fs;
+#ifdef _WIN32
+  ASSERT_SAME_TYPE(path::value_type, wchar_t);
+#else
   ASSERT_SAME_TYPE(path::value_type, char);
+#endif
   ASSERT_SAME_TYPE(path::string_type, std::basic_string<path::value_type>);
   {
     ASSERT_SAME_TYPE(const path::value_type, decltype(path::preferred_separator));
+#ifdef _WIN32
+    static_assert(path::preferred_separator == '\\', "");
+#else
     static_assert(path::preferred_separator == '/', "");
+#endif
     // Make preferred_separator ODR used by taking its address.
-    const char* dummy = &path::preferred_separator;
+    const path::value_type* dummy = &path::preferred_separator;
     ((void)dummy);
   }
 
   return 0;
 }