[libcxx] [test] Simplify the handling of platform specific NAN formatting in put_long_double

[mstorsjo]

Summary

Also opt in to testing the hexadecimal float formatting for glibc; glibc does matches the current test references there.

[mstorsjo]

Rebased on top of current git main, simplifying the already committed fix doing similar things.

[Mordante]

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

10916–10917

How do you feel about always using strings like pnan_padding25 + pnan_sign + "nan" and not have pnan and PNAN?

24428

Is this change still needed? The test currently passes CI without this change.

[mstorsjo]

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

10916–10917

That’d work for me too.

24428

It’s not needed, but this is a test that currently only is executed on apple platforms (because it hadn’t passed on FreeBSD). This test does pass on glibc too, so let’s run it there too, for increased test coverage.

[mstorsjo]

Removed the pnan/PNAN strings and kept literal "nan" and "NAN".

If preferred, I could split out the change to opt in to the hexadecimal formatting tests into a separate change.

[Mordante]

LGTM!

[• Quuxplusone]

I suggest an alternative approach, but I see no reason to block over that, so might as well accept. Feel free to adopt the IF_GLIBC idea or not, I guess.

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

10900–10901

This is obscure enough I shouldn't really care, but wouldn't it be easier to understand the test if it was like

assert(ex == IF_GLIBC("+nan", "nan"));
~~~
assert(ex == IF_GLIBC("+nan*********************",
                      "nan**********************"));

and so on? (The IF_GLIBC macro would just be scoped to this one file.)

[mstorsjo]

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

10900–10901

I think I’d prefer to not go with this approach. I’ll add windows into the mix soon (which does the same as glibc here) so the macro naming would be less straightforward then. And going further, there could (theoretically, at least in some other test) be more than two different variations, which is easier if the conditionals are centralized.

[Mordante]

In D118238#3319384, @Quuxplusone wrote:

I suggest an alternative approach, but I see no reason to block over that, so might as well accept. Feel free to adopt the IF_GLIBC idea or not, I guess.

I don't mind that approach, but then I prefer a global macro. There are more localization tests disabled due to glibc giving a different result.

[mstorsjo]

In D118238#3319443, @Mordante wrote:

In D118238#3319384, @Quuxplusone wrote:

I suggest an alternative approach, but I see no reason to block over that, so might as well accept. Feel free to adopt the IF_GLIBC idea or not, I guess.

I don't mind that approach, but then I prefer a global macro. There are more localization tests disabled due to glibc giving a different result.

I think I'll go with my original approach for now. Especially in this test, I think that results in less clunky code. And for other tests, given that there's more than two platforms that may want to expect different results, the exact form of handling it can differ a bit between all tests. (FWIW I have a couple more glibc locale fixes in my queue in various state of finished, and a bunch of more windows locale fixes on top of those too.)

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // class num_put<charT, OutputIterator>
 
 // iter_type put(iter_type s, ios_base& iob, char_type fill, long double v) const;
 
-// TODO GLIBC uses a different string for positive and negative NAN numbers.
-// XFAIL: target={{.*}}-linux-gnu{{.*}}
-
 // XFAIL: LIBCXX-WINDOWS-FIXME
 // XFAIL: LIBCXX-AIX-FIXME
 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <cmath>

 
 void test5()
 {
     char str[200];
     output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
     const my_facet f(1);
+#ifdef TEST_HAS_GLIBC
+    std::string pnan = "+nan";
+    std::string PNAN = "+NAN";
+    std::string pnan_sign = "+";
+    std::string pnan_padding25 = "*********************";
+#else
+    std::string pnan = "nan";
+    std::string PNAN = "NAN";
+    std::string pnan_sign = "";
+    std::string pnan_padding25 = "**********************";
+#endif
     {
         long double v = std::nan("");
         std::ios ios(0);
         // %g
         {
             ios.precision(0);
             {
                 nouppercase(ios);
#endif
                         noshowpoint(ios);
                         {
                             ios.imbue(lc);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == pnan + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_padding25 + pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_sign + pnan_padding25 + "nan");
                                     assert(ios.width() == 0);
                                 }
                             }
                             ios.imbue(lg);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == pnan + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_padding25 + pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_sign + pnan_padding25 + "nan");
                                     assert(ios.width() == 0);
                                 }
                             }
                         }
                         showpoint(ios);
                         {
                             ios.imbue(lc);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == pnan + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_padding25 + pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_sign + pnan_padding25 + "nan");
                                     assert(ios.width() == 0);
                                 }
                             }
                             ios.imbue(lg);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan");
+                                    assert(ex == pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "nan**********************");
+                                    assert(ex == pnan + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_padding25 + pnan);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************nan");
+                                    assert(ex == pnan_sign + pnan_padding25 + "nan");
                                     assert(ios.width() == 0);
                                 }
                             }
                         }
                     }
                 }
                 uppercase(ios);
                 {
#endif
                         noshowpoint(ios);
                         {
                             ios.imbue(lc);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == PNAN + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_padding25 + PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_sign + pnan_padding25 + "NAN");
                                     assert(ios.width() == 0);
                                 }
                             }
                             ios.imbue(lg);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == PNAN + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_padding25 + PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_sign + pnan_padding25 + "NAN");
                                     assert(ios.width() == 0);
                                 }
                             }
                         }
                         showpoint(ios);
                         {
                             ios.imbue(lc);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == PNAN + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_padding25 + PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_sign + pnan_padding25 + "NAN");
                                     assert(ios.width() == 0);
                                 }
                             }
                             ios.imbue(lg);
                             {
                                 ios.width(0);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN");
+                                    assert(ex == PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 left(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "NAN**********************");
+                                    assert(ex == PNAN + pnan_padding25);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 right(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_padding25 + PNAN);
                                     assert(ios.width() == 0);
                                 }
                                 ios.width(25);
                                 internal(ios);
                                 {
                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
                                     std::string ex(str, iter.base());
-                                    assert(ex == "**********************NAN");
+                                    assert(ex == pnan_sign + pnan_padding25 + "NAN");
                                     assert(ios.width() == 0);
                                 }
                             }
                         }
                     }
                 }
             }
             ios.precision(1);

         }
     }
 }
 
 void test12()
 {
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
-#if defined(__APPLE__) && defined(__x86_64__)
+#if (defined(__APPLE__) || defined(TEST_HAS_GLIBC)) && defined(__x86_64__)
 // This test is failing on FreeBSD, possibly due to different representations
 // of the floating point numbers.
     output_iterator<char*> iter;
     const my_facet f(1);
     char str[200];
     {
         long double v = 1234567890.125;
         std::ios ios(0);