[libcxx] [test] Fix get_string_en_US, get_long_double_en_US for Windows

[mstorsjo]

Summary

In the en_US locale on Windows, negative currency amounts is formatted
as "($0.01)" instead of "-$0.01".

This is the same issue as D120798, but with a different fix strategy.

To avoid excessive amounts of ifdefs to get the right string form for
each of them, just ifdef out groups of tests that test negative values.
(This keeps the number of ifdefs needed more reasonable, as there's 2-3
strings per ifdef in this case.)

Alternatively, we could just keep the XFAIL without the FIXME part and
conclude that this is known to be different and we don't want the churn
to fix it.

[mstorsjo]

Use a small local helper function for producing the expected negative value form.

[• Quuxplusone]

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

64

Could this go in LocaleHelpers instead? Or would that be problematic because the behavior depends on the specific locale too? (Or is that a good thing because it indicates that this function should actually be named currency_negate_en_US or something?)

Worth thinking about, but IMHO not worth my blocking this PR over. :)

[mstorsjo]

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

64

Yeah it could go there with such a name too - making all the calls to it slightly longer and more verbose though. But possibly still tolerable.

[Mordante]

Thanks for this improvement, LGTM!
Before committing, please update the summary and make sure the CI passes.

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

64

Since the code is duplicated I also have a slight preference to move it, but non-blocking for me too.

[mstorsjo]

Move the negate helper function to locale_helpers.h, fix building without wchar. Will push tomorrow if CI is green.

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.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 money_get<charT, InputIterator>
 
 // iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob,
 //               ios_base::iostate& err, long double& v) const;
 
 // REQUIRES: locale.en_US.UTF-8
-// XFAIL: LIBCXX-WINDOWS-FIXME
 
 #include <locale>
 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
class my_facetw
     : public Fw
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
 #endif
 
+std::string negate(std::string s) {
+#if defined(_WIN32)
+  return "(" + s + ")";
+#else
+  return "-" + s;
+#endif
+}
+
+std::wstring negate(std::wstring s) {
+#if defined(_WIN32)
+  return L"(" + s + L")";
+#else
+  return L"-" + s;
+#endif
+}
+
 int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<char, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<char, true>(loc_name)));
#endif
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
-            std::string v = "-0.01";
+            std::string v = negate("0.01");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::string v = "1,234,567.89";
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
-            std::string v = "-1,234,567.89";
+            std::string v = negate("1,234,567.89");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
-            std::string v = "-1234567.89";
+            std::string v = negate("1234567.89");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
#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 == 0);
             std::noshowbase(ios);
         }
         {   // negative one, showbase
-            std::string v = "-$0.01";
+            std::string v = negate("$0.01");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
-            std::string v = "-$0.01";
+            std::string v = negate("$0.01");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
#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";
+            std::string v = negate("$1,234,567.89");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-USD 1,234,567.89";
+            std::string v = negate("USD 1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-USD 1,234,567.89";
+            std::string v = negate("USD 1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facet f(1);
         // char, international
         {   // zero
             std::string v = "0.00";
             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);
         }
         {   // negative one
-            std::string v = "-0.01";
+            std::string v = negate("0.01");
             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);
         }
         {   // positive
             std::string v = "1,234,567.89";
             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);
         }
         {   // negative
-            std::string v = "-1,234,567.89";
+            std::string v = negate("1,234,567.89");
             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);
         }
         {   // negative
-            std::string v = "-1234567.89";
+            std::string v = negate("1234567.89");
             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);
#endif
             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);
         }
         {   // negative one, showbase
-            std::string v = "-USD 0.01";
+            std::string v = negate("USD 0.01");
             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);
         }
         {   // negative one, showbase
-            std::string v = "-USD 0.01";
+            std::string v = negate("USD 0.01");
             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);
#endif
             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);
         }
         {   // negative, showbase
-            std::string v = "-USD 1,234,567.89";
+            std::string v = negate("USD 1,234,567.89");
             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);
         }
         {   // negative, showbase
-            std::string v = "-$1,234,567.89";
+            std::string v = negate("$1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-$1,234,567.89";
+            std::string v = negate("$1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
         }
#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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
-            std::wstring v = L"-0.01";
+            std::wstring v = negate(L"0.01");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
-            std::wstring v = L"-1,234,567.89";
+            std::wstring v = negate(L"1,234,567.89");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
-            std::wstring v = L"-1234567.89";
+            std::wstring v = negate(L"1234567.89");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
#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 == 0);
             std::noshowbase(ios);
         }
         {   // negative one, showbase
-            std::wstring v = L"-$0.01";
+            std::wstring v = negate(L"$0.01");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
-            std::wstring v = L"-$0.01";
+            std::wstring v = negate(L"$0.01");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
#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";
+            std::wstring v = negate(L"$1,234,567.89");
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-USD 1,234,567.89";
+            std::wstring v = negate(L"USD 1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-USD 1,234,567.89";
+            std::wstring v = negate(L"USD 1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facetw f(1);
         // wchar_t, international
         {   // zero
             std::wstring v = L"0.00";
             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);
         }
         {   // negative one
-            std::wstring v = L"-0.01";
+            std::wstring v = negate(L"0.01");
             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);
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             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);
         }
         {   // negative
-            std::wstring v = L"-1,234,567.89";
+            std::wstring v = negate(L"1,234,567.89");
             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);
         }
         {   // negative
-            std::wstring v = L"-1234567.89";
+            std::wstring v = negate(L"1234567.89");
             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);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
             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);
         }
         {   // negative one, showbase
-            std::wstring v = L"-USD 0.01";
+            std::wstring v = negate(L"USD 0.01");
             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);
         }
         {   // negative one, showbase
-            std::wstring v = L"-USD 0.01";
+            std::wstring v = negate(L"USD 0.01");
             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);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
             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);
         }
         {   // negative, showbase
-            std::wstring v = L"-USD 1,234,567.89";
+            std::wstring v = negate(L"USD 1,234,567.89");
             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);
         }
         {   // negative, showbase
-            std::wstring v = L"-$1,234,567.89";
+            std::wstring v = negate(L"$1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-$1,234,567.89";
+            std::wstring v = negate(L"$1,234,567.89");
             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() + 1);
             assert(err == std::ios_base::failbit);
         }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.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 money_get<charT, InputIterator>
 
 // iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob,
 //               ios_base::iostate& err, string_type& v) const;
 
 // REQUIRES: locale.en_US.UTF-8
-// XFAIL: LIBCXX-WINDOWS-FIXME
 
 #include <locale>
 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
class my_facetw
     : public Fw
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
 #endif
 
+std::string negate(std::string s) {
+#if defined(_WIN32)
+  return "(" + s + ")";
+#else
+  return "-" + s;
+#endif
+}
+
+std::wstring negate(std::wstring s) {
+#if defined(_WIN32)
+  return L"(" + s + L")";
+#else
+  return L"-" + s;
+#endif
+}
+
 int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<char, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<char, true>(loc_name)));
#endif
             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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // negative one
-            std::string v = "-0.01";
+            std::string v = negate("0.01");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // positive
             std::string v = "1,234,567.89";
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // negative
-            std::string v = "-1,234,567.89";
+            std::string v = negate("1,234,567.89");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // negative
-            std::string v = "-1234567.89";
+            std::string v = negate("1234567.89");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
#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 == "0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
-            std::string v = "-$0.01";
+            std::string v = negate("$0.01");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // negative one, showbase
-            std::string v = "-$0.01";
+            std::string v = negate("$0.01");
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
#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";
+            std::string v = negate("$1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-USD 1,234,567.89";
+            std::string v = negate("USD 1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-USD 1,234,567.89";
+            std::string v = negate("USD 1,234,567.89");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
#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 == "0");
         }
         {   // negative one
-            std::string v = "-0.01";
+            std::string v = negate("0.01");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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");
         }
         {   // positive
             std::string v = "1,234,567.89";
             typedef cpp17_input_iterator<const char*> I;
             std::string 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");
         }
         {   // negative
-            std::string v = "-1,234,567.89";
+            std::string v = negate("1,234,567.89");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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");
         }
         {   // negative
-            std::string v = "-1234567.89";
+            std::string v = negate("1234567.89");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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");
#endif
             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);
         }
         {   // negative one, showbase
-            std::string v = "-USD 0.01";
+            std::string v = negate("USD 0.01");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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");
         }
         {   // negative one, showbase
-            std::string v = "-USD 0.01";
+            std::string v = negate("USD 0.01");
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             std::string 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);
#endif
             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);
         }
         {   // negative, showbase
-            std::string v = "-USD 1,234,567.89";
+            std::string v = negate("USD 1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             std::string 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);
         }
         {   // negative, showbase
-            std::string v = "-$1,234,567.89";
+            std::string v = negate("$1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-$1,234,567.89";
+            std::string v = negate("$1,234,567.89");
             typedef cpp17_input_iterator<const char*> I;
             std::string 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
#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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // negative one
-            std::wstring v = L"-0.01";
+            std::wstring v = negate(L"0.01");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // negative
-            std::wstring v = L"-1,234,567.89";
+            std::wstring v = negate(L"1,234,567.89");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // negative
-            std::wstring v = L"-1234567.89";
+            std::wstring v = negate(L"1234567.89");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
#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 == L"0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
-            std::wstring v = L"-$0.01";
+            std::wstring v = negate(L"$0.01");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // negative one, showbase
-            std::wstring v = L"-$0.01";
+            std::wstring v = negate(L"$0.01");
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
#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 == L"123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-$1,234,567.89";
+            std::wstring v = negate(L"$1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-USD 1,234,567.89";
+            std::wstring v = negate(L"USD 1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-USD 1,234,567.89";
+            std::wstring v = negate(L"USD 1,234,567.89");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
#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 == L"0");
         }
         {   // negative one
-            std::wstring v = L"-0.01";
+            std::wstring v = negate(L"0.01");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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 == L"-1");
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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 == L"123456789");
         }
         {   // negative
-            std::wstring v = L"-1,234,567.89";
+            std::wstring v = negate(L"1,234,567.89");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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 == L"-123456789");
         }
         {   // negative
-            std::wstring v = L"-1234567.89";
+            std::wstring v = negate(L"1234567.89");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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 == L"-123456789");
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
             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 == L"0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
-            std::wstring v = L"-USD 0.01";
+            std::wstring v = negate(L"USD 0.01");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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 == L"-1");
         }
         {   // negative one, showbase
-            std::wstring v = L"-USD 0.01";
+            std::wstring v = negate(L"USD 0.01");
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
             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 == L"123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-USD 1,234,567.89";
+            std::wstring v = negate(L"USD 1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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 == L"-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-$1,234,567.89";
+            std::wstring v = negate(L"$1,234,567.89");
             std::showbase(ios);
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
             std::noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-$1,234,567.89";
+            std::wstring v = negate(L"$1,234,567.89");
             typedef cpp17_input_iterator<const wchar_t*> I;
             std::wstring 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() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");