[libcxx] [test] Fix the collate compare test for Glibc, Windows and FreeBSD

[mstorsjo]

Summary

The old expected behaviour was specific to Apple platforms, while Glibc, Windows and FreeBSD collate differently (ignoring case). Make the old tested behaviour a special case for Apple platforms, and make the default case the one used by the other three.

In clang-cl/DLL configurations, the test is hit by https://llvm.org/PR41018 (making the test fail to link).

[• Quuxplusone]

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp

21–24

Both glibc and Win32 have a different collation order from libc++-on-Apple. Are they the same collation order? Is this just a bug on Apple, perhaps?

That said, lines 47-62 totally reasonable to me. They're using std::collate in the en_US.UTF-8 locale to compare "aaaaaaA" against "BaaaaaA", and expecting "B" to collate after "a" in dictionary order. That seems totally fine and correct to me.
Lines 66-81 look fishy. They're doing the same dictionary-order test, but in the C locale! Isn't the C locale supposed to use basically strcmp to do its collation? B should sort before a in strcmp order. I suspect that perhaps this test should be flipped, enabled on Linux and XFAILed (if necessary) on Apple targets.

[mstorsjo]

Rewrote the test to make it pass on Glibc and Windows (and also tested on FreeBSD, even if that's not available in CI).

[• Quuxplusone]

I'm not 100% happy with the wording of the comments "Apple seems to collate lexicographically" and "Glibc, Windows and FreeBSD collate ignoring case here" — I think "lexicographically" is ambiguous. Lexicographical order unambiguously describes how to order variable-length sequences of elements given that you know how to compare two elements, but it doesn't imply anything about the way in which you compare those elements. A dictionary that sorts "run, Runescape, runt" is still lexicographically ordered; it just happens to collate r and R together.

How about "Apple's default collation is case-sensitive" and "Glibc, Windows, and FreeBSD's default collation is case-insensitive"?

[mstorsjo]

In D120797#3355365, @Quuxplusone wrote:

How about "Apple's default collation is case-sensitive" and "Glibc, Windows, and FreeBSD's default collation is case-insensitive"?

Sure, that sounds good to me - I'll update my local copy of the patch that way.

[ldionne]

It's kind of crazy that different C libraries have such fundamental differences.

[Mordante]

In D120797#3355399, @ldionne wrote:

It's kind of crazy that different C libraries have such fundamental differences.

Agreed, this isn't what I expect of locales :-( But since this is how libc++ get's the information LGTM.

[EricWF]

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp

36

The indirection here makes it harder to understand what the test is actually doing. For example, the actual object under test, the facet, isn't visibly used at the callsites.
"Don't repeat yourself" might be a good maxim most places, but it's totally fine for tests to contain repeated code.

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp

 // template <class charT> class collate_byname
 
 // int compare(const charT* low1, const charT* high1,
 //             const charT* low2, const charT* high2) const;
 
 //  I'm currently unable to confirm that collation based on named locales
 //     has any difference from "C" collation.  But I do believe I'm picking
 //     up the OS's collation files.
 
-// TODO investigation needed.
-// Glibc seems to collate files differently from the way Apple's C library does it.
-// XFAIL: target={{.*}}-linux-gnu{{.*}}
-
-// XFAIL: LIBCXX-WINDOWS-FIXME
+// https://llvm.org/PR41018
+// XFAIL: windows-dll && msvc
 
 // XFAIL: LIBCXX-AIX-FIXME
 
 #include <locale>
 #include <string>
 #include <cassert>
 
 #include <stdio.h>
 
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
+#define ASSERT_COMPARE(type, str1, str2, expected) \
+    do { \
+        type s1(str1); \
+        type s2(str2); \
+        assert(f.compare(s1.data(), s1.data() + s1.size(), \
+                         s2.data(), s2.data() + s2.size()) == (expected)); \
+    } while (0)
+
 int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
         {
             const std::collate<char>& f = std::use_facet<std::collate<char> >(l);
-            std::string s2("aaaaaaA");
-            std::string s3("BaaaaaA");
-            assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
+
+            ASSERT_COMPARE(std::string, "aaa", "bbb", -1);
+            ASSERT_COMPARE(std::string, "AAA", "BBB", -1);
+            ASSERT_COMPARE(std::string, "bbb", "aaa", 1);
+            ASSERT_COMPARE(std::string, "ccc", "ccc", 0);
+
+#if defined(__APPLE__)
+            // Apple's default collation is case-sensitive
+            ASSERT_COMPARE(std::string, "aaaaaaA", "BaaaaaA", 1);
+#else
+            // Glibc, Windows, and FreeBSD's default collation is case-insensitive
+            ASSERT_COMPARE(std::string, "aaaaaaA", "BaaaaaA", -1);
+#endif
         }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
         {
             const std::collate<wchar_t>& f = std::use_facet<std::collate<wchar_t> >(l);
-            std::wstring s2(L"aaaaaaA");
-            std::wstring s3(L"BaaaaaA");
-            assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
+
+            ASSERT_COMPARE(std::wstring, L"aaa", L"bbb", -1);
+            ASSERT_COMPARE(std::wstring, L"AAA", L"BBB", -1);
+            ASSERT_COMPARE(std::wstring, L"bbb", L"aaa", 1);
+            ASSERT_COMPARE(std::wstring, L"ccc", L"ccc", 0);
+#if defined(__APPLE__)
+            // Apple's default collation is case-sensitive
+            ASSERT_COMPARE(std::wstring, L"aaaaaaA", L"BaaaaaA", 1);
+#else
+            // Glibc, Windows, and FreeBSD's default collation is case-insensitive
+            ASSERT_COMPARE(std::wstring, L"aaaaaaA", L"BaaaaaA", -1);
+#endif
         }
 #endif
     }
     {
         std::locale l("C");
         {
             const std::collate<char>& f = std::use_facet<std::collate<char> >(l);
-            std::string s2("aaaaaaA");
-            std::string s3("BaaaaaA");
-            assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
+            ASSERT_COMPARE(std::string, "aaa", "bbb", -1);
+            ASSERT_COMPARE(std::string, "AAA", "BBB", -1);
+            ASSERT_COMPARE(std::string, "bbb", "aaa", 1);
+            ASSERT_COMPARE(std::string, "ccc", "ccc", 0);
+
+            // In the C locale, these are collated lexicographically.
+            ASSERT_COMPARE(std::string, "aaaaaaA", "BaaaaaA", 1);
         }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
         {
             const std::collate<wchar_t>& f = std::use_facet<std::collate<wchar_t> >(l);
-            std::wstring s2(L"aaaaaaA");
-            std::wstring s3(L"BaaaaaA");
-            assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
+
+            ASSERT_COMPARE(std::wstring, L"aaa", L"bbb", -1);
+            ASSERT_COMPARE(std::wstring, L"AAA", L"BBB", -1);
+            ASSERT_COMPARE(std::wstring, L"bbb", L"aaa", 1);
+            ASSERT_COMPARE(std::wstring, L"ccc", L"ccc", 0);
+
+            // In the C locale, these are collated lexicographically.
+            ASSERT_COMPARE(std::wstring, L"aaaaaaA", L"BaaaaaA", 1);
         }
 #endif
     }
 
   return 0;
 }