[libcxx] [test] Fix the get/put long_double_ru_RU tests on Apple platforms

[mstorsjo]

Summary

This fixes issue #45084 (https://llvm.org/PR45739).

Remove unnecessary trailing spaces after the "RUB" international
currency symbol (and after the plain number in some parts of the
put_long_double test).

The previously commented out code never seemed to be passing in any
current configuration; the whole tests were XFAILed on all other
platforms than Apple platforms, and on Apple platforms, some parts
of the tests (where the trailing space made a difference) were
ifdeffed out.

[Mordante]

Thanks for the fix. Based on the fact the CI is still happy LGTM.

[• Quuxplusone]

Yeesh, yeah, LGTM. I'd characterize this PR as follows, and feel free to take any of this wording into your commit message:

Both of these test files are XFAIL: netbsd || linux || LIBCXX-WINDOWS-FIXME, and then have some of their test cases commented out when __APPLE__. This PR comments-in those test cases and adjusts them all to work on Apple, while leaving the test XFAILed on NetBSD, Linux, and Windows.

[ldionne]

Thanks a lot for fixing this :)

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

 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
 
-// TODO:
-// Some of the assertions in this test are failing on Apple platforms.
-// Until we figure out the problem and fix it, disable these tests on
-// Apple platforms. Note that we're not using XFAIL or UNSUPPORTED markup
-// here, because this test would otherwise be disabled on all platforms
-// we test. To avoid this test becoming entirely stale, we just disable
-// the parts that fail.
-//
-// See https://llvm.org/PR45739 for the bug tracking this.
-#if defined(__APPLE__)
-#   define APPLE_FIXME
-#endif
-
 typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
 
 class my_facet
     : public Fn
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : Fn(refs) {}
#endif
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-1 234 567,89 RUB ";
+            std::string v = "-1 234 567,89 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-1 234 567,89 RUB ";
+            std::string v = "-1 234 567,89 RUB";
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::goodbit);
             assert(ex == -123456789);
#endif
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
-            std::string v = "0,00 RUB ";
+            std::string v = "0,00 RUB";
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 5);
             assert(err == std::ios_base::goodbit);
             assert(ex == 0);
         }
-#if !defined(APPLE_FIXME)
         {   // zero, showbase
-            std::string v = "0,00 RUB ";
+            std::string v = "0,00 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             std::noshowbase(ios);
         }
-#endif
         {   // negative one, showbase
-            std::string v = "-0,01 RUB ";
+            std::string v = "-0,01 RUB";
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 6);
             assert(err == std::ios_base::goodbit);
             assert(ex == -1);
         }
-#if !defined(APPLE_FIXME)
         {   // negative one, showbase
-            std::string v = "-0,01 RUB ";
+            std::string v = "-0,01 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             std::noshowbase(ios);
         }
-#endif
         {   // positive, showbase
-            std::string v = "1 234 567,89 RUB ";
+            std::string v = "1 234 567,89 RUB";
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
-#if !defined(APPLE_FIXME)
         {   // positive, showbase
-            std::string v = "1 234 567,89 RUB ";
+            std::string v = "1 234 567,89 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
-#endif
-#if !defined(APPLE_FIXME)
         {   // negative, showbase
-            std::string v = "-1 234 567,89 RUB ";
+            std::string v = "-1 234 567,89 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
-#endif
         {   // negative, showbase
             std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-1 234 567,89 RUB ";
+            std::wstring v = L"-1 234 567,89 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-1 234 567,89 RUB ";
+            std::wstring v = L"-1 234 567,89 RUB";
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::goodbit);
             assert(ex == -123456789);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
-            std::wstring v = L"0,00 RUB ";
+            std::wstring v = L"0,00 RUB";
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 5);
             assert(err == std::ios_base::goodbit);
             assert(ex == 0);
         }
-#if !defined(APPLE_FIXME)
         {   // zero, showbase
-            std::wstring v = L"0,00 RUB ";
+            std::wstring v = L"0,00 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             std::noshowbase(ios);
         }
-#endif
         {   // negative one, showbase
-            std::wstring v = L"-0,01 RUB ";
+            std::wstring v = L"-0,01 RUB";
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 6);
             assert(err == std::ios_base::goodbit);
             assert(ex == -1);
         }
-#if !defined(APPLE_FIXME)
         {   // negative one, showbase
-            std::wstring v = L"-0,01 RUB ";
+            std::wstring v = L"-0,01 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             std::noshowbase(ios);
         }
-#endif
         {   // positive, showbase
-            std::wstring v = L"1 234 567,89 RUB ";
+            std::wstring v = L"1 234 567,89 RUB";
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
-#if !defined(APPLE_FIXME)
         {   // positive, showbase
-            std::wstring v = L"1 234 567,89 RUB ";
+            std::wstring v = L"1 234 567,89 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
-#endif
-#if !defined(APPLE_FIXME)
         {   // negative, showbase
-            std::wstring v = L"-1 234 567,89 RUB ";
+            std::wstring v = L"-1 234 567,89 RUB";
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
-#endif
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
                                                 true, ios, err, ex);

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

 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
 
-// TODO:
-// Some of the assertions in this test are failing on Apple platforms.
-// Until we figure out the problem and fix it, disable these tests on
-// Apple platforms. Note that we're not using XFAIL or UNSUPPORTED markup
-// here, because this test would otherwise be disabled on all platforms
-// we test. To avoid this test becoming entirely stale, we just disable
-// the parts that fail.
-//
-// See https://llvm.org/PR45739 for the bug tracking this.
-#if defined(__APPLE__)
-#   define APPLE_FIXME
-#endif
-
 typedef std::money_put<char, cpp17_output_iterator<char*> > Fn;
 
 class my_facet
     : public Fn
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : Fn(refs) {}
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
 #endif
 {
     const my_facet f(1);
     // char, national
-#if !defined(APPLE_FIXME)
     {   // zero
         long double v = 0;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "0,00 ");
+        assert(ex == "0,00");
     }
     {   // negative one
         long double v = -1;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "-0,01 ");
+        assert(ex == "-0,01");
     }
     {   // positive
         long double v = 123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "1 234 567,89 ");
+        assert(ex == "1 234 567,89");
     }
     {   // negative
         long double v = -123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "-1 234 567,89 ");
+        assert(ex == "-1 234 567,89");
     }
-#endif // APPLE_FIXME
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
         std::string ex(str, iter.base());
         assert(ex == "0,00 \xD1\x80\xD1\x83\xD0\xB1"".");
     }
// char, national
         std::string ex(str, iter.base());
         assert(ex == "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".");
         assert(ios.width() == 0);
     }
 
     // char, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
-#if !defined(APPLE_FIXME)
     {   // zero
         long double v = 0;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "0,00 ");
+        assert(ex == "0,00");
     }
     {   // negative one
         long double v = -1;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "-0,01 ");
+        assert(ex == "-0,01");
     }
     {   // positive
         long double v = 123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "1 234 567,89 ");
+        assert(ex == "1 234 567,89");
     }
     {   // negative
         long double v = -123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "-1 234 567,89 ");
+        assert(ex == "-1 234 567,89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "0,00 RUB ");
+        assert(ex == "0,00 RUB");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "-0,01 RUB ");
+        assert(ex == "-0,01 RUB");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "1 234 567,89 RUB ");
+        assert(ex == "1 234 567,89 RUB");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
         std::string ex(str, iter.base());
-        assert(ex == "-1 234 567,89 RUB ");
+        assert(ex == "-1 234 567,89 RUB");
     }
-#endif // APPLE_FIXME
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
         std::string ex(str, iter.base());
         assert(ex == "-1 234 567,89 RUB   ");
         assert(ios.width() == 0);
     }
-#if !defined(APPLE_FIXME)
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
         std::string ex(str, iter.base());
-        assert(ex == "-1 234 567,89   RUB ");
+        assert(ex == "-1 234 567,89    RUB");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
         std::string ex(str, iter.base());
-        assert(ex == "  -1 234 567,89 RUB ");
+        assert(ex == "   -1 234 567,89 RUB");
         assert(ios.width() == 0);
     }
-#endif // APPLE_FIXME
 }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 {
     const my_facetw f(1);
     // wchar_t, national
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
-#if !defined(APPLE_FIXME)
     {   // zero
         long double v = 0;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"0,00 ");
+        assert(ex == L"0,00");
     }
     {   // negative one
         long double v = -1;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-0,01 ");
+        assert(ex == L"-0,01");
     }
     {   // positive
         long double v = 123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"1 234 567,89 ");
+        assert(ex == L"1 234 567,89");
     }
     {   // negative
         long double v = -123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-1 234 567,89 ");
+        assert(ex == L"-1 234 567,89");
     }
-#endif // APPLE_FIXME
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
         std::wstring ex(str, iter.base());
         assert(ex == L"0,00 \x440\x443\x431"".");
     }
ios.unsetf(std::ios_base::adjustfield);
         std::wstring ex(str, iter.base());
         assert(ex == L"  -1 234 567,89 \x440\x443\x431"".");
         assert(ios.width() == 0);
     }
 
     // wchar_t, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
-#if !defined(APPLE_FIXME)
     {   // zero
         long double v = 0;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"0,00 ");
+        assert(ex == L"0,00");
     }
     {   // negative one
         long double v = -1;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-0,01 ");
+        assert(ex == L"-0,01");
     }
     {   // positive
         long double v = 123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"1 234 567,89 ");
+        assert(ex == L"1 234 567,89");
     }
     {   // negative
         long double v = -123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-1 234 567,89 ");
+        assert(ex == L"-1 234 567,89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"0,00 RUB ");
+        assert(ex == L"0,00 RUB");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-0,01 RUB ");
+        assert(ex == L"-0,01 RUB");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"1 234 567,89 RUB ");
+        assert(ex == L"1 234 567,89 RUB");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-1 234 567,89 RUB ");
+        assert(ex == L"-1 234 567,89 RUB");
     }
-#endif // APPLE_FIXME
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
         std::wstring ex(str, iter.base());
         assert(ex == L"-1 234 567,89 RUB   ");
         assert(ios.width() == 0);
     }
-#if !defined(APPLE_FIXME)
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"-1 234 567,89   RUB ");
+        assert(ex == L"-1 234 567,89    RUB");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
         std::wstring ex(str, iter.base());
-        assert(ex == L"  -1 234 567,89 RUB ");
+        assert(ex == L"   -1 234 567,89 RUB");
         assert(ios.width() == 0);
     }
-#endif // APPLE_FIXME
 }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }