[libc++][format] Fixes year formatter on Windows.

[Mordante]

Summary

Windows' libc, like some other libc implementations do not work as
specified for %Y and %y. This uses the fixes used for other libc
implementations.

The work was part of D150593.

[Mordante]

Enable the full CI again.

libcxx/include/__chrono/formatter.h

if (*__it == _CharT('%')) {
         // systems the required information can be extracted by nl_langinfo
         // https://man7.org/linux/man-pages/man3/nl_langinfo.3.html
         //
         // Note since year < -1000 is expected to be rare it uses the more
         // expensive year routine.
         //
         // TODO FMT evaluate the comment above.
 
-#  if defined(__GLIBC__) || defined(_AIX)
+#  if defined(__GLIBC__) || defined(_AIX) || defined(_WIN32)
       case _CharT('y'):
         // Glibc fails for negative values, AIX for positive values too.
         __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02}"), (std::abs(__t.tm_year + 1900)) % 100);
         break;
-#  endif // defined(__GLIBC__) || defined(_AIX)
+#  endif // defined(__GLIBC__) || defined(_AIX) || defined(_WIN32)
 
-      case _CharT('Y'): {
-        int __year = __t.tm_year + 1900;
-        if (__year < 1000)
-          __formatter::__format_year(__year, __sstr);
-        else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
-      } break;
+      case _CharT('Y'):
+        // Depending on the platform's libc the range of supported years is
+        // limited. Intead of of testing all conditions use the internal
+        // implementation unconditionally.
+        __formatter::__format_year(__t.tm_year + 1900, __sstr);
+        break;
 
       case _CharT('F'): {
         int __year = __t.tm_year + 1900;
         if (__year < 1000) {
           __formatter::__format_year(__year, __sstr);
           __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "-{:02}-{:02}"), __t.tm_mon + 1, __t.tm_mday);
         } else
           __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));

libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/ostream.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: no-localization
 
-// TODO FMT Investigate Windows issues.
-// UNSUPPORTED: msvc, target={{.+}}-windows-gnu
-
 // TODO FMT Fix this test using GCC, it currently crashes.
 // UNSUPPORTED: gcc-12
 
 // TODO FMT This test should not require std::to_chars(floating-point)
 // XFAIL: availability-fp_to_chars-missing
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class year;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&
 //     operator<<(basic_ostream<charT, traits>& os, const year& year);
 
 #include <chrono>
 #include <cassert>
 #include <sstream>
 
 #include "make_string.h"
 #include "platform_support.h" // locale name macros
 #include "test_macros.h"
+#include "assert_macros.h"
+#include "concat_macros.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
+#define TEST_EQUAL(OUT, EXPECTED)                                                                                      \
+  TEST_REQUIRE(OUT == EXPECTED,                                                                                        \
+               TEST_WRITE_CONCATENATED(                                                                                \
+                   "\nExpression      ", #OUT, "\nExpected output ", EXPECTED, "\nActual output   ", OUT, '\n'));
+
 template <class CharT>
 static std::basic_string<CharT> stream_c_locale(std::chrono::year year) {
   std::basic_stringstream<CharT> sstr;
   sstr << year;
   return sstr.str();
 }
 
 template <class CharT>
static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::year year) {
   const std::locale locale(LOCALE_ja_JP_UTF_8);
   sstr.imbue(locale);
   sstr << year;
   return sstr.str();
 }
 
 template <class CharT>
 static void test() {
-  assert(stream_c_locale<CharT>(std::chrono::year{-32'768}) == SV("-32768 is not a valid year"));
-  assert(stream_c_locale<CharT>(std::chrono::year{-32'767}) == SV("-32767"));
-  assert(stream_c_locale<CharT>(std::chrono::year{0}) == SV("0000"));
-  assert(stream_c_locale<CharT>(std::chrono::year{1970}) == SV("1970"));
-  assert(stream_c_locale<CharT>(std::chrono::year{32'767}) == SV("32767"));
-
-  assert(stream_fr_FR_locale<CharT>(std::chrono::year{-32'768}) == SV("-32768 is not a valid year"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::year{-32'767}) == SV("-32767"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::year{0}) == SV("0000"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::year{1970}) == SV("1970"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::year{32'767}) == SV("32767"));
-
-  assert(stream_ja_JP_locale<CharT>(std::chrono::year{-32'768}) == SV("-32768 is not a valid year"));
-  assert(stream_ja_JP_locale<CharT>(std::chrono::year{-32'767}) == SV("-32767"));
-  assert(stream_ja_JP_locale<CharT>(std::chrono::year{0}) == SV("0000"));
-  assert(stream_ja_JP_locale<CharT>(std::chrono::year{1970}) == SV("1970"));
-  assert(stream_ja_JP_locale<CharT>(std::chrono::year{32'767}) == SV("32767"));
+  TEST_EQUAL(stream_c_locale<CharT>(std::chrono::year{-32'768}), SV("-32768 is not a valid year"));
+  TEST_EQUAL(stream_c_locale<CharT>(std::chrono::year{-32'767}), SV("-32767"));
+  TEST_EQUAL(stream_c_locale<CharT>(std::chrono::year{0}), SV("0000"));
+  TEST_EQUAL(stream_c_locale<CharT>(std::chrono::year{1970}), SV("1970"));
+  TEST_EQUAL(stream_c_locale<CharT>(std::chrono::year{32'767}), SV("32767"));
+
+  TEST_EQUAL(stream_fr_FR_locale<CharT>(std::chrono::year{-32'768}), SV("-32768 is not a valid year"));
+  TEST_EQUAL(stream_fr_FR_locale<CharT>(std::chrono::year{-32'767}), SV("-32767"));
+  TEST_EQUAL(stream_fr_FR_locale<CharT>(std::chrono::year{0}), SV("0000"));
+  TEST_EQUAL(stream_fr_FR_locale<CharT>(std::chrono::year{1970}), SV("1970"));
+  TEST_EQUAL(stream_fr_FR_locale<CharT>(std::chrono::year{32'767}), SV("32767"));
+
+  TEST_EQUAL(stream_ja_JP_locale<CharT>(std::chrono::year{-32'768}), SV("-32768 is not a valid year"));
+  TEST_EQUAL(stream_ja_JP_locale<CharT>(std::chrono::year{-32'767}), SV("-32767"));
+  TEST_EQUAL(stream_ja_JP_locale<CharT>(std::chrono::year{0}), SV("0000"));
+  TEST_EQUAL(stream_ja_JP_locale<CharT>(std::chrono::year{1970}), SV("1970"));
+  TEST_EQUAL(stream_ja_JP_locale<CharT>(std::chrono::year{32'767}), SV("32767"));
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year.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
 //
 //===----------------------------------------------------------------------===//
 
 // XFAIL: LIBCXX-FREEBSD-FIXME
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: no-localization
 
-// TODO FMT Investigate Windows issues.
-// UNSUPPORTED: msvc, target={{.+}}-windows-gnu
-
 // TODO FMT Fix this test using GCC, it currently crashes.
 // UNSUPPORTED: gcc-12
 
 // TODO FMT This test should not require std::to_chars(floating-point)
 // XFAIL: availability-fp_to_chars-missing
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
constexpr std::basic_string_view<CharT> lfmt = SV(
       "%%EY='%EY'%t"
       "%n}");
 
   const std::locale loc(LOCALE_ja_JP_UTF_8);
   std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
 
   // Non localized output using C-locale
   check(SV("%C='00'\t"
-#if defined(__APPLE__)
+#if defined(__APPLE__) || defined(_WIN32)
            "%EC='00'\t"
 #else
            "%EC='0'\t"
 #endif
            "%y='00'\t"
            "%Ey='00'\t"
            "%Oy='00'\t"
            "%Y='0000'\t"
-#if defined(__APPLE__)
+#if defined(__APPLE__) || defined(_WIN32)
            "%EY='0000'\t"
 #elif defined(_AIX)
            "%EY=''\t"
 #else
            "%EY='0'\t"
 #endif
            "\n"),
         fmt,
check(SV("%C='20'\t"
            "%Y='2038'\t"
            "%EY='2038'\t"
            "\n"),
         fmt,
         std::chrono::year{2038});
 
   // Use the global locale (fr_FR)
   check(SV("%C='00'\t"
-#if defined(__APPLE__)
+#if defined(__APPLE__) || defined(_WIN32)
            "%EC='00'\t"
 #else
            "%EC='0'\t"
 #endif
            "%y='00'\t"
            "%Ey='00'\t"
            "%Oy='00'\t"
            "%Y='0000'\t"
-#if defined(__APPLE__)
+#if defined(__APPLE__) || defined(_WIN32)
            "%EY='0000'\t"
 #elif defined(_AIX)
            "%EY=''\t"
 #else
            "%EY='0'\t"
 #endif
            "\n"),
         lfmt,
check(SV("%C='20'\t"
            "%Oy='38'\t"
            "%Y='2038'\t"
            "%EY='2038'\t"
            "\n"),
         lfmt,
         std::chrono::year{2038});
 
   // Use supplied locale (ja_JP). This locale has a different alternate.
-#if defined(__APPLE__) || defined(_AIX)
+#if defined(__APPLE__) || defined(_AIX) || defined(_WIN32)
 
   check(SV("%C='00'\t"
-#  if defined(__APPLE__)
+#  if defined(__APPLE__) || defined(_WIN32)
            "%EC='00'\t"
 #  else
            "%EC='0'\t"
 #  endif
            "%y='00'\t"
            "%Ey='00'\t"
            "%Oy='00'\t"
            "%Y='0000'\t"
check(SV("%C='20'\t"
            "%Ey='38'\t"
            "%Oy='38'\t"
            "%Y='2038'\t"
            "%EY='2038'\t"
            "\n"),
         lfmt,
         std::chrono::year{2038});
 
-#else // defined(__APPLE__) || defined(_AIX)
+#else // defined(__APPLE__) || defined(_AIX) || defined(_WIN32)
   check(loc,
         SV("%C='00'\t"
            "%EC='紀元前'\t"
            "%y='00'\t"
   // https://sourceware.org/bugzilla/show_bug.cgi?id=23758
 #  if defined(__GLIBC__) && __GLIBC__ <= 2 && __GLIBC_MINOR__ < 29
            "%Ey='1'\t"
 #  else
            "%Ey='01'\t"
 #  endif
            "%Oy='〇'\t"
            "%Y='0000'\t"
   // https://sourceware.org/bugzilla/show_bug.cgi?id=23758
 #  if defined(__GLIBC__) && __GLIBC__ <= 2 && __GLIBC_MINOR__ < 29
            "%EY='紀元前1年'\t"
 #  else
            "%EY='紀元前01年'\t"
 #  endif
            "\n"),
         lfmt,
         std::chrono::year{0});
check(loc,
            "%y='38'\t"
            "%Ey='20'\t"
            "%Oy='三十八'\t"
            "%Y='2038'\t"
            "%EY='令和20年'\t"
            "\n"),
         lfmt,
         std::chrono::year{2038});
-#endif // defined(__APPLE__) || defined(_AIX)
+#endif // defined(__APPLE__) || defined(_AIX) || defined(_WIN32)
 
   std::locale::global(std::locale::classic());
 }
 
 template <class CharT>
 static void test_padding() {
   constexpr std::basic_string_view<CharT> fmt = SV("{:%%C='%C'%t%%y='%y'%t%%Y='%Y'%t%n}");
-
   check(SV("%C='-100'\t%y='99'\t%Y='-9999'\t\n"), fmt, std::chrono::year{-9'999});
   check(SV("%C='-10'\t%y='99'\t%Y='-0999'\t\n"), fmt, std::chrono::year{-999});
   check(SV("%C='-1'\t%y='99'\t%Y='-0099'\t\n"), fmt, std::chrono::year{-99});
   check(SV("%C='-1'\t%y='09'\t%Y='-0009'\t\n"), fmt, std::chrono::year{-9});
   check(SV("%C='00'\t%y='00'\t%Y='0000'\t\n"), fmt, std::chrono::year{0});
   check(SV("%C='00'\t%y='09'\t%Y='0009'\t\n"), fmt, std::chrono::year{9});
   check(SV("%C='00'\t%y='99'\t%Y='0099'\t\n"), fmt, std::chrono::year{99});
   check(SV("%C='09'\t%y='99'\t%Y='0999'\t\n"), fmt, std::chrono::year{999});