Get all localization tests passing on linux!

[EricWF]

Summary

This patch gets all localization tests passing on linux.
It doesn't actually change any code in locale. Only tests.
Most of the failures were due to different locale behavior between apple and linux.
Other failures seem to be related to bugs in GLIBCs handling of some characters.

[danalbert]

I think I may have misled you when I said we should #ifdef the differences between glibc and Mac. If there are legitimate differences, we should #ifdef them. If glibc is wrong (it looks like it often is), we should just XFAIL the test and file a bug against glibc (or does that data come from an OS package?).

I usually only commented on one test of a given type, but the comments apply to all similar.

test/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp

11 ↗

(On Diff #12383)

Doh! My mistake.

test/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp

38

I think you meant to #ifdef this one as you did in the next test.

Either way, this doesn't look right to me. Do we know why this is happening? Is this a legitimate difference between Mac and glibc, or is glibc broken? If it's just a difference, then we should still check against the expected glibc behavior. If Linux is broken, we should XFAIL the test rather than skipping the broken part.

test/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

11

We're XFAILing these as a TODO, right? I wish LIT had a way to distinguish between intended failures and known failures.

test/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

311

I think glibc's locale data is wrong here. We should mark these tests as XFAIL rather than hiding the failure. A bug will need to be filed against glibc (or wherever glibc gets their locale data from).

test/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp

133

The test is right, glibc's locale data is wrong. Russia uses ',' for a decimal separator (according to wikipedia). This test (and those like it) should be XFAIL.

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

63

Looks like more bad locale data to me.

79

What?

92

Looks like it wouldn't be the first time :)

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

86

Then let's XFAIL it for now.

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

47

There should be an #else case that tests the Linux behavior.

70

Pretty sure this is more bad locale data.

117

Phabricator: "Context not available"
Me: Damn you, Phabricator!

*checks the source*

Well, that didn't make it any clearer. I presume that mess of hex is encoding cyrillic characters. Are these tests like the other Russian ones where the separators are wrong? If so, XFAIL, not #ifdef.

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

73

What's with the case differences? I see that was actually already the case, but why?

test/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp

60

Looks like more glibc wrongness.

[EricWF]

Hi Dan,

Thanks for the review. I'll follow your suggestions. However I want to ask a question. Since the glibc data is frequently wrong we sacrifice a lot of test coverage on linux by marking the tests
XFAIL. Is there a point at which test coverage should trump glibc wrongness?

[EricWF]

Hi Dan,

I've addressed most of your comments. Thanks for the input.
I'll post a revised patch closely after.

test/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp

38

FreeBSD also fails on these tests as well for the same reason and I suspect darwin does as well. This needs more investigation.

test/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

11

Yep. I'll add a comment saying its TODO and explain the likely cause (translation of U00A0).

test/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

311

GLIBC's locale definition doesn't seem that unreasonable. I'll look more into it but I don't know if we can say its test data is for sure wrong.
I'm going to hold off on changing this.

test/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp

133

Yep. That seems wrong. I'll back out the GLIBC changes and just mark it as XFAIL. I'll also file a bug with GLIBC.

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

63

I think this might be bad locale data on apples part as opposed to GLIBCs. I'm basing that off
http://www.localeplanet.com/icu/fr-FR/
http://en.wikipedia.org/wiki/Date_format_by_country

79

GLIBC's locale data says that U002E is used as the separator.
http://www.fileformat.info/info/unicode/char/2e/index.htm

I don't think that seems unreasonable. More investigation needed though.

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

86

Ok. Done.

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

47

Not quite sure how to write one. The output depends on the timezone your in.

70

Probably, but I think GLIBC is correct. Having 12 hour time for en_US seems to make more sense than 24 hour.

117

Done. Changed backed out. I suspect the difference is between upper and lower case cyrillic characters. However more investigation is needed.

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

73

Not sure. glibc uses lower case. I've seperated the glibc change and only check the lower case version.

test/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp

60

Perhaps. Some of the sources I've found online suggest that ' ' is valid.
http://docs.oracle.com/cd/E19455-01/806-0169/overview-9/index.html
I'll leave this in for now.

[EricWF]

Implement most of Dan's comments. I've also backed out any changes to ctype tests. They need more investigation. They are just marked xfail now.

[jroelofs]

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

117

@danalbert: the "Context not available" bit isn't phabricator's fault. This happens when a patch is made without '-U999'.

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

73

The lowercase versions of that abbreviation are suspect to me. IIRC French folks capitalize it always.

[danalbert]

test/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp

38

Okay. Still, if it needs more investigation then it needs more investigation, but we definitely shouldn't be commenting out anything.

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

79

But 0x2e == '.'

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

70

Yeah, that's strange. Does this test fail on Mac? If it doesn't, it probably should.

[EricWF]

Thanks for the comments. It seems not all of the changes made it into the last patch. I'll implement your advice and back out all of the categories.ctype tests and just mark them XFAIL.

test/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp

38

Yeah, Sorry I thought I took that out and just marked it XFAIL.

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

79

I must have been tired. Thanks for the correction. I'll see what up with these tests.

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

70

I'll double check on this. I think this test passes on mac.

[danalbert]

It might be worth splitting this up into a couple patches. I think all the XFAILs can probably be submitted (just the XFAIL line, not the rest of the changes to the file). It would clean up a lot of the test results so you can have less noise tracking down the others, as well as making the next update easier to review.

[EricWF]

Splitting this revision up into smaller parts.

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

 
 int main()
 {
+#if !defined(__GLIBC__)
+    int const expect = 1;
+#else
+    int const expect = -1;
+#endif
     {
         std::locale l(LOCALE_en_US_UTF_8);
         {

             std::string s2("aaaaaaA");
             std::string s3("BaaaaaA");
             assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
-        }
-        {
-            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);
-        }
-    }
-    {
-        std::locale l("");
-        {
-            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);
+                             s3.data(), s3.data() + s3.size()) == expect);
         }
         {
             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);
+                             s3.data(), s3.data() + s3.size()) == expect);
         }
     }
     {

test/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp

 
 // XFAIL: with_system_lib=x86_64-apple-darwin11
 // XFAIL: with_system_lib=x86_64-apple-darwin12
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 
 #include <locale>
 #include <cassert>

             assert(f.tolower('.') == '.');
             assert(f.tolower('a') == 'a');
             assert(f.tolower('1') == '1');
+            //NOTE: fails with GLIBC and on FreeBSD
             assert(f.tolower('\xDA') == '\xFA');
             assert(f.tolower('\xFA') == '\xFA');
         }

test/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp

 
 // XFAIL: with_system_lib=x86_64-apple-darwin11
 // XFAIL: with_system_lib=x86_64-apple-darwin12
+// Investigation needed for linux failures.
+// XFAIL: linux
 
 #include <locale>
 #include <string>

             std::string in("\xDA A\x07.a1");
 
             assert(f.tolower(&in[0], in.data() + in.size()) == in.data() + in.size());
+            // NOTE: First case fails on linux and FreeBSD
             assert(in[0] == '\xFA');
             assert(in[1] == ' ');
             assert(in[2] == 'a');

test/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp

 // XFAIL: with_system_lib=x86_64-apple-darwin11
 // XFAIL: with_system_lib=x86_64-apple-darwin12
 
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 #include <locale>
 #include <cassert>
 

             assert(f.toupper('a') == 'A');
             assert(f.toupper('1') == '1');
             assert(f.toupper('\xDA') == '\xDA');
+            // NOTE: This fails on linux
             assert(f.toupper('\xFA') == '\xDA');
         }
     }

test/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp

 // XFAIL: with_system_lib=x86_64-apple-darwin11
 // XFAIL: with_system_lib=x86_64-apple-darwin12
 
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 #include <locale>
 #include <string>
 #include <cassert>

             std::string in("\xFA A\x07.a1");
 
             assert(f.toupper(&in[0], in.data() + in.size()) == in.data() + in.size());
+            // NOTE: first case fails on linux.
             assert(in[0] == '\xDA');
             assert(in[1] == ' ');
             assert(in[2] == 'A');

test/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp

 
 // I doubt this test is portable
 
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 #include <locale>
 #include <cassert>
 #include <limits.h>

             assert(f.widen('.') == L'.');
             assert(f.widen('a') == L'a');
             assert(f.widen('1') == L'1');
+            // NOTE: This fails on linux
             assert(f.widen(char(-5)) == wchar_t(251));
         }
     }

test/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp

 
 // I doubt this test is portable
 
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 #include <locale>
 #include <string>
 #include <vector>

             assert(v[3] == L'.');
             assert(v[4] == L'a');
             assert(v[5] == L'1');
+            // NOTE: this case fails on linux
             assert(v[6] == wchar_t(133));
         }
     }

test/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

 //
 // XFAIL: apple-darwin
 
+// Failure related to GLIBC's use of U00A0 as mon_thousands_sep
+// and U002E as mon_decimal_point.
+// TODO: U00A0 should be investigated.
+// Possibly related to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=16006
+// XFAIL: linux
+
 // REQUIRES: locale.ru_RU.UTF-8
 
 // <locale>

test/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

 // iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob,
 //               ios_base::iostate& err, long double& v) const;
 
+// NOTE: GLIBC locale data specifies that the negative sign goes before
+// the currency name. However if a currency symbol is used the negative goes after.
+
 #include <locale>
 #include <ios>
 #include <streambuf>

             noshowbase(ios);
         }
         {   // negative one, showbase
+#       if !defined(__GLIBC__)
             std::string v = "CNY -0.01";
+#       else
+            std::string v = "-CNY 0.01";
+#       endif
             typedef input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;

             assert(ex == -1);
         }
         {   // negative one, showbase
+#       if !defined(__GLIBC__)
             std::string v = "CNY -0.01";
+#       else
+            std::string v = "-CNY 0.01";
+#       endif
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;

             noshowbase(ios);
         }
         {   // negative, showbase
+#       if !defined(__GLIBC__)
             std::string v = "CNY -1,234,567.89";
+#       else
+            std::string v = "-CNY 1,234,567.89";
+#       endif
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;

             noshowbase(ios);
         }
         {   // negative one, showbase
+#       if !defined(__GLIBC__)
             std::wstring v = L"CNY -0.01";
+#       else
+            std::wstring v = L"-CNY 0.01";
+#       endif
             typedef input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;

             assert(ex == -1);
         }
         {   // negative one, showbase
+#       if !defined(__GLIBC__)
             std::wstring v = L"CNY -0.01";
+#       else
+            std::wstring v = L"-CNY 0.01";
+#       endif
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;

             noshowbase(ios);
         }
         {   // negative, showbase
+#       if !defined(__GLIBC__)
             std::wstring v = L"CNY -1,234,567.89";
+#       else
+            std::wstring v = L"-CNY 1,234,567.89";
+#       endif
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;

test/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp

 //
 // XFAIL: apple-darwin
 
+// Failure related to GLIBC's use of U00A0 as mon_thousands_sep
+// and U002E as mon_decimal_point.
+// TODO: U00A0 should be investigated.
+// Possibly related to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=16006
+// XFAIL: linux
+
 // REQUIRES: locale.ru_RU.UTF-8
 
 // <locale>

test/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp

 // iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
 //               long double units) const;
 
+// NOTE: GLIBC locale data specifies that the negative sign goes before
+// the currency name. However if a currency symbol is used the negative goes after.
+
 #include <locale>
 #include <ios>
 #include <streambuf>

         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
                                             true, ios, '*', v);
         std::string ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == "CNY -0.01");
+#   else
+        assert(ex == "-CNY 0.01");
+#   endif
     }
     {   // positive, showbase
         long double v = 123456789;

         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
                                             true, ios, '*', v);
         std::string ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == "CNY -1,234,567.89");
+#   else
+        assert(ex == "-CNY 1,234,567.89");
+#   endif
     }
     {   // negative, showbase, left
         long double v = -123456789;

         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
                                             true, ios, ' ', v);
         std::string ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == "CNY -1,234,567.89   ");
+#   else
+        assert(ex == "-CNY 1,234,567.89   ");
+#   endif
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal

         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
                                             true, ios, ' ', v);
         std::string ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == "CNY -   1,234,567.89");
+#   else
+        assert(ex == "-CNY    1,234,567.89");
+#   endif
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right

         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
                                             true, ios, ' ', v);
         std::string ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == "   CNY -1,234,567.89");
+#   else
+        assert(ex == "   -CNY 1,234,567.89");
+#   endif
         assert(ios.width() == 0);
     }
 }

         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
                                             true, ios, '*', v);
         std::wstring ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == L"CNY -0.01");
+#   else
+        assert(ex == L"-CNY 0.01");
+#   endif
     }
     {   // positive, showbase
         long double v = 123456789;

         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
                                             true, ios, '*', v);
         std::wstring ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == L"CNY -1,234,567.89");
+#   else
+        assert(ex == L"-CNY 1,234,567.89");
+#   endif
     }
     {   // negative, showbase, left
         long double v = -123456789;

         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
                                             true, ios, ' ', v);
         std::wstring ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == L"CNY -1,234,567.89   ");
+#   else
+        assert(ex == L"-CNY 1,234,567.89   ");
+#   endif
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal

         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
                                             true, ios, ' ', v);
         std::wstring ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == L"CNY -   1,234,567.89");
+#   else
+        assert(ex == L"-CNY    1,234,567.89");
+#   endif
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right

         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
                                             true, ios, ' ', v);
         std::wstring ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert(ex == L"   CNY -1,234,567.89");
+#   else
+        assert(ex == L"   -CNY 1,234,567.89");
+#   endif
         assert(ios.width() == 0);
     }
 }

test/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp

 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
+// GLIBC specifies the decimal_point for ru_RU to be '.' even though it
+// should be ','.
+// XFAIL: linux
+
 // class moneypunct_byname<charT, International>
 
 // charT decimal_point() const;

test/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp

 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
+// possibly related to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=16006
+// My locale says the separator is \xA0
+// XFAIL: linux
+
 // <locale>
 
 // class moneypunct_byname<charT, International>

         Fwt f(LOCALE_fr_FR_UTF_8, 1);
         assert(f.thousands_sep() == L' ');
     }
-
     {
         Fnf f(LOCALE_ru_RU_UTF_8, 1);
         assert(f.thousands_sep() == ' ');

         Fwt f(LOCALE_ru_RU_UTF_8, 1);
         assert(f.thousands_sep() == L' ');
     }
-
     {
         Fnf f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.thousands_sep() == ',');

test/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp

     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
     const my_facet f(1);
+
+#if !defined(__GLIBC__)
+    std::string const lnan1 = "nan";
+    std::string const lnan2 = "nan**********************";
+    std::string const lnan3 = "**********************nan";
+    std::string const lnan4 = "**********************nan";
+
+    std::string const unan1 = "NAN";
+    std::string const unan2 = "NAN**********************";
+    std::string const unan3 = "**********************NAN";
+    std::string const unan4 = "**********************NAN";
+#else
+    std::string const lnan1 = "+nan";
+    std::string const lnan2 = "+nan*********************";
+    std::string const lnan3 = "*********************+nan";
+    std::string const lnan4 = "+*********************nan";
+
+    std::string const unan1 = "+NAN";
+    std::string const unan2 = "+NAN*********************";
+    std::string const unan3 = "*********************+NAN";
+    std::string const unan4 = "+*********************NAN";
+#endif
+
     {
         long double v = std::nan("");
         std::ios ios(0);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == lnan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == lnan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == lnan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == lnan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == lnan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == lnan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == lnan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == lnan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == lnan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == unan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == unan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == unan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == unan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == unan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == unan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan4);
                                     assert(ios.width() == 0);
                                 }
                             }

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == unan1);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == unan2);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan3);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);

                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == unan4);
                                     assert(ios.width() == 0);
                                 }
                             }

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

 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 // <locale>
 
 // class time_get_byname<charT, InputIterator>

 // get_date(iter_type s, iter_type end, ios_base& str,
 //          ios_base::iostate& err, tm* t) const;
 
+
+
+
 #include <locale>
 #include <cassert>
 #include "test_iterators.h"

     }
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
+#   if !defined(__GLIBC__)
         const char in[] = "10.06.2009";
+#   else
+        const char in[] = "10/06/2009";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);

     }
     {
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
+#   if !defined(__GLIBC__)
         const char in[] = "10.06.2009";
+#   else
+        // NOTE: GLIBC uses U002E (FULL STOP) for the period instead of just
+        // '.' in ru_RU
+        const char in[] = "10" "\x2E" "06" "\x2E" "2009";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);

         assert(err == std::ios_base::eofbit);
     }
     {
+        // NOTE: this test fails on linux. Investigation needed.
+        // It looks like bad GLIBC locale data.
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const char in[] = "2009/06/10";
         err = std::ios_base::goodbit;

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

 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
+// Investigation needed for linux failures.
+// XFAIL: linux
+
 // <locale>
 
 // class time_get_byname<charT, InputIterator>

     }
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
+#   if !defined(__GLIBC__)
         const wchar_t in[] = L"10.06.2009";
+#   else
+        const wchar_t in[] = L"10/06/2009";
+#   endif
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);

         assert(err == std::ios_base::eofbit);
     }
     {
+        // NOTE: this test fails on linux. Investigation needed.
+        // It looks like bad GLIBC locale data.
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const wchar_t in[] = L"2009/06/10";
         err = std::ios_base::goodbit;

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

 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
+// investigation needed for linux failures.
+// XFAIL: linux
+
 // <locale>
 
 // class time_get_byname<charT, InputIterator>

     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
+    // %c specifier is locale specific. with GLIBC it includes the timezone.
+    // This test is not portible on linux.
+#if !defined(__GLIBC__)
     {
         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);
+#   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);
     }
+    // %c specifier is non-portable with GLIBC. (includes time zone)
+#if !defined(__GLIBC__)
     {
         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(err == std::ios_base::eofbit);
     }
     {
+        // NOTE: fails on linux needs investigation
         const my_facet f(LOCALE_ru_RU_UTF_8, 1);
         const char in[] = "\xD1\x81\xD1\x83\xD0\xB1\xD0\xB1"
                           "\xD0\xBE\xD1\x82\xD0\xB0"

         assert(err == std::ios_base::eofbit);
     }
     {
+        // NOTE: Fails on linux. needs investigation.
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const char in[] = "\xE5\x85\xAD"
                           " 12/31 23:55:59 2061";

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
 
+// investigation needed for linux failures.
+// XFAIL: linux
+
 // <locale>
 
 // class time_get_byname<charT, InputIterator>

     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
+#if !defined(__GLIBC__)
     {
         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);
+#   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);
     }
+#if !defined(__GLIBC__)
     {
         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";

         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
-#ifdef __APPLE__
     {
-        const my_facet f("ru_RU", 1);
+        // NOTE: fails on linux needs investigation.
+        const my_facet f(LOCALE_ru_RU_UTF_8, 1);
         const wchar_t in[] = L"\x441\x443\x431\x431\x43E\x442\x430"
                           ", 31 "
                           "\x434\x435\x43A\x430\x431\x440\x44F"

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

         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
-#ifdef __APPLE__
     {
-        const my_facet f("zh_CN", 1);
+        // NOTE: fails on linux needs investigation.
+        const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const wchar_t in[] = L"\x516D"
                           " 12/31 23:55:59 2061";
         err = std::ios_base::goodbit;

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

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

         iter = f.put(output_iterator<char*>(str), ios, '*', &t,
                      pat.data(), pat.data() + pat.size());
         std::string ex(str, iter.base());
+#   if !defined(__GLIBC__)
         assert((ex == "Today is Samedi which is abbreviated Sam.")||
                (ex == "Today is samedi which is abbreviated sam." ));
+#   else
+        // w/ GLIBC fr_FR.UTF-8 day abreviations can end with a '.'
+        assert(ex == "Today is samedi which is abbreviated sam..");
+#   endif
     }
 }

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");

test/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp

         {
             typedef char C;
             const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
+#       if !defined(__GLIBC__)
             assert(np.grouping() == "\x7F");
+#       else
+            assert(np.grouping() == "\3");
+#       endif
         }
         {
             typedef wchar_t C;
             const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
+#       if !defined(__GLIBC__)
             assert(np.grouping() == "\x7F");
+#       else
+            assert(np.grouping() == "\3");
+#       endif
         }
     }
 }

test/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp

 
 // char_type thousands_sep() const;
 
+// NOTE: GLIBC uses ' ' as fr_FR's thousands_sep instead of ','
+
 #include <locale>
 #include <cassert>
 

         {
             typedef char C;
             const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
+#       if !defined(__GLIBC__)
             assert(np.thousands_sep() == ',');
+#       else
+            assert(np.thousands_sep() == ' ');
+#       endif
         }
         {
             typedef wchar_t C;
             const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
+#       if !defined(__GLIBC__)
             assert(np.thousands_sep() == L',');
+#       else
+            assert(np.thousands_sep() == L' ');
+#       endif
         }
     }
 }