[libcxx] [test] Change the generic_string_alloc test to do a conversion that also does something on windows

[mstorsjo]

Summary

On windows, the native path char type is wchar_t - therefore, this test
didn't actually do the conversion that the test was supposed to exercise.
Instead use a type that ends up converted on all current platforms
(char32_t), and use the typedef CharT instead of hardcoding wchar_t in
multiple places.

The charset conversions on windows do cause extra allocations outside of
the provided allocator though, so that bit of the test has to be waived
now that the test actually does something. (Other tests have similar
TEST_NOT_WIN32() for allocation checks for charset conversions.)

[• Quuxplusone]

Seems reasonable to me. (The existing code's MultiStringType is insane — took me a while to figure out why casting it to (const char*) on line 47 wasn't a bug — but that's not your problem.)

[mstorsjo]

Rerun CI

[curdeius]

LGTM. What do you think, would there be any value in testing different char types?

[mstorsjo]

Test all char types in generic_string_alloc, fix a typo, and add testing of char8_t in path.native.obs/string_alloc too.

[mstorsjo]

In D102360#2757455, @curdeius wrote:

LGTM. What do you think, would there be any value in testing different char types?

Hmm, I guess it would be good to test all cases, just for completeness - amended the patch.

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

 #include "count_new.h"
 #include "min_allocator.h"
 #include "filesystem_test_helper.h"
 
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
 
 // generic_string<C, T, A> forwards to string<C, T, A>. Tests for
-// string<C, T, A>() are in "path.native.op/string_alloc.pass.cpp".
+// string<C, T, A>() are in "path.native.obs/string_alloc.pass.cpp".
 // generic_string is minimally tested here.
-int main(int, char**)
+template <class CharT>
+void doAllocTest()
 {
   using namespace fs;
-  using CharT = wchar_t;
   using Traits = std::char_traits<CharT>;
   using Alloc = malloc_allocator<CharT>;
   using Str = std::basic_string<CharT, Traits, Alloc>;
-  const wchar_t* expect = longString;
+  const CharT* expect = longString;
   const path p((const char*)longString);
   {
-    DisableAllocationGuard g;
+    // On Windows, charset conversions cause allocations outside of the
+    // provided allocator.
+    TEST_NOT_WIN32(DisableAllocationGuard g);
     Alloc a;
     Alloc::disable_default_constructor = true;
-    Str s = p.generic_string<wchar_t, Traits, Alloc>(a);
+    Str s = p.generic_string<CharT, Traits, Alloc>(a);
     assert(s == expect);
     assert(Alloc::alloc_count > 0);
     assert(Alloc::outstanding_alloc() == 1);
-  }
+    Alloc::disable_default_constructor = false;
+  }
 
+int main(int, char**)
+{
+  doAllocTest<char>();
+  doAllocTest<wchar_t>();
+  doAllocTest<char16_t>();
+  doAllocTest<char32_t>();
+#if TEST_STD_VER > 17 && defined(__cpp_lib_char8_t)
+  doAllocTest<char8_t>();
+#endif
   return 0;
 }

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

 {
   using namespace fs;
   {
     auto const& S = shortString;
     doShortStringTest<char>(S);
     doShortStringTest<wchar_t>(S);
     doShortStringTest<char16_t>(S);
     doShortStringTest<char32_t>(S);
+#if TEST_STD_VER > 17 && defined(__cpp_lib_char8_t)
+    doShortStringTest<char8_t>(S);
+#endif
   }
   {
     auto const& S = longString;
     doLongStringTest<char>(S);
     doLongStringTest<wchar_t>(S);
     doLongStringTest<char16_t>(S);
     doLongStringTest<char32_t>(S);
+#if TEST_STD_VER > 17 && defined(__cpp_lib_char8_t)
+    doLongStringTest<char8_t>(S);
+#endif
   }
 
   return 0;
 }