[libcxx] Get categories.time localization tests passing on linux

[EricWF]

Summary

This gets all of the test under test/localization/locale.categories/category.time passing (or XFAIL) under linux.

[EricWF]

I changed the month name test data for ru_RU since the 5th month is not consistent across GLIBC distributions.

[emaste]

test/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp

47

Perhaps !defined(__GLIBC__) instead. FreeBSD has no timezone with %c either.

[mclow.lists]

Same comment as previous change: Is there are *correct* result (i.e, mandated by a standard), and if so, what is it.

If it's just "implementation defined", then we're going to have to figure out how to test this stuff, and this is a reasonable start.

[EricWF]

I need to back out the changes to get_monthname.pass.cpp and get_monthname_wide.pass.cpp. It doesn't actually fix what I had hoped.

@mclow.lists I'll keep my eye on the standard, but for the most part I'm just checking that the output matches what is in /usr/share/i18n/locales.

test/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp

47

Sounds good. The actual format of %c is still unspecified but I see the test is currently passing on FreeBSD10.

[EricWF]

I backed out changes to get_one and get_one_wide. I incorrectly thought it used the timezone, but trying to get the actual output causes it to print a bunch of non-sense characters at the end. Investigation is needed. Those tests are just marked XFAIL on linux now.

CREDITS.TXT

 E: [e-mail]
 D: C++14 support, patches and bug fixes.
 
-N: Eric Fiselier
-E: [e-mail]
-D: LFTS support, patches and bug fixes.
-
 N: Bill Fisher
 E: [e-mail]
 D: Regex bug fixes.

test/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp

     }
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
-        const char in[] = "\xD0\xB8\xD1\x8E\xD0\xBD\xD1\x8F";
+        const char in[] = "\xD0\xBC\xD0\xB0\xD1\x8F";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
         assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
-        assert(t.tm_mon == 5);
+        assert(t.tm_mon == 4);
         assert(err == std::ios_base::eofbit);
     }
     {

test/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp

     }
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
-        const wchar_t in[] = L"\x438\x44E\x43D\x44F";
+        const wchar_t in[] = L"\x43C\x430\x44F";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
         assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
-        assert(t.tm_mon == 5);
+        assert(t.tm_mon == 4);
         assert(err == std::ios_base::eofbit);
     }
     {

test/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp

     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
+    // NOTE: %c is locale specific. with GLIBC it includes the timezone making
+    // this test non-portable
+#ifdef __APPLE__
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
         const char in[] = "Sat Dec 31 23:55:59 2061";

         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+#endif
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
+    // NOTE: GLIBC uses 12 hour time for en_US.
+#   if !defined(__GLIBC__)
         const char in[] = "23:55:59";
+#   else
+        const char in[] = "11:55:59 PM";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');

         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+#ifdef __APPLE__
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
         const char in[] = "Sam 31 d""\xC3\xA9""c 23:55:59 2061";

         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+#endif
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
         const char in[] = "23:55:59";

         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+#ifdef __APPLE__
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
         const char in[] = "\xD1\x81\xD1\x83\xD0\xB1\xD0\xB1"

         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+#endif
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
         const char in[] = "23:55:59";

         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+#ifdef __APPLE__
     {
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const char in[] = "\xE5\x85\xAD"

         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+#endif
     {
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const char in[] = "23""\xE6\x97\xB6""55""\xE5\x88\x86""59""\xE7\xA7\x92";

test/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp

 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
+
+
 // <locale>
 
 // class time_get_byname<charT, InputIterator>

     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
+    // %c is locale dependant. With GLIBC it includes the timezone making this
+    // test non-portible
+#ifdef __APPLE__
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
         const wchar_t in[] = L"Sat Dec 31 23:55:59 2061";

         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+#endif
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
+    // NOTE: GLIBC uses 12 hour time for en_US
+#   if !defined(__GLIBC__)
         const wchar_t in[] = L"23:55:59";
+#   else
+        const wchar_t in[] = L"11:55:59 PM";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');

         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+#ifdef __APPLE__
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
         const wchar_t in[] = L"Sam 31 d""\xE9""c 23:55:59 2061";

         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+#endif
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
         const wchar_t in[] = L"23:55:59";

test/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp

     }
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
+#   if !defined(__GLIBC__)
         const char in[] = "\xD0\xBF\xD0\xBE\xD0\xBD\xD0\xB5"
                           "\xD0\xB4\xD0\xB5\xD0\xBB\xD1\x8C"
                           "\xD0\xBD\xD0\xB8\xD0\xBA";
+#   else
+        // NOTE: GLIBC uses U041F instead of 043F. It seems to be the difference
+        // between an upper and lower case letter. This changes the second
+        // byte from \xBF to \x9F.
+        const char in[] = "\xD0\x9F\xD0\xBE\xD0\xBD\xD0\xB5"
+                          "\xD0\xB4\xD0\xB5\xD0\xBB\xD1\x8C"
+                          "\xD0\xBD\xD0\xB8\xD0\xBA";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);

test/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp

     }
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
+#   if !defined(__linux__)
         const wchar_t in[] = L"\x43F\x43E\x43D\x435\x434\x435\x43B\x44C\x43D\x438\x43A";
+#   else
+        // NOTE: GLIBC uses U041F instead of 043F. It seems to be the difference
+        // between an upper and lower case letter.
+        const wchar_t in[] = L"\x41F\x43E\x43D\x435\x434\x435\x43B\x44C\x43D\x438\x43A";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);

test/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp

 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.fr_FR.UTF-8
 
+// GLIBC uses lower case names and their short forms end with a dot.
+// The last test returns "Today is samedi which is abbreviated sam.."
+// XFAIL: linux
+
 // <locale>
 
 // template <class CharT, class OutputIterator = ostreambuf_iterator<CharT> >

test/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// Investigation needed. It seems like it might just be bad tests.
+// XFAIL: linux
+
 // <locale>
 
 // class time_put<charT, OutputIterator>

         std::string ex(str, iter.base());
         assert(ex == "09");
     }
+    // %OB is a BSD libc extension.
+#if !defined(__GLIBC__)
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'B', 'O');
         std::string ex(str, iter.base());
         assert(ex == "May");
     }
+#endif
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'e');
         std::string ex(str, iter.base());

         std::string ex(str, iter.base());
         assert(ex == "52");
     }
+    // %v is a BSD libc extension
+#if !defined(__GLIBC__)
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'v');
         std::string ex(str, iter.base());
         assert(ex == " 2-May-2009");
     }
+#endif
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'W');
         std::string ex(str, iter.base());

         assert(ex == "%");
     }
     {
+        // NOTE: fails on linux. More investigation needed. Seems to
+        // be a difference in the implementation of GLIBC.
+        // I don't think this is a portible test.
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, '%', 'J');
         std::string ex(str, iter.base());
         assert(ex == "J%");
     }
     {
+        // NOTE: fails on linux. More investigation needed. Seems to
+        // be a difference in the implementation of GLIBC.
+        // I don't think this is a portible test.
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'J');
         std::string ex(str, iter.base());
         assert(ex == "J");