[libc++] DO NOT REVIEW chrono formatting

[Mordante]

Summary

This is an incomplete not yet ready for review version of the code.

Since the output of these formatters are locale dependant it's expected
to fail on a lot of non-Linux platforms. There the list of CI's used has
been limited. There's no need to test every iteration of this patch on
all CI's.

It's intended to split this review in smaller parts for its real review.

Depends on D125606

[Mordante]

Rebased to trigger CI

[Mordante]

Rebased to fix CI and attempts fixing several other build issues.

[Mordante]

Rebased and applies several locale fixes.

[Mordante]

Try to fix CI.

[Mordante]

More CI fixes.

[Mordante]

Another CI test, disable AIX and GCC since they have hard failures and not test failures.

[Mordante]

More Windows fixes.

[Mordante]

The changes in this patch have landed in main via several other patches.

libcxx/include/CMakeLists.txt

set(files
   __charconv/chars_format.h
   __charconv/from_chars_result.h
   __charconv/to_chars_result.h
   __chrono/calendar.h
   __chrono/convert_to_timespec.h
   __chrono/day.h
   __chrono/duration.h
   __chrono/file_clock.h
+  __chrono/formatter.h
   __chrono/hh_mm_ss.h
   __chrono/high_resolution_clock.h
   __chrono/literals.h
   __chrono/month.h
   __chrono/month_weekday.h
   __chrono/monthday.h
+  __chrono/ostream.h
+  __chrono/parser_std_format_spec.h
+  __chrono/statically_widen.h
   __chrono/steady_clock.h
   __chrono/system_clock.h
   __chrono/time_point.h
   __chrono/weekday.h
   __chrono/year.h
   __chrono/year_month.h
   __chrono/year_month_day.h
   __chrono/year_month_weekday.h

libcxx/include/__chrono/formatter.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CHRONO_FORMATTER_H
+#define _LIBCPP___CHRONO_FORMATTER_H
+
+// Make sure all feature-test macros are available.
+#include <version>
+// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+#  include <__chrono/calendar.h>
+#  include <__chrono/day.h>
+#  include <__chrono/hh_mm_ss.h>
+#  include <__chrono/month.h>
+#  include <__chrono/month_weekday.h>
+#  include <__chrono/monthday.h>
+#  include <__chrono/ostream.h>
+#  include <__chrono/parser_std_format_spec.h>
+#  include <__chrono/statically_widen.h>
+#  include <__chrono/weekday.h>
+#  include <__chrono/year.h>
+#  include <__chrono/year_month.h>
+#  include <__chrono/year_month_day.h>
+#  include <__chrono/year_month_weekday.h>
+#  include <__concepts/arithmetic.h>
+#  include <__concepts/same_as.h>
+#  include <__config>
+#  include <__memory/addressof.h>
+#  include <cmath>
+#  include <ctime>
+#  include <format>
+#  include <iterator>
+#  include <ratio>
+#  include <sstream>
+#  include <string_view>
+
+// clang-format off
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+// clang-format on
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// The time format functions use ostream which requires locale support.
+#  if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {} // namespace chrono
+
+namespace __formatter {
+
+/// Formats a time based on a tm struct.
+///
+/// This formatter passes the formatting to time_put which uses strftime. When
+/// the value is outside the valid range it's unspecified what strftime will
+/// output. For example weekday 8, can print 1 when the day is processed module
+/// 7 since that handles the Sunday for 0-based weekday. It can also print 8 if
+/// 7 is handled as a special case.)
+///
+/// The Standard doesn't specify what to do in this case so the result depends
+/// on the result of the underlaying code.
+///
+/// \pre When the (abbreviated) weekday on month name are used the caller
+///      validates the value is valid. So the caller handles that requirement
+///      of Table 97: Meaning of conversion specifiers [tab:time.format.spec].
+/// Formats a time based on a tm struct.
+///
+/// When no chrono-specs are provided it uses the stream formatter.
+
+// Based on p2098r1, which is based on MSVC STL
+template <class, template <class...> class >
+inline constexpr bool __is_specialization_v = false; // true if and only if _Type is a specialization of _Template
+template <template <class...> class _Tp, class... _Args>
+inline constexpr bool __is_specialization_v<_Tp<_Args...>, _Tp> = true;
+
+template <class _Tp>
+concept __is_duration = __is_specialization_v<_Tp, chrono::duration>;
+
+template <class _Tp>
+concept __is_hh_mm_ss = __is_specialization_v<_Tp, chrono::hh_mm_ss>;
+
+template <class _Tp>
+concept __is_time_point = __is_specialization_v<_Tp, chrono::time_point>;
+
+template <class _CharT, __is_hh_mm_ss _Tp>
+_LIBCPP_HIDE_FROM_ABI void __format_sub_seconds(const _Tp& __value, basic_stringstream<_CharT>& __sstr) {
+  __sstr << std::use_facet<numpunct<_CharT>>(__sstr.getloc()).decimal_point();
+  if constexpr (chrono::treat_as_floating_point_v<typename _Tp::precision::rep>)
+    std::format_to(std::ostreambuf_iterator<_CharT>{__sstr}, _STATICALLY_WIDEN("{:0{}.0f}"),
+                   __value.subseconds().count(), __value.fractional_width);
+  else
+    std::format_to(std::ostreambuf_iterator<_CharT>{__sstr}, _STATICALLY_WIDEN("{:0{}}"), __value.subseconds().count(),
+                   __value.fractional_width);
+}
+
+// For tiny ratios it's not possible to convert a duration to a hh_mm_ss. This
+// fails compile-time due to the limited precision of the ratio (64-bit is too
+// small). Therefore a duration uses its own conversion.
+template <class _CharT, __is_duration _Tp>
+_LIBCPP_HIDE_FROM_ABI void __format_sub_seconds(const _Tp& __value, basic_stringstream<_CharT>& __sstr) {
+
+  __sstr << std::use_facet<numpunct<_CharT>>(__sstr.getloc()).decimal_point();
+
+  auto __fraction = __value - chrono::duration_cast<chrono::seconds>(__value);
+  if constexpr (chrono::treat_as_floating_point_v<typename _Tp::rep>)
+    // When the floating-point value has digits itself they are ignored based
+    // on the wording in [tab:time.format.spec]
+    //   If the precision of the input cannot be exactly represented with
+    //   seconds, then the format is a decimal floating-point number with a
+    //   fixed format and a precision matching that of the precision of the
+    //   input (or to a microseconds precision if the conversion to
+    //   floating-point decimal seconds cannot be made within 18 fractional
+    //   digits).
+    //
+    // This matches the behaviour of MSVC STL, fmtlib interprets this
+    // differently and uses 3 decimals.
+    // https://godbolt.org/z/6dsbnW8ba
+    std::format_to(std::ostreambuf_iterator<_CharT>{__sstr}, _STATICALLY_WIDEN("{:0{}.0f}"), __fraction.count(),
+                   chrono::hh_mm_ss<_Tp>::fractional_width);
+  else
+    std::format_to(std::ostreambuf_iterator<_CharT>{__sstr}, _STATICALLY_WIDEN("{:0{}}"), __fraction.count(),
+                   chrono::hh_mm_ss<_Tp>::fractional_width);
+}
+
+template <class _CharT, __is_time_point _Tp>
+_LIBCPP_HIDE_FROM_ABI void __format_sub_seconds(const _Tp& __value, basic_stringstream<_CharT>& __sstr) {
+  __format_sub_seconds(__value.time_since_epoch(), __sstr);
+}
+
+template < class _Tp>
+_LIBCPP_HIDE_FROM_ABI tm __make_tm(const _Tp& __value) {
+  tm __result{.tm_sec = 0,
+              .tm_min = 0,
+              .tm_hour = 0,
+              .tm_mday = 0,
+              .tm_mon = 0,
+              .tm_year = 0,
+              .tm_wday = 0,
+              .tm_yday = 0,
+              .tm_isdst = 0
+#    ifdef __GLIBC__
+              ,
+              .tm_gmtoff = 0,
+              .tm_zone = "UTC"
+#    endif
+  };
+  if constexpr (__is_duration<_Tp>) {
+    uint64_t __sec = chrono::duration_cast<chrono::seconds>(__value).count();
+    __sec %= 24 * 3600;
+    __result.tm_hour = __sec / 3600;
+    __sec %= 3600;
+    __result.tm_min = __sec / 60;
+    __result.tm_sec = __sec % 60;
+  } else if constexpr (__is_time_point<_Tp>) {
+    if constexpr (same_as<typename _Tp::clock, chrono::system_clock>) {
+      time_t __t = chrono::system_clock::to_time_t(__value);
+#    ifdef _LIBCPP_WIN32API // Windows doesn't have gmtime_r, but gmtime is thread-safe.
+      __result = *gmtime(std::addressof(__t));
+#    else
+      gmtime_r(std::addressof(__t), std::addressof(__result));
+#    endif
+    } else
+      static_assert(sizeof(_Tp) == 0, "Add the missing clock specialization");
+  } else if constexpr (same_as<_Tp, chrono::day>)
+    __result.tm_mday = static_cast<unsigned>(__value);
+  else if constexpr (same_as<_Tp, chrono::month>)
+    __result.tm_mon = static_cast<unsigned>(__value) - 1; // XXX test when set to 0, what happens.
+  else if constexpr (same_as<_Tp, chrono::year>)
+    __result.tm_year = static_cast<int>(__value) - 1900;
+  else if constexpr (same_as<_Tp, chrono::weekday>)
+    __result.tm_wday = __value.c_encoding();
+  else if constexpr (same_as<_Tp, chrono::weekday_indexed> || same_as<_Tp, chrono::weekday_last>)
+    __result.tm_wday = __value.weekday().c_encoding();
+  else if constexpr (same_as<_Tp, chrono::month_day>) {
+    __result.tm_mday = static_cast<unsigned>(__value.day());
+    __result.tm_mon = static_cast<unsigned>(__value.month()) - 1; // XXX test when set to 0, what happens.
+  } else if constexpr (same_as<_Tp, chrono::month_day_last>) {
+    __result.tm_mon = static_cast<unsigned>(__value.month()) - 1; // XXX test when set to 0, what happens.
+  } else if constexpr (same_as<_Tp, chrono::month_weekday> || same_as<_Tp, chrono::month_weekday_last>) {
+    __result.tm_wday = __value.weekday_indexed().weekday().c_encoding();
+    __result.tm_mon = static_cast<unsigned>(__value.month()) - 1; // XXX test when set to 0, what happens.
+  } else if constexpr (same_as<_Tp, chrono::year_month>) {
+    __result.tm_year = static_cast<int>(__value.year()) - 1900;
+    __result.tm_mon = static_cast<unsigned>(__value.month()) - 1; // XXX test when set to 0, what happens.
+  } else if constexpr (same_as<_Tp, chrono::year_month_day> || same_as<_Tp, chrono::year_month_day_last>) {
+    if (__value.ok()) {
+      time_t __t = chrono::system_clock::to_time_t(static_cast<chrono::sys_days>(__value));
+#    ifdef _LIBCPP_WIN32API // Windows doesn't have gmtime_r, but gmtime is thread-safe.
+      __result = *gmtime(std::addressof(__t));
+#    else
+      gmtime_r(std::addressof(__t), std::addressof(__result));
+#    endif
+    } else {
+      __result.tm_year = static_cast<int>(__value.year()) - 1900;
+      __result.tm_mon = static_cast<unsigned>(__value.month()) - 1; // XXX test when set to 0, what happens.
+      __result.tm_mday = static_cast<unsigned>(__value.day());
+    }
+  } else if constexpr (same_as<_Tp, chrono::year_month_weekday> || same_as<_Tp, chrono::year_month_weekday_last>) {
+
+    // The interesting question is what it the date of a year_month_weekday.
+    // - ok() specifies the date as ok when it's round-trippable. So if an
+    //   index of 5 may change the month making the date invalid. An index of
+    //   0 is invalid.
+    // - sys_days() gives a valid result if y_.ok() && m_.ok() &&
+    //   wdi_.weekday().ok(). The date is specified in terms of index() and
+    //   even specifies an invalid index of 0.
+
+    if (__value.year().ok() && __value.month().ok() && __value.weekday().ok()) {
+      time_t __t = chrono::system_clock::to_time_t(static_cast<chrono::sys_days>(__value));
+#    ifdef _LIBCPP_WIN32API // Windows doesn't have gmtime_r, but gmtime is thread-safe.
+      __result = *gmtime(std::addressof(__t));
+#    else
+      gmtime_r(std::addressof(__t), std::addressof(__result));
+#    endif
+    } else {
+
+      // When the index doesn't result in a valid date nothing might be known
+      // This includes the valid index 5. For example the 5th Monday of January 1970 doesn't exist
+
+      __result.tm_year = static_cast<int>(__value.year()) - 1900;
+      __result.tm_mon = static_cast<unsigned>(__value.month()) - 1; // XXX test when set to 0, what happens.
+      __result.tm_wday = static_cast<unsigned>(__value.weekday().c_encoding());
+    }
+  } else if constexpr (__is_hh_mm_ss<_Tp>) {
+    __result.tm_sec = __value.seconds().count();
+    __result.tm_min = __value.minutes().count();
+    __result.tm_hour = __value.hours().count(); // TODO FMT hours can overflow
+  } else
+    static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
+
+  return __result;
+}
+
+template <class _Tp>
+consteval bool __use_fraction() {
+  if constexpr (__is_duration<_Tp>)
+    return chrono::hh_mm_ss<_Tp>::fractional_width;
+  else if constexpr (__is_hh_mm_ss<_Tp>)
+    return _Tp::fractional_width;
+  else if constexpr (__is_time_point<_Tp>)
+    return chrono::hh_mm_ss<typename _Tp::duration>::fractional_width;
+  else
+    return false;
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI void __format_year(int __year, basic_stringstream<_CharT>& __sstr) {
+  __year += 1900; // tm_year to year conversion.
+  if (__year < 0) {
+    __sstr << _CharT('-');
+    // The chrono library requires a year fits in a short.
+    __year = -__year;
+  }
+
+  __sstr << format(_STATICALLY_WIDEN("{:04}"), __year);
+}
+
+template <class _CharT, class _Tp>
+_LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(const _Tp& __value, basic_stringstream<_CharT>& __sstr,
+                                                              basic_string_view<_CharT> __chrono_specs) {
+
+  tm __t = __make_tm(__value);
+  const auto& __facet = std::use_facet<time_put<_CharT>>(__sstr.getloc());
+  for (auto __it = __chrono_specs.begin(); __it != __chrono_specs.end(); ++__it) {
+    if (*__it == _CharT('%')) {
+      auto __s = __it;
+      ++__it;
+      // We only handle the types that can't be directly handled by time_put.
+      switch (*__it) {
+        // TODO FMT Optimize %nt
+
+      case _CharT('j'):
+        if constexpr (__is_duration<_Tp>)
+          // Converting a duration where the period has a small ratio to days
+          // may fail to compile. This due to loss of precision in the
+          // conversion. In order to avoid that issue convert to seconds as
+          // an intemediate step.
+          __sstr << chrono::duration_cast<chrono::days>(chrono::duration_cast<chrono::seconds>(__value)).count();
+        else
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        break;
+      case _CharT('q'):
+        if constexpr (__is_duration<_Tp>) {
+          __sstr << chrono::__units_suffix<_CharT, typename _Tp::period>();
+          break;
+        }
+        __builtin_unreachable();
+      case _CharT('Q'):
+        // TODO FMT Determine the proper ideas
+        // - Should it honour the precision?
+        // - Shoult it honour the locale setting for the separators?
+        // The wording for Q doesn't use the word locale and the effect of
+        // precision is unspecified.
+        //
+        // MSVC STL ignores precision but uses separator
+        // FMT honours precision and has a bug for separator
+        // https://godbolt.org/z/78b7sMxns
+        if constexpr (__is_duration<_Tp>) {
+          __sstr << format(_STATICALLY_WIDEN("{}"), __value.count());
+          break;
+        }
+        __builtin_unreachable();
+      case _CharT('S'):
+      case _CharT('T'):
+        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        if constexpr (__use_fraction<_Tp>())
+          __formatter::__format_sub_seconds(__value, __sstr);
+        break;
+
+        // Unlike time_put and strftime the formatting library requires %Y
+        //
+        // [tab:time.format.spec]
+        //   The year as a decimal number. If the result is less than four digits
+        //   it is left-padded with 0 to four digits.
+        //
+        // This means years in the range (-1000, 1000) need manual formatting.
+        // It's unclear whether %EY needs the same treatment. For example the
+        // Japanese EY contains the era name and year. This is zero padded to 2
+        // digits time_put (note older glibc versions didn't do padding.)
+        // However most eras won't reach a 100 years, let alone 1000. So
+        // padding to 4 digits seems unwanted for Japanese.
+        //
+        // The same applies to %Ex since that too depends on the era.
+        //
+        // %x the locale's date representation is currently doesn't handle the
+        // zero-padding too.
+        //
+        // The 4 digits can be implemented better at a later time. On POSIX
+        // 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.
+
+      case _CharT('Y'):
+        if (__t.tm_year < 1000)
+          __formatter::__format_year(__t.tm_year, __sstr);
+        else
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        break;
+
+      case _CharT('F'):
+        if (__t.tm_year < 1000) {
+          __formatter::__format_year(__t.tm_year, __sstr);
+          __sstr << std::format(_STATICALLY_WIDEN("-{:02}-{:02}"), __t.tm_mon + 1, __t.tm_mday);
+        } else
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        break;
+
+      case _CharT('Z'):
+        // TODO FMT Add proper timezone support.
+        __sstr << _STATICALLY_WIDEN("UTC");
+        break;
+
+      case _CharT('O'):
+        if constexpr (__use_fraction<_Tp>()) {
+          // Handle OS using the normal representation for the fractional
+          // part. There seems to be no locale information regarding how the
+          // fractional part should be formatted.
+          if (*(__it + 1) == 'S') {
+            ++__it;
+            __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+            __formatter::__format_sub_seconds(__value, __sstr);
+            break;
+          }
+        }
+        [[fallthrough]];
+      case _CharT('E'):
+        ++__it;
+        [[fallthrough]];
+      default:
+        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        break;
+      }
+    } else {
+      // TODO FMT Copying a substring is probably cheaper.
+      __sstr << *__it;
+    }
+  }
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __weekday_ok(const _Tp& __value) {
+  if constexpr (__is_time_point<_Tp>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_day_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_weekday>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::year_month>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::year_month_day>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
+    return __value.weekday().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
+    return __value.weekday().ok();
+  else if constexpr (__is_hh_mm_ss<_Tp>)
+    return true;
+  else
+    static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __weekday_name_ok(const _Tp& __value) {
+  if constexpr (__is_time_point<_Tp>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
+    return __value.weekday().ok();
+  else if constexpr (same_as<_Tp, chrono::weekday_last>)
+    return __value.weekday().ok();
+  else if constexpr (same_as<_Tp, chrono::month_day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_day_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_weekday>)
+    return __value.weekday_indexed().ok();
+  else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
+    return __value.weekday_indexed().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::year_month_day>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
+    return __value.weekday().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
+    return __value.weekday().ok();
+  else if constexpr (__is_hh_mm_ss<_Tp>)
+    return true;
+  else
+    static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __day_of_year_ok(const _Tp& __value) {
+  if constexpr (__is_time_point<_Tp>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_day_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_weekday>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::year_month>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::year_month_day>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
+    //    return __value.ok() ;
+
+    return (__value.year().ok() && __value.month().ok() && __value.weekday().ok());
+
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
+    return __value.ok();
+  else if constexpr (__is_hh_mm_ss<_Tp>)
+    return true;
+  else
+    static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __month_name_ok(const _Tp& __value) {
+  if constexpr (__is_time_point<_Tp>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::day>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month>)
+    return __value.ok();
+  else if constexpr (same_as<_Tp, chrono::year>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::weekday_last>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::month_day>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::month_day_last>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::month_weekday>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_day>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
+    return __value.month().ok();
+  else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
+    return __value.month().ok();
+  else if constexpr (__is_hh_mm_ss<_Tp>)
+    return true;
+  else
+    static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
+}
+
+template <class _CharT, class _Tp>
+_LIBCPP_HIDE_FROM_ABI auto __format_chrono(const _Tp& __value, auto& __ctx, __format_spec::__parser<_CharT> __parser,
+                                           basic_string_view<_CharT> __chrono_specs) -> decltype(__ctx.out()) {
+
+  basic_stringstream<_CharT> __sstr;
+  // [time.format]/2
+  // 2.1 - the "C" locale if the L option is not present in chrono-format-spec, otherwise
+  // 2.2 - the locale passed to the formatting function if any, otherwise
+  // 2.3 - the global locale.
+  // Note that the __ctx's locale() call does 2.2 and 2.3.
+  if (__parser.__locale_specific_form_)
+    __sstr.imbue(__ctx.locale());
+  else
+    __sstr.imbue(locale::classic());
+
+  if (__chrono_specs.empty())
+    __sstr << __value;
+  else {
+    if constexpr (__is_duration<_Tp>) { // XXX order of the formatter specializations
+      if (__value < __value.zero())
+        __sstr << _CharT('-');
+      __formatter::__format_chrono_using_chrono_specs(chrono::abs(__value), __sstr, __chrono_specs);
+      // TODO FMT When keeping the precision it will truncate the string.
+      __parser.__precision_ = -1;
+    } else {
+      // Before weekday since the error is more specific
+      if (__parser.__weekday_name_ && !__formatter::__weekday_name_ok(__value))
+        __throw_format_error("formatting a weekday name needs a valid value");
+
+      if (__parser.__weekday_ && !__formatter::__weekday_ok(__value))
+        __throw_format_error("formatting a weekday needs a valid value");
+
+      if (__parser.__day_of_year_ && !__formatter::__day_of_year_ok(__value))
+        __throw_format_error("formatting a day of year needs a valid value");
+
+      if (__parser.__month_name_ && !__formatter::__month_name_ok(__value))
+        __throw_format_error("formatting a month name needs a valid value");
+
+      if constexpr (__is_hh_mm_ss<_Tp>) {
+        // Note this is a pedantic intepretation of the Standard. A hh_mm_ss
+        // is no longer a time_of_day and can store an arbitrary number of
+        // hours. A number of hours in a 12 or 24 hour clock can't represent
+        // 24 hours or more. The functions std::chrono::make12 and
+        // std::chrono::make24 reaffirm this view point.
+        //
+        // Interestingly this will be the only output stream function that
+        // throws.
+        //
+        // TODO FMT Propbaby the wording needs to be adapted to
+        // - The displayed hours is hh_mm_ss.hours() % 24
+        // - It should probably allow %j in the same fashion as duration.
+        // - The stream formatter should change its output when hours >= 24
+        //   - Write it as not valid,
+        //   - or write the number of days.
+        if (__parser.__hour_ && __value.hours().count() > 23)
+          __throw_format_error("formatting a hour needs a valid value");
+
+        if (__value.is_negative())
+          __sstr << _CharT('-');
+      }
+      __format_chrono_using_chrono_specs(__value, __sstr, __chrono_specs);
+    }
+  }
+
+  // TODO FMT Use view after P0408R7 has been implemented.
+  basic_string<_CharT> __str = __sstr.str();
+  return __formatter::__format_string_view(basic_string_view<_CharT>{__str}, __ctx.out(), __parser);
+}
+
+} // namespace __formatter
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_chrono {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx,
+                                             __format_spec::__fields __fields, __format_spec::__flags __flags)
+      -> decltype(__parse_ctx.begin()) {
+    return __parser_.__parse(__parse_ctx, __fields, __flags);
+  }
+
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI auto format(const _Tp& __value, auto& __ctx) const -> decltype(__ctx.out()) const {
+    return __formatter::__format_chrono(__value, __ctx, __parser_.__parser_.__resolve_dynamic_sizes(__ctx),
+                                        __parser_.__chrono_specs_);
+  }
+
+  __format_spec::__parser_chrono<_CharT> __parser_;
+};
+
+template <class _Rep, class _Period, __formatter::__char_type _CharT>
+struct formatter<chrono::duration<_Rep, _Period>, _CharT> : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    // [time.format]/1
+    // Giving a precision specification in the chrono-format-spec is valid only
+    // for std::chrono::duration types where the representation type Rep is a
+    // floating-point type.  For all other Rep types, an exception of type
+    // format_error is thrown if the chrono-format-spec contains a precision
+    // specification.
+    //
+    // Note this doesn't refer to chrono::treat_as_floating_point_v<_Rep>.
+    if constexpr (std::floating_point<_Rep>)
+      return _Base::parse(__parse_ctx, __format_spec::__fields_chrono_fractional, __format_spec::__flags::__duration);
+    else
+      return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__duration);
+  }
+};
+
+template <class _Duration, __formatter::__char_type _CharT>
+struct formatter<chrono::sys_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__clock);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::day, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__day);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::weekday, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::weekday_indexed, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  // TODO FMT is there a way to extract the index?
+  // %i as an option?
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::weekday_last, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_day, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_day);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_day_last, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_weekday, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_weekday_last, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year_month);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_day, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_day_last, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_weekday, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
+  }
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_weekday_last, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
+  }
+};
+
+template <class _Duration, __formatter::__char_type _CharT>
+struct formatter<chrono::hh_mm_ss<_Duration>, _CharT> : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__time);
+  }
+};
+
+// Due to cyclic dependencies between the formatter and the operator<< some are
+// defined in this header instead of their specific header.
+//
+// TODO FMT add an ostream header instead?
+namespace chrono {} // namespace chrono
+
+#  endif //if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+#endif //  _LIBCPP___CHRONO_FORMATTER_H

libcxx/include/__chrono/ostream.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CHRONO_OSTREAM_H
+#define _LIBCPP___CHRONO_OSTREAM_H
+
+// Make sure all feature-test macros are available.
+#include <version>
+// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+#  include <__chrono/day.h>
+#  include <__chrono/duration.h>
+#  include <__chrono/hh_mm_ss.h>
+#  include <__chrono/month.h>
+#  include <__chrono/month_weekday.h>
+#  include <__chrono/monthday.h>
+#  include <__chrono/statically_widen.h>
+#  include <__chrono/system_clock.h>
+#  include <__chrono/weekday.h>
+#  include <__chrono/year.h>
+#  include <__chrono/year_month.h>
+#  include <__chrono/year_month_day.h>
+#  include <__chrono/year_month_weekday.h>
+#  include <__config>
+#  include <format>
+#  include <ostream>
+
+// clang-format off
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+// clang-format on
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// The time format functions use ostream which requires locale support.
+#  if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+template <class _CharT, class _Period>
+_LIBCPP_HIDE_FROM_ABI auto __units_suffix() {
+  // LWG the suffixes are always char and not STATICALLY-WIDEN'ed
+  // TODO FMT The code implements LWG-xxxx because the wording in the
+  if constexpr (same_as<typename _Period::type, atto>)
+    return _STATICALLY_WIDEN("as");
+  else if constexpr (same_as<typename _Period::type, femto>)
+    return _STATICALLY_WIDEN("fs");
+  else if constexpr (same_as<typename _Period::type, pico>)
+    return _STATICALLY_WIDEN("ps");
+  else if constexpr (same_as<typename _Period::type, nano>)
+    return _STATICALLY_WIDEN("ns");
+  else if constexpr (same_as<typename _Period::type, micro>)
+#    ifndef _LIBCPP_HAS_NO_UNICODE
+    return _STATICALLY_WIDEN("\u00b5s");
+#    else
+    return _STATICALLY_WIDEN("us");
+#    endif
+  else if constexpr (same_as<typename _Period::type, milli>)
+    return _STATICALLY_WIDEN("ms");
+  else if constexpr (same_as<typename _Period::type, centi>)
+    return _STATICALLY_WIDEN("cs");
+  else if constexpr (same_as<typename _Period::type, deci>)
+    return _STATICALLY_WIDEN("ds");
+  else if constexpr (same_as<typename _Period::type, ratio<1>>)
+    return _STATICALLY_WIDEN("s");
+  else if constexpr (same_as<typename _Period::type, deca>)
+    return _STATICALLY_WIDEN("das");
+  else if constexpr (same_as<typename _Period::type, hecto>)
+    return _STATICALLY_WIDEN("hs");
+  else if constexpr (same_as<typename _Period::type, kilo>)
+    return _STATICALLY_WIDEN("ks");
+  else if constexpr (same_as<typename _Period::type, mega>)
+    return _STATICALLY_WIDEN("Ms");
+  else if constexpr (same_as<typename _Period::type, giga>)
+    return _STATICALLY_WIDEN("Gs");
+  else if constexpr (same_as<typename _Period::type, tera>)
+    return _STATICALLY_WIDEN("Ts");
+  else if constexpr (same_as<typename _Period::type, peta>)
+    return _STATICALLY_WIDEN("Ps");
+  else if constexpr (same_as<typename _Period::type, exa>)
+    return _STATICALLY_WIDEN("Es");
+  else if constexpr (same_as<typename _Period::type, ratio<60>>)
+    return _STATICALLY_WIDEN("min");
+  else if constexpr (same_as<typename _Period::type, ratio<3600>>)
+    return _STATICALLY_WIDEN("h");
+  else if constexpr (same_as<typename _Period::type, ratio<86400>>)
+    return _STATICALLY_WIDEN("d");
+  else if constexpr (_Period::den == 1)
+    return format(_STATICALLY_WIDEN("[{}]s"), _Period::num);
+  else
+    return format(_STATICALLY_WIDEN("[{}/{}]s"), _Period::num, _Period::den);
+}
+template <class _CharT, class _Traits, class _Rep, class _Period>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const duration<_Rep, _Period>& __d) {
+  basic_ostringstream<_CharT, _Traits> __s;
+  __s.flags(__os.flags());
+  __s.imbue(__os.getloc());
+  __s.precision(__os.precision());
+  __s << __d.count() << __units_suffix<_CharT, _Period>();
+  return __os << __s.str();
+}
+
+template <class _CharT, class _Traits, class _Duration>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_time<_Duration> __tp) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L%F %T}"), __tp);
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d) {
+  return __os << (__d.ok() ? std::format(_STATICALLY_WIDEN("{:%d}"), __d)
+                           : std::format(_STATICALLY_WIDEN("{:%d} is not a valid day"), __d));
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m) {
+  return __os << (__m.ok() ? std::format(__os.getloc(), _STATICALLY_WIDEN("{:L%b}"), __m)
+                           : std::format(__os.getloc(), _STATICALLY_WIDEN("{} is not a valid month"),
+                                         static_cast<unsigned>(__m))); // TODO FMT locale not needed
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y) {
+  return __os << (__y.ok() ? std::format(_STATICALLY_WIDEN("{:%Y}"), __y)
+                           : std::format(_STATICALLY_WIDEN("{:%Y} is not a valid year"), __y));
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd) {
+  return __os << (__wd.ok() ? std::format(__os.getloc(), _STATICALLY_WIDEN("{:L%a}"), __wd)
+                            : std::format(__os.getloc(), // XXX doesn't need locale???
+                                          _STATICALLY_WIDEN("{} is not a valid weekday"),
+                                          static_cast<unsigned>(__wd.c_encoding())));
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday_indexed& __wdi) {
+  auto __i = __wdi.index();
+  return __os << (__i >= 1 && __i <= 5 ? std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}[{}]"), __wdi.weekday(), __i)
+                                       : std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}[{} is not a valid index]"),
+                                                     __wdi.weekday(), __i));
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday_last& __wdl) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}[last]"), __wdl.weekday());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md) {
+  // TODO FMT not test for ok()...
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}/{}"), __md.month(), __md.day());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day_last& __mdl) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}[last]"), __mdl.month());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const month_weekday& __mwd) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}/{:L}"), __mwd.month(), __mwd.weekday_indexed());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const month_weekday_last& __mwdl) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L}/{:L}"), __mwdl.month(), __mwdl.weekday_last());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{}/{:L}"), __ym.year(), __ym.month());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month_day& __ymd) {
+  return __os << (__ymd.ok() ? std::format(_STATICALLY_WIDEN("{:%F}"), __ymd)
+                             : std::format(_STATICALLY_WIDEN("{:%F} is not a valid date"), __ymd));
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month_day_last& __ymdl) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{}/{:L}"), __ymdl.year(), __ymdl.month_day_last());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month_weekday& __ymwd) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{}/{:L}/{:L}"), __ymwd.year(), __ymwd.month(),
+                             __ymwd.weekday_indexed());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month_weekday_last& __ymwdl) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{}/{:L}/{:L}"), __ymwdl.year(), __ymwdl.month(),
+                             __ymwdl.weekday_last());
+}
+
+template <class _CharT, class _Traits, class _Duration>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const hh_mm_ss<_Duration> __hms) {
+  return __os << std::format(__os.getloc(), _STATICALLY_WIDEN("{:L%T}"), __hms);
+}
+
+} // namespace chrono
+
+#  endif //if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+#endif // _LIBCPP___CHRONO_OSTREAM_H

libcxx/include/__chrono/parser_std_format_spec.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H
+#define _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H
+
+// Make sure all feature-test macros are available.
+#include <version>
+// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+#  include <__config>
+#  include <__format/format_error.h>
+#  include <__format/format_fwd.h> // for __char_type TODO FMT Move the concept?
+#  include <__format/format_parse_context.h>
+#  include <__format/formatter_string.h>
+#  include <__format/parser_std_format_spec.h>
+#  include <string_view>
+
+// clang-format off
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+// clang-format on
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// This code doesn't require locales, but the formatters do.
+// Therefore this code is unused when no locale support is available.
+#  if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace __format_spec {
+
+// By not placing this constant in the formatter class it's not duplicated for char and wchar_t
+inline constexpr __fields __fields_chrono_fractional{
+    .__precision_ = true, .__locale_specific_form_ = true, .__type_ = false};
+inline constexpr __fields __fields_chrono{.__locale_specific_form_ = true, .__type_ = false};
+
+/// Flags available or required in a chrono type.
+///
+/// The caller of the chrono formatter lists the types it has available and the
+/// validation tests whether the requested type spec (e.g. %M) is available in
+/// the formatter.
+/// When the type in the chrono-format-spec isn't present in the data a
+/// format_error is thrown.
+enum class __flags {
+  __second = 0x1,
+  __minute = 0x2,
+  __hour = 0x4,
+  __time = __hour | __minute | __second,
+
+  __day = 0x8,
+  __month = 0x10,
+  __year = 0x20,
+
+  __weekday = 0x40,
+
+  __month_day = __day | __month,
+  __month_weekday = __weekday | __month,
+  __year_month = __month | __year,
+  __date = __day | __month | __year | __weekday,
+
+  __date_time = __date | __time,
+
+  __duration = 0x80 | __time,
+
+  __time_zone = 0x100,
+
+  __clock = __date_time | __time_zone
+};
+
+_LIBCPP_HIDE_FROM_ABI constexpr __flags operator&(__flags __lhs, __flags __rhs) {
+  return static_cast<__flags>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_second(__flags __flags) {
+  if ((__flags & __flags::__second) != __flags::__second)
+    std::__throw_format_error("The supplied date time doesn't contain a second");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_minute(__flags __flags) {
+  if ((__flags & __flags::__minute) != __flags::__minute)
+    std::__throw_format_error("The supplied date time doesn't contain a minute");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_hour(__flags __flags) {
+  if ((__flags & __flags::__hour) != __flags::__hour)
+    std::__throw_format_error("The supplied date time doesn't contain a hour");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_time(__flags __flags) {
+  if ((__flags & __flags::__time) != __flags::__time)
+    std::__throw_format_error("The supplied date time doesn't contain a time");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_day(__flags __flags) {
+  if ((__flags & __flags::__day) != __flags::__day)
+    std::__throw_format_error("The supplied date time doesn't contain a day");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_month(__flags __flags) {
+  if ((__flags & __flags::__month) != __flags::__month)
+    std::__throw_format_error("The supplied date time doesn't contain a month");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_year(__flags __flags) {
+  if ((__flags & __flags::__year) != __flags::__year)
+    std::__throw_format_error("The supplied date time doesn't contain a year");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_date(__flags __flags) {
+  if ((__flags & __flags::__date) != __flags::__date)
+    std::__throw_format_error("The supplied date time doesn't contain a date");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_date_or_duration(__flags __flags) {
+  if (((__flags & __flags::__date) != __flags::__date) && ((__flags & __flags::__duration) != __flags::__duration))
+    std::__throw_format_error("The supplied date time doesn't contain a date or duration");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_date_time(__flags __flags) {
+  if ((__flags & __flags::__date_time) != __flags::__date_time)
+    std::__throw_format_error("The supplied date time doesn't contain a date and time");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_weekday(__flags __flags) {
+  if ((__flags & __flags::__weekday) != __flags::__weekday)
+    std::__throw_format_error("The supplied date time doesn't contain a weekday");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_duration(__flags __flags) {
+  if ((__flags & __flags::__duration) != __flags::__duration)
+    std::__throw_format_error("The supplied date time doesn't contain a duration");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_time_zone(__flags __flags) {
+  if ((__flags & __flags::__time_zone) != __flags::__time_zone)
+    std::__throw_format_error("The supplied date time doesn't contain a time zone");
+}
+
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser_chrono {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields,
+                                               __flags __flags) -> decltype(__parse_ctx.begin()) {
+
+    const _CharT* __begin = __parser_.__parse(__parse_ctx, __fields);
+    const _CharT* __end = __parse_ctx.end();
+    if (__begin == __end)
+      return __begin;
+
+    const _CharT* __last = __parse_chrono_specs(__begin, __end, __flags);
+    __chrono_specs_ = basic_string_view<_CharT>{__begin, __last};
+
+    return __last;
+  }
+
+  __parser<_CharT> __parser_;
+  basic_string_view<_CharT> __chrono_specs_;
+
+private:
+  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __parse_chrono_specs(const _CharT* __begin, const _CharT* __end,
+                                                                     __flags __flags) {
+    _LIBCPP_ASSERT(__begin != __end, "When called with an empty input the function will cause "
+                                     "undefined behavior by evaluating data not in the input");
+
+    if (*__begin != _CharT('%') && *__begin != _CharT('}'))
+      __throw_format_error("Expected '%' or '}' in the chrono format-string");
+
+    do {
+      switch (*__begin) {
+      case _CharT('{'):
+        __throw_format_error("The chrono-specs contains a '{'");
+
+      case _CharT('}'):
+        return __begin;
+
+      case _CharT('%'):
+        __parse_escape(__begin, __end, __flags);
+        [[fallthrough]];
+
+      default:
+        // All other literals
+        ++__begin;
+      }
+
+    } while (__begin != __end && *__begin != _CharT('}'));
+
+    return __begin;
+  }
+
+  // TODO FMT Evaluate __parse_escape
+  // Another approach is to have a set of valid escape sequences based on the
+  // type being parsed this selection can be done based on the flags or the
+  // type. Doing it based on the type may cause the binary size to increment.
+
+  // pre __begin == %
+  // post __end = ++__begin
+  // When a weekday or monthname are required the __parser_'s status is updated.
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_escape(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+    ++__begin;
+    if (__begin == __end)
+      __throw_format_error("End of input while parsing the modifier chrono conversion-spec");
+
+    switch (*__begin) {
+    case _CharT('n'):
+    case _CharT('t'):
+    case _CharT('%'):
+      break;
+
+    case _CharT('S'):
+      __validate_second(__flags);
+      break;
+
+    case _CharT('M'):
+      __validate_minute(__flags);
+      break;
+
+    case _CharT('p'): // TODO FMT does the formater require an hour or a time?
+    case _CharT('H'):
+    case _CharT('I'):
+      __parser_.__hour_ = true;
+      __validate_hour(__flags);
+      break;
+
+    case _CharT('r'):
+    case _CharT('R'):
+    case _CharT('T'):
+    case _CharT('X'):
+      __parser_.__hour_ = true;
+      __validate_time(__flags);
+      break;
+
+    case _CharT('d'):
+    case _CharT('e'):
+      __validate_day(__flags);
+      break;
+
+    case _CharT('b'):
+    case _CharT('h'):
+    case _CharT('B'):
+      __parser_.__month_name_ = true;
+      [[fallthrough]];
+    case _CharT('m'):
+      __validate_month(__flags);
+      break;
+
+    case _CharT('y'):
+    case _CharT('C'):
+    case _CharT('Y'):
+      __validate_year(__flags);
+      break;
+
+    case _CharT('j'):
+      __parser_.__day_of_year_ = true;
+      __validate_date_or_duration(__flags);
+      break;
+
+    case _CharT('g'):
+    case _CharT('x'):
+    case _CharT('D'):
+    case _CharT('F'):
+    case _CharT('G'):
+    case _CharT('U'):
+    case _CharT('V'):
+    case _CharT('W'):
+      __validate_date(__flags);
+      break;
+
+    case _CharT('c'):
+      __validate_date_time(__flags);
+      break;
+
+    case _CharT('a'):
+    case _CharT('A'):
+      __parser_.__weekday_name_ = true;
+      [[fallthrough]];
+    case _CharT('u'):
+    case _CharT('w'):
+      __parser_.__weekday_ = true;
+      __validate_weekday(__flags);
+      break;
+
+    case _CharT('q'):
+    case _CharT('Q'):
+      __validate_duration(__flags);
+      break;
+
+    case _CharT('E'):
+      __parse_modifier_E(__begin, __end, __flags);
+      break;
+
+    case _CharT('O'):
+      __parse_modifier_O(__begin, __end, __flags);
+      break;
+
+    case _CharT('z'):
+    case _CharT('Z'):
+      // Currently there's no time zone information. However some clocks have a
+      // hard-coded "time zone", for these clocks the information can be used.
+      // TODO FMT implement time zones.
+      __validate_time_zone(__flags);
+      break;
+
+    default: // unknown type;
+      std::__throw_format_error("The date time type specifier is invalid");
+    }
+  }
+
+  // pre __begin == E
+  // post __end = ++__begin
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_modifier_E(const _CharT*& __begin, const _CharT* __end,
+                                                          __flags __flags) /*const*/ {
+    ++__begin;
+    if (__begin == __end)
+      __throw_format_error("End of input while parsing the modifier E");
+
+    switch (*__begin) {
+    case _CharT('X'):
+      __parser_.__hour_ = true;
+      __validate_time(__flags);
+      break;
+
+    case _CharT('y'):
+    case _CharT('C'):
+    case _CharT('Y'):
+      __validate_year(__flags);
+      break;
+
+    case _CharT('x'):
+      __validate_date(__flags);
+      break;
+
+    case _CharT('c'):
+      __validate_date_time(__flags);
+      break;
+
+    case _CharT('z'):
+      // Currently there's no time zone information. However some clocks have a
+      // hard-coded "time zone", for these clocks the information can be used.
+      // TODO FMT implement time zones.
+      __validate_time_zone(__flags);
+      break;
+
+    default:
+      std::__throw_format_error("The date time type specifier for modifier E is invalid");
+    }
+  }
+
+  // pre __begin == O
+  // post __end = ++__begin
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_modifier_O(const _CharT*& __begin, const _CharT* __end,
+                                                          __flags __flags) {
+    ++__begin;
+    if (__begin == __end)
+      __throw_format_error("End of input while parsing the modifier O");
+
+    switch (*__begin) {
+    case _CharT('S'):
+      __validate_second(__flags);
+      break;
+
+    case _CharT('M'):
+      __validate_minute(__flags);
+      break;
+
+    case _CharT('I'):
+    case _CharT('H'):
+      __parser_.__hour_ = true;
+      __validate_hour(__flags);
+      break;
+
+    case _CharT('d'):
+    case _CharT('e'):
+      __validate_day(__flags);
+      break;
+
+    case _CharT('m'):
+      __validate_month(__flags);
+      break;
+
+    case _CharT('y'):
+      __validate_year(__flags);
+      break;
+
+    case _CharT('U'):
+    case _CharT('V'):
+    case _CharT('W'):
+      __validate_date(__flags);
+      break;
+
+    case _CharT('u'):
+    case _CharT('w'):
+      __parser_.__weekday_ = true;
+      __validate_weekday(__flags);
+      break;
+
+    case _CharT('z'):
+      // Currently there's no time zone information. However some clocks have a
+      // hard-coded "time zone", for these clocks the information can be used.
+      // TODO FMT implement time zones.
+      __validate_time_zone(__flags);
+      break;
+
+    default:
+      std::__throw_format_error("The date time type specifier for modifier O is invalid");
+    }
+  }
+};
+
+} // namespace __format_spec
+
+#  endif //_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+#endif // _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H

libcxx/include/__chrono/statically_widen.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CHRONO_STATICALLY_WIDEN_H
+#define _LIBCPP___CHRONO_STATICALLY_WIDEN_H
+
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <__formatter::__char_type _CharT>
+constexpr const _CharT* __statically_widen(const char* __str, const wchar_t* __wstr) {
+  if constexpr (same_as<_CharT, char>)
+    return __str;
+  else
+    return __wstr;
+}
+#  define _STATICALLY_WIDEN(__str) (std::__statically_widen<_CharT>(__str, L##__str))
+#else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  define _STATICALLY_WIDEN(__str) (__str)
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif //  _LIBCPP___CHRONO_FORMATTER

libcxx/include/__format/parser_std_format_spec.h

public:
   bool __alternate_form_ : 1 {false};
   bool __zero_padding_ : 1 {false};
   bool __locale_specific_form_ : 1 {false};
   __type __type_ : 5 {__type::__default};
 
   bool __width_as_arg_ : 1 {false};
   bool __precision_as_arg_ : 1 {false};
 
-  // These two flags are used for formatting chrono. Since the struct has
+  // These flags are only used for formatting chrono. Since the struct has
   // padding space left it's added to this structure.
   bool __weekday_name_ : 1 {false};
   bool __month_name_ : 1 {false};
+
+  bool __weekday_ : 1 {false};
+  bool __day_of_year_ : 1 {false};
+
+  bool __hour_ : 1 {false}; // a clock hours requires a maximum of 24 hours
+
   // LWG 3576 will probably change this to always accept a Unicode code point
   // To avoid changing the size with that change align the field so when it
   // becomes 32-bit its alignment will remain the same. That also means the
   // size will remain the same. (D2572 addresses the solution for LWG 3576.)
   alignas(4) _CharT __fill_{_CharT(' ')};
   int32_t __width_{0};
   int32_t __precision_{-1};
 

libcxx/include/chrono

 
 template <class ToDuration, class Rep, class Period>
     constexpr ToDuration floor(const duration<Rep, Period>& d);    // C++17
 template <class ToDuration, class Rep, class Period>
     constexpr ToDuration ceil(const duration<Rep, Period>& d);     // C++17
 template <class ToDuration, class Rep, class Period>
     constexpr ToDuration round(const duration<Rep, Period>& d);    // C++17
 
-// duration I/O is elsewhere
+// duration I/O
+template<class charT, class traits, class Rep, class Period>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os,
+               const duration<Rep, Period>& d);
 
 // time_point arithmetic (all constexpr in C++14)
 template <class Clock, class Duration1, class Rep2, class Period2>
   time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Clock, class Duration2>
   time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
public:
     static time_point from_time_t(time_t __t) noexcept;
 };
 
 template <class Duration>
   using sys_time  = time_point<system_clock, Duration>; // C++20
 using sys_seconds = sys_time<seconds>;                  // C++20
 using sys_days    = sys_time<days>;                     // C++20
 
+template<class charT, class traits, class Duration>  // C++20
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);
+
 class file_clock                                        // C++20
 {
 public:
     typedef see-below                      rep;
     typedef nano                           period;
     typedef chrono::duration<rep, period>  duration;
     typedef chrono::time_point<file_clock> time_point;
     static constexpr bool is_steady =      false;

 constexpr bool operator< (const day& x, const day& y) noexcept;
 constexpr bool operator> (const day& x, const day& y) noexcept;
 constexpr bool operator<=(const day& x, const day& y) noexcept;
 constexpr bool operator>=(const day& x, const day& y) noexcept;
 constexpr day  operator+(const day&  x, const days& y) noexcept;
 constexpr day  operator+(const days& x, const day&  y) noexcept;
 constexpr day  operator-(const day&  x, const days& y) noexcept;
 constexpr days operator-(const day&  x, const day&  y) noexcept;
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const day& d);
 
 // 25.8.4, class month    // C++20
 class month;
 constexpr bool operator==(const month& x, const month& y) noexcept;
 constexpr bool operator!=(const month& x, const month& y) noexcept;
 constexpr bool operator< (const month& x, const month& y) noexcept;
 constexpr bool operator> (const month& x, const month& y) noexcept;
 constexpr bool operator<=(const month& x, const month& y) noexcept;
 constexpr bool operator>=(const month& x, const month& y) noexcept;
 constexpr month  operator+(const month&  x, const months& y) noexcept;
 constexpr month  operator+(const months& x,  const month& y) noexcept;
 constexpr month  operator-(const month&  x, const months& y) noexcept;
 constexpr months operator-(const month&  x,  const month& y) noexcept;
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const month& m);
 
 // 25.8.5, class year    // C++20
 class year;
 constexpr bool operator==(const year& x, const year& y) noexcept;
 constexpr bool operator!=(const year& x, const year& y) noexcept;
 constexpr bool operator< (const year& x, const year& y) noexcept;
 constexpr bool operator> (const year& x, const year& y) noexcept;
 constexpr bool operator<=(const year& x, const year& y) noexcept;
 constexpr bool operator>=(const year& x, const year& y) noexcept;
 constexpr year  operator+(const year&  x, const years& y) noexcept;
 constexpr year  operator+(const years& x, const year&  y) noexcept;
 constexpr year  operator-(const year&  x, const years& y) noexcept;
 constexpr years operator-(const year&  x, const year&  y) noexcept;
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const year& y);
 
 // 25.8.6, class weekday    // C++20
 class weekday;
 
 constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
 constexpr bool operator!=(const weekday& x, const weekday& y) noexcept;
 constexpr weekday operator+(const weekday& x, const days&    y) noexcept;
 constexpr weekday operator+(const days&    x, const weekday& y) noexcept;
 constexpr weekday operator-(const weekday& x, const days&    y) noexcept;
 constexpr days    operator-(const weekday& x, const weekday& y) noexcept;
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
 
 // 25.8.7, class weekday_indexed    // C++20
 
 class weekday_indexed;
 constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 constexpr bool operator!=(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 
 // 25.8.8, class weekday_last    // C++20
public:
     constexpr chrono::minutes minutes() const noexcept;
     constexpr chrono::seconds seconds() const noexcept;
     constexpr precision subseconds() const noexcept;
 
     constexpr explicit operator  precision()   const noexcept;
     constexpr          precision to_duration() const noexcept;
 };
 
+template<class charT, class traits, class Duration>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms); // C++20
+
 // 26.10, 12/24 hour functions
 constexpr bool is_am(hours const& h) noexcept;
 constexpr bool is_pm(hours const& h) noexcept;
 constexpr hours make12(const hours& h) noexcept;
 constexpr hours make24(const hours& h, bool is_pm) noexcept;
 
 // 25.10.5, class time_zone    // C++20
 enum class choose {earliest, latest};
 class time_zone;
 bool operator==(const time_zone& x, const time_zone& y) noexcept;
 bool operator!=(const time_zone& x, const time_zone& y) noexcept;
 bool operator<(const time_zone& x, const time_zone& y) noexcept;
 bool operator>(const time_zone& x, const time_zone& y) noexcept;
 bool operator<=(const time_zone& x, const time_zone& y) noexcept;
 bool operator>=(const time_zone& x, const time_zone& y) noexcept;
+}  // chrono
 
+namespace std {
+  template<class Rep, class Period, class charT>
+    struct formatter<chrono::duration<Rep, Period>, charT>;                       // C++20
+  template<class Duration, class charT>
+    struct formatter<chrono::sys_time<Duration>, charT>;                          // C++20
+  template<class charT> struct formatter<chrono::day, charT>;                     // C++20
+  template<class charT> struct formatter<chrono::month, charT>;                   // C++20
+  template<class charT> struct formatter<chrono::year, charT>;                    // C++20
+  template<class charT> struct formatter<chrono::weekday, charT>;                 // C++20
+  template<class charT> struct formatter<chrono::weekday_indexed, charT>;         // C++20
+  template<class charT> struct formatter<chrono::weekday_last, charT>;            // C++20
+  template<class charT> struct formatter<chrono::month_day, charT>;               // C++20
+  template<class charT> struct formatter<chrono::month_day_last, charT>;          // C++20
+  template<class charT> struct formatter<chrono::month_weekday, charT>;           // C++20
+  template<class charT> struct formatter<chrono::month_weekday_last, charT>;      // C++20
+  template<class charT> struct formatter<chrono::year_month, charT>;              // C++20
+  template<class charT> struct formatter<chrono::year_month_day, charT>;          // C++20
+  template<class charT> struct formatter<chrono::year_month_day_last, charT>;     // C++20
+  template<class charT> struct formatter<chrono::year_month_weekday, charT>;      // C++20
+  template<class charT> struct formatter<chrono::year_month_weekday_last, charT>; // C++20
+  template<class Rep, class Period, class charT>
+    struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;             // C++20
+} // namespace std
+
+namespace chrono {
 // calendrical constants
 inline constexpr last_spec                              last{};       // C++20
 inline constexpr chrono::weekday                        Sunday{0};    // C++20
 inline constexpr chrono::weekday                        Monday{1};    // C++20
 inline constexpr chrono::weekday                        Tuesday{2};   // C++20
 inline constexpr chrono::weekday                        Wednesday{3}; // C++20
 inline constexpr chrono::weekday                        Thursday{4};  // C++20
 inline constexpr chrono::weekday                        Friday{5};    // C++20

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/calendar.h>
 #include <__chrono/convert_to_timespec.h>
 #include <__chrono/day.h>
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
+#include <__chrono/formatter.h>
 #include <__chrono/hh_mm_ss.h>
 #include <__chrono/high_resolution_clock.h>
 #include <__chrono/literals.h>
 #include <__chrono/month.h>
 #include <__chrono/month_weekday.h>
 #include <__chrono/monthday.h>
+#include <__chrono/ostream.h>
+#include <__chrono/parser_std_format_spec.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__chrono/weekday.h>
 #include <__chrono/year.h>
 #include <__chrono/year_month.h>
 #include <__chrono/year_month_day.h>
 #include <__chrono/year_month_weekday.h>

libcxx/include/module.modulemap

module charconv {
     }
 
   }
   module chrono {
     header "chrono"
     export *
 
     module __chrono {
-      module calendar              { private header "__chrono/calendar.h" }
-      module convert_to_timespec   { private header "__chrono/convert_to_timespec.h" }
-      module day                   { private header "__chrono/day.h" }
-      module duration              { private header "__chrono/duration.h" }
-      module file_clock            { private header "__chrono/file_clock.h" }
-      module hh_mm_ss              { private header "__chrono/hh_mm_ss.h" }
-      module high_resolution_clock { private header "__chrono/high_resolution_clock.h" }
-      module literals              { private header "__chrono/literals.h" }
-      module month                 { private header "__chrono/month.h" }
-      module month_weekday         { private header "__chrono/month_weekday.h" }
-      module monthday              { private header "__chrono/monthday.h" }
-      module steady_clock          { private header "__chrono/steady_clock.h" }
-      module system_clock          { private header "__chrono/system_clock.h" }
-      module time_point            { private header "__chrono/time_point.h" }
-      module weekday               { private header "__chrono/weekday.h" }
-      module year                  { private header "__chrono/year.h" }
-      module year_month            { private header "__chrono/year_month.h" }
-      module year_month_day        { private header "__chrono/year_month_day.h" }
-      module year_month_weekday    { private header "__chrono/year_month_weekday.h" }
+      module calendar               { private header "__chrono/calendar.h" }
+      module convert_to_timespec    { private header "__chrono/convert_to_timespec.h" }
+      module day                    { private header "__chrono/day.h" }
+      module duration               { private header "__chrono/duration.h" }
+      module file_clock             { private header "__chrono/file_clock.h" }
+      module formatter              { private header "__chrono/formatter.h" }
+      module hh_mm_ss               { private header "__chrono/hh_mm_ss.h" }
+      module high_resolution_clock  { private header "__chrono/high_resolution_clock.h" }
+      module literals               { private header "__chrono/literals.h" }
+      module month                  { private header "__chrono/month.h" }
+      module month_weekday          { private header "__chrono/month_weekday.h" }
+      module monthday               { private header "__chrono/monthday.h" }
+      module ostream                { private header "__chrono/ostream.h" }
+      module parser_std_format_spec { private header "__chrono/parser_std_format_spec.h" }
+      module statically_widen       { private header "__chrono/statically_widen.h" }
+      module steady_clock           { private header "__chrono/steady_clock.h" }
+      module system_clock           { private header "__chrono/system_clock.h" }
+      module time_point             { private header "__chrono/time_point.h" }
+      module weekday                { private header "__chrono/weekday.h" }
+      module year                   { private header "__chrono/year.h" }
+      module year_month             { private header "__chrono/year_month.h" }
+      module year_month_day         { private header "__chrono/year_month_day.h" }
+      module year_month_weekday     { private header "__chrono/year_month_weekday.h" }
     }
   }
   module codecvt {
     header "codecvt"
     export *
   }
   module compare {
     header "compare"

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__charconv/chars_format.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/chars_format.h'}}
 #include <__charconv/from_chars_result.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/from_chars_result.h'}}
 #include <__charconv/to_chars_result.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/to_chars_result.h'}}
 #include <__chrono/calendar.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/calendar.h'}}
 #include <__chrono/convert_to_timespec.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/convert_to_timespec.h'}}
 #include <__chrono/day.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/day.h'}}
 #include <__chrono/duration.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/duration.h'}}
 #include <__chrono/file_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/file_clock.h'}}
+#include <__chrono/formatter.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/formatter.h'}}
 #include <__chrono/hh_mm_ss.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/hh_mm_ss.h'}}
 #include <__chrono/high_resolution_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/high_resolution_clock.h'}}
 #include <__chrono/literals.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/literals.h'}}
 #include <__chrono/month.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/month.h'}}
 #include <__chrono/month_weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/month_weekday.h'}}
 #include <__chrono/monthday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/monthday.h'}}
+#include <__chrono/ostream.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/ostream.h'}}
+#include <__chrono/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/parser_std_format_spec.h'}}
+#include <__chrono/statically_widen.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/statically_widen.h'}}
 #include <__chrono/steady_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/steady_clock.h'}}
 #include <__chrono/system_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/system_clock.h'}}
 #include <__chrono/time_point.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/time_point.h'}}
 #include <__chrono/weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/weekday.h'}}
 #include <__chrono/year.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year.h'}}
 #include <__chrono/year_month.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month.h'}}
 #include <__chrono/year_month_day.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month_day.h'}}
 #include <__chrono/year_month_weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month_weekday.h'}}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
                 || std::same_as<CharT, wchar_t>
 #endif
   )
     static_assert(std::__formattable<T, CharT>);
   else
     assert_is_not_formattable<T, CharT>();
 }
 
+// The chrono formatters require localization support.
+// When this isn't available the formatter specialization isn't available
+// and the formatter is disabled.
+template <class T, class CharT>
+void assert_is_formattable_with_localization_support() {
+#ifndef TEST_HAS_NO_LOCALIZATION
+  assert_is_formattable<T, CharT>();
+#else
+  assert_is_not_formattable<T, CharT>();
+#endif
+}
+
 // Tests for P0645 Text Formatting
 template <class CharT>
 void test_P0645() {
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   // Tests the special formatter that converts a char to a wchar_t.
   assert_is_formattable<char, wchar_t>();
 #endif
   assert_is_formattable<CharT, CharT>();

 
 // Tests for P1361 Integration of chrono with text formatting
 //
 // Some tests are commented out since these types haven't been implemented in
 // chrono yet. After P1361 has been implemented these formatters should be all
 // enabled.
 template <class CharT>
 void test_P1361() {
-  assert_is_not_formattable<std::chrono::microseconds, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::microseconds, CharT>();
 
-  assert_is_not_formattable<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
   //assert_is_formattable<std::chrono::utc_time<std::chrono::microseconds>, CharT>();
   //assert_is_formattable<std::chrono::tai_time<std::chrono::microseconds>, CharT>();
   //assert_is_formattable<std::chrono::gps_time<std::chrono::microseconds>, CharT>();
   assert_is_not_formattable<std::chrono::file_time<std::chrono::microseconds>, CharT>();
   assert_is_not_formattable<std::chrono::local_time<std::chrono::microseconds>, CharT>();
 
-  assert_is_not_formattable<std::chrono::day, CharT>();
-  assert_is_not_formattable<std::chrono::month, CharT>();
-  assert_is_not_formattable<std::chrono::year, CharT>();
-
-  assert_is_not_formattable<std::chrono::weekday, CharT>();
-  assert_is_not_formattable<std::chrono::weekday_indexed, CharT>();
-  assert_is_not_formattable<std::chrono::weekday_last, CharT>();
-
-  assert_is_not_formattable<std::chrono::month_day, CharT>();
-  assert_is_not_formattable<std::chrono::month_day_last, CharT>();
-  assert_is_not_formattable<std::chrono::month_weekday, CharT>();
-  assert_is_not_formattable<std::chrono::month_weekday_last, CharT>();
-
-  assert_is_not_formattable<std::chrono::year_month, CharT>();
-  assert_is_not_formattable<std::chrono::year_month_day, CharT>();
-  assert_is_not_formattable<std::chrono::year_month_day_last, CharT>();
-  assert_is_not_formattable<std::chrono::year_month_weekday, CharT>();
-  assert_is_not_formattable<std::chrono::year_month_weekday_last, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::day, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::month, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::year, CharT>();
+
+  assert_is_formattable_with_localization_support<std::chrono::weekday, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::weekday_indexed, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::weekday_last, CharT>();
+
+  assert_is_formattable_with_localization_support<std::chrono::month_day, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::month_day_last, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::month_weekday, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::month_weekday_last, CharT>();
+
+  assert_is_formattable_with_localization_support<std::chrono::year_month, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::year_month_day, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::year_month_day_last, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::year_month_weekday, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::year_month_weekday_last, CharT>();
 
-  assert_is_not_formattable<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
+  assert_is_formattable_with_localization_support<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
 
   //assert_is_formattable<std::chrono::sys_info, CharT>();
   //assert_is_formattable<std::chrono::local_info, CharT>();
 
   //assert_is_formattable<std::chrono::zoned_time, CharT>();
 }
 
 // Tests for P1636 Formatters for library types

libcxx/test/std/time/time.hms/time.hms.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// class hh_mm_ss;
+
+// template<class charT, class traits, class Duration>
+//   basic_ostream<charT, traits>&
+//     operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms);
+
+#include <chrono>
+#include <cassert>
+#include <sstream>
+
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT, class Duration>
+static std::basic_string<CharT> stream_c_locale(std::chrono::hh_mm_ss<Duration> hms) {
+  std::basic_stringstream<CharT> sstr;
+  sstr << hms;
+  return sstr.str();
+}
+
+template <class CharT, class Duration>
+static std::basic_string<CharT> stream_fr_FR_locale(std::chrono::hh_mm_ss<Duration> hms) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr << hms;
+  return sstr.str();
+}
+
+template <class CharT, class Duration>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::hh_mm_ss<Duration> hms) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_ja_JP_UTF_8);
+  sstr.imbue(locale);
+  sstr << hms;
+  return sstr.str();
+}
+
+template <class CharT>
+static void test() {
+
+  // Note std::atto can't be tested since the ratio conversion from std::atto
+  // std::chrono::seconds to std::chrono::hours overflows when intmax_t is a
+  // 64-bit type.
+
+  // C locale - integral power of 10 ratios
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::femto>{1'234'567'890}}) ==
+         SV("00:00:00.000001234567890"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::pico>{1'234'567'890}}) ==
+         SV("00:00:00.001234567890"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::nano>{1'234'567'890}}) ==
+         SV("00:00:01.234567890"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::micro>{1'234'567}}) ==
+         SV("00:00:01.234567"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::milli>{123'456}}) ==
+         SV("00:02:03.456"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::centi>{12'345}}) ==
+         SV("00:02:03.45"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::deci>{1'234}}) ==
+         SV("00:02:03.4"));
+
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t>{123}}) == SV("00:02:03"));
+
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::deca>{-366}}) ==
+         SV("-01:01:00"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::hecto>{-72}}) ==
+         SV("-02:00:00"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::kilo>{-86}}) ==
+         SV("-23:53:20"));
+
+  // Starting at mega it will pass one day
+
+  // fr_FR locale - integral power of not 10 ratios
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{
+             std::chrono::duration<intmax_t, std::ratio<1, 5'000'000>>{5'000}}) == SV("00:00:00,0010000"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 8'000>>{3}}) ==
+         SV("00:00:00,000375"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 4'000>>{1}}) ==
+         SV("00:00:00,00025"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 5'000>>{5}}) ==
+         SV("00:00:00,0010"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 8>>{-4}}) ==
+         SV("-00:00:00,500"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 4>>{-8}}) ==
+         SV("-00:00:02,00"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 5>>{-5}}) ==
+         SV("-00:00:01,0"));
+
+  // TODO FMT Note there's no wording on the rounding
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 9>>{5}}) ==
+         SV("00:00:00,555555"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 7>>{7}}) ==
+         SV("00:00:01,000000"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 6>>{1}}) ==
+         SV("00:00:00,166666"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 3>>{2}}) ==
+         SV("00:00:00,666666"));
+
+  // ja_JP locale - floating points
+
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{
+             std::chrono::duration<long double, std::femto>{1'234'567'890.123}}) == SV("00:00:00.000001234567890"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{
+             std::chrono::duration<long double, std::pico>{1'234'567'890.123}}) == SV("00:00:00.001234567890"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{
+             std::chrono::duration<long double, std::nano>{1'234'567'890.123}}) == SV("00:00:01.234567890"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<double, std::micro>{1'234'567.123}}) ==
+         SV("00:00:01.234567"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<double, std::milli>{123'456.123}}) ==
+         SV("00:02:03.456"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<double, std::centi>{12'345.123}}) ==
+         SV("00:02:03.45"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<float, std::deci>{1'234.123}}) ==
+         SV("00:02:03.4"));
+
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<float>{123.123}}) == SV("00:02:03"));
+
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<double, std::deca>{-366.5}}) ==
+         SV("-01:01:05"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<double, std::hecto>{-72.64}}) ==
+         SV("-02:01:04"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<double, std::kilo>{-86}}) ==
+         SV("-23:53:20"));
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+// class day;
+
+// template<class charT, class traits>
+//   basic_ostream<charT, traits>&
+//     operator<<(basic_ostream<charT, traits>& os, const day& d);
+
+#include <chrono>
+#include <cassert>
+#include <sstream>
+
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static std::basic_string<CharT> stream_c_locale(std::chrono::day day) {
+  std::basic_stringstream<CharT> sstr;
+  sstr << day;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_fr_FR_locale(std::chrono::day day) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr << day;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::day day) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_ja_JP_UTF_8);
+  sstr.imbue(locale);
+  sstr << day;
+  return sstr.str();
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  assert(stream_c_locale<CharT>(0d) == SV("00 is not a valid day"));
+  assert(stream_c_locale<CharT>(1d) == SV("01"));
+  assert(stream_c_locale<CharT>(31d) == SV("31"));
+  assert(stream_c_locale<CharT>(255d) == SV("255 is not a valid day"));
+
+  assert(stream_fr_FR_locale<CharT>(0d) == SV("00 is not a valid day"));
+  assert(stream_fr_FR_locale<CharT>(1d) == SV("01"));
+  assert(stream_fr_FR_locale<CharT>(31d) == SV("31"));
+  assert(stream_fr_FR_locale<CharT>(255d) == SV("255 is not a valid day"));
+
+  assert(stream_ja_JP_locale<CharT>(0d) == SV("00 is not a valid day"));
+  assert(stream_ja_JP_locale<CharT>(1d) == SV("01"));
+  assert(stream_ja_JP_locale<CharT>(31d) == SV("31"));
+  assert(stream_ja_JP_locale<CharT>(255d) == SV("255 is not a valid day"));
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+// class weekday;
+
+// template<class charT, class traits>
+//   basic_ostream<charT, traits>&
+//     operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
+
+#include <chrono>
+#include <cassert>
+#include <sstream>
+
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static std::basic_string<CharT> stream_c_locale(std::chrono::weekday weekday) {
+  std::basic_stringstream<CharT> sstr;
+  sstr << weekday;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_fr_FR_locale(std::chrono::weekday weekday) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr << weekday;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::weekday weekday) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_ja_JP_UTF_8);
+  sstr.imbue(locale);
+  sstr << weekday;
+  return sstr.str();
+}
+
+template <class CharT>
+static void test() {
+  assert(stream_c_locale<CharT>(std::chrono::weekday(0)) == SV("Sun"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(1)) == SV("Mon"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(2)) == SV("Tue"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(3)) == SV("Wed"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(4)) == SV("Thu"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(5)) == SV("Fri"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(6)) == SV("Sat"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(7)) == SV("Sun"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(8)) == SV("8 is not a valid weekday"));
+  assert(stream_c_locale<CharT>(std::chrono::weekday(255)) == SV("255 is not a valid weekday"));
+
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(0)) == SV("dim."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(1)) == SV("lun."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(2)) == SV("mar."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(3)) == SV("mer."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(4)) == SV("jeu."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(5)) == SV("ven."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(6)) == SV("sam."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(7)) == SV("dim."));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(8)) == SV("8 is not a valid weekday"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::weekday(255)) == SV("255 is not a valid weekday"));
+
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(0)) == SV("日"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(1)) == SV("月"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(2)) == SV("火"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(3)) == SV("水"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(4)) == SV("木"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(5)) == SV("金"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(6)) == SV("土"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(7)) == SV("日"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(8)) == SV("8 is not a valid weekday"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::weekday(255)) == SV("255 is not a valid weekday"));
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// 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"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+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_fr_FR_locale(std::chrono::year year) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr << year;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::year year) {
+  std::basic_stringstream<CharT> sstr;
+  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"));
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.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
 
int main(int, char**)
     {
     constexpr year_month_weekday ymwd{year{2000}, month{2}, weekday_indexed{std::chrono::Wednesday, 1}};
     constexpr sys_days sd{ymwd};
 
     static_assert( sd.time_since_epoch() == days{10957+32}, "");
     static_assert( year_month_weekday{sd} == ymwd, ""); // and back
     }
 
+    {
+    constexpr year_month_weekday ymwd{year{2000}, month{2}, weekday_indexed{std::chrono::Wednesday, 0}};
+    constexpr sys_days sd{ymwd};
+    static_assert( !ymwd.ok() );
+
+    static_assert( sd.time_since_epoch() == days{10957+25}, "");
+//    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+            // for example the 5th Wednessday of 2022 doesn't exist, counting
+            // from the first Wednessday it would be the first Wednessday of
+    {
+    constexpr year_month_weekday ymwd{year{2022}, month{12}, weekday_indexed{std::chrono::Wednesday, 5}};
+//    constexpr sys_days sd{ymwd};
+    static_assert( !ymwd.ok() );
+
+//    static_assert( sd.time_since_epoch() == days{10957+25}, "");
+//    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+            // 2023.
+
+
     // There's one more leap day between 1/1/40 and 1/1/70
     // when compared to 1/1/70 -> 1/1/2000
     {
     constexpr year_month_weekday ymwd{year{1940}, month{1},weekday_indexed{std::chrono::Tuesday, 1}};
     constexpr sys_days sd{ymwd};
 
     static_assert( sd.time_since_epoch() == days{-10957}, "");
     static_assert( year_month_weekday{sd} == ymwd, ""); // and back

libcxx/test/std/time/time.clock/time.clock.file/consistency.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
 
 // Due to C++17 inline variables ASAN flags this test as containing an ODR
 // violation because Clock::is_steady is defined in both the dylib and this TU.
-// UNSUPPORTED: asan
+// XFAIL: asan
 
 // <chrono>
 
 // file_clock
 
 // check clock invariants
 
 #include <chrono>

libcxx/test/std/time/time.clock/time.clock.system/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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// class system_clock;
+
+// template<class charT, class traits, class Duration>
+//   basic_ostream<charT, traits>&
+//     operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);
+
+#include <chrono>
+#include <cassert>
+#include <sstream>
+
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT, class Duration>
+static std::basic_string<CharT> stream_c_locale(std::chrono::sys_time<Duration> time_point) {
+  std::basic_stringstream<CharT> sstr;
+  sstr << std::fixed << time_point;
+  return sstr.str();
+}
+
+template <class CharT, class Duration>
+static std::basic_string<CharT> stream_fr_FR_locale(std::chrono::sys_time<Duration> time_point) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr << std::fixed << time_point;
+  return sstr.str();
+}
+
+template <class CharT, class Duration>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::sys_time<Duration> time_point) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_ja_JP_UTF_8);
+  sstr.imbue(locale);
+  sstr << std::fixed << time_point;
+  return sstr.str();
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  // XXX format tests don't use fraction of second!!!
+  //
+  //
+  //
+  //
+  //
+  //
+  //
+
+  // hours days etc
+
+  assert(stream_c_locale<CharT>(std::chrono::sys_seconds{0s}) == SV("1970-01-01 00:00:00"));
+  assert(stream_c_locale<CharT>(std::chrono::sys_time<std::chrono::milliseconds>{946'684'800'123ms}) ==
+         SV("2000-01-01 00:00:00.123"));
+  assert(stream_c_locale<CharT>(std::chrono::sys_time<std::chrono::microseconds>{946'688'523'123'456us}) ==
+         SV("2000-01-01 01:02:03.123456"));
+
+  // ns
+  // tm atto is volle resolutie
+  // maar zepto gaat naar 6
+
+  assert(stream_fr_FR_locale<CharT>(std::chrono::sys_seconds{0s}) == SV("1970-01-01 00:00:00"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::sys_time<std::chrono::milliseconds>{946'684'800'123ms}) ==
+         SV("2000-01-01 00:00:00,123"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::sys_time<std::chrono::microseconds>{946'688'523'123'456us}) ==
+         SV("2000-01-01 01:02:03,123456"));
+
+  assert(stream_ja_JP_locale<CharT>(std::chrono::sys_seconds{0s}) == SV("1970-01-01 00:00:00"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::sys_time<std::chrono::milliseconds>{946'684'800'123ms}) ==
+         SV("2000-01-01 00:00:00.123"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::sys_time<std::chrono::microseconds>{946'688'523'123'456us}) ==
+         SV("2000-01-01 01:02:03.123456"));
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+//  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.duration/time.duration.nonmember/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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class Rep, class Period = ratio<1>> class duration;
+
+// template<class charT, class traits, class Rep, class Period>
+//   basic_ostream<charT, traits>&
+//     operator<<(basic_ostream<charT, traits>& os,
+//                const duration<Rep, Period>& d);
+
+#include <chrono>
+#include <cassert>
+#include <sstream>
+
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT, class Rep, class Period>
+static std::basic_string<CharT> stream_c_locale(std::chrono::duration<Rep, Period> duration) {
+  std::basic_stringstream<CharT> sstr;
+  sstr.precision(4);
+  sstr << std::fixed << duration;
+  return sstr.str();
+}
+
+template <class CharT, class Rep, class Period>
+static std::basic_string<CharT> stream_fr_FR_locale(std::chrono::duration<Rep, Period> duration) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr.precision(4);
+  sstr << std::fixed << duration;
+  return sstr.str();
+}
+
+template <class CharT, class Rep, class Period>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::duration<Rep, Period> duration) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_ja_JP_UTF_8);
+  sstr.imbue(locale);
+  sstr.precision(4);
+  sstr << std::fixed << duration;
+  return sstr.str();
+}
+
+template <class CharT>
+static void test_values() {
+  using namespace std::literals::chrono_literals;
+
+  assert(stream_c_locale<CharT>(-1'000'000s) == SV("-1000000s"));
+  assert(stream_c_locale<CharT>(1'000'000s) == SV("1000000s"));
+  assert(stream_c_locale<CharT>(-1'000.123456s) == SV("-1000.1235s"));
+  assert(stream_c_locale<CharT>(1'000.123456s) == SV("1000.1235s"));
+
+  if constexpr (std::same_as<CharT, char>) {
+    assert(stream_fr_FR_locale<CharT>(-1'000'000s) == SV("-1 000 000s"));
+    assert(stream_fr_FR_locale<CharT>(1'000'000s) == SV("1 000 000s"));
+    assert(stream_fr_FR_locale<CharT>(-1'000.123456s) == SV("-1 000,1235s"));
+    assert(stream_fr_FR_locale<CharT>(1'000.123456s) == SV("1 000,1235s"));
+  } else {
+#ifdef _WIN32
+    assert(stream_fr_FR_locale<CharT>(-1'000'000s) == SV("-1\u00A0000\u00A0000s"));
+    assert(stream_fr_FR_locale<CharT>(1'000'000s) == SV("1\u00A0000\u00A0000s"));
+    assert(stream_fr_FR_locale<CharT>(-1'000.123456s) == SV("-1\u00A0000,1235s"));
+    assert(stream_fr_FR_locale<CharT>(1'000.123456s) == SV("1\u00A0000,1235s"));
+#else
+    assert(stream_fr_FR_locale<CharT>(-1'000'000s) == SV("-1\u202f000\u202f000s"));
+    assert(stream_fr_FR_locale<CharT>(1'000'000s) == SV("1\u202f000\u202f000s"));
+    assert(stream_fr_FR_locale<CharT>(-1'000.123456s) == SV("-1\u202f000,1235s"));
+    assert(stream_fr_FR_locale<CharT>(1'000.123456s) == SV("1\u202f000,1235s"));
+#endif
+  }
+
+  assert(stream_ja_JP_locale<CharT>(-1'000'000s) == SV("-1,000,000s"));
+  assert(stream_ja_JP_locale<CharT>(1'000'000s) == SV("1,000,000s"));
+  assert(stream_ja_JP_locale<CharT>(-1'000.123456s) == SV("-1,000.1235s"));
+  assert(stream_ja_JP_locale<CharT>(1'000.123456s) == SV("1,000.1235s"));
+}
+
+template <class CharT>
+static void test_units() {
+  using namespace std::literals::chrono_literals;
+
+  // C locale
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::atto>(0)) == SV("0as"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::femto>(0)) == SV("0fs"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::pico>(0)) == SV("0ps"));
+  assert(stream_c_locale<CharT>(0ns) == SV("0ns"));
+#ifndef TEST_HAS_NO_UNICODE
+  assert(stream_c_locale<CharT>(0us) == SV("0\u00b5s"));
+#else
+  assert(stream_c_locale<CharT>(0us) == SV("0us"));
+#endif
+  assert(stream_c_locale<CharT>(0ms) == SV("0ms"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::centi>(0)) == SV("0cs"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::deci>(0)) == SV("0ds"));
+
+  assert(stream_c_locale<CharT>(0s) == SV("0s"));
+
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::deca>(0)) == SV("0das"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::hecto>(0)) == SV("0hs"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::kilo>(0)) == SV("0ks"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::mega>(0)) == SV("0Ms"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::giga>(0)) == SV("0Gs"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::tera>(0)) == SV("0Ts"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::peta>(0)) == SV("0Ps"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::exa>(0)) == SV("0Es"));
+
+  assert(stream_c_locale<CharT>(0min) == SV("0min"));
+  assert(stream_c_locale<CharT>(0h) == SV("0h"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::ratio<86400>>(0)) == SV("0d"));
+
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::ratio<42>>(0)) == SV("0[42]s"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::ratio<33, 3>>(0)) == SV("0[11]s"));
+  assert(stream_c_locale<CharT>(std::chrono::duration<int, std::ratio<11, 9>>(0)) == SV("0[11/9]s"));
+
+  // fr_FR locale
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::atto>(0)) == SV("0as"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::femto>(0)) == SV("0fs"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::pico>(0)) == SV("0ps"));
+  assert(stream_fr_FR_locale<CharT>(0ns) == SV("0ns"));
+#ifndef TEST_HAS_NO_UNICODE
+  assert(stream_fr_FR_locale<CharT>(0us) == SV("0\u00b5s"));
+#else
+  assert(stream_fr_FR_locale<CharT>(0us) == SV("0us"));
+#endif
+  assert(stream_fr_FR_locale<CharT>(0ms) == SV("0ms"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::centi>(0)) == SV("0cs"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::deci>(0)) == SV("0ds"));
+
+  assert(stream_fr_FR_locale<CharT>(0s) == SV("0s"));
+
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::deca>(0)) == SV("0das"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::hecto>(0)) == SV("0hs"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::kilo>(0)) == SV("0ks"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::mega>(0)) == SV("0Ms"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::giga>(0)) == SV("0Gs"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::tera>(0)) == SV("0Ts"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::peta>(0)) == SV("0Ps"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::exa>(0)) == SV("0Es"));
+
+  assert(stream_fr_FR_locale<CharT>(0min) == SV("0min"));
+  assert(stream_fr_FR_locale<CharT>(0h) == SV("0h"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::ratio<86400>>(0)) == SV("0d"));
+
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::ratio<42>>(0)) == SV("0[42]s"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::ratio<33, 3>>(0)) == SV("0[11]s"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::duration<int, std::ratio<11, 9>>(0)) == SV("0[11/9]s"));
+
+  // ja_JP locale
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::atto>(0)) == SV("0as"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::femto>(0)) == SV("0fs"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::pico>(0)) == SV("0ps"));
+  assert(stream_ja_JP_locale<CharT>(0ns) == SV("0ns"));
+#ifndef TEST_HAS_NO_UNICODE
+  assert(stream_ja_JP_locale<CharT>(0us) == SV("0\u00b5s"));
+#else
+  assert(stream_ja_JP_locale<CharT>(0us) == SV("0us"));
+#endif
+  assert(stream_ja_JP_locale<CharT>(0ms) == SV("0ms"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::centi>(0)) == SV("0cs"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::deci>(0)) == SV("0ds"));
+
+  assert(stream_ja_JP_locale<CharT>(0s) == SV("0s"));
+
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::deca>(0)) == SV("0das"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::hecto>(0)) == SV("0hs"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::kilo>(0)) == SV("0ks"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::mega>(0)) == SV("0Ms"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::giga>(0)) == SV("0Gs"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::tera>(0)) == SV("0Ts"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::peta>(0)) == SV("0Ps"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::exa>(0)) == SV("0Es"));
+
+  assert(stream_ja_JP_locale<CharT>(0min) == SV("0min"));
+  assert(stream_ja_JP_locale<CharT>(0h) == SV("0h"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::ratio<86400>>(0)) == SV("0d"));
+
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::ratio<42>>(0)) == SV("0[42]s"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::ratio<33, 3>>(0)) == SV("0[11]s"));
+  assert(stream_ja_JP_locale<CharT>(std::chrono::duration<int, std::ratio<11, 9>>(0)) == SV("0[11/9]s"));
+}
+
+template <class CharT>
+static void test() {
+  test_values<CharT>();
+  test_units<CharT>();
+}
+
+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.hh_mm_ss.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class Rep, class Period, class charT>
+//   struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+  // Non localized output
+  check.template operator()<"{}">(SV("00:00:00.000"), std::chrono::hh_mm_ss{0ms});
+  check.template operator()<"{:*^14}">(SV("*00:00:00.000*"), std::chrono::hh_mm_ss{0ms});
+  check.template operator()<"{:*>13}">(SV("*00:00:00.000"), std::chrono::hh_mm_ss{0ms});
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:"
+                               "%%H='%H'%t"
+                               "%%OH='%OH'%t"
+                               "%%I='%I'%t"
+                               "%%OI='%OI'%t"
+                               "%%M='%M'%t"
+                               "%%OM='%OM'%t"
+                               "%%S='%S'%t"
+                               "%%OS='%OS'%t"
+                               "%%p='%p'%t"
+                               "%%R='%R'%t"
+                               "%%T='%T'%t"
+                               "%%r='%r'%t"
+                               "%%X='%X'%t"
+                               "%%EX='%EX'%t"
+                               "%n}"};
+  constexpr string_literal lfmt{"{:L"
+                                "%%H='%H'%t"
+                                "%%OH='%OH'%t"
+                                "%%I='%I'%t"
+                                "%%OI='%OI'%t"
+                                "%%M='%M'%t"
+                                "%%OM='%OM'%t"
+                                "%%S='%S'%t"
+                                "%%OS='%OS'%t"
+                                "%%p='%p'%t"
+                                "%%R='%R'%t"
+                                "%%T='%T'%t"
+                                "%%r='%r'%t"
+                                "%%X='%X'%t"
+                                "%%EX='%EX'%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.template operator()<fmt>(SV("%H='00'\t"
+                                    "%OH='00'\t"
+                                    "%I='12'\t"
+                                    "%OI='12'\t"
+                                    "%M='00'\t"
+                                    "%OM='00'\t"
+                                    "%S='00'\t"
+                                    "%OS='00'\t"
+                                    "%p='AM'\t"
+                                    "%R='00:00'\t"
+                                    "%T='00:00:00'\t"
+                                    "%r='12:00:00 AM'\t"
+                                    "%X='00:00:00'\t"
+                                    "%EX='00:00:00'\t"
+                                    "\n"),
+                                 std::chrono::hh_mm_ss(0s));
+
+  check.template operator()<fmt>(SV("%H='23'\t"
+                                    "%OH='23'\t"
+                                    "%I='11'\t"
+                                    "%OI='11'\t"
+                                    "%M='31'\t"
+                                    "%OM='31'\t"
+                                    "%S='30.123'\t"
+                                    "%OS='30.123'\t"
+                                    "%p='PM'\t"
+                                    "%R='23:31'\t"
+                                    "%T='23:31:30.123'\t"
+                                    "%r='11:31:30 PM'\t"
+                                    "%X='23:31:30'\t"
+                                    "%EX='23:31:30'\t"
+                                    "\n"),
+                                 std::chrono::hh_mm_ss(23h + 31min + 30s + 123ms));
+
+  check.template operator()<fmt>(
+      SV("-%H='03'\t"
+         "%OH='03'\t"
+         "%I='03'\t"
+         "%OI='03'\t"
+         "%M='02'\t"
+         "%OM='02'\t"
+         "%S='01.123456789012'\t"
+         "%OS='01.123456789012'\t"
+         "%p='AM'\t"
+         "%R='03:02'\t"
+         "%T='03:02:01.123456789012'\t"
+         "%r='03:02:01 AM'\t"
+         "%X='03:02:01'\t"
+         "%EX='03:02:01'\t"
+         "\n"),
+      std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+
+  // The number of fractional seconds is 0 according to the Standard
+  // TODO FMT verify that's really the case.
+  check.template operator()<fmt>(SV("%H='01'\t"
+                                    "%OH='01'\t"
+                                    "%I='01'\t"
+                                    "%OI='01'\t"
+                                    "%M='01'\t"
+                                    "%OM='01'\t"
+                                    "%S='01'\t"
+                                    "%OS='01'\t"
+                                    "%p='AM'\t"
+                                    "%R='01:01'\t"
+                                    "%T='01:01:01'\t"
+                                    "%r='01:01:01 AM'\t"
+                                    "%X='01:01:01'\t"
+                                    "%EX='01:01:01'\t"
+                                    "\n"),
+                                 std::chrono::hh_mm_ss(std::chrono::duration<double>(3661.123456)));
+
+  // TODO FMT What when hours > 23, add a test.
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%H='00'\t"
+                                     "%OH='00'\t"
+                                     "%I='12'\t"
+                                     "%OI='12'\t"
+                                     "%M='00'\t"
+                                     "%OM='00'\t"
+                                     "%S='00'\t"
+                                     "%OS='00'\t"
+                                     "%p=''\t"
+                                     "%R='00:00'\t"
+                                     "%T='00:00:00'\t"
+#ifdef _WIN32
+                                     "%r='00:00:00'\t"
+#else
+                                     "%r='12:00:00 '\t"
+#endif
+                                     "%X='00:00:00'\t"
+                                     "%EX='00:00:00'\t"
+                                     "\n"),
+                                  std::chrono::hh_mm_ss(0s));
+
+  check.template operator()<lfmt>(SV("%H='23'\t"
+                                     "%OH='23'\t"
+                                     "%I='11'\t"
+                                     "%OI='11'\t"
+                                     "%M='31'\t"
+                                     "%OM='31'\t"
+                                     "%S='30,123'\t"
+                                     "%OS='30,123'\t"
+                                     "%p=''\t"
+                                     "%R='23:31'\t"
+                                     "%T='23:31:30,123'\t"
+#ifdef _WIN32
+                                     "%r='23:31:30'\t"
+#else
+                                     "%r='11:31:30 '\t"
+#endif
+                                     "%X='23:31:30'\t"
+                                     "%EX='23:31:30'\t"
+                                     "\n"),
+                                  std::chrono::hh_mm_ss(23h + 31min + 30s + 123ms));
+
+  check.template operator()<lfmt>(
+      SV("-%H='03'\t"
+         "%OH='03'\t"
+         "%I='03'\t"
+         "%OI='03'\t"
+         "%M='02'\t"
+         "%OM='02'\t"
+         "%S='01,123456789012'\t"
+         "%OS='01,123456789012'\t"
+         "%p=''\t"
+         "%R='03:02'\t"
+         "%T='03:02:01,123456789012'\t"
+#ifdef _WIN32
+         "%r='03:02:01'\t"
+#else
+         "%r='03:02:01 '\t"
+#endif
+         "%X='03:02:01'\t"
+         "%EX='03:02:01'\t"
+         "\n"),
+      std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+
+  check.template operator()<lfmt>(SV("%H='01'\t"
+                                     "%OH='01'\t"
+                                     "%I='01'\t"
+                                     "%OI='01'\t"
+                                     "%M='01'\t"
+                                     "%OM='01'\t"
+                                     "%S='01'\t"
+                                     "%OS='01'\t"
+                                     "%p=''\t"
+                                     "%R='01:01'\t"
+                                     "%T='01:01:01'\t"
+#ifdef _WIN32
+                                     "%r='01:01:01'\t"
+#else
+                                     "%r='01:01:01 '\t"
+#endif
+                                     "%X='01:01:01'\t"
+                                     "%EX='01:01:01'\t"
+                                     "\n"),
+                                  std::chrono::hh_mm_ss(std::chrono::duration<double>(3661.123456)));
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='00'\t"
+                                      "%OH='〇'\t"
+                                      "%I='12'\t"
+                                      "%OI='十二'\t"
+                                      "%M='00'\t"
+                                      "%OM='〇'\t"
+                                      "%S='00'\t"
+                                      "%OS='〇'\t"
+                                      "%p='午前'\t"
+                                      "%R='00:00'\t"
+                                      "%T='00:00:00'\t"
+                                      "%r='午前12時00分00秒'\t"
+                                      "%X='00時00分00秒'\t"
+                                      "%EX='00時00分00秒'\t"
+                                      "\n"),
+                                   std::chrono::hh_mm_ss(0s));
+
+  // TODO FMT What should fractions be in alternate display mode?
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='23'\t"
+                                      "%OH='二十三'\t"
+                                      "%I='11'\t"
+                                      "%OI='十一'\t"
+                                      "%M='31'\t"
+                                      "%OM='三十一'\t"
+                                      "%S='30.123'\t"
+                                      "%OS='三十.123'\t"
+                                      "%p='午後'\t"
+                                      "%R='23:31'\t"
+                                      "%T='23:31:30.123'\t"
+                                      "%r='午後11時31分30秒'\t"
+                                      "%X='23時31分30秒'\t"
+                                      "%EX='23時31分30秒'\t"
+                                      "\n"),
+                                   std::chrono::hh_mm_ss(23h + 31min + 30s + 123ms));
+
+  lcheck.template operator()<lfmt>(
+      loc,
+      SV("-%H='03'\t"
+         "%OH='三'\t"
+         "%I='03'\t"
+         "%OI='三'\t"
+         "%M='02'\t"
+         "%OM='二'\t"
+         "%S='01.123456789012'\t"
+         "%OS='一.123456789012'\t"
+         "%p='午前'\t"
+         "%R='03:02'\t"
+         "%T='03:02:01.123456789012'\t"
+         "%r='午前03時02分01秒'\t"
+         "%X='03時02分01秒'\t"
+         "%EX='03時02分01秒'\t"
+         "\n"),
+      std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='01'\t"
+                                      "%OH='一'\t"
+                                      "%I='01'\t"
+                                      "%OI='一'\t"
+                                      "%M='01'\t"
+                                      "%OM='一'\t"
+                                      "%S='01'\t"
+                                      "%OS='一'\t"
+                                      "%p='午前'\t"
+                                      "%R='01:01'\t"
+                                      "%T='01:01:01'\t"
+                                      "%r='午前01時01分01秒'\t"
+                                      "%X='01時01分01秒'\t"
+                                      "%EX='01時01分01秒'\t"
+                                      "\n"),
+                                   std::chrono::hh_mm_ss(std::chrono::duration<double>(3661.123456)));
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_invalid_values() {
+  using namespace std::literals::chrono_literals;
+
+  check_exception("formatting a hour needs a valid value", SV("{:%H"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%OH"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%I"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%OI"), std::chrono::hh_mm_ss{24h});
+  check.template operator()<"{:%M}">(SV("00"), std::chrono::hh_mm_ss{24h});
+  check.template operator()<"{:%OM}">(SV("00"), std::chrono::hh_mm_ss{24h});
+  check.template operator()<"{:%S}">(SV("00"), std::chrono::hh_mm_ss{24h});
+  check.template operator()<"{:%OS}">(SV("00"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%p"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%R"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%T"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%r"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%X"), std::chrono::hh_mm_ss{24h});
+  check_exception("formatting a hour needs a valid value", SV("{:%EX"), std::chrono::hh_mm_ss{24h});
+}
+
+// time of day
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1466r3.html
+//
+//time_of_day is poorly specified. It suffers from an overly complicated
+//specification, and at the same time, insufficient functionality from that
+//specification. Additionally, guidance from the LEWG mailing list indicates
+//significant dissatisfaction with the name of time_of_day and its internal
+//state that changes mode between 24h and 12h time. This note changes the name
+//of time_of_day to hh_mm_ss to bring the semantics away from holding just a
+//time duration since midnight, and more towards holding any duration as an
+//{hours, minutes, seconds, subseconds} data structure. Also the 24h/12h
+//functionality is moved out of this structure and into namespace-scope
+//functions. And finally this change both simplifies the specification while
+//providing more pertinent functionality. However the basic functionality is
+//maintained: hh_mm_ss is an {hours, minutes, seconds, subseconds} structure
+//which easily converts to and from a duration and provides easy formatting.
+//
+// http://eel.is/c++draft/time.format#6
+//
+// However, if a flag refers to a “time of day” (e.g. %H, %I, %p, etc.), then a
+// specialization of duration is interpreted as the time of day elapsed since
+// midnight.
+//
+// if hours > 23 what's %H intended to print? Even more interesting %OH for the
+// Japanese locale
+
+#if 0
+P1466R3 changed the time_of_day to hh_mm_ss, with the rationale
+
+  This note changes the name of time_of_day to hh_mm_ss to bring the semantics
+  away from holding just a time duration since midnight, and more towards
+  holding any duration as an {hours, minutes, seconds, subseconds} data
+  structure.
+
+This change means it's intended that a duration of 25 hours is a valid
+hh_mm_ss. The paper doesn't mention the consequences of this change to the
+output functions for this class.
+
+[time.hms.nonmembers]
+  template<class charT, class traits, class Duration>
+  basic_ostream<charT, traits>&
+  operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms);
+
+  1 Effects: Equivalent to:
+      return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%T}"), hms);
+
+[tab:time.format.spec] defines %T as
+
+  Equivalent to %H:%M:%S.
+
+and %H as
+
+  The hour (24-hour clock) as a decimal number.
+  If the result is a single digit, it is prefixed with 0.
+  The modified command %OH produces the locale's alternative representation.
+
+Based on http://eel.is/c++draft/time.format#6
+
+  If the type being formatted does not contain the information that the format
+  flag needs, an exception of type format_error is thrown.
+
+  [Example 2: A duration does not contain enough information to format as a
+  weekday.  — end example]
+
+  However, if a flag refers to a “time of day” (e.g. %H, %I, %p, etc.), then a
+  specialization of duration is interpreted as the time of day elapsed since
+  midnight.
+
+If hh::mm::ss contains a time with hours > 23 it doesn't contain a 24 hour
+clock time and a hh:mm:ss isn't a duration. This means it should thrown an
+exception. This differs from other output formatters where an invalid value
+prints an error.
+
+#endif
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  // TODO FMT test os << with negative values
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  test_invalid_values<CharT>();
+  check_invalid_types<CharT>({SV("H"), SV("I"), SV("M"), SV("S"), SV("p"), SV("r"), SV("R"), SV("T"), SV("X"), SV("OH"),
+                              SV("OI"), SV("OM"), SV("OS"), SV("EX")},
+                             std::chrono::hh_mm_ss{0ms});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::hh_mm_ss{0ms});
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::hh_mm_ss{0ms});
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+                  std::chrono::hh_mm_ss{0ms});
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::hh_mm_ss{0ms});
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::hh_mm_ss{0ms});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::hh_mm_ss{0ms});
+}
+
+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.day.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::day, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  // Valid day
+  check.template operator()<"{}">(SV("01"), 1d);
+  check.template operator()<"{:*^4}">(SV("*01*"), 1d);
+  check.template operator()<"{:*>3}">(SV("*01"), 1d);
+
+  // Invalid day
+  check.template operator()<"{}">(SV("00 is not a valid day"), 0d);
+  check.template operator()<"{:*^23}">(SV("*00 is not a valid day*"), 0d);
+}
+
+template <class CharT>
+static void test_valid_values() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%d='%d'%t%%Od='%Od'%t%%e='%e'%t%%Oe='%Oe'%n}"};
+  constexpr string_literal lfmt{"{:L%%d='%d'%t%%Od='%Od'%t%%e='%e'%t%%Oe='%Oe'%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.template operator()<fmt>(SV("%d='00'\t%Od='00'\t%e=' 0'\t%Oe=' 0'\n"), 0d);
+  check.template operator()<fmt>(SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"), 1d);
+  check.template operator()<fmt>(SV("%d='31'\t%Od='31'\t%e='31'\t%Oe='31'\n"), 31d);
+  check.template operator()<fmt>(SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%d='00'\t%Od='00'\t%e=' 0'\t%Oe=' 0'\n"), 0d);
+  check.template operator()<lfmt>(SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"), 1d);
+  check.template operator()<lfmt>(SV("%d='31'\t%Od='31'\t%e='31'\t%Oe='31'\n"), 31d);
+  check.template operator()<lfmt>(SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%d='00'\t%Od='〇'\t%e=' 0'\t%Oe='〇'\n"), 0d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='01'\t%Od='一'\t%e=' 1'\t%Oe='一'\n"), 1d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='31'\t%Od='三十一'\t%e='31'\t%Oe='三十一'\n"), 31d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("d"), SV("e"), SV("Od"), SV("Oe")}, 0d);
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), 0d);
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), 0d);
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), 0d);
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), 0d);
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), 0d);
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), 0d);
+}
+
+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.duration.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::day, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  check.template operator()<"{}">(SV("1as"), std::chrono::duration<int, std::atto>(1));
+  check.template operator()<"{}">(SV("1fs"), std::chrono::duration<int, std::femto>(1));
+  check.template operator()<"{}">(SV("1ps"), std::chrono::duration<int, std::pico>(1));
+  check.template operator()<"{}">(SV("1ns"), 1ns);
+#ifndef TEST_HAS_NO_UNICODE
+  check.template operator()<"{}">(SV("1\u00b5s"), 1us);
+#else
+  check.template operator()<"{}">(SV("1us"), 1us);
+#endif
+  check.template operator()<"{}">(SV("1ms"), 1ms);
+  check.template operator()<"{}">(SV("1cs"), std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{}">(SV("1ds"), std::chrono::duration<int, std::deci>(1));
+
+  check.template operator()<"{}">(SV("1s"), 1s);
+
+  check.template operator()<"{}">(SV("1das"), std::chrono::duration<int, std::deca>(1));
+  check.template operator()<"{}">(SV("1hs"), std::chrono::duration<int, std::hecto>(1));
+  check.template operator()<"{}">(SV("1ks"), std::chrono::duration<int, std::kilo>(1));
+  check.template operator()<"{}">(SV("1Ms"), std::chrono::duration<int, std::mega>(1));
+  check.template operator()<"{}">(SV("1Gs"), std::chrono::duration<int, std::giga>(1));
+  check.template operator()<"{}">(SV("1Ts"), std::chrono::duration<int, std::tera>(1));
+  check.template operator()<"{}">(SV("1Ps"), std::chrono::duration<int, std::peta>(1));
+  check.template operator()<"{}">(SV("1Es"), std::chrono::duration<int, std::exa>(1));
+
+  check.template operator()<"{}">(SV("1min"), 1min);
+  check.template operator()<"{}">(SV("1h"), 1h);
+  check.template operator()<"{}">(SV("1d"), std::chrono::duration<int, std::ratio<86400>>(1));
+
+  check.template operator()<"{}">(SV("1[42]s"), std::chrono::duration<int, std::ratio<42>>(1));
+  check.template operator()<"{}">(SV("1[11]s"), std::chrono::duration<int, std::ratio<33, 3>>(1));
+  check.template operator()<"{}">(SV("1[11/9]s"), std::chrono::duration<int, std::ratio<11, 9>>(1));
+}
+
+template <class CharT>
+static void test_valid_positive_integral_values() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt = "{:"
+                                 "%%H='%H'%t"
+                                 "%%OH='%OH'%t"
+                                 "%%I='%I'%t"
+                                 "%%OI='%OI'%t"
+                                 "%%M='%M'%t"
+                                 "%%OM='%OM'%t"
+                                 "%%S='%S'%t"
+                                 "%%OS='%OS'%t"
+                                 "%%p='%p'%t"
+                                 "%%R='%R'%t"
+                                 "%%T='%T'%t"
+                                 "%%r='%r'%t"
+                                 "%%X='%X'%t"
+                                 "%%EX='%EX'%t"
+                                 "%%j='%j'%t"
+                                 "%%Q='%Q'%t"
+                                 "%%q='%q'%t"
+                                 "%n}";
+  constexpr string_literal lfmt = "{:L"
+                                  "%%H='%H'%t"
+                                  "%%OH='%OH'%t"
+                                  "%%I='%I'%t"
+                                  "%%OI='%OI'%t"
+                                  "%%M='%M'%t"
+                                  "%%OM='%OM'%t"
+                                  "%%S='%S'%t"
+                                  "%%OS='%OS'%t"
+                                  "%%p='%p'%t"
+                                  "%%R='%R'%t"
+                                  "%%T='%T'%t"
+                                  "%%r='%r'%t"
+                                  "%%X='%X'%t"
+                                  "%%EX='%EX'%t"
+                                  "%%j='%j'%t"
+                                  "%%Q='%Q'%t"
+                                  "%%q='%q'%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.template operator()<fmt>(SV("%H='00'\t"
+                                    "%OH='00'\t"
+                                    "%I='12'\t"
+                                    "%OI='12'\t"
+                                    "%M='00'\t"
+                                    "%OM='00'\t"
+                                    "%S='00'\t"
+                                    "%OS='00'\t"
+                                    "%p='AM'\t"
+                                    "%R='00:00'\t"
+                                    "%T='00:00:00'\t"
+                                    "%r='12:00:00 AM'\t"
+                                    "%X='00:00:00'\t"
+                                    "%EX='00:00:00'\t"
+                                    "%j='0'\t"
+                                    "%Q='0'\t"
+                                    "%q='s'\t"
+                                    "\n"),
+                                 0s);
+
+  check.template operator()<fmt>(SV("%H='11'\t"
+                                    "%OH='11'\t"
+                                    "%I='11'\t"
+                                    "%OI='11'\t"
+                                    "%M='59'\t"
+                                    "%OM='59'\t"
+                                    "%S='59'\t"
+                                    "%OS='59'\t"
+                                    "%p='AM'\t"
+                                    "%R='11:59'\t"
+                                    "%T='11:59:59'\t"
+                                    "%r='11:59:59 AM'\t"
+                                    "%X='11:59:59'\t"
+                                    "%EX='11:59:59'\t"
+                                    "%j='0'\t"
+                                    "%Q='43199'\t"
+                                    "%q='s'\t"
+                                    "\n"),
+                                 11h + 59min + 59s);
+
+  check.template operator()<fmt>(SV("%H='12'\t"
+                                    "%OH='12'\t"
+                                    "%I='12'\t"
+                                    "%OI='12'\t"
+                                    "%M='00'\t"
+                                    "%OM='00'\t"
+                                    "%S='00'\t"
+                                    "%OS='00'\t"
+                                    "%p='PM'\t"
+                                    "%R='12:00'\t"
+                                    "%T='12:00:00'\t"
+                                    "%r='12:00:00 PM'\t"
+                                    "%X='12:00:00'\t"
+                                    "%EX='12:00:00'\t"
+                                    "%j='0'\t"
+                                    "%Q='12'\t"
+                                    "%q='h'\t"
+                                    "\n"),
+                                 12h);
+
+  check.template operator()<fmt>(SV("%H='23'\t"
+                                    "%OH='23'\t"
+                                    "%I='11'\t"
+                                    "%OI='11'\t"
+                                    "%M='59'\t"
+                                    "%OM='59'\t"
+                                    "%S='59'\t"
+                                    "%OS='59'\t"
+                                    "%p='PM'\t"
+                                    "%R='23:59'\t"
+                                    "%T='23:59:59'\t"
+                                    "%r='11:59:59 PM'\t"
+                                    "%X='23:59:59'\t"
+                                    "%EX='23:59:59'\t"
+                                    "%j='0'\t"
+                                    "%Q='86399'\t"
+                                    "%q='s'\t"
+                                    "\n"),
+                                 23h + 59min + 59s);
+
+  check.template operator()<fmt>(SV("%H='00'\t"
+                                    "%OH='00'\t"
+                                    "%I='12'\t"
+                                    "%OI='12'\t"
+                                    "%M='00'\t"
+                                    "%OM='00'\t"
+                                    "%S='00'\t"
+                                    "%OS='00'\t"
+                                    "%p='AM'\t"
+                                    "%R='00:00'\t"
+                                    "%T='00:00:00'\t"
+                                    "%r='12:00:00 AM'\t"
+                                    "%X='00:00:00'\t"
+                                    "%EX='00:00:00'\t"
+                                    "%j='7'\t"
+                                    "%Q='7'\t"
+                                    "%q='d'\t"
+                                    "\n"),
+                                 std::chrono::duration<int, std::ratio<86400>>(7));
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%H='00'\t"
+                                     "%OH='00'\t"
+                                     "%I='12'\t"
+                                     "%OI='12'\t"
+                                     "%M='00'\t"
+                                     "%OM='00'\t"
+                                     "%S='00'\t"
+                                     "%OS='00'\t"
+                                     "%p=''\t"
+                                     "%R='00:00'\t"
+                                     "%T='00:00:00'\t"
+#ifdef _WIN32
+                                     "%r='12:00:00'\t"
+#else
+                                     "%r='12:00:00 '\t"
+#endif
+                                     "%X='00:00:00'\t"
+                                     "%EX='00:00:00'\t"
+                                     "%j='0'\t"
+                                     "%Q='0'\t"
+                                     "%q='s'\t"
+                                     "\n"),
+                                  0s);
+#if 0
+  if constexpr (std::same_as<CharT, char>)
+    check.template operator()<lfmt>(SV("%H='11'\t"
+                                       "%OH='11'\t"
+                                       "%I='11'\t"
+                                       "%OI='11'\t"
+                                       "%M='59'\t"
+                                       "%OM='59'\t"
+                                       "%S='59'\t"
+                                       "%OS='59'\t"
+                                       "%p=''\t"
+                                       "%R='11:59'\t"
+                                       "%T='11:59:59'\t"
+                                       "%r='11:59:59 '\t"
+                                       "%X='11:59:59'\t"
+                                       "%EX='11:59:59'\t"
+                                       "%j='0'\t"
+                                       "%Q='43 199'\t"
+                                       "%q='s'\t"
+                                       "\n"),
+                                    11h + 59min + 59s);
+  else
+    check.template operator()<lfmt>(SV("%H='11'\t"
+                                       "%OH='11'\t"
+                                       "%I='11'\t"
+                                       "%OI='11'\t"
+                                       "%M='59'\t"
+                                       "%OM='59'\t"
+                                       "%S='59'\t"
+                                       "%OS='59'\t"
+                                       "%p=''\t"
+                                       "%R='11:59'\t"
+                                       "%T='11:59:59'\t"
+                                       "%r='11:59:59 '\t"
+                                       "%X='11:59:59'\t"
+                                       "%EX='11:59:59'\t"
+                                       "%j='0'\t"
+                                       "%Q='43\u202f199'\t"
+                                       "%q='s'\t"
+                                       "\n"),
+                                    11h + 59min + 59s);
+#else
+  check.template operator()<lfmt>(SV("%H='11'\t"
+                                     "%OH='11'\t"
+                                     "%I='11'\t"
+                                     "%OI='11'\t"
+                                     "%M='59'\t"
+                                     "%OM='59'\t"
+                                     "%S='59'\t"
+                                     "%OS='59'\t"
+                                     "%p=''\t"
+                                     "%R='11:59'\t"
+                                     "%T='11:59:59'\t"
+#  ifdef _WIN32
+                                     "%r='11:59:59'\t"
+#  else
+                                     "%r='11:59:59 '\t"
+#  endif
+                                     "%X='11:59:59'\t"
+                                     "%EX='11:59:59'\t"
+                                     "%j='0'\t"
+                                     "%Q='43199'\t"
+                                     "%q='s'\t"
+                                     "\n"),
+                                  11h + 59min + 59s);
+#endif
+
+  check.template operator()<lfmt>(SV("%H='12'\t"
+                                     "%OH='12'\t"
+                                     "%I='12'\t"
+                                     "%OI='12'\t"
+                                     "%M='00'\t"
+                                     "%OM='00'\t"
+                                     "%S='00'\t"
+                                     "%OS='00'\t"
+                                     "%p=''\t"
+                                     "%R='12:00'\t"
+                                     "%T='12:00:00'\t"
+#ifdef _WIN32
+                                     "%r='00:00:00'\t"
+#else
+                                     "%r='12:00:00 '\t"
+#endif
+                                     "%X='12:00:00'\t"
+                                     "%EX='12:00:00'\t"
+                                     "%j='0'\t"
+                                     "%Q='12'\t"
+                                     "%q='h'\t"
+                                     "\n"),
+                                  12h);
+
+#if 0
+  if constexpr (std::same_as<CharT, char>)
+    check.template operator()<lfmt>(SV("%H='23'\t"
+                                       "%OH='23'\t"
+                                       "%I='11'\t"
+                                       "%OI='11'\t"
+                                       "%M='59'\t"
+                                       "%OM='59'\t"
+                                       "%S='59'\t"
+                                       "%OS='59'\t"
+                                       "%p=''\t"
+                                       "%R='23:59'\t"
+                                       "%T='23:59:59'\t"
+                                       "%r='11:59:59 '\t"
+                                       "%X='23:59:59'\t"
+                                       "%EX='23:59:59'\t"
+                                       "%j='0'\t"
+                                       "%Q='86 399'\t"
+                                       "%q='s'\t"
+                                       "\n"),
+                                    23h + 59min + 59s);
+  else
+    check.template operator()<lfmt>(SV("%H='23'\t"
+                                       "%OH='23'\t"
+                                       "%I='11'\t"
+                                       "%OI='11'\t"
+                                       "%M='59'\t"
+                                       "%OM='59'\t"
+                                       "%S='59'\t"
+                                       "%OS='59'\t"
+                                       "%p=''\t"
+                                       "%R='23:59'\t"
+                                       "%T='23:59:59'\t"
+                                       "%r='11:59:59 '\t"
+                                       "%X='23:59:59'\t"
+                                       "%EX='23:59:59'\t"
+                                       "%j='0'\t"
+                                       "%Q='86\u202f399'\t"
+                                       "%q='s'\t"
+                                       "\n"),
+                                    23h + 59min + 59s);
+#else
+  check.template operator()<lfmt>(SV("%H='23'\t"
+                                     "%OH='23'\t"
+                                     "%I='11'\t"
+                                     "%OI='11'\t"
+                                     "%M='59'\t"
+                                     "%OM='59'\t"
+                                     "%S='59'\t"
+                                     "%OS='59'\t"
+                                     "%p=''\t"
+                                     "%R='23:59'\t"
+                                     "%T='23:59:59'\t"
+                                     "%r='11:59:59 '\t"
+                                     "%X='23:59:59'\t"
+                                     "%EX='23:59:59'\t"
+                                     "%j='0'\t"
+                                     "%Q='86399'\t"
+                                     "%q='s'\t"
+                                     "\n"),
+                                  23h + 59min + 59s);
+
+#endif
+
+  check.template operator()<lfmt>(SV("%H='00'\t"
+                                     "%OH='00'\t"
+                                     "%I='12'\t"
+                                     "%OI='12'\t"
+                                     "%M='00'\t"
+                                     "%OM='00'\t"
+                                     "%S='00'\t"
+                                     "%OS='00'\t"
+                                     "%p=''\t"
+                                     "%R='00:00'\t"
+                                     "%T='00:00:00'\t"
+#ifdef _WIN32
+                                     "%r='00:00:00'\t"
+#else
+                                     "%r='12:00:00 '\t"
+#endif
+                                     "%X='00:00:00'\t"
+                                     "%EX='00:00:00'\t"
+                                     "%j='7'\t"
+                                     "%Q='7'\t"
+                                     "%q='d'\t"
+                                     "\n"),
+                                  std::chrono::duration<int, std::ratio<86400>>(7));
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='00'\t"
+                                      "%OH='〇'\t"
+                                      "%I='12'\t"
+                                      "%OI='十二'\t"
+                                      "%M='00'\t"
+                                      "%OM='〇'\t"
+                                      "%S='00'\t"
+                                      "%OS='〇'\t"
+                                      "%p='午前'\t"
+                                      "%R='00:00'\t"
+                                      "%T='00:00:00'\t"
+                                      "%r='午前12時00分00秒'\t"
+                                      "%X='00時00分00秒'\t"
+                                      "%EX='00時00分00秒'\t"
+                                      "%j='0'\t"
+                                      "%Q='0'\t"
+                                      "%q='s'\t"
+                                      "\n"),
+                                   0s);
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='11'\t"
+                                      "%OH='十一'\t"
+                                      "%I='11'\t"
+                                      "%OI='十一'\t"
+                                      "%M='59'\t"
+                                      "%OM='五十九'\t"
+                                      "%S='59'\t"
+                                      "%OS='五十九'\t"
+                                      "%p='午前'\t"
+                                      "%R='11:59'\t"
+                                      "%T='11:59:59'\t"
+                                      "%r='午前11時59分59秒'\t"
+                                      "%X='11時59分59秒'\t"
+                                      "%EX='11時59分59秒'\t"
+                                      "%j='0'\t"
+#if 0
+                                      "%Q='43,199'\t"
+#else
+                                      "%Q='43199'\t"
+#endif
+                                      "%q='s'\t"
+                                      "\n"),
+                                   11h + 59min + 59s);
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='12'\t"
+                                      "%OH='十二'\t"
+                                      "%I='12'\t"
+                                      "%OI='十二'\t"
+                                      "%M='00'\t"
+                                      "%OM='〇'\t"
+                                      "%S='00'\t"
+                                      "%OS='〇'\t"
+                                      "%p='午後'\t"
+                                      "%R='12:00'\t"
+                                      "%T='12:00:00'\t"
+                                      "%r='午後12時00分00秒'\t"
+                                      "%X='12時00分00秒'\t"
+                                      "%EX='12時00分00秒'\t"
+                                      "%j='0'\t"
+                                      "%Q='12'\t"
+                                      "%q='h'\t"
+                                      "\n"),
+                                   12h);
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='23'\t"
+                                      "%OH='二十三'\t"
+                                      "%I='11'\t"
+                                      "%OI='十一'\t"
+                                      "%M='59'\t"
+                                      "%OM='五十九'\t"
+                                      "%S='59'\t"
+                                      "%OS='五十九'\t"
+                                      "%p='午後'\t"
+                                      "%R='23:59'\t"
+                                      "%T='23:59:59'\t"
+                                      "%r='午後11時59分59秒'\t"
+                                      "%X='23時59分59秒'\t"
+                                      "%EX='23時59分59秒'\t"
+                                      "%j='0'\t"
+#if 0
+                                      "%Q='86,399'\t"
+#else
+                                      "%Q='86399'\t"
+#endif
+                                      "%q='s'\t"
+                                      "\n"),
+                                   23h + 59min + 59s);
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='00'\t"
+                                      "%OH='〇'\t"
+                                      "%I='12'\t"
+                                      "%OI='十二'\t"
+                                      "%M='00'\t"
+                                      "%OM='〇'\t"
+                                      "%S='00'\t"
+                                      "%OS='〇'\t"
+                                      "%p='午前'\t"
+                                      "%R='00:00'\t"
+                                      "%T='00:00:00'\t"
+                                      "%r='午前12時00分00秒'\t"
+                                      "%X='00時00分00秒'\t"
+                                      "%EX='00時00分00秒'\t"
+                                      "%j='7'\t"
+                                      "%Q='7'\t"
+                                      "%q='d'\t"
+                                      "\n"),
+                                   std::chrono::duration<int, std::ratio<86400>>(7));
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_negative_integral_values() {
+  // [time.format]/4 The result of formatting a std::chrono::duration instance
+  // holding a negative value, or an hh_mm_ss object h for which
+  // h.is_negative() is true, is equivalent to the output of the corresponding
+  // positive value, with a STATICALLY-WIDEN<charT>("-") character sequence
+  // placed before the replacement of the initial conversion specifier.
+  //
+  // Note in this case %% is the initial conversion specifier.
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt = "{:"
+                                 "%%H='%H'%t"
+                                 "%%OH='%OH'%t"
+                                 "%%I='%I'%t"
+                                 "%%OI='%OI'%t"
+                                 "%%M='%M'%t"
+                                 "%%OM='%OM'%t"
+                                 "%%S='%S'%t"
+                                 "%%OS='%OS'%t"
+                                 "%%p='%p'%t"
+                                 "%%R='%R'%t"
+                                 "%%T='%T'%t"
+                                 "%%r='%r'%t"
+                                 "%%X='%X'%t"
+                                 "%%EX='%EX'%t"
+                                 "%%j='%j'%t"
+                                 "%%Q='%Q'%t"
+                                 "%%q='%q'%t"
+                                 "%n}";
+  constexpr string_literal lfmt = "{:L"
+                                  "%%H='%H'%t"
+                                  "%%OH='%OH'%t"
+                                  "%%I='%I'%t"
+                                  "%%OI='%OI'%t"
+                                  "%%M='%M'%t"
+                                  "%%OM='%OM'%t"
+                                  "%%S='%S'%t"
+                                  "%%OS='%OS'%t"
+                                  "%%p='%p'%t"
+                                  "%%R='%R'%t"
+                                  "%%T='%T'%t"
+                                  "%%r='%r'%t"
+                                  "%%X='%X'%t"
+                                  "%%EX='%EX'%t"
+                                  "%%j='%j'%t"
+                                  "%%Q='%Q'%t"
+                                  "%%q='%q'%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.template operator()<fmt>(SV("-%H='23'\t"
+                                    "%OH='23'\t"
+                                    "%I='11'\t"
+                                    "%OI='11'\t"
+                                    "%M='59'\t"
+                                    "%OM='59'\t"
+                                    "%S='59'\t"
+                                    "%OS='59'\t"
+                                    "%p='PM'\t"
+                                    "%R='23:59'\t"
+                                    "%T='23:59:59'\t"
+                                    "%r='11:59:59 PM'\t"
+                                    "%X='23:59:59'\t"
+                                    "%EX='23:59:59'\t"
+                                    "%j='0'\t"
+                                    "%Q='86399'\t"
+                                    "%q='s'\t"
+                                    "\n"),
+                                 -(23h + 59min + 59s));
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("-%H='23'\t"
+                                     "%OH='23'\t"
+                                     "%I='11'\t"
+                                     "%OI='11'\t"
+                                     "%M='59'\t"
+                                     "%OM='59'\t"
+                                     "%S='59'\t"
+                                     "%OS='59'\t"
+                                     "%p=''\t"
+                                     "%R='23:59'\t"
+                                     "%T='23:59:59'\t"
+                                     "%r='11:59:59 '\t"
+                                     "%X='23:59:59'\t"
+                                     "%EX='23:59:59'\t"
+                                     "%j='0'\t"
+                                     "%Q='86399'\t"
+                                     "%q='s'\t"
+                                     "\n"),
+                                  -(23h + 59min + 59s));
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("-%H='23'\t"
+                                      "%OH='二十三'\t"
+                                      "%I='11'\t"
+                                      "%OI='十一'\t"
+                                      "%M='59'\t"
+                                      "%OM='五十九'\t"
+                                      "%S='59'\t"
+                                      "%OS='五十九'\t"
+                                      "%p='午後'\t"
+                                      "%R='23:59'\t"
+                                      "%T='23:59:59'\t"
+                                      "%r='午後11時59分59秒'\t"
+                                      "%X='23時59分59秒'\t"
+                                      "%EX='23時59分59秒'\t"
+                                      "%j='0'\t"
+                                      "%Q='86399'\t"
+                                      "%q='s'\t"
+                                      "\n"),
+                                   -(23h + 59min + 59s));
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_fractional_values() {
+  using namespace std::literals::chrono_literals;
+
+  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.template operator()<"{:%S}">(SV("00.000000001"), 1ns);
+  check.template operator()<"{:%S}">(SV("00.000000501"), 501ns);
+  check.template operator()<"{:%S}">(SV("00.000001000"), 1000ns);
+  check.template operator()<"{:%S}">(SV("00.000000000001"), std::chrono::duration<int, std::pico>(1));
+  check.template operator()<"{:%S}">(SV("00.000000000000001"), std::chrono::duration<int, std::femto>(1));
+  check.template operator()<"{:%S}">(SV("00.000000000000000001"), std::chrono::duration<int, std::atto>(1));
+
+  check.template operator()<"{:%S}">(SV("00.001"), 1ms);
+  check.template operator()<"{:%S}">(SV("00.01"), std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{:%S}">(SV("00.1"), std::chrono::duration<int, std::deci>(1));
+  check.template operator()<"{:%S}">(SV("01.1"), std::chrono::duration<int, std::deci>(11));
+
+  check.template operator()<"{:%S}">(SV("00.001"), std::chrono::duration<float, std::milli>(1.123456789));
+  check.template operator()<"{:%S}">(SV("00.011"), std::chrono::duration<double, std::milli>(11.123456789));
+  check.template operator()<"{:%S}">(SV("01"), std::chrono::duration<long double>(61.123456789));
+
+  check.template operator()<"{:%OS}">(SV("00.000000001"), 1ns);
+  check.template operator()<"{:%OS}">(SV("00.000000501"), 501ns);
+  check.template operator()<"{:%OS}">(SV("00.000001000"), 1000ns);
+  check.template operator()<"{:%OS}">(SV("00.000000000001"), std::chrono::duration<int, std::pico>(1));
+  check.template operator()<"{:%OS}">(SV("00.000000000000001"), std::chrono::duration<int, std::femto>(1));
+  check.template operator()<"{:%OS}">(SV("00.000000000000000001"), std::chrono::duration<int, std::atto>(1));
+
+  check.template operator()<"{:%OS}">(SV("00.001"), 1ms);
+  check.template operator()<"{:%OS}">(SV("00.01"), std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{:%OS}">(SV("00.1"), std::chrono::duration<int, std::deci>(1));
+  check.template operator()<"{:%OS}">(SV("01.1"), std::chrono::duration<int, std::deci>(11));
+
+  check.template operator()<"{:%OS}">(SV("00.001"), std::chrono::duration<float, std::milli>(1.123456789));
+  check.template operator()<"{:%OS}">(SV("00.011"), std::chrono::duration<double, std::milli>(11.123456789));
+  check.template operator()<"{:%OS}">(SV("01"), std::chrono::duration<long double>(61.123456789));
+
+  check.template operator()<"{:%T}">(SV("01:05:06.000000001"), 1h + 5min + 6s + 1ns);
+  check.template operator()<"{:%T}">(SV("01:05:06.000000501"), 1h + 5min + 6s + 501ns);
+  check.template operator()<"{:%T}">(SV("01:05:06.000001000"), 1h + 5min + 6s + 1000ns);
+
+  check.template operator()<"{:%T}">(SV("01:05:06.001"), 1h + 5min + 6s + 1ms);
+  check.template operator()<"{:%T}">(SV("01:05:06.01"), 1h + 5min + 6s + std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{:%T}">(SV("01:05:06.1"), 1h + 5min + 6s + std::chrono::duration<int, std::deci>(1));
+  check.template operator()<"{:%T}">(SV("01:05:07.1"), 1h + 5min + 6s + std::chrono::duration<int, std::deci>(11));
+
+  check.template operator()<"{:%T}">(SV("00:01:02"), std::chrono::duration<float, std::ratio<60>>(1) +
+                                                         std::chrono::duration<float>(2.5));
+  check.template operator()<"{:%T}">(SV("01:05:11"), std::chrono::duration<double, std::ratio<3600>>(1) +
+                                                         std::chrono::duration<double, std::ratio<60>>(5) +
+                                                         std::chrono::duration<double>(11.123456789));
+  check.template operator()<"{:%T}">(SV("01:06:01"), std::chrono::duration<long double, std::ratio<3600>>(1) +
+                                                         std::chrono::duration<long double, std::ratio<60>>(5) +
+                                                         std::chrono::duration<long double>(61.123456789));
+
+  check.template operator()<"{:%j}">(SV("0"), std::chrono::duration<float, std::milli>(1.));
+  check.template operator()<"{:%j}">(SV("1"), std::chrono::duration<double, std::milli>(86'400'000));
+  check.template operator()<"{:%j}">(SV("1"),
+                                     std::chrono::duration<long double, std::ratio<7 * 24 * 3600>>(0.14285714286));
+
+  check.template operator()<"{:%Q}">(SV("1"), std::chrono::duration<float, std::milli>(1.));
+  check.template operator()<"{:.6%Q}">(SV("1.123456789"), std::chrono::duration<double, std::milli>(1.123456789));
+  check.template operator()<"{:.9%Q}">(SV("1.123456789"), std::chrono::duration<long double, std::milli>(1.123456789));
+
+  // Use the global locale (fr_FR)
+  check.template operator()<"{:L%S}">(SV("00,000000001"), 1ns);
+  check.template operator()<"{:L%S}">(SV("00,000000501"), 501ns);
+  check.template operator()<"{:L%S}">(SV("00,000001000"), 1000ns);
+  check.template operator()<"{:L%S}">(SV("00,000000000001"), std::chrono::duration<int, std::pico>(1));
+  check.template operator()<"{:L%S}">(SV("00,000000000000001"), std::chrono::duration<int, std::femto>(1));
+  check.template operator()<"{:L%S}">(SV("00,000000000000000001"), std::chrono::duration<int, std::atto>(1));
+
+  check.template operator()<"{:L%S}">(SV("00,001"), 1ms);
+  check.template operator()<"{:L%S}">(SV("00,01"), std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{:L%S}">(SV("00,1"), std::chrono::duration<int, std::deci>(1));
+  check.template operator()<"{:L%S}">(SV("01,1"), std::chrono::duration<int, std::deci>(11));
+
+  check.template operator()<"{:L%S}">(SV("00,001"), std::chrono::duration<float, std::milli>(1.123456789));
+  check.template operator()<"{:L%S}">(SV("00,011"), std::chrono::duration<double, std::milli>(11.123456789));
+  check.template operator()<"{:L%S}">(SV("01"), std::chrono::duration<long double>(61.123456789));
+
+  check.template operator()<"{:L%OS}">(SV("00,000000001"), 1ns);
+  check.template operator()<"{:L%OS}">(SV("00,000000501"), 501ns);
+  check.template operator()<"{:L%OS}">(SV("00,000001000"), 1000ns);
+  check.template operator()<"{:L%OS}">(SV("00,000000000001"), std::chrono::duration<int, std::pico>(1));
+  check.template operator()<"{:L%OS}">(SV("00,000000000000001"), std::chrono::duration<int, std::femto>(1));
+  check.template operator()<"{:L%OS}">(SV("00,000000000000000001"), std::chrono::duration<int, std::atto>(1));
+
+  check.template operator()<"{:L%OS}">(SV("00,001"), 1ms);
+  check.template operator()<"{:L%OS}">(SV("00,01"), std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{:L%OS}">(SV("00,1"), std::chrono::duration<int, std::deci>(1));
+  check.template operator()<"{:L%OS}">(SV("01,1"), std::chrono::duration<int, std::deci>(11));
+
+  check.template operator()<"{:L%OS}">(SV("00,001"), std::chrono::duration<float, std::milli>(1.123456789));
+  check.template operator()<"{:L%OS}">(SV("00,011"), std::chrono::duration<double, std::milli>(11.123456789));
+  check.template operator()<"{:L%OS}">(SV("01"), std::chrono::duration<long double>(61.123456789));
+
+  check.template operator()<"{:L%T}">(SV("01:05:06,000000001"), 1h + 5min + 6s + 1ns);
+  check.template operator()<"{:L%T}">(SV("01:05:06,000000501"), 1h + 5min + 6s + 501ns);
+  check.template operator()<"{:L%T}">(SV("01:05:06,000001000"), 1h + 5min + 6s + 1000ns);
+
+  check.template operator()<"{:L%T}">(SV("01:05:06,001"), 1h + 5min + 6s + 1ms);
+  check.template operator()<"{:L%T}">(SV("01:05:06,01"), 1h + 5min + 6s + std::chrono::duration<int, std::centi>(1));
+  check.template operator()<"{:L%T}">(SV("01:05:06,1"), 1h + 5min + 6s + std::chrono::duration<int, std::deci>(1));
+  check.template operator()<"{:L%T}">(SV("01:05:07,1"), 1h + 5min + 6s + std::chrono::duration<int, std::deci>(11));
+
+  check.template operator()<"{:L%T}">(SV("00:01:02"), std::chrono::duration<float, std::ratio<60>>(1) +
+                                                          std::chrono::duration<float>(2.5));
+  check.template operator()<"{:L%T}">(SV("01:05:11"), std::chrono::duration<double, std::ratio<3600>>(1) +
+                                                          std::chrono::duration<double, std::ratio<60>>(5) +
+                                                          std::chrono::duration<double>(11.123456789));
+  check.template operator()<"{:L%T}">(SV("01:06:01"), std::chrono::duration<long double, std::ratio<3600>>(1) +
+                                                          std::chrono::duration<long double, std::ratio<60>>(5) +
+                                                          std::chrono::duration<long double>(61.123456789));
+
+  check.template operator()<"{:L%j}">(SV("0"), std::chrono::duration<float, std::milli>(1.));
+  check.template operator()<"{:L%j}">(SV("1"), std::chrono::duration<double, std::milli>(86'400'000));
+  check.template operator()<"{:L%j}">(SV("1"),
+                                      std::chrono::duration<long double, std::ratio<7 * 24 * 3600>>(0.14285714286));
+
+  check.template operator()<"{:L%Q}">(SV("1"), std::chrono::duration<float, std::milli>(1.));
+  check.template operator()<"{:.6L%Q}">(SV("1.123456789"), std::chrono::duration<double, std::milli>(1.123456789));
+  check.template operator()<"{:.9L%Q}">(SV("1.123456789"), std::chrono::duration<long double, std::milli>(1.123456789));
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.000000001"), 1ns);
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.000000501"), 501ns);
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.000001000"), 1000ns);
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.000000000001"), std::chrono::duration<int, std::pico>(1));
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.000000000000001"), std::chrono::duration<int, std::femto>(1));
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.000000000000000001"), std::chrono::duration<int, std::atto>(1));
+
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.001"), 1ms);
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.01"), std::chrono::duration<int, std::centi>(1));
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.1"), std::chrono::duration<int, std::deci>(1));
+  lcheck.template operator()<"{:L%S}">(loc, SV("01.1"), std::chrono::duration<int, std::deci>(11));
+
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.001"), std::chrono::duration<float, std::milli>(1.123456789));
+  lcheck.template operator()<"{:L%S}">(loc, SV("00.011"), std::chrono::duration<double, std::milli>(11.123456789));
+  lcheck.template operator()<"{:L%S}">(loc, SV("01"), std::chrono::duration<long double>(61.123456789));
+
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.000000001"), 1ns);
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.000000501"), 501ns);
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.000001000"), 1000ns);
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.000000000001"), std::chrono::duration<int, std::pico>(1));
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.000000000000001"), std::chrono::duration<int, std::femto>(1));
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.000000000000000001"), std::chrono::duration<int, std::atto>(1));
+
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.001"), 1ms);
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.01"), std::chrono::duration<int, std::centi>(1));
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.1"), std::chrono::duration<int, std::deci>(1));
+  lcheck.template operator()<"{:L%OS}">(loc, SV("一.1"), std::chrono::duration<int, std::deci>(11));
+
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.001"), std::chrono::duration<float, std::milli>(1.123456789));
+  lcheck.template operator()<"{:L%OS}">(loc, SV("〇.011"), std::chrono::duration<double, std::milli>(11.123456789));
+  lcheck.template operator()<"{:L%OS}">(loc, SV("一"), std::chrono::duration<long double>(61.123456789));
+
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:06.000000001"), 1h + 5min + 6s + 1ns);
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:06.000000501"), 1h + 5min + 6s + 501ns);
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:06.000001000"), 1h + 5min + 6s + 1000ns);
+
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:06.001"), 1h + 5min + 6s + 1ms);
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:06.01"),
+                                       1h + 5min + 6s + std::chrono::duration<int, std::centi>(1));
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:06.1"),
+                                       1h + 5min + 6s + std::chrono::duration<int, std::deci>(1));
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:07.1"),
+                                       1h + 5min + 6s + std::chrono::duration<int, std::deci>(11));
+
+  lcheck.template operator()<"{:L%T}">(
+      loc, SV("00:01:02"), std::chrono::duration<float, std::ratio<60>>(1) + std::chrono::duration<float>(2.5));
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:05:11"),
+                                       std::chrono::duration<double, std::ratio<3600>>(1) +
+                                           std::chrono::duration<double, std::ratio<60>>(5) +
+                                           std::chrono::duration<double>(11.123456789));
+  lcheck.template operator()<"{:L%T}">(loc, SV("01:06:01"),
+                                       std::chrono::duration<long double, std::ratio<3600>>(1) +
+                                           std::chrono::duration<long double, std::ratio<60>>(5) +
+                                           std::chrono::duration<long double>(61.123456789));
+
+  lcheck.template operator()<"{:L%j}">(loc, SV("0"), std::chrono::duration<float, std::milli>(1.));
+  lcheck.template operator()<"{:L%j}">(loc, SV("1"), std::chrono::duration<double, std::milli>(86'400'000));
+  lcheck.template operator()<"{:L%j}">(loc, SV("1"),
+                                       std::chrono::duration<long double, std::ratio<7 * 24 * 3600>>(0.14285714286));
+
+  lcheck.template operator()<"{:L%Q}">(loc, SV("1"), std::chrono::duration<float, std::milli>(1.));
+  lcheck.template operator()<"{:.6L%Q}">(loc, SV("1.123456789"),
+                                         std::chrono::duration<double, std::milli>(1.123456789));
+  lcheck.template operator()<"{:.9L%Q}">(loc, SV("1.123456789"),
+                                         std::chrono::duration<long double, std::milli>(1.123456789));
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values() {
+  test_valid_positive_integral_values<CharT>();
+  test_valid_negative_integral_values<CharT>();
+  test_valid_fractional_values<CharT>();
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("H"), SV("I"),  SV("j"),  SV("M"),  SV("n"),  SV("O"), SV("p"),
+                              SV("q"), SV("Q"),  SV("r"),  SV("R"),  SV("S"),  SV("t"), SV("T"),
+                              SV("X"), SV("EX"), SV("OH"), SV("OI"), SV("OM"), SV("OS")},
+                             0ms);
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), 0ms);
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), 0ms);
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), 0ms);
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), 0ms);
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), 0ms);
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), 0ms);
+}
+
+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.month.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::month, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid month
+  check.template operator()<"{}">(SV("Jan"), std::chrono::month{1});
+  check.template operator()<"{:*^5}">(SV("*Jan*"), std::chrono::month{1});
+  check.template operator()<"{:*>4}">(SV("*Jan"), std::chrono::month{1});
+
+  // Invalid month
+  check.template operator()<"{}">(SV("0 is not a valid month"), std::chrono::month{0});
+  check.template operator()<"{:*^24}">(SV("*0 is not a valid month*"), std::chrono::month{0});
+}
+
+template <class CharT>
+static void test_valid_values() {
+  // Test that %b, %h, and %B throw an exception.
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"), std::chrono::month{200});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"), std::chrono::month{13});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"), std::chrono::month{255});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"), std::chrono::month{0});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"), std::chrono::month{13});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"), std::chrono::month{255});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"), std::chrono::month{0});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"), std::chrono::month{13});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"), std::chrono::month{255});
+
+  constexpr string_literal fmt{"{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}"};
+  constexpr string_literal lfmt{"{:L%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%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.template operator()<fmt>(SV("%b='Jan'\t%B='January'\t%h='Jan'\t%m='01'\t%Om='01'\n"), std::chrono::January);
+  check.template operator()<fmt>(SV("%b='Feb'\t%B='February'\t%h='Feb'\t%m='02'\t%Om='02'\n"), std::chrono::February);
+  check.template operator()<fmt>(SV("%b='Mar'\t%B='March'\t%h='Mar'\t%m='03'\t%Om='03'\n"), std::chrono::March);
+  check.template operator()<fmt>(SV("%b='Apr'\t%B='April'\t%h='Apr'\t%m='04'\t%Om='04'\n"), std::chrono::April);
+  check.template operator()<fmt>(SV("%b='May'\t%B='May'\t%h='May'\t%m='05'\t%Om='05'\n"), std::chrono::May);
+  check.template operator()<fmt>(SV("%b='Jun'\t%B='June'\t%h='Jun'\t%m='06'\t%Om='06'\n"), std::chrono::June);
+  check.template operator()<fmt>(SV("%b='Jul'\t%B='July'\t%h='Jul'\t%m='07'\t%Om='07'\n"), std::chrono::July);
+  check.template operator()<fmt>(SV("%b='Aug'\t%B='August'\t%h='Aug'\t%m='08'\t%Om='08'\n"), std::chrono::August);
+  check.template operator()<fmt>(SV("%b='Sep'\t%B='September'\t%h='Sep'\t%m='09'\t%Om='09'\n"), std::chrono::September);
+  check.template operator()<fmt>(SV("%b='Oct'\t%B='October'\t%h='Oct'\t%m='10'\t%Om='10'\n"), std::chrono::October);
+  check.template operator()<fmt>(SV("%b='Nov'\t%B='November'\t%h='Nov'\t%m='11'\t%Om='11'\n"), std::chrono::November);
+  check.template operator()<fmt>(SV("%b='Dec'\t%B='December'\t%h='Dec'\t%m='12'\t%Om='12'\n"), std::chrono::December);
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%b='janv.'\t%B='janvier'\t%h='janv.'\t%m='01'\t%Om='01'\n"),
+                                  std::chrono::January);
+  check.template operator()<lfmt>(SV("%b='févr.'\t%B='février'\t%h='févr.'\t%m='02'\t%Om='02'\n"),
+                                  std::chrono::February);
+  check.template operator()<lfmt>(SV("%b='mars'\t%B='mars'\t%h='mars'\t%m='03'\t%Om='03'\n"), std::chrono::March);
+#ifdef _WIN32
+  check.template operator()<lfmt>(SV("%b='avr.'\t%B='avril'\t%h='avr.'\t%m='04'\t%Om='04'\n"), std::chrono::April);
+#else
+  check.template operator()<lfmt>(SV("%b='avril'\t%B='avril'\t%h='avril'\t%m='04'\t%Om='04'\n"), std::chrono::April);
+#endif
+  check.template operator()<lfmt>(SV("%b='mai'\t%B='mai'\t%h='mai'\t%m='05'\t%Om='05'\n"), std::chrono::May);
+  check.template operator()<lfmt>(SV("%b='juin'\t%B='juin'\t%h='juin'\t%m='06'\t%Om='06'\n"), std::chrono::June);
+  check.template operator()<lfmt>(SV("%b='juil.'\t%B='juillet'\t%h='juil.'\t%m='07'\t%Om='07'\n"), std::chrono::July);
+  check.template operator()<lfmt>(SV("%b='août'\t%B='août'\t%h='août'\t%m='08'\t%Om='08'\n"), std::chrono::August);
+  check.template operator()<lfmt>(SV("%b='sept.'\t%B='septembre'\t%h='sept.'\t%m='09'\t%Om='09'\n"),
+                                  std::chrono::September);
+  check.template operator()<lfmt>(SV("%b='oct.'\t%B='octobre'\t%h='oct.'\t%m='10'\t%Om='10'\n"), std::chrono::October);
+  check.template operator()<lfmt>(SV("%b='nov.'\t%B='novembre'\t%h='nov.'\t%m='11'\t%Om='11'\n"),
+                                  std::chrono::November);
+  check.template operator()<lfmt>(SV("%b='déc.'\t%B='décembre'\t%h='déc.'\t%m='12'\t%Om='12'\n"),
+                                  std::chrono::December);
+
+  // Use supplied locale (ja_JP)
+#ifdef _WIN32
+  lcheck.template operator()<lfmt>(loc, SV("%b='1'\t%B='1月'\t%h='1'\t%m='01'\t%Om='01'\n"), std::chrono::January);
+  lcheck.template operator()<lfmt>(loc, SV("%b='2'\t%B='2月'\t%h='2'\t%m='02'\t%Om='02'\n"), std::chrono::February);
+  lcheck.template operator()<lfmt>(loc, SV("%b='3'\t%B='3月'\t%h='3'\t%m='03'\t%Om='03'\n"), std::chrono::March);
+  lcheck.template operator()<lfmt>(loc, SV("%b='4'\t%B='4月'\t%h='4'\t%m='04'\t%Om='04'\n"), std::chrono::April);
+  lcheck.template operator()<lfmt>(loc, SV("%b='5'\t%B='5月'\t%h='5'\t%m='05'\t%Om='05'\n"), std::chrono::May);
+  lcheck.template operator()<lfmt>(loc, SV("%b='6'\t%B='6月'\t%h='6'\t%m='06'\t%Om='06'\n"), std::chrono::June);
+  lcheck.template operator()<lfmt>(loc, SV("%b='7'\t%B='7月'\t%h='7'\t%m='07'\t%Om='07'\n"), std::chrono::July);
+  lcheck.template operator()<lfmt>(loc, SV("%b='8'\t%B='8月'\t%h='8'\t%m='08'\t%Om='08'\n"), std::chrono::August);
+  lcheck.template operator()<lfmt>(loc, SV("%b='9'\t%B='9月'\t%h='9'\t%m='09'\t%Om='09'\n"), std::chrono::September);
+  lcheck.template operator()<lfmt>(loc, SV("%b='10'\t%B='10月'\t%h='10'\t%m='10'\t%Om='10'\n"), std::chrono::October);
+  lcheck.template operator()<lfmt>(loc, SV("%b='11'\t%B='11月'\t%h='11'\t%m='11'\t%Om='11'\n"), std::chrono::November);
+  lcheck.template operator()<lfmt>(loc, SV("%b='12'\t%B='12月'\t%h='12'\t%m='12'\t%Om='12'\n"), std::chrono::December);
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 1月'\t%B='1月'\t%h=' 1月'\t%m='01'\t%Om='一'\n"),
+                                   std::chrono::January);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 2月'\t%B='2月'\t%h=' 2月'\t%m='02'\t%Om='二'\n"),
+                                   std::chrono::February);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 3月'\t%B='3月'\t%h=' 3月'\t%m='03'\t%Om='三'\n"), std::chrono::March);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 4月'\t%B='4月'\t%h=' 4月'\t%m='04'\t%Om='四'\n"), std::chrono::April);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 5月'\t%B='5月'\t%h=' 5月'\t%m='05'\t%Om='五'\n"), std::chrono::May);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 6月'\t%B='6月'\t%h=' 6月'\t%m='06'\t%Om='六'\n"), std::chrono::June);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 7月'\t%B='7月'\t%h=' 7月'\t%m='07'\t%Om='七'\n"), std::chrono::July);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 8月'\t%B='8月'\t%h=' 8月'\t%m='08'\t%Om='八'\n"), std::chrono::August);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 9月'\t%B='9月'\t%h=' 9月'\t%m='09'\t%Om='九'\n"),
+                                   std::chrono::September);
+  lcheck.template operator()<lfmt>(loc, SV("%b='10月'\t%B='10月'\t%h='10月'\t%m='10'\t%Om='十'\n"),
+                                   std::chrono::October);
+  lcheck.template operator()<lfmt>(loc, SV("%b='11月'\t%B='11月'\t%h='11月'\t%m='11'\t%Om='十一'\n"),
+                                   std::chrono::November);
+  lcheck.template operator()<lfmt>(loc, SV("%b='12月'\t%B='12月'\t%h='12月'\t%m='12'\t%Om='十二'\n"),
+                                   std::chrono::December);
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("b"), SV("B"), SV("h"), SV("m"), SV("Om")}, std::chrono::January);
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::January);
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::January);
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), std::chrono::January);
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::January);
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::January);
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::January);
+}
+
+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.month_day.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::month_day, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid month "valid" day
+  // TODO FMT month_day has an 'ok' flag but it's ignored/
+  check.template operator()<"{}">(SV("Feb/31"), std::chrono::month_day{std::chrono::month{2}, std::chrono::day{31}});
+  check.template operator()<"{:*^8}">(SV("*Feb/31*"),
+                                      std::chrono::month_day{std::chrono::month{2}, std::chrono::day{31}});
+  check.template operator()<"{:*>7}">(SV("*Feb/31"),
+                                      std::chrono::month_day{std::chrono::month{2}, std::chrono::day{31}});
+
+  // Invalid month "valid" day
+  check.template operator()<"{}">(SV("0 is not a valid month/31"),
+                                  std::chrono::month_day{std::chrono::month{0}, std::chrono::day{31}});
+  check.template operator()<"{:*^27}">(SV("*0 is not a valid month/31*"),
+                                       std::chrono::month_day{std::chrono::month{0}, std::chrono::day{31}});
+
+  // Valid month invalid day
+  check.template operator()<"{}">(SV("Feb/32 is not a valid day"),
+                                  std::chrono::month_day{std::chrono::month{2}, std::chrono::day{32}});
+  check.template operator()<"{:*^27}">(SV("*Feb/32 is not a valid day*"),
+                                       std::chrono::month_day{std::chrono::month{2}, std::chrono::day{32}});
+  check.template operator()<"{:*>26}">(SV("*Feb/32 is not a valid day"),
+                                       std::chrono::month_day{std::chrono::month{2}, std::chrono::day{32}});
+
+  // Invalid month invalid day
+  check.template operator()<"{}">(SV("0 is not a valid month/32 is not a valid day"),
+                                  std::chrono::month_day{std::chrono::month{0}, std::chrono::day{32}});
+  check.template operator()<"{:*^46}">(SV("*0 is not a valid month/32 is not a valid day*"),
+                                       std::chrono::month_day{std::chrono::month{0}, std::chrono::day{32}});
+}
+
+template <class CharT>
+static void test_valid_values() {
+  // Test that %b, %h, and %B throw an exception.
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::month_day{std::chrono::month{200}, std::chrono::day{31}});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::month_day{std::chrono::month{13}, std::chrono::day{31}});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::month_day{std::chrono::month{255}, std::chrono::day{31}});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::month_day{std::chrono::month{0}, std::chrono::day{31}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::month_day{std::chrono::month{13}, std::chrono::day{31}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::month_day{std::chrono::month{255}, std::chrono::day{31}});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::month_day{std::chrono::month{0}, std::chrono::day{31}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::month_day{std::chrono::month{13}, std::chrono::day{31}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::month_day{std::chrono::month{255}, std::chrono::day{31}});
+
+  constexpr string_literal fmt{
+      "{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%t%%d='%d'%t%%e='%e'%t%%Od='%Od'%t%%Oe='%Oe'%n}"};
+  constexpr string_literal lfmt{
+      "{:L%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%t%%d='%d'%t%%e='%e'%t%%Od='%Od'%t%%Oe='%Oe'%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.template operator()<fmt>(
+      SV("%b='Jan'\t%B='January'\t%h='Jan'\t%m='01'\t%Om='01'\t%d='00'\t%e=' 0'\t%Od='00'\t%Oe=' 0'\n"),
+      std::chrono::month_day{std::chrono::January, std::chrono::day{0}});
+  check.template operator()<fmt>(
+      SV("%b='Feb'\t%B='February'\t%h='Feb'\t%m='02'\t%Om='02'\t%d='01'\t%e=' 1'\t%Od='01'\t%Oe=' 1'\n"),
+      std::chrono::month_day{std::chrono::February, std::chrono::day{1}});
+  check.template operator()<fmt>(
+      SV("%b='Mar'\t%B='March'\t%h='Mar'\t%m='03'\t%Om='03'\t%d='09'\t%e=' 9'\t%Od='09'\t%Oe=' 9'\n"),
+      std::chrono::month_day{std::chrono::March, std::chrono::day{9}});
+  check.template operator()<fmt>(
+      SV("%b='Apr'\t%B='April'\t%h='Apr'\t%m='04'\t%Om='04'\t%d='10'\t%e='10'\t%Od='10'\t%Oe='10'\n"),
+      std::chrono::month_day{std::chrono::April, std::chrono::day{10}});
+  check.template operator()<fmt>(
+      SV("%b='May'\t%B='May'\t%h='May'\t%m='05'\t%Om='05'\t%d='28'\t%e='28'\t%Od='28'\t%Oe='28'\n"),
+      std::chrono::month_day{std::chrono::May, std::chrono::day{28}});
+  check.template operator()<fmt>(
+      SV("%b='Jun'\t%B='June'\t%h='Jun'\t%m='06'\t%Om='06'\t%d='29'\t%e='29'\t%Od='29'\t%Oe='29'\n"),
+      std::chrono::month_day{std::chrono::June, std::chrono::day{29}});
+  check.template operator()<fmt>(
+      SV("%b='Jul'\t%B='July'\t%h='Jul'\t%m='07'\t%Om='07'\t%d='30'\t%e='30'\t%Od='30'\t%Oe='30'\n"),
+      std::chrono::month_day{std::chrono::July, std::chrono::day{30}});
+  check.template operator()<fmt>(
+      SV("%b='Aug'\t%B='August'\t%h='Aug'\t%m='08'\t%Om='08'\t%d='31'\t%e='31'\t%Od='31'\t%Oe='31'\n"),
+      std::chrono::month_day{std::chrono::August, std::chrono::day{31}});
+  check.template operator()<fmt>(
+      SV("%b='Sep'\t%B='September'\t%h='Sep'\t%m='09'\t%Om='09'\t%d='32'\t%e='32'\t%Od='32'\t%Oe='32'\n"),
+      std::chrono::month_day{std::chrono::September, std::chrono::day{32}});
+  check.template operator()<fmt>(
+      SV("%b='Oct'\t%B='October'\t%h='Oct'\t%m='10'\t%Om='10'\t%d='99'\t%e='99'\t%Od='99'\t%Oe='99'\n"),
+      std::chrono::month_day{std::chrono::October, std::chrono::day{99}});
+  check.template operator()<fmt>(
+      SV("%b='Nov'\t%B='November'\t%h='Nov'\t%m='11'\t%Om='11'\t%d='100'\t%e='100'\t%Od='100'\t%Oe='100'\n"),
+      std::chrono::month_day{std::chrono::November, std::chrono::day{100}});
+  check.template operator()<fmt>(
+      SV("%b='Dec'\t%B='December'\t%h='Dec'\t%m='12'\t%Om='12'\t%d='255'\t%e='255'\t%Od='255'\t%Oe='255'\n"),
+      std::chrono::month_day{std::chrono::December, std::chrono::day{255}});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(
+      SV("%b='janv.'\t%B='janvier'\t%h='janv.'\t%m='01'\t%Om='01'\t%d='00'\t%e=' 0'\t%Od='00'\t%Oe=' 0'\n"),
+      std::chrono::month_day{std::chrono::January, std::chrono::day{0}});
+  check.template operator()<lfmt>(
+      SV("%b='févr.'\t%B='février'\t%h='févr.'\t%m='02'\t%Om='02'\t%d='01'\t%e=' 1'\t%Od='01'\t%Oe=' 1'\n"),
+      std::chrono::month_day{std::chrono::February, std::chrono::day{1}});
+  check.template operator()<lfmt>(
+      SV("%b='mars'\t%B='mars'\t%h='mars'\t%m='03'\t%Om='03'\t%d='09'\t%e=' 9'\t%Od='09'\t%Oe=' 9'\n"),
+      std::chrono::month_day{std::chrono::March, std::chrono::day{9}});
+  check.template operator()<lfmt>(
+#ifdef _WIN32
+      SV("%b='avr.'\t%B='avril'\t%h='avr.'\t%m='04'\t%Om='04'\t%d='10'\t%e='10'\t%Od='10'\t%Oe='10'\n"),
+#else
+      SV("%b='avril'\t%B='avril'\t%h='avril'\t%m='04'\t%Om='04'\t%d='10'\t%e='10'\t%Od='10'\t%Oe='10'\n"),
+#endif
+      std::chrono::month_day{std::chrono::April, std::chrono::day{10}});
+  check.template operator()<lfmt>(
+      SV("%b='mai'\t%B='mai'\t%h='mai'\t%m='05'\t%Om='05'\t%d='28'\t%e='28'\t%Od='28'\t%Oe='28'\n"),
+      std::chrono::month_day{std::chrono::May, std::chrono::day{28}});
+  check.template operator()<lfmt>(
+      SV("%b='juin'\t%B='juin'\t%h='juin'\t%m='06'\t%Om='06'\t%d='29'\t%e='29'\t%Od='29'\t%Oe='29'\n"),
+      std::chrono::month_day{std::chrono::June, std::chrono::day{29}});
+  check.template operator()<lfmt>(
+      SV("%b='juil.'\t%B='juillet'\t%h='juil.'\t%m='07'\t%Om='07'\t%d='30'\t%e='30'\t%Od='30'\t%Oe='30'\n"),
+      std::chrono::month_day{std::chrono::July, std::chrono::day{30}});
+  check.template operator()<lfmt>(
+      SV("%b='août'\t%B='août'\t%h='août'\t%m='08'\t%Om='08'\t%d='31'\t%e='31'\t%Od='31'\t%Oe='31'\n"),
+      std::chrono::month_day{std::chrono::August, std::chrono::day{31}});
+  check.template operator()<lfmt>(
+      SV("%b='sept.'\t%B='septembre'\t%h='sept.'\t%m='09'\t%Om='09'\t%d='32'\t%e='32'\t%Od='32'\t%Oe='32'\n"),
+      std::chrono::month_day{std::chrono::September, std::chrono::day{32}});
+  check.template operator()<lfmt>(
+      SV("%b='oct.'\t%B='octobre'\t%h='oct.'\t%m='10'\t%Om='10'\t%d='99'\t%e='99'\t%Od='99'\t%Oe='99'\n"),
+      std::chrono::month_day{std::chrono::October, std::chrono::day{99}});
+  check.template operator()<lfmt>(
+      SV("%b='nov.'\t%B='novembre'\t%h='nov.'\t%m='11'\t%Om='11'\t%d='100'\t%e='100'\t%Od='100'\t%Oe='100'\n"),
+      std::chrono::month_day{std::chrono::November, std::chrono::day{100}});
+  check.template operator()<lfmt>(
+      SV("%b='déc.'\t%B='décembre'\t%h='déc.'\t%m='12'\t%Om='12'\t%d='255'\t%e='255'\t%Od='255'\t%Oe='255'\n"),
+      std::chrono::month_day{std::chrono::December, std::chrono::day{255}});
+
+  // Use supplied locale (ja_JP)
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 1月'\t%B='1月'\t%h=' 1月'\t%m='01'\t%Om='一'\t%d='00'\t%e=' 0'\t%Od='〇'\t%Oe='〇'\n"),
+      std::chrono::month_day{std::chrono::January, std::chrono::day{0}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 2月'\t%B='2月'\t%h=' 2月'\t%m='02'\t%Om='二'\t%d='01'\t%e=' 1'\t%Od='一'\t%Oe='一'\n"),
+      std::chrono::month_day{std::chrono::February, std::chrono::day{1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 3月'\t%B='3月'\t%h=' 3月'\t%m='03'\t%Om='三'\t%d='09'\t%e=' 9'\t%Od='九'\t%Oe='九'\n"),
+      std::chrono::month_day{std::chrono::March, std::chrono::day{9}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 4月'\t%B='4月'\t%h=' 4月'\t%m='04'\t%Om='四'\t%d='10'\t%e='10'\t%Od='十'\t%Oe='十'\n"),
+      std::chrono::month_day{std::chrono::April, std::chrono::day{10}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 5月'\t%B='5月'\t%h=' 5月'\t%m='05'\t%Om='五'\t%d='28'\t%e='28'\t%Od='二十八'\t%Oe='二十八'\n"),
+      std::chrono::month_day{std::chrono::May, std::chrono::day{28}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 6月'\t%B='6月'\t%h=' 6月'\t%m='06'\t%Om='六'\t%d='29'\t%e='29'\t%Od='二十九'\t%Oe='二十九'\n"),
+      std::chrono::month_day{std::chrono::June, std::chrono::day{29}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 7月'\t%B='7月'\t%h=' 7月'\t%m='07'\t%Om='七'\t%d='30'\t%e='30'\t%Od='三十'\t%Oe='三十'\n"),
+      std::chrono::month_day{std::chrono::July, std::chrono::day{30}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 8月'\t%B='8月'\t%h=' 8月'\t%m='08'\t%Om='八'\t%d='31'\t%e='31'\t%Od='三十一'\t%Oe='三十一'\n"),
+      std::chrono::month_day{std::chrono::August, std::chrono::day{31}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 9月'\t%B='9月'\t%h=' 9月'\t%m='09'\t%Om='九'\t%d='32'\t%e='32'\t%Od='三十二'\t%Oe='三十二'\n"),
+      std::chrono::month_day{std::chrono::September, std::chrono::day{32}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='10月'\t%B='10月'\t%h='10月'\t%m='10'\t%Om='十'\t%d='99'\t%e='99'\t%Od='九十九'\t%Oe='九十九'\n"),
+      std::chrono::month_day{std::chrono::October, std::chrono::day{99}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='11月'\t%B='11月'\t%h='11月'\t%m='11'\t%Om='十一'\t%d='100'\t%e='100'\t%Od='100'\t%Oe='100'\n"),
+      std::chrono::month_day{std::chrono::November, std::chrono::day{100}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='12月'\t%B='12月'\t%h='12月'\t%m='12'\t%Om='十二'\t%d='255'\t%e='255'\t%Od='255'\t%Oe='255'\n"),
+      std::chrono::month_day{std::chrono::December, std::chrono::day{255}});
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("b"), SV("B"), SV("d"), SV("e"), SV("h"), SV("m"), SV("Od"), SV("Oe"), SV("Om")},
+                             std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"),
+                  std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"),
+                  std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+                  std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+  check_exception("End of input while parsing the modifier E", SV("{:%E"),
+                  std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+  check_exception("End of input while parsing the modifier O", SV("{:%O"),
+                  std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"),
+                  std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
+}
+
+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.month_day_last.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::month_day_last, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid month
+  check.template operator()<"{}">(SV("Jan[last]"), std::chrono::month_day_last{std::chrono::month{1}});
+  check.template operator()<"{:*^11}">(SV("*Jan[last]*"), std::chrono::month_day_last{std::chrono::month{1}});
+  check.template operator()<"{:*>10}">(SV("*Jan[last]"), std::chrono::month_day_last{std::chrono::month{1}});
+
+  // Invalid month
+  check.template operator()<"{}">(SV("0 is not a valid month[last]"),
+                                  std::chrono::month_day_last{std::chrono::month{0}});
+  check.template operator()<"{:*^30}">(SV("*0 is not a valid month[last]*"),
+                                       std::chrono::month_day_last{std::chrono::month{0}});
+}
+
+template <class CharT>
+static void test_valid_values() {
+  // Test that %b, %h, and %B throw an exception.
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::month_day_last{std::chrono::month{200}});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::month_day_last{std::chrono::month{13}});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::month_day_last{std::chrono::month{255}});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::month_day_last{std::chrono::month{0}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::month_day_last{std::chrono::month{13}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::month_day_last{std::chrono::month{255}});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::month_day_last{std::chrono::month{0}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::month_day_last{std::chrono::month{13}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::month_day_last{std::chrono::month{255}});
+
+  constexpr string_literal fmt{"{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}"};
+  constexpr string_literal lfmt{"{:L%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%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.template operator()<fmt>(SV("%b='Jan'\t%B='January'\t%h='Jan'\t%m='01'\t%Om='01'\n"),
+                                 std::chrono::month_day_last{std::chrono::January});
+  check.template operator()<fmt>(SV("%b='Feb'\t%B='February'\t%h='Feb'\t%m='02'\t%Om='02'\n"),
+                                 std::chrono::month_day_last{std::chrono::February});
+  check.template operator()<fmt>(SV("%b='Mar'\t%B='March'\t%h='Mar'\t%m='03'\t%Om='03'\n"),
+                                 std::chrono::month_day_last{std::chrono::March});
+  check.template operator()<fmt>(SV("%b='Apr'\t%B='April'\t%h='Apr'\t%m='04'\t%Om='04'\n"),
+                                 std::chrono::month_day_last{std::chrono::April});
+  check.template operator()<fmt>(SV("%b='May'\t%B='May'\t%h='May'\t%m='05'\t%Om='05'\n"),
+                                 std::chrono::month_day_last{std::chrono::May});
+  check.template operator()<fmt>(SV("%b='Jun'\t%B='June'\t%h='Jun'\t%m='06'\t%Om='06'\n"),
+                                 std::chrono::month_day_last{std::chrono::June});
+  check.template operator()<fmt>(SV("%b='Jul'\t%B='July'\t%h='Jul'\t%m='07'\t%Om='07'\n"),
+                                 std::chrono::month_day_last{std::chrono::July});
+  check.template operator()<fmt>(SV("%b='Aug'\t%B='August'\t%h='Aug'\t%m='08'\t%Om='08'\n"),
+                                 std::chrono::month_day_last{std::chrono::August});
+  check.template operator()<fmt>(SV("%b='Sep'\t%B='September'\t%h='Sep'\t%m='09'\t%Om='09'\n"),
+                                 std::chrono::month_day_last{std::chrono::September});
+  check.template operator()<fmt>(SV("%b='Oct'\t%B='October'\t%h='Oct'\t%m='10'\t%Om='10'\n"),
+                                 std::chrono::month_day_last{std::chrono::October});
+  check.template operator()<fmt>(SV("%b='Nov'\t%B='November'\t%h='Nov'\t%m='11'\t%Om='11'\n"),
+                                 std::chrono::month_day_last{std::chrono::November});
+  check.template operator()<fmt>(SV("%b='Dec'\t%B='December'\t%h='Dec'\t%m='12'\t%Om='12'\n"),
+                                 std::chrono::month_day_last{std::chrono::December});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%b='janv.'\t%B='janvier'\t%h='janv.'\t%m='01'\t%Om='01'\n"),
+                                  std::chrono::month_day_last{std::chrono::January});
+  check.template operator()<lfmt>(SV("%b='févr.'\t%B='février'\t%h='févr.'\t%m='02'\t%Om='02'\n"),
+                                  std::chrono::month_day_last{std::chrono::February});
+  check.template operator()<lfmt>(SV("%b='mars'\t%B='mars'\t%h='mars'\t%m='03'\t%Om='03'\n"),
+                                  std::chrono::month_day_last{std::chrono::March});
+  check.template operator()<lfmt>(
+#ifdef _WIN32
+      SV("%b='avr.'\t%B='avril'\t%h='avr.'\t%m='04'\t%Om='04'\n"),
+#else
+      SV("%b='avril'\t%B='avril'\t%h='avril'\t%m='04'\t%Om='04'\n"),
+#endif
+      std::chrono::month_day_last{std::chrono::April});
+  check.template operator()<lfmt>(SV("%b='mai'\t%B='mai'\t%h='mai'\t%m='05'\t%Om='05'\n"),
+                                  std::chrono::month_day_last{std::chrono::May});
+  check.template operator()<lfmt>(SV("%b='juin'\t%B='juin'\t%h='juin'\t%m='06'\t%Om='06'\n"),
+                                  std::chrono::month_day_last{std::chrono::June});
+  check.template operator()<lfmt>(SV("%b='juil.'\t%B='juillet'\t%h='juil.'\t%m='07'\t%Om='07'\n"),
+                                  std::chrono::month_day_last{std::chrono::July});
+  check.template operator()<lfmt>(SV("%b='août'\t%B='août'\t%h='août'\t%m='08'\t%Om='08'\n"),
+                                  std::chrono::month_day_last{std::chrono::August});
+  check.template operator()<lfmt>(SV("%b='sept.'\t%B='septembre'\t%h='sept.'\t%m='09'\t%Om='09'\n"),
+                                  std::chrono::month_day_last{std::chrono::September});
+  check.template operator()<lfmt>(SV("%b='oct.'\t%B='octobre'\t%h='oct.'\t%m='10'\t%Om='10'\n"),
+                                  std::chrono::month_day_last{std::chrono::October});
+  check.template operator()<lfmt>(SV("%b='nov.'\t%B='novembre'\t%h='nov.'\t%m='11'\t%Om='11'\n"),
+                                  std::chrono::month_day_last{std::chrono::November});
+  check.template operator()<lfmt>(SV("%b='déc.'\t%B='décembre'\t%h='déc.'\t%m='12'\t%Om='12'\n"),
+                                  std::chrono::month_day_last{std::chrono::December});
+
+  // Use supplied locale (ja_JP)
+#ifdef _WIN32
+  lcheck.template operator()<lfmt>(loc, SV("%b='1'\t%B='1月'\t%h='1'\t%m='01'\t%Om='01'\n"),
+                                   std::chrono::month_day_last{std::chrono::January});
+  lcheck.template operator()<lfmt>(loc, SV("%b='2'\t%B='2月'\t%h='2'\t%m='02'\t%Om='02'\n"),
+                                   std::chrono::month_day_last{std::chrono::February});
+  lcheck.template operator()<lfmt>(loc, SV("%b='3'\t%B='3月'\t%h='3'\t%m='03'\t%Om='03'\n"),
+                                   std::chrono::month_day_last{std::chrono::March});
+  lcheck.template operator()<lfmt>(loc, SV("%b='4'\t%B='4月'\t%h='4'\t%m='04'\t%Om='04'\n"),
+                                   std::chrono::month_day_last{std::chrono::April});
+  lcheck.template operator()<lfmt>(loc, SV("%b='5'\t%B='5月'\t%h='5'\t%m='05'\t%Om='05'\n"),
+                                   std::chrono::month_day_last{std::chrono::May});
+  lcheck.template operator()<lfmt>(loc, SV("%b='6'\t%B='6月'\t%h='6'\t%m='06'\t%Om='06'\n"),
+                                   std::chrono::month_day_last{std::chrono::June});
+  lcheck.template operator()<lfmt>(loc, SV("%b='7'\t%B='7月'\t%h='7'\t%m='07'\t%Om='07'\n"),
+                                   std::chrono::month_day_last{std::chrono::July});
+  lcheck.template operator()<lfmt>(loc, SV("%b='8'\t%B='8月'\t%h='8'\t%m='08'\t%Om='08'\n"),
+                                   std::chrono::month_day_last{std::chrono::August});
+  lcheck.template operator()<lfmt>(loc, SV("%b='9'\t%B='9月'\t%h='9'\t%m='09'\t%Om='09'\n"),
+                                   std::chrono::month_day_last{std::chrono::September});
+  lcheck.template operator()<lfmt>(loc, SV("%b='10'\t%B='10月'\t%h='10'\t%m='10'\t%Om='10'\n"),
+                                   std::chrono::month_day_last{std::chrono::October});
+  lcheck.template operator()<lfmt>(loc, SV("%b='11'\t%B='11月'\t%h='11'\t%m='11'\t%Om='11'\n"),
+                                   std::chrono::month_day_last{std::chrono::November});
+  lcheck.template operator()<lfmt>(loc, SV("%b='12'\t%B='12月'\t%h='12'\t%m='12'\t%Om='12'\n"),
+                                   std::chrono::month_day_last{std::chrono::December});
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 1月'\t%B='1月'\t%h=' 1月'\t%m='01'\t%Om='一'\n"),
+                                   std::chrono::month_day_last{std::chrono::January});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 2月'\t%B='2月'\t%h=' 2月'\t%m='02'\t%Om='二'\n"),
+                                   std::chrono::month_day_last{std::chrono::February});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 3月'\t%B='3月'\t%h=' 3月'\t%m='03'\t%Om='三'\n"),
+                                   std::chrono::month_day_last{std::chrono::March});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 4月'\t%B='4月'\t%h=' 4月'\t%m='04'\t%Om='四'\n"),
+                                   std::chrono::month_day_last{std::chrono::April});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 5月'\t%B='5月'\t%h=' 5月'\t%m='05'\t%Om='五'\n"),
+                                   std::chrono::month_day_last{std::chrono::May});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 6月'\t%B='6月'\t%h=' 6月'\t%m='06'\t%Om='六'\n"),
+                                   std::chrono::month_day_last{std::chrono::June});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 7月'\t%B='7月'\t%h=' 7月'\t%m='07'\t%Om='七'\n"),
+                                   std::chrono::month_day_last{std::chrono::July});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 8月'\t%B='8月'\t%h=' 8月'\t%m='08'\t%Om='八'\n"),
+                                   std::chrono::month_day_last{std::chrono::August});
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 9月'\t%B='9月'\t%h=' 9月'\t%m='09'\t%Om='九'\n"),
+                                   std::chrono::month_day_last{std::chrono::September});
+  lcheck.template operator()<lfmt>(loc, SV("%b='10月'\t%B='10月'\t%h='10月'\t%m='10'\t%Om='十'\n"),
+                                   std::chrono::month_day_last{std::chrono::October});
+  lcheck.template operator()<lfmt>(loc, SV("%b='11月'\t%B='11月'\t%h='11月'\t%m='11'\t%Om='十一'\n"),
+                                   std::chrono::month_day_last{std::chrono::November});
+  lcheck.template operator()<lfmt>(loc, SV("%b='12月'\t%B='12月'\t%h='12月'\t%m='12'\t%Om='十二'\n"),
+                                   std::chrono::month_day_last{std::chrono::December});
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("b"), SV("B"), SV("h"), SV("m"), SV("Om")},
+                             std::chrono::month_day_last{std::chrono::January});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"),
+                  std::chrono::month_day_last{std::chrono::January});
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::month_day_last{std::chrono::January});
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+                  std::chrono::month_day_last{std::chrono::January});
+  check_exception("End of input while parsing the modifier E", SV("{:%E"),
+                  std::chrono::month_day_last{std::chrono::January});
+  check_exception("End of input while parsing the modifier O", SV("{:%O"),
+                  std::chrono::month_day_last{std::chrono::January});
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"),
+                  std::chrono::month_day_last{std::chrono::January});
+}
+
+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.month_weekday.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::month_weekday, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Month: valid,   weekday: valid,   index: invalid
+  check.template operator()<"{}">(
+      SV("Jan/Sun[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 0}});
+  check.template operator()<"{:*^33}">(
+      SV("*Jan/Sun[0 is not a valid index]*"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 0}});
+  check.template operator()<"{:*>32}">(
+      SV("*Jan/Sun[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 0}});
+
+  // Month: valid,   weekday: invalid, index: valid
+  check.template operator()<"{}">(
+      SV("Jan/8 is not a valid weekday[1]"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{:*^33}">(
+      SV("*Jan/8 is not a valid weekday[1]*"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{:*>32}">(
+      SV("*Jan/8 is not a valid weekday[1]"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+
+  // Month: valid,   weekday: invalid,   index: invalid
+  check.template operator()<"{}">(
+      SV("Jan/8 is not a valid weekday[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+  check.template operator()<"{:*^54}">(
+      SV("*Jan/8 is not a valid weekday[0 is not a valid index]*"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+  check.template operator()<"{:*>53}">(
+      SV("*Jan/8 is not a valid weekday[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+
+  // Month: invalid, weekday: valid,   index: valid
+  check.template operator()<"{}">(
+      SV("0 is not a valid month/Sun[1]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<"{:*^31}">(
+      SV("*0 is not a valid month/Sun[1]*"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<"{:*>30}">(
+      SV("*0 is not a valid month/Sun[1]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  // Month: invalid, weekday: valid,   index: invalid
+  check.template operator()<"{}">(
+      SV("0 is not a valid month/Sun[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 0}});
+  check.template operator()<"{:*^52}">(
+      SV("*0 is not a valid month/Sun[0 is not a valid index]*"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 0}});
+  check.template operator()<"{:*>51}">(
+      SV("*0 is not a valid month/Sun[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 0}});
+
+  // Month: invalid, weekday: invalid, index: valid
+  check.template operator()<"{}">(
+      SV("0 is not a valid month/8 is not a valid weekday[1]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{:*^52}">(
+      SV("*0 is not a valid month/8 is not a valid weekday[1]*"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{:*>51}">(
+      SV("*0 is not a valid month/8 is not a valid weekday[1]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+
+  // Month: invalid, weekday: valid,   index: invalid
+  check.template operator()<"{}">(
+      SV("0 is not a valid month/8 is not a valid weekday[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+  check.template operator()<"{:*^73}">(
+      SV("*0 is not a valid month/8 is not a valid weekday[0 is not a valid index]*"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+  check.template operator()<"{:*>72}">(
+      SV("*0 is not a valid month/8 is not a valid weekday[0 is not a valid index]"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+}
+
+template <class CharT>
+static void test_invalid_values() {
+  // Test that %a, %b, %h, %a, and %B throw an exception.
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%a}"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%a}"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{255}, 1}});
+
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%b}"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%b}"),
+      std::chrono::month_weekday{std::chrono::month{13}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%b}"),
+      std::chrono::month_weekday{std::chrono::month{255}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%h}"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%h}"),
+      std::chrono::month_weekday{std::chrono::month{13}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%h}"),
+      std::chrono::month_weekday{std::chrono::month{255}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%A}"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%A}"),
+      std::chrono::month_weekday{std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{255}, 1}});
+
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%B}"),
+      std::chrono::month_weekday{std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%B}"),
+      std::chrono::month_weekday{std::chrono::month{13}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%B}"),
+      std::chrono::month_weekday{std::chrono::month{255}, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+}
+
+template <class CharT>
+static void test_valid_month() {
+  constexpr string_literal fmt{"{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}"};
+  constexpr string_literal lfmt{"{:L%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%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.template operator()<fmt>(
+      SV("%b='Jan'\t%B='January'\t%h='Jan'\t%m='01'\t%Om='01'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Feb'\t%B='February'\t%h='Feb'\t%m='02'\t%Om='02'\n"),
+      std::chrono::month_weekday{std::chrono::February, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Mar'\t%B='March'\t%h='Mar'\t%m='03'\t%Om='03'\n"),
+      std::chrono::month_weekday{std::chrono::March, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Apr'\t%B='April'\t%h='Apr'\t%m='04'\t%Om='04'\n"),
+      std::chrono::month_weekday{std::chrono::April, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='May'\t%B='May'\t%h='May'\t%m='05'\t%Om='05'\n"),
+      std::chrono::month_weekday{std::chrono::May, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Jun'\t%B='June'\t%h='Jun'\t%m='06'\t%Om='06'\n"),
+      std::chrono::month_weekday{std::chrono::June, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Jul'\t%B='July'\t%h='Jul'\t%m='07'\t%Om='07'\n"),
+      std::chrono::month_weekday{std::chrono::July, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Aug'\t%B='August'\t%h='Aug'\t%m='08'\t%Om='08'\n"),
+      std::chrono::month_weekday{std::chrono::August, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Sep'\t%B='September'\t%h='Sep'\t%m='09'\t%Om='09'\n"),
+      std::chrono::month_weekday{std::chrono::September, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Oct'\t%B='October'\t%h='Oct'\t%m='10'\t%Om='10'\n"),
+      std::chrono::month_weekday{std::chrono::October, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Nov'\t%B='November'\t%h='Nov'\t%m='11'\t%Om='11'\n"),
+      std::chrono::month_weekday{std::chrono::November, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%b='Dec'\t%B='December'\t%h='Dec'\t%m='12'\t%Om='12'\n"),
+      std::chrono::month_weekday{std::chrono::December, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(
+      SV("%b='janv.'\t%B='janvier'\t%h='janv.'\t%m='01'\t%Om='01'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='févr.'\t%B='février'\t%h='févr.'\t%m='02'\t%Om='02'\n"),
+      std::chrono::month_weekday{std::chrono::February, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='mars'\t%B='mars'\t%h='mars'\t%m='03'\t%Om='03'\n"),
+      std::chrono::month_weekday{std::chrono::March, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+#ifdef _WIN32
+      SV("%b='avr.'\t%B='avril'\t%h='avr.'\t%m='04'\t%Om='04'\n"),
+#else
+      SV("%b='avril'\t%B='avril'\t%h='avril'\t%m='04'\t%Om='04'\n"),
+#endif
+      std::chrono::month_weekday{std::chrono::April, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='mai'\t%B='mai'\t%h='mai'\t%m='05'\t%Om='05'\n"),
+      std::chrono::month_weekday{std::chrono::May, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='juin'\t%B='juin'\t%h='juin'\t%m='06'\t%Om='06'\n"),
+      std::chrono::month_weekday{std::chrono::June, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='juil.'\t%B='juillet'\t%h='juil.'\t%m='07'\t%Om='07'\n"),
+      std::chrono::month_weekday{std::chrono::July, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='août'\t%B='août'\t%h='août'\t%m='08'\t%Om='08'\n"),
+      std::chrono::month_weekday{std::chrono::August, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='sept.'\t%B='septembre'\t%h='sept.'\t%m='09'\t%Om='09'\n"),
+      std::chrono::month_weekday{std::chrono::September, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='oct.'\t%B='octobre'\t%h='oct.'\t%m='10'\t%Om='10'\n"),
+      std::chrono::month_weekday{std::chrono::October, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='nov.'\t%B='novembre'\t%h='nov.'\t%m='11'\t%Om='11'\n"),
+      std::chrono::month_weekday{std::chrono::November, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%b='déc.'\t%B='décembre'\t%h='déc.'\t%m='12'\t%Om='12'\n"),
+      std::chrono::month_weekday{std::chrono::December, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  // Use supplied locale (ja_JP)
+#ifdef _WIN32
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='1'\t%B='1月'\t%h='1'\t%m='01'\t%Om='01'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='2'\t%B='2月'\t%h='2'\t%m='02'\t%Om='02'\n"),
+      std::chrono::month_weekday{std::chrono::February, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='3'\t%B='3月'\t%h='3'\t%m='03'\t%Om='03'\n"),
+      std::chrono::month_weekday{std::chrono::March, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='4'\t%B='4月'\t%h='4'\t%m='04'\t%Om='04'\n"),
+      std::chrono::month_weekday{std::chrono::April, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='5'\t%B='5月'\t%h='5'\t%m='05'\t%Om='05'\n"),
+      std::chrono::month_weekday{std::chrono::May, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='6'\t%B='6月'\t%h='6'\t%m='06'\t%Om='06'\n"),
+      std::chrono::month_weekday{std::chrono::June, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='7'\t%B='7月'\t%h='7'\t%m='07'\t%Om='07'\n"),
+      std::chrono::month_weekday{std::chrono::July, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='8'\t%B='8月'\t%h='8'\t%m='08'\t%Om='08'\n"),
+      std::chrono::month_weekday{std::chrono::August, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='9'\t%B='9月'\t%h='9'\t%m='09'\t%Om='09'\n"),
+      std::chrono::month_weekday{std::chrono::September, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='10'\t%B='10月'\t%h='10'\t%m='10'\t%Om='10'\n"),
+      std::chrono::month_weekday{std::chrono::October, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='11'\t%B='11月'\t%h='11'\t%m='11'\t%Om='11'\n"),
+      std::chrono::month_weekday{std::chrono::November, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='12'\t%B='12月'\t%h='12'\t%m='12'\t%Om='12'\n"),
+      std::chrono::month_weekday{std::chrono::December, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+#else
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 1月'\t%B='1月'\t%h=' 1月'\t%m='01'\t%Om='一'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 2月'\t%B='2月'\t%h=' 2月'\t%m='02'\t%Om='二'\n"),
+      std::chrono::month_weekday{std::chrono::February, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 3月'\t%B='3月'\t%h=' 3月'\t%m='03'\t%Om='三'\n"),
+      std::chrono::month_weekday{std::chrono::March, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 4月'\t%B='4月'\t%h=' 4月'\t%m='04'\t%Om='四'\n"),
+      std::chrono::month_weekday{std::chrono::April, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 5月'\t%B='5月'\t%h=' 5月'\t%m='05'\t%Om='五'\n"),
+      std::chrono::month_weekday{std::chrono::May, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 6月'\t%B='6月'\t%h=' 6月'\t%m='06'\t%Om='六'\n"),
+      std::chrono::month_weekday{std::chrono::June, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 7月'\t%B='7月'\t%h=' 7月'\t%m='07'\t%Om='七'\n"),
+      std::chrono::month_weekday{std::chrono::July, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 8月'\t%B='8月'\t%h=' 8月'\t%m='08'\t%Om='八'\n"),
+      std::chrono::month_weekday{std::chrono::August, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b=' 9月'\t%B='9月'\t%h=' 9月'\t%m='09'\t%Om='九'\n"),
+      std::chrono::month_weekday{std::chrono::September, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='10月'\t%B='10月'\t%h='10月'\t%m='10'\t%Om='十'\n"),
+      std::chrono::month_weekday{std::chrono::October, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='11月'\t%B='11月'\t%h='11月'\t%m='11'\t%Om='十一'\n"),
+      std::chrono::month_weekday{std::chrono::November, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%b='12月'\t%B='12月'\t%h='12月'\t%m='12'\t%Om='十二'\n"),
+      std::chrono::month_weekday{std::chrono::December, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_weekday() {
+  constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%n}";
+  constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%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.template operator()<fmt>(
+      SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='Mon'\t%A='Monday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='Tue'\t%A='Tuesday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{2}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='Wed'\t%A='Wednesday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{3}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='Thu'\t%A='Thursday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{4}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='Fri'\t%A='Friday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{5}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='Sat'\t%A='Saturday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{6}, 1}});
+  check.template operator()<fmt>(
+      SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{7}, 1}});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(
+      SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='lun.'\t%A='lundi'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='mar.'\t%A='mardi'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{2}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='mer.'\t%A='mercredi'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{3}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='jeu.'\t%A='jeudi'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{4}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='ven.'\t%A='vendredi'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{5}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='sam.'\t%A='samedi'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{6}, 1}});
+  check.template operator()<lfmt>(
+      SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{7}, 1}});
+
+  // Use supplied locale (ja_JP).
+  // This locale has a different alternate, but not on all platforms
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='月'\t%A='月曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='火'\t%A='火曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{2}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='水'\t%A='水曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{3}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='木'\t%A='木曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{4}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='金'\t%A='金曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{5}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='土'\t%A='土曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{6}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{7}, 1}});
+#else
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='1'\t%Ou='一'\t%w='1'\t%Ow='一'\t%a='月'\t%A='月曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='2'\t%Ou='二'\t%w='2'\t%Ow='二'\t%a='火'\t%A='火曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{2}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='3'\t%Ou='三'\t%w='3'\t%Ow='三'\t%a='水'\t%A='水曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{3}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='4'\t%Ou='四'\t%w='4'\t%Ow='四'\t%a='木'\t%A='木曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{4}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='5'\t%Ou='五'\t%w='5'\t%Ow='五'\t%a='金'\t%A='金曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{5}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='6'\t%Ou='六'\t%w='6'\t%Ow='六'\t%a='土'\t%A='土曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{6}, 1}});
+  lcheck.template operator()<lfmt>(
+      loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{7}, 1}});
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values() {
+  test_valid_month<CharT>();
+  test_valid_weekday<CharT>();
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_invalid_values<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>(
+      {SV("a"), SV("A"), SV("b"), SV("B"), SV("h"), SV("m"), SV("u"), SV("w"), SV("Om"), SV("Ou"), SV("Ow")},
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  check_exception(
+      "Expected '%' or '}' in the chrono format-string", SV("{:A"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "The chrono-specs contains a '{'", SV("{:%%{"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "End of input while parsing the modifier E", SV("{:%E"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+  check_exception(
+      "End of input while parsing the modifier O", SV("{:%O"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+
+  // Precision not allowed
+  check_exception(
+      "Expected '%' or '}' in the chrono format-string", SV("{:.3}"),
+      std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
+}
+
+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.sys_time.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+//
+// template<class charT> struct formatter<chrono::day, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+  // Non localized output
+  check.template operator()<"{}">(SV("1970-01-01 00:00:00"), std::chrono::sys_seconds(0s));
+  check.template operator()<"{}">(SV("2000-01-01 00:00:00"), std::chrono::sys_seconds(946'684'800s));
+  check.template operator()<"{}">(SV("2000-01-01 01:02:03"), std::chrono::sys_seconds(946'688'523s));
+
+  check.template operator()<"{}">(SV("2000-01-01 01:02:03.123"),
+                                  std::chrono::sys_time<std::chrono::milliseconds>(946'688'523'123ms));
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_year() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%C='%C'%t%%EC='%EC'%t%%y='%y'%t%%Oy='%Oy'%t%%Ey='%Ey'%t%%Y='%Y'%t%%EY='%EY'%n}"};
+  constexpr string_literal lfmt{"{:L%%C='%C'%t%%EC='%EC'%t%%y='%y'%t%%Oy='%Oy'%t%%Ey='%Ey'%t%%Y='%Y'%t%%EY='%EY'%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.template operator()<fmt>(SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+                                 std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+                                  std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+#ifdef _WIN32
+  lcheck.template operator()<lfmt>(loc, SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(
+      loc, SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+#else
+  lcheck.template operator()<lfmt>(
+      loc, SV("%C='19'\t%EC='昭和'\t%y='70'\t%Oy='七十'\t%Ey='45'\t%Y='1970'\t%EY='昭和45年'\n"),
+      std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(
+      loc, SV("%C='20'\t%EC='平成'\t%y='09'\t%Oy='九'\t%Ey='21'\t%Y='2009'\t%EY='平成21年'\n"),
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_month() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%b='%b'%t%%h='%h'%t%%B='%B'%t%%m='%m'%t%%Om='%Om'%n}"};
+  constexpr string_literal lfmt{"{:L%%b='%b'%t%%h='%h'%t%%B='%B'%t%%m='%m'%t%%Om='%Om'%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.template operator()<fmt>(SV("%b='Jan'\t%h='Jan'\t%B='January'\t%m='01'\t%Om='01'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%b='May'\t%h='May'\t%B='May'\t%m='05'\t%Om='05'\n"),
+                                 std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%b='janv.'\t%h='janv.'\t%B='janvier'\t%m='01'\t%Om='01'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%b='mai'\t%h='mai'\t%B='mai'\t%m='05'\t%Om='05'\n"),
+                                  std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+#ifdef _WIN32
+  lcheck.template operator()<lfmt>(loc, SV("%b='1'\t%h='1'\t%B='1月'\t%m='01'\t%Om='01'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc, SV("%b='5'\t%h='5'\t%B='5月'\t%m='05'\t%Om='05'\n"),
+                                   std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 1月'\t%h=' 1月'\t%B='1月'\t%m='01'\t%Om='一'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 5月'\t%h=' 5月'\t%B='5月'\t%m='05'\t%Om='五'\n"),
+                                   std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_day() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%d='%d'%t%%Od='%Od'%t%%e='%e'%t%%Oe='%Oe'%n}"};
+  constexpr string_literal lfmt{"{:L%%d='%d'%t%%Od='%Od'%t%%e='%e'%t%%Oe='%Oe'%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.template operator()<fmt>(SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%d='13'\t%Od='13'\t%e='13'\t%Oe='13'\n"),
+                                 std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%d='13'\t%Od='13'\t%e='13'\t%Oe='13'\n"),
+                                  std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%d='01'\t%Od='一'\t%e=' 1'\t%Oe='一'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(
+      loc, SV("%d='13'\t%Od='十三'\t%e='13'\t%Oe='十三'\n"),
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_weekday() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%a='%a'%t%%A='%A'%t%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}"};
+  constexpr string_literal lfmt{"{:L%%a='%a'%t%%A='%A'%t%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%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.template operator()<fmt>(SV("%a='Thu'\t%A='Thursday'\t%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%a='Sun'\t%A='Sunday'\t%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\n"),
+                                 std::chrono::sys_seconds(4'294'967'295s)); // 06:28:15 UTC on Sunday, 7 February 2106
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%a='jeu.'\t%A='jeudi'\t%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%a='dim.'\t%A='dimanche'\t%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\n"),
+                                  std::chrono::sys_seconds(4'294'967'295s)); // 06:28:15 UTC on Sunday, 7 February 2106
+
+  // Use supplied locale (ja_JP).
+  // This locale has a different alternate, but not on all platforms
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(loc, SV("%a='木'\t%A='木曜日'\t%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc, SV("%a='日'\t%A='日曜日'\t%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\n"),
+                                   std::chrono::sys_seconds(4'294'967'295s)); // 06:28:15 UTC on Sunday, 7 February 2106
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%a='木'\t%A='木曜日'\t%u='4'\t%Ou='四'\t%w='4'\t%Ow='四'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc, SV("%a='日'\t%A='日曜日'\t%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\n"),
+                                   std::chrono::sys_seconds(4'294'967'295s)); // 06:28:15 UTC on Sunday, 7 February 2106
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_day_of_year() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%j='%j'%n}"};
+  constexpr string_literal lfmt{"{:L%%j='%j'%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.template operator()<fmt>(SV("%j='001'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%j='138'\n"),
+                                 std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%j='001'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%j='138'\n"),
+                                  std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%j='001'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc, SV("%j='138'\n"),
+                                   std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_week() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%U='%U'%t%%OU='%OU'%t%%W='%W'%t%%OW='%OW'%n}"};
+  constexpr string_literal lfmt{"{:L%%U='%U'%t%%OU='%OU'%t%%W='%W'%t%%OW='%OW'%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.template operator()<fmt>(SV("%U='00'\t%OU='00'\t%W='00'\t%OW='00'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%U='20'\t%OU='20'\t%W='20'\t%OW='20'\n"),
+                                 std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%U='00'\t%OU='00'\t%W='00'\t%OW='00'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%U='20'\t%OU='20'\t%W='20'\t%OW='20'\n"),
+                                  std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%U='00'\t%OU='〇'\t%W='00'\t%OW='〇'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc, SV("%U='20'\t%OU='二十'\t%W='20'\t%OW='二十'\n"),
+                                   std::chrono::sys_seconds(2'000'000'000s)); // 03:33:20 UTC on Wednesday, 18 May 2033
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_iso_8601_week() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%g='%g'%t%%G='%G'%t%%V='%V'%t%%OV='%OV'%n}"};
+  constexpr string_literal lfmt{"{:L%%g='%g'%t%%G='%G'%t%%V='%V'%t%%OV='%OV'%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.template operator()<fmt>(SV("%g='70'\t%G='1970'\t%V='01'\t%OV='01'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%g='09'\t%G='2009'\t%V='07'\t%OV='07'\n"),
+                                 std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%g='70'\t%G='1970'\t%V='01'\t%OV='01'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%g='09'\t%G='2009'\t%V='07'\t%OV='07'\n"),
+                                  std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%g='70'\t%G='1970'\t%V='01'\t%OV='一'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(
+      loc, SV("%g='09'\t%G='2009'\t%V='07'\t%OV='七'\n"),
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_date() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%D='%D'%t%%F='%F'%t%%x='%x'%t%%Ex='%Ex'%n}"};
+  constexpr string_literal lfmt{"{:L%%D='%D'%t%%F='%F'%t%%x='%x'%t%%Ex='%Ex'%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.template operator()<fmt>(SV("%D='01/01/70'\t%F='1970-01-01'\t%x='01/01/70'\t%Ex='01/01/70'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%D='02/13/09'\t%F='2009-02-13'\t%x='02/13/09'\t%Ex='02/13/09'\n"),
+                                 std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%D='01/01/70'\t%F='1970-01-01'\t%x='01/01/1970'\t%Ex='01/01/1970'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%D='02/13/09'\t%F='2009-02-13'\t%x='13/02/2009'\t%Ex='13/02/2009'\n"),
+                                  std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.a
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%D='01/01/70'\t%F='1970-01-01'\t%x='1970年01月01日'\t%Ex='昭和45年01月01日'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(
+      loc, SV("%D='02/13/09'\t%F='2009-02-13'\t%x='2009年02月13日'\t%Ex='平成21年02月13日'\n"),
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_time() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:"
+                               "%%H='%H'%t"
+                               "%%OH='%OH'%t"
+                               "%%I='%I'%t"
+                               "%%OI='%OI'%t"
+                               "%%M='%M'%t"
+                               "%%OM='%OM'%t"
+                               "%%S='%S'%t"
+                               "%%OS='%OS'%t"
+                               "%%p='%p'%t"
+                               "%%R='%R'%t"
+                               "%%T='%T'%t"
+                               "%%r='%r'%t"
+                               "%%X='%X'%t"
+                               "%%EX='%EX'%t"
+                               "%n}"};
+  constexpr string_literal lfmt{"{:L"
+                                "%%H='%H'%t"
+                                "%%OH='%OH'%t"
+                                "%%I='%I'%t"
+                                "%%OI='%OI'%t"
+                                "%%M='%M'%t"
+                                "%%OM='%OM'%t"
+                                "%%S='%S'%t"
+                                "%%OS='%OS'%t"
+                                "%%p='%p'%t"
+                                "%%R='%R'%t"
+                                "%%T='%T'%t"
+                                "%%r='%r'%t"
+                                "%%X='%X'%t"
+                                "%%EX='%EX'%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.template operator()<fmt>(SV("%H='00'\t"
+                                    "%OH='00'\t"
+                                    "%I='12'\t"
+                                    "%OI='12'\t"
+                                    "%M='00'\t"
+                                    "%OM='00'\t"
+                                    "%S='00'\t"
+                                    "%OS='00'\t"
+                                    "%p='AM'\t"
+                                    "%R='00:00'\t"
+                                    "%T='00:00:00'\t"
+                                    "%r='12:00:00 AM'\t"
+                                    "%X='00:00:00'\t"
+                                    "%EX='00:00:00'\t"
+                                    "\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%H='23'\t"
+                                    "%OH='23'\t"
+                                    "%I='11'\t"
+                                    "%OI='11'\t"
+                                    "%M='31'\t"
+                                    "%OM='31'\t"
+                                    "%S='30.123'\t"
+                                    "%OS='30.123'\t"
+                                    "%p='PM'\t"
+                                    "%R='23:31'\t"
+                                    "%T='23:31:30.123'\t"
+                                    "%r='11:31:30 PM'\t"
+                                    "%X='23:31:30'\t"
+                                    "%EX='23:31:30'\t"
+                                    "\n"),
+                                 std::chrono::sys_time<std::chrono::milliseconds>(
+                                     1'234'567'890'123ms)); // 23:31:30 UTC on Friday, 13 February 2009
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%H='00'\t"
+                                     "%OH='00'\t"
+                                     "%I='12'\t"
+                                     "%OI='12'\t"
+                                     "%M='00'\t"
+                                     "%OM='00'\t"
+                                     "%S='00'\t"
+                                     "%OS='00'\t"
+                                     "%p=''\t"
+                                     "%R='00:00'\t"
+                                     "%T='00:00:00'\t"
+#ifdef _WIN32
+                                     "%r='00:00:00'\t"
+#else
+                                     "%r='12:00:00 '\t"
+#endif
+                                     "%X='00:00:00'\t"
+                                     "%EX='00:00:00'\t"
+                                     "\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%H='23'\t"
+                                     "%OH='23'\t"
+                                     "%I='11'\t"
+                                     "%OI='11'\t"
+                                     "%M='31'\t"
+                                     "%OM='31'\t"
+                                     "%S='30,123'\t"
+                                     "%OS='30,123'\t"
+                                     "%p=''\t"
+                                     "%R='23:31'\t"
+                                     "%T='23:31:30,123'\t"
+#ifdef _WIN32
+                                     "%r='23:31:30'\t"
+#else
+                                     "%r='11:31:30 '\t"
+#endif
+
+                                     "%X='23:31:30'\t"
+                                     "%EX='23:31:30'\t"
+                                     "\n"),
+                                  std::chrono::sys_time<std::chrono::milliseconds>(
+                                      1'234'567'890'123ms)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.a
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='00'\t"
+                                      "%OH='〇'\t"
+                                      "%I='12'\t"
+                                      "%OI='十二'\t"
+                                      "%M='00'\t"
+                                      "%OM='〇'\t"
+                                      "%S='00'\t"
+                                      "%OS='〇'\t"
+                                      "%p='午前'\t"
+                                      "%R='00:00'\t"
+                                      "%T='00:00:00'\t"
+                                      "%r='午前12時00分00秒'\t"
+                                      "%X='00時00分00秒'\t"
+                                      "%EX='00時00分00秒'\t"
+                                      "\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%H='23'\t"
+                                      "%OH='二十三'\t"
+                                      "%I='11'\t"
+                                      "%OI='十一'\t"
+                                      "%M='31'\t"
+                                      "%OM='三十一'\t"
+                                      "%S='30.123'\t"
+                                      "%OS='三十.123'\t"
+                                      "%p='午後'\t"
+                                      "%R='23:31'\t"
+                                      "%T='23:31:30.123'\t"
+                                      "%r='午後11時31分30秒'\t"
+                                      "%X='23時31分30秒'\t"
+                                      "%EX='23時31分30秒'\t"
+                                      "\n"),
+                                   std::chrono::sys_time<std::chrono::milliseconds>(
+                                       1'234'567'890'123ms)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_date_time() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%c='%c'%t%%Ec='%Ec'%n}"};
+  constexpr string_literal lfmt{"{:L%%c='%c'%t%%Ec='%Ec'%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.template operator()<fmt>(SV("%c='Thu Jan  1 00:00:00 1970'\t%Ec='Thu Jan  1 00:00:00 1970'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<fmt>(SV("%c='Fri Feb 13 23:31:30 2009'\t%Ec='Fri Feb 13 23:31:30 2009'\n"),
+                                 std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(
+// https://sourceware.org/bugzilla/show_bug.cgi?id=24054
+#if defined(__GLIBC__) && __GLIBC__ <= 2 && __GLIBC_MINOR__ < 29
+      SV("%c='jeu. 01 janv. 1970 00:00:00 GMT'\t%Ec='jeu. 01 janv. 1970 00:00:00 GMT'\n"),
+#else
+      SV("%c='jeu. 01 janv. 1970 00:00:00'\t%Ec='jeu. 01 janv. 1970 00:00:00'\n"),
+#endif
+      std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(
+// https://sourceware.org/bugzilla/show_bug.cgi?id=24054
+#if defined(__GLIBC__) && __GLIBC__ <= 2 && __GLIBC_MINOR__ < 29
+      SV("%c='ven. 13 févr. 2009 23:31:30 GMT'\t%Ec='ven. 13 févr. 2009 23:31:30 GMT'\n"),
+#else
+      SV("%c='ven. 13 févr. 2009 23:31:30'\t%Ec='ven. 13 févr. 2009 23:31:30'\n"),
+#endif
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.a
+  lcheck.template operator()<lfmt>(loc, SV("%c='1970年01月01日 00時00分00秒'\t%Ec='昭和45年01月01日 00時00分00秒'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  lcheck.template operator()<lfmt>(
+      loc, SV("%c='2009年02月13日 23時31分30秒'\t%Ec='平成21年02月13日 23時31分30秒'\n"),
+      std::chrono::sys_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday, 13 February 2009
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values_time_zone() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%z='%z'%t%%Ez='%Ez'%t%%Oz='%Oz'%t%%Z='%Z'%n}"};
+  constexpr string_literal lfmt{"{:L%%z='%z'%t%%Ez='%Ez'%t%%Oz='%Oz'%t%%Z='%Z'%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.template operator()<fmt>(SV("%z='+0000'\t%Ez='+0000'\t%Oz='+0000'\t%Z='UTC'\n"),
+                                 std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%z='+0000'\t%Ez='+0000'\t%Oz='+0000'\t%Z='UTC'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.a
+  lcheck.template operator()<lfmt>(loc, SV("%z='+0000'\t%Ez='+0000'\t%Oz='+〇'\t%Z='UTC'\n"),
+                                   std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_valid_values() {
+  test_valid_values_year<CharT>();
+  test_valid_values_month<CharT>();
+  test_valid_values_day<CharT>();
+  test_valid_values_weekday<CharT>();
+  test_valid_values_day_of_year<CharT>();
+  test_valid_values_week<CharT>();
+  test_valid_values_iso_8601_week<CharT>();
+  test_valid_values_date<CharT>();
+  test_valid_values_time<CharT>();
+  test_valid_values_date_time<CharT>();
+  test_valid_values_time_zone<CharT>();
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>(
+      {SV("a"),  SV("A"),  SV("b"),  SV("B"),  SV("c"),  SV("C"),  SV("d"),  SV("D"),  SV("e"),  SV("F"),  SV("g"),
+       SV("G"),  SV("h"),  SV("H"),  SV("I"),  SV("j"),  SV("m"),  SV("M"),  SV("p"),  SV("r"),  SV("R"),  SV("S"),
+       SV("T"),  SV("u"),  SV("U"),  SV("V"),  SV("w"),  SV("W"),  SV("x"),  SV("X"),  SV("y"),  SV("Y"),  SV("z"),
+       SV("Z"),  SV("Ec"), SV("EC"), SV("Ex"), SV("EX"), SV("Ey"), SV("EY"), SV("Ez"), SV("Od"), SV("Oe"), SV("OH"),
+       SV("OI"), SV("Om"), SV("OM"), SV("OS"), SV("Ou"), SV("OU"), SV("OV"), SV("Ow"), SV("OW"), SV("Oy"), SV("Oz")},
+      std::chrono::sys_seconds(0s));
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::sys_seconds(0s));
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::sys_seconds(0s));
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+                  std::chrono::sys_seconds(0s));
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::sys_seconds(0s));
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::sys_seconds(0s));
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::sys_seconds(0s));
+}
+
+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.weekday.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::weekday, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#if 0
+template <class CharT>
+struct numpunct;
+template <>
+struct numpunct<char> : std::numpunct<char> {
+  string_type do_truename() const override { return "yes"; }
+  string_type do_falsename() const override { return "no"; }
+
+  std::string do_grouping() const override { return "\1"; };
+  char do_thousands_sep() const override { return '_'; }
+  char do_decimal_point() const override { return '#'; }
+};
+
+#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
+template <>
+struct numpunct<wchar_t> : std::numpunct<wchar_t> {
+  string_type do_truename() const override { return L"yes"; }
+  string_type do_falsename() const override { return L"no"; }
+
+  std::string do_grouping() const override { return "\1"; };
+  wchar_t do_thousands_sep() const override { return L'_'; }
+  wchar_t do_decimal_point() const override { return L'#'; }
+};
+#  endif
+
+  // XXX validate :L doesn't apply locale!
+  // make more generic... note that weekday index does require :L to work...
+  std::locale::global(std::locale(std::locale(), new numpunct<CharT>()));
+  check.template operator()<"{}">(SV("18 is not a valid weekday"), std::chrono::weekday(18));
+  check.template operator()<"{:L}">(SV("18 is not a valid weekday"), std::chrono::weekday(18));
+
+#endif
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  // Valid day
+  check.template operator()<"{}">(SV("Sun"), std::chrono::weekday(0));
+
+  // Invalid day
+  check.template operator()<"{}">(SV("8 is not a valid weekday"), std::chrono::weekday(8));
+}
+
+template <class CharT>
+static void test_valid_values() {
+  constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%n}";
+  constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%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.template operator()<fmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+                                 std::chrono::weekday(0));
+  check.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='Mon'\t%A='Monday'\n"),
+                                 std::chrono::weekday(1));
+  check.template operator()<fmt>(SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='Tue'\t%A='Tuesday'\n"),
+                                 std::chrono::weekday(2));
+  check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='Wed'\t%A='Wednesday'\n"),
+                                 std::chrono::weekday(3));
+  check.template operator()<fmt>(SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='Thu'\t%A='Thursday'\n"),
+                                 std::chrono::weekday(4));
+  check.template operator()<fmt>(SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='Fri'\t%A='Friday'\n"),
+                                 std::chrono::weekday(5));
+  check.template operator()<fmt>(SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='Sat'\t%A='Saturday'\n"),
+                                 std::chrono::weekday(6));
+  check.template operator()<fmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+                                 std::chrono::weekday(7));
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+                                  std::chrono::weekday(0));
+  check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='lun.'\t%A='lundi'\n"),
+                                  std::chrono::weekday(1));
+  check.template operator()<lfmt>(SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='mar.'\t%A='mardi'\n"),
+                                  std::chrono::weekday(2));
+  check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='mer.'\t%A='mercredi'\n"),
+                                  std::chrono::weekday(3));
+  check.template operator()<lfmt>(SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='jeu.'\t%A='jeudi'\n"),
+                                  std::chrono::weekday(4));
+  check.template operator()<lfmt>(SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='ven.'\t%A='vendredi'\n"),
+                                  std::chrono::weekday(5));
+  check.template operator()<lfmt>(SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='sam.'\t%A='samedi'\n"),
+                                  std::chrono::weekday(6));
+  check.template operator()<lfmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+                                  std::chrono::weekday(7));
+
+  // Use supplied locale (ja_JP).
+  // This locale has a different alternate, but not on all platforms
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday(0));
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='月'\t%A='月曜日'\n"),
+                                   std::chrono::weekday(1));
+  lcheck.template operator()<lfmt>(loc, SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='火'\t%A='火曜日'\n"),
+                                   std::chrono::weekday(2));
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='水'\t%A='水曜日'\n"),
+                                   std::chrono::weekday(3));
+  lcheck.template operator()<lfmt>(loc, SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='木'\t%A='木曜日'\n"),
+                                   std::chrono::weekday(4));
+  lcheck.template operator()<lfmt>(loc, SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='金'\t%A='金曜日'\n"),
+                                   std::chrono::weekday(5));
+  lcheck.template operator()<lfmt>(loc, SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='土'\t%A='土曜日'\n"),
+                                   std::chrono::weekday(6));
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday(7));
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday(0));
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='1'\t%Ow='一'\t%a='月'\t%A='月曜日'\n"),
+                                   std::chrono::weekday(1));
+  lcheck.template operator()<lfmt>(loc, SV("%u='2'\t%Ou='二'\t%w='2'\t%Ow='二'\t%a='火'\t%A='火曜日'\n"),
+                                   std::chrono::weekday(2));
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='3'\t%Ow='三'\t%a='水'\t%A='水曜日'\n"),
+                                   std::chrono::weekday(3));
+  lcheck.template operator()<lfmt>(loc, SV("%u='4'\t%Ou='四'\t%w='4'\t%Ow='四'\t%a='木'\t%A='木曜日'\n"),
+                                   std::chrono::weekday(4));
+  lcheck.template operator()<lfmt>(loc, SV("%u='5'\t%Ou='五'\t%w='5'\t%Ow='五'\t%a='金'\t%A='金曜日'\n"),
+                                   std::chrono::weekday(5));
+  lcheck.template operator()<lfmt>(loc, SV("%u='6'\t%Ou='六'\t%w='6'\t%Ow='六'\t%a='土'\t%A='土曜日'\n"),
+                                   std::chrono::weekday(6));
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday(7));
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_invalid_values() {
+  // Test that %a and %A throw an exception.
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"), std::chrono::weekday(8));
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"), std::chrono::weekday(255));
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"), std::chrono::weekday(8));
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"), std::chrono::weekday(255));
+
+  constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}";
+  constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%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.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"), std::chrono::weekday(8));
+  check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"), std::chrono::weekday(255));
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"), std::chrono::weekday(8));
+  check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"), std::chrono::weekday(255));
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='8'\t%Ow='八'\n"), std::chrono::weekday(8));
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='255'\t%Ow='255'\n"), std::chrono::weekday(255));
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  test_invalid_values<CharT>();
+  check_invalid_types<CharT>({SV("a"), SV("A"), SV("t"), SV("u"), SV("w"), SV("Ou"), SV("Ow")},
+                             std::chrono::weekday(0));
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::weekday(0));
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::weekday(0));
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), std::chrono::weekday(0));
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::weekday(0));
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::weekday(0));
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::weekday(0));
+}
+
+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.weekday_index.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::weekday_index, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  // Valid weekday valid index
+  check.template operator()<"{}">(SV("Sun[1]"), std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+
+  // Invalid weekday valid index
+  check.template operator()<"{}">(SV("8 is not a valid weekday[1]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
+  check.template operator()<"{}">(SV("255 is not a valid weekday[1]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
+
+  // Valid weekday invalid index
+  check.template operator()<"{}">(SV("Sun[0 is not a valid index]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+  check.template operator()<"{}">(SV("Sun[6 is not a valid index]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(0), 6});
+  check.template operator()<"{}">(SV("Sun[255 is not a valid index]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(0), 255});
+
+  // Invalid weekday invalid index
+  check.template operator()<"{}">(SV("8 is not a valid weekday[0 is not a valid index]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(8), 0});
+  check.template operator()<"{}">(SV("127 is not a valid weekday[6 is not a valid index]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(127), 6});
+  check.template operator()<"{}">(SV("255 is not a valid weekday[255 is not a valid index]"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(255), 255});
+}
+
+template <class CharT>
+static void test_valid_values() {
+  constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%n}";
+  constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%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.template operator()<fmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+  check.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='Mon'\t%A='Monday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(1), 1});
+  check.template operator()<fmt>(SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='Tue'\t%A='Tuesday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(2), 2});
+  check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='Wed'\t%A='Wednesday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(3), 3});
+  check.template operator()<fmt>(SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='Thu'\t%A='Thursday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(4), 4});
+  check.template operator()<fmt>(SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='Fri'\t%A='Friday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(5), 5});
+  check.template operator()<fmt>(SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='Sat'\t%A='Saturday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(6), 6});
+  check.template operator()<fmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+                                 std::chrono::weekday_indexed{std::chrono::weekday(7), 7});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+  check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='lun.'\t%A='lundi'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(1), 1});
+  check.template operator()<lfmt>(SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='mar.'\t%A='mardi'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(2), 2});
+  check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='mer.'\t%A='mercredi'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(3), 3});
+  check.template operator()<lfmt>(SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='jeu.'\t%A='jeudi'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(4), 4});
+  check.template operator()<lfmt>(SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='ven.'\t%A='vendredi'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(5), 5});
+  check.template operator()<lfmt>(SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='sam.'\t%A='samedi'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(6), 6});
+  check.template operator()<lfmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+                                  std::chrono::weekday_indexed{std::chrono::weekday(7), 7});
+
+  // Use supplied locale (ja_JP).
+  // This locale has a different alternate, but not on all platforms
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='月'\t%A='月曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(1), 1});
+  lcheck.template operator()<lfmt>(loc, SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='火'\t%A='火曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(2), 2});
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='水'\t%A='水曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(3), 3});
+  lcheck.template operator()<lfmt>(loc, SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='木'\t%A='木曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(4), 4});
+  lcheck.template operator()<lfmt>(loc, SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='金'\t%A='金曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(5), 5});
+  lcheck.template operator()<lfmt>(loc, SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='土'\t%A='土曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(6), 6});
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(7), 7});
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='1'\t%Ow='一'\t%a='月'\t%A='月曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(1), 1});
+  lcheck.template operator()<lfmt>(loc, SV("%u='2'\t%Ou='二'\t%w='2'\t%Ow='二'\t%a='火'\t%A='火曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(2), 2});
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='3'\t%Ow='三'\t%a='水'\t%A='水曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(3), 3});
+  lcheck.template operator()<lfmt>(loc, SV("%u='4'\t%Ou='四'\t%w='4'\t%Ow='四'\t%a='木'\t%A='木曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(4), 4});
+  lcheck.template operator()<lfmt>(loc, SV("%u='5'\t%Ou='五'\t%w='5'\t%Ow='五'\t%a='金'\t%A='金曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(5), 5});
+  lcheck.template operator()<lfmt>(loc, SV("%u='6'\t%Ou='六'\t%w='6'\t%Ow='六'\t%a='土'\t%A='土曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(6), 6});
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(7), 7});
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_invalid_values() {
+  // Test that %a and %A throw an exception.
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
+
+  const std::locale loc(LOCALE_ja_JP_UTF_8);
+  std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+  { // Invalid weekday, can't test %a and %A
+    constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}";
+    constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}";
+
+    // Non localized output using C-locale
+    check.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(8), 0});
+    check.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
+    check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(255), 0});
+    check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
+
+    // Use the global locale (fr_FR)
+    check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"),
+                                    std::chrono::weekday_indexed{std::chrono::weekday(8), 0});
+    check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"),
+                                    std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
+    check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"),
+                                    std::chrono::weekday_indexed{std::chrono::weekday(255), 0});
+    check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"),
+                                    std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
+
+    // Use supplied locale (ja_JP). This locale has a different alternate.
+    lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='8'\t%Ow='八'\n"),
+                                     std::chrono::weekday_indexed{std::chrono::weekday(8), 0});
+    lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='8'\t%Ow='八'\n"),
+                                     std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
+    lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='255'\t%Ow='255'\n"),
+                                     std::chrono::weekday_indexed{std::chrono::weekday(255), 0});
+    lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='255'\t%Ow='255'\n"),
+                                     std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
+  }
+
+  { // Valid weekday, tests %a and %A
+    constexpr string_literal fmt = "{:%%a='%a'%t%%A='%A'%n}";
+    constexpr string_literal lfmt = "{:L%%a='%a'%t%%A='%A'%n}";
+
+    // Non localized output using C-locale
+    check.template operator()<fmt>(SV("%a='Sun'\t%A='Sunday'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+    check.template operator()<fmt>(SV("%a='Sun'\t%A='Sunday'\n"),
+                                   std::chrono::weekday_indexed{std::chrono::weekday(0), 6});
+
+    // Use the global locale (fr_FR)
+    check.template operator()<lfmt>(SV("%a='dim.'\t%A='dimanche'\n"),
+                                    std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+    check.template operator()<lfmt>(SV("%a='dim.'\t%A='dimanche'\n"),
+                                    std::chrono::weekday_indexed{std::chrono::weekday(0), 6});
+
+    // Use supplied locale (ja_JP)
+    lcheck.template operator()<lfmt>(loc, SV("%a='日'\t%A='日曜日'\n"),
+                                     std::chrono::weekday_indexed{std::chrono::weekday(0), 0});
+    lcheck.template operator()<lfmt>(loc, SV("%a='日'\t%A='日曜日'\n"),
+                                     std::chrono::weekday_indexed{std::chrono::weekday(0), 6});
+  }
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  test_invalid_values<CharT>();
+  check_invalid_types<CharT>({SV("a"), SV("A"), SV("t"), SV("u"), SV("w"), SV("Ou"), SV("Ow")},
+                             std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+  check_exception("End of input while parsing the modifier E", SV("{:%E"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+  check_exception("End of input while parsing the modifier O", SV("{:%O"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"),
+                  std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+}
+
+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.weekday_last.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::weekday_last, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  // Valid day
+  check.template operator()<"{}">(SV("Sun[last]"), std::chrono::weekday_last{std::chrono::weekday(0)});
+
+  // Invalid day
+  check.template operator()<"{}">(SV("8 is not a valid weekday[last]"),
+                                  std::chrono::weekday_last{std::chrono::weekday(8)});
+}
+
+template <class CharT>
+static void test_valid_values() {
+  constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%n}";
+  constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%t%%a='%a'%t%%A='%A'%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.template operator()<fmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(0)});
+  check.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='Mon'\t%A='Monday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(1)});
+  check.template operator()<fmt>(SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='Tue'\t%A='Tuesday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(2)});
+  check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='Wed'\t%A='Wednesday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(3)});
+  check.template operator()<fmt>(SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='Thu'\t%A='Thursday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(4)});
+  check.template operator()<fmt>(SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='Fri'\t%A='Friday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(5)});
+  check.template operator()<fmt>(SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='Sat'\t%A='Saturday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(6)});
+  check.template operator()<fmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='Sun'\t%A='Sunday'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(7)});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(0)});
+  check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='lun.'\t%A='lundi'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(1)});
+  check.template operator()<lfmt>(SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='mar.'\t%A='mardi'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(2)});
+  check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='mer.'\t%A='mercredi'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(3)});
+  check.template operator()<lfmt>(SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='jeu.'\t%A='jeudi'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(4)});
+  check.template operator()<lfmt>(SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='ven.'\t%A='vendredi'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(5)});
+  check.template operator()<lfmt>(SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='sam.'\t%A='samedi'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(6)});
+  check.template operator()<lfmt>(SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='dim.'\t%A='dimanche'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(7)});
+
+  // Use supplied locale (ja_JP).
+  // This locale has a different alternate, but not on all platforms
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(0)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='1'\t%w='1'\t%Ow='1'\t%a='月'\t%A='月曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(1)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='2'\t%Ou='2'\t%w='2'\t%Ow='2'\t%a='火'\t%A='火曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(2)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='3'\t%w='3'\t%Ow='3'\t%a='水'\t%A='水曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(3)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='4'\t%Ou='4'\t%w='4'\t%Ow='4'\t%a='木'\t%A='木曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(4)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='5'\t%Ou='5'\t%w='5'\t%Ow='5'\t%a='金'\t%A='金曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(5)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='6'\t%Ou='6'\t%w='6'\t%Ow='6'\t%a='土'\t%A='土曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(6)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='7'\t%w='0'\t%Ow='0'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(7)});
+#else
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(0)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='1'\t%Ow='一'\t%a='月'\t%A='月曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(1)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='2'\t%Ou='二'\t%w='2'\t%Ow='二'\t%a='火'\t%A='火曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(2)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='3'\t%Ow='三'\t%a='水'\t%A='水曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(3)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='4'\t%Ou='四'\t%w='4'\t%Ow='四'\t%a='木'\t%A='木曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(4)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='5'\t%Ou='五'\t%w='5'\t%Ow='五'\t%a='金'\t%A='金曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(5)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='6'\t%Ou='六'\t%w='6'\t%Ow='六'\t%a='土'\t%A='土曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(6)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='7'\t%Ou='七'\t%w='0'\t%Ow='〇'\t%a='日'\t%A='日曜日'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(7)});
+#endif
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test_invalid_values() {
+  // Test that %a and %A throw an exception.
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::weekday_last{std::chrono::weekday(8)});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::weekday_last{std::chrono::weekday(255)});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::weekday_last{std::chrono::weekday(8)});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::weekday_last{std::chrono::weekday(255)});
+
+  constexpr string_literal fmt = "{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}";
+  constexpr string_literal lfmt = "{:L%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%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.template operator()<fmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(8)});
+  check.template operator()<fmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"),
+                                 std::chrono::weekday_last{std::chrono::weekday(255)});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%u='1'\t%Ou='1'\t%w='8'\t%Ow='8'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(8)});
+  check.template operator()<lfmt>(SV("%u='3'\t%Ou='3'\t%w='255'\t%Ow='255'\n"),
+                                  std::chrono::weekday_last{std::chrono::weekday(255)});
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc, SV("%u='1'\t%Ou='一'\t%w='8'\t%Ow='八'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(8)});
+  lcheck.template operator()<lfmt>(loc, SV("%u='3'\t%Ou='三'\t%w='255'\t%Ow='255'\n"),
+                                   std::chrono::weekday_last{std::chrono::weekday(255)});
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  test_invalid_values<CharT>();
+  check_invalid_types<CharT>({SV("a"), SV("A"), SV("t"), SV("u"), SV("w"), SV("Ou"), SV("Ow")},
+                             std::chrono::weekday_last{std::chrono::weekday(0)});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"),
+                  std::chrono::weekday_last{std::chrono::weekday(0)});
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::weekday_last{std::chrono::weekday(0)});
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"),
+                  std::chrono::weekday_last{std::chrono::weekday(0)});
+  check_exception("End of input while parsing the modifier E", SV("{:%E"),
+                  std::chrono::weekday_last{std::chrono::weekday(0)});
+  check_exception("End of input while parsing the modifier O", SV("{:%O"),
+                  std::chrono::weekday_last{std::chrono::weekday(0)});
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"),
+                  std::chrono::weekday_last{std::chrono::weekday(0)});
+}
+
+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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::year, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  check.template operator()<"{}">(SV("-32767"), std::chrono::year{-32'767});
+  check.template operator()<"{}">(SV("-1000"), std::chrono::year{-1000});
+  check.template operator()<"{}">(SV("-0100"), std::chrono::year{-100});
+  check.template operator()<"{}">(SV("-0010"), std::chrono::year{-10});
+  check.template operator()<"{}">(SV("-0001"), std::chrono::year{-1});
+  check.template operator()<"{}">(SV("0000"), std::chrono::year{0});
+  check.template operator()<"{}">(SV("0001"), std::chrono::year{1});
+  check.template operator()<"{}">(SV("0010"), std::chrono::year{10});
+  check.template operator()<"{}">(SV("0100"), std::chrono::year{100});
+  check.template operator()<"{}">(SV("1000"), std::chrono::year{1000});
+  check.template operator()<"{}">(SV("32727"), std::chrono::year{32'727});
+
+  // Invalid year
+  // TODO FMT How is this useful? The year is initialialized by an int and stored by a short
+  // so most invalid values have no relation to the input for the user
+  check.template operator()<"{}">(SV("-32768 is not a valid year"), std::chrono::year{-32'768});
+  check.template operator()<"{}">(SV("-32768 is not a valid year"), std::chrono::year{32'768});
+}
+
+template <class CharT>
+static void test_valid_values() {
+  constexpr string_literal fmt{"{:"
+                               "%%C='%C'%t"
+                               "%%EC='%EC'%t"
+                               "%%y='%y'%t"
+                               "%%Ey='%Ey'%t"
+                               "%%Oy='%Oy'%t"
+                               "%%Y='%Y'%t"
+                               "%%EY='%EY'%t"
+                               "%n}"};
+  constexpr string_literal lfmt{"{:L"
+                                "%%C='%C'%t"
+                                "%%EC='%EC'%t"
+                                "%%y='%y'%t"
+                                "%%Ey='%Ey'%t"
+                                "%%Oy='%Oy'%t"
+                                "%%Y='%Y'%t"
+                                "%%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.template operator()<fmt>(SV("%C='0'\t"
+                                    "%EC='0'\t"
+                                    "%y='00'\t"
+                                    "%Ey='00'\t"
+                                    "%Oy='00'\t"
+                                    "%Y='0000'\t"
+                                    "%EY='0'\t"
+                                    "\n"),
+                                 std::chrono::year{0});
+
+  check.template operator()<fmt>(SV("%C='19'\t"
+                                    "%EC='19'\t"
+                                    "%y='70'\t"
+                                    "%Ey='70'\t"
+                                    "%Oy='70'\t"
+                                    "%Y='1970'\t"
+                                    "%EY='1970'\t"
+                                    "\n"),
+                                 std::chrono::year{1970});
+
+  check.template operator()<fmt>(SV("%C='20'\t"
+                                    "%EC='20'\t"
+                                    "%y='38'\t"
+                                    "%Ey='38'\t"
+                                    "%Oy='38'\t"
+                                    "%Y='2038'\t"
+                                    "%EY='2038'\t"
+                                    "\n"),
+                                 std::chrono::year{2038});
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%C='0'\t"
+                                     "%EC='0'\t"
+                                     "%y='00'\t"
+                                     "%Ey='00'\t"
+                                     "%Oy='00'\t"
+                                     "%Y='0000'\t"
+                                     "%EY='0'\t"
+                                     "\n"),
+                                  std::chrono::year{0});
+
+  check.template operator()<lfmt>(SV("%C='19'\t"
+                                     "%EC='19'\t"
+                                     "%y='70'\t"
+                                     "%Ey='70'\t"
+                                     "%Oy='70'\t"
+                                     "%Y='1970'\t"
+                                     "%EY='1970'\t"
+                                     "\n"),
+                                  std::chrono::year{1970});
+
+  check.template operator()<lfmt>(SV("%C='20'\t"
+                                     "%EC='20'\t"
+                                     "%y='38'\t"
+                                     "%Ey='38'\t"
+                                     "%Oy='38'\t"
+                                     "%Y='2038'\t"
+                                     "%EY='2038'\t"
+                                     "\n"),
+                                  std::chrono::year{2038});
+
+  // Use supplied locale (ja_JP). This locale has a different alternate.
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%C='0'\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"),
+                                   std::chrono::year{0});
+
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%C='19'\t"
+                                      "%EC='昭和'\t"
+                                      "%y='70'\t"
+                                      "%Ey='45'\t"
+                                      "%Oy='七十'\t"
+                                      "%Y='1970'\t"
+                                      "%EY='昭和45年'\t"
+                                      "\n"),
+                                   std::chrono::year{1970});
+
+  // Note this test will fail if the Reiwa era ends before 2038.
+  lcheck.template operator()<lfmt>(loc,
+                                   SV("%C='20'\t"
+                                      "%EC='令和'\t"
+                                      "%y='38'\t"
+                                      "%Ey='20'\t"
+                                      "%Oy='三十八'\t"
+                                      "%Y='2038'\t"
+                                      "%EY='令和20年'\t"
+                                      "\n"),
+                                   std::chrono::year{2038});
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("C"), SV("y"), SV("Y"), SV("EC"), SV("Ey"), SV("EY"), SV("Oy")},
+                             std::chrono::year{1970});
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::year{1970});
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::year{1970});
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), std::chrono::year{1970});
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::year{1970});
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::year{1970});
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::year{1970});
+}
+
+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_month.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::year_month, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid month
+  check.template operator()<"{}">(SV("1970/Jan"),
+                                  std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{1}});
+  check.template operator()<"{:*^10}">(SV("*1970/Jan*"),
+                                       std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{1}});
+  check.template operator()<"{:*>9}">(SV("*1970/Jan"),
+                                      std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{1}});
+
+  // Invalid month
+  check.template operator()<"{}">(SV("1970/0 is not a valid month"),
+                                  std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{0}});
+  check.template operator()<"{:*^29}">(SV("*1970/0 is not a valid month*"),
+                                       std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{0}});
+}
+#if 0
+template <class CharT>
+static void test_valid_values() {
+  // Test that %b, %h, and %B throw an exception.
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"), std::chrono::month{200});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"), std::chrono::month{13});
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"), std::chrono::month{255});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"), std::chrono::month{0});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"), std::chrono::month{13});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"), std::chrono::month{255});
+
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"), std::chrono::month{0});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"), std::chrono::month{13});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"), std::chrono::month{255});
+
+  constexpr string_literal fmt{"{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}"};
+  constexpr string_literal lfmt{"{:L%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%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.template operator()<fmt>(SV("%b='Jan'\t%B='January'\t%h='Jan'\t%m='01'\t%Om='01'\n"), std::chrono::January);
+  check.template operator()<fmt>(SV("%b='Feb'\t%B='February'\t%h='Feb'\t%m='02'\t%Om='02'\n"), std::chrono::February);
+  check.template operator()<fmt>(SV("%b='Mar'\t%B='March'\t%h='Mar'\t%m='03'\t%Om='03'\n"), std::chrono::March);
+  check.template operator()<fmt>(SV("%b='Apr'\t%B='April'\t%h='Apr'\t%m='04'\t%Om='04'\n"), std::chrono::April);
+  check.template operator()<fmt>(SV("%b='May'\t%B='May'\t%h='May'\t%m='05'\t%Om='05'\n"), std::chrono::May);
+  check.template operator()<fmt>(SV("%b='Jun'\t%B='June'\t%h='Jun'\t%m='06'\t%Om='06'\n"), std::chrono::June);
+  check.template operator()<fmt>(SV("%b='Jul'\t%B='July'\t%h='Jul'\t%m='07'\t%Om='07'\n"), std::chrono::July);
+  check.template operator()<fmt>(SV("%b='Aug'\t%B='August'\t%h='Aug'\t%m='08'\t%Om='08'\n"), std::chrono::August);
+  check.template operator()<fmt>(SV("%b='Sep'\t%B='September'\t%h='Sep'\t%m='09'\t%Om='09'\n"), std::chrono::September);
+  check.template operator()<fmt>(SV("%b='Oct'\t%B='October'\t%h='Oct'\t%m='10'\t%Om='10'\n"), std::chrono::October);
+  check.template operator()<fmt>(SV("%b='Nov'\t%B='November'\t%h='Nov'\t%m='11'\t%Om='11'\n"), std::chrono::November);
+  check.template operator()<fmt>(SV("%b='Dec'\t%B='December'\t%h='Dec'\t%m='12'\t%Om='12'\n"), std::chrono::December);
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%b='janv.'\t%B='janvier'\t%h='janv.'\t%m='01'\t%Om='01'\n"),
+                                  std::chrono::January);
+  check.template operator()<lfmt>(SV("%b='févr.'\t%B='février'\t%h='févr.'\t%m='02'\t%Om='02'\n"),
+                                  std::chrono::February);
+  check.template operator()<lfmt>(SV("%b='mars'\t%B='mars'\t%h='mars'\t%m='03'\t%Om='03'\n"), std::chrono::March);
+  check.template operator()<lfmt>(SV("%b='avril'\t%B='avril'\t%h='avril'\t%m='04'\t%Om='04'\n"), std::chrono::April);
+  check.template operator()<lfmt>(SV("%b='mai'\t%B='mai'\t%h='mai'\t%m='05'\t%Om='05'\n"), std::chrono::May);
+  check.template operator()<lfmt>(SV("%b='juin'\t%B='juin'\t%h='juin'\t%m='06'\t%Om='06'\n"), std::chrono::June);
+  check.template operator()<lfmt>(SV("%b='juil.'\t%B='juillet'\t%h='juil.'\t%m='07'\t%Om='07'\n"), std::chrono::July);
+  check.template operator()<lfmt>(SV("%b='août'\t%B='août'\t%h='août'\t%m='08'\t%Om='08'\n"), std::chrono::August);
+  check.template operator()<lfmt>(SV("%b='sept.'\t%B='septembre'\t%h='sept.'\t%m='09'\t%Om='09'\n"),
+                                  std::chrono::September);
+  check.template operator()<lfmt>(SV("%b='oct.'\t%B='octobre'\t%h='oct.'\t%m='10'\t%Om='10'\n"), std::chrono::October);
+  check.template operator()<lfmt>(SV("%b='nov.'\t%B='novembre'\t%h='nov.'\t%m='11'\t%Om='11'\n"),
+                                  std::chrono::November);
+  check.template operator()<lfmt>(SV("%b='déc.'\t%B='décembre'\t%h='déc.'\t%m='12'\t%Om='12'\n"),
+                                  std::chrono::December);
+
+  // Use supplied locale (ja_JP)
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 1月'\t%B='1月'\t%h=' 1月'\t%m='01'\t%Om='一'\n"),
+                                   std::chrono::January);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 2月'\t%B='2月'\t%h=' 2月'\t%m='02'\t%Om='二'\n"),
+                                   std::chrono::February);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 3月'\t%B='3月'\t%h=' 3月'\t%m='03'\t%Om='三'\n"), std::chrono::March);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 4月'\t%B='4月'\t%h=' 4月'\t%m='04'\t%Om='四'\n"), std::chrono::April);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 5月'\t%B='5月'\t%h=' 5月'\t%m='05'\t%Om='五'\n"), std::chrono::May);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 6月'\t%B='6月'\t%h=' 6月'\t%m='06'\t%Om='六'\n"), std::chrono::June);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 7月'\t%B='7月'\t%h=' 7月'\t%m='07'\t%Om='七'\n"), std::chrono::July);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 8月'\t%B='8月'\t%h=' 8月'\t%m='08'\t%Om='八'\n"), std::chrono::August);
+  lcheck.template operator()<lfmt>(loc, SV("%b=' 9月'\t%B='9月'\t%h=' 9月'\t%m='09'\t%Om='九'\n"),
+                                   std::chrono::September);
+  lcheck.template operator()<lfmt>(loc, SV("%b='10月'\t%B='10月'\t%h='10月'\t%m='10'\t%Om='十'\n"),
+                                   std::chrono::October);
+  lcheck.template operator()<lfmt>(loc, SV("%b='11月'\t%B='11月'\t%h='11月'\t%m='11'\t%Om='十一'\n"),
+                                   std::chrono::November);
+  lcheck.template operator()<lfmt>(loc, SV("%b='12月'\t%B='12月'\t%h='12月'\t%m='12'\t%Om='十二'\n"),
+                                   std::chrono::December);
+
+  std::locale::global(std::locale::classic());
+}
+#endif
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+#if 0
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("b"), SV("B"), SV("h"), SV("m"), SV("Om")}, std::chrono::January);
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::January);
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::January);
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), std::chrono::January);
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::January);
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::January);
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::January);
+#endif
+}
+
+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_month_day.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::year_month_day, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid month
+  check.template operator()<"{}">(
+      SV("1970-01-01"),
+      std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{1}});
+  check.template operator()<"{:*^12}">(
+      SV("*1970-01-01*"),
+      std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{1}});
+  check.template operator()<"{:*>11}">(
+      SV("*1970-01-01"),
+      std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{1}});
+
+  // Invalid month_day
+  check.template operator()<"{}">(
+      SV("1970-00-01 is not a valid date"),
+      std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check.template operator()<"{:*^32}">(
+      SV("*1970-00-01 is not a valid date*"),
+      std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+
+  // Not a leap year
+  check.template operator()<"{}">(
+      SV("1970-02-29 is not a valid date"),
+      std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}});
+}
+
+template <class CharT>
+static void test_valid_values() {
+
+  // *** Invalid day ***
+
+  // Weekday name conversion
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+
+  // Weekday conversion
+  check_exception("formatting a weekday needs a valid value", SV("{:%u}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%w}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ou}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ow}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
+
+  // *** Invalid month ***
+
+  // Weekday name conversion
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+
+  // Weekday conversion
+  check_exception("formatting a weekday needs a valid value", SV("{:%u}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%w}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ou}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ow}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+
+  // Month name conversion
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{1}});
+
+  // *** Invalid year ***
+
+  // Weekday name conversion
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+
+  // Weekday conversion
+  check_exception("formatting a weekday needs a valid value", SV("{:%u}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%w}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ou}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ow}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+  check.template operator()<"{:%B}">(
+      SV("January"),
+      std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{1}});
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+}
+
+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_month_day_last.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::year_month_day_last_last, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid month
+  check.template operator()<"{}">(
+      SV("1970/Jan[last]"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check.template operator()<"{:*^16}">(
+      SV("*1970/Jan[last]*"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check.template operator()<"{:*>15}">(
+      SV("*1970/Jan[last]"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Invalid month_day
+  /*  check.template operator()<"{}">(
+      SV("1970-00-01 is not a valid date"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check.template operator()<"{:*^32}">(
+      SV("*1970-00-01 is not a valid date*"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+
+  // Not a leap year
+  check.template operator()<"{}">(
+      SV("1970-02-29 is not a valid date"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{2}}});*/
+}
+
+template <class CharT>
+static void test_valid_values() {
+
+  // *** Invalid day ***
+  /*
+  // Weekday name conversion
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Weekday conversion
+  check_exception("formatting a weekday needs a valid value", SV("{:%u}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%w}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ou}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ow}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{1}}});
+*/
+  // *** Invalid month ***
+
+  // Weekday name conversion
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%a}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%A}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+
+  // Weekday conversion
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%u}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%w}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%Ou}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%Ow}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+
+  // Day of year field
+  check_exception(
+      "formatting a day of year needs a valid value", SV("{:%j}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+
+  // Month name conversion
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%b}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%h}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+  check_exception(
+      "formatting a month name needs a valid value", SV("{:%B}"),
+      std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
+
+  // *** Invalid year ***
+
+  // Weekday name conversion
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%a}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception(
+      "formatting a weekday name needs a valid value", SV("{:%A}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Weekday conversion
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%u}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%w}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%Ou}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check_exception(
+      "formatting a weekday needs a valid value", SV("{:%Ow}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Day of year field
+  check_exception(
+      "formatting a day of year needs a valid value", SV("{:%j}"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+  check.template operator()<"{:%B}">(
+      SV("January"),
+      std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+}
+
+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_month_weekday.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::year_month_weekday, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid
+  check.template operator()<"{}">(
+      SV("1970/Jan/Mon[1]"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                             std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:*^17}">(
+      SV("*1970/Jan/Mon[1]*"),
+      std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                      std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:*>16}">(
+      SV("*1970/Jan/Mon[1]"),
+      std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                      std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // Invalid
+  check.template operator()<"{}">(
+      SV("1970/Jan/Mon[0 is not a valid index]"),
+      std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                      std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+  check.template operator()<"{}">(
+      SV("1970/Jan/8 is not a valid weekday[1]"),
+      std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                      std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{}">(
+      SV("1970/0 is not a valid month/Mon[1]"),
+      std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                      std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{}">(
+      SV("-32768 is not a valid year/Jan/Mon[1]"),
+      std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                      std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+}
+
+template <class CharT>
+static void test_invalid_values() {
+
+  // *** Invalid index ***
+  //
+  //
+  // invalid index does not lead to invalid dates... needs more tests
+#if 0
+  // Weekday name conversion
+  check.template operator()<"{:%a}">(
+      SV("Mon"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+  check.template operator()<"{:%A}">(
+      SV("Monday"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                    std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+  // Weekday conversion
+  check.template operator()<"{:%u}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+  check.template operator()<"{:%w}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+  check.template operator()<"{:%Ou}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+  check.template operator()<"{:%Ow}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 0}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                     std::chrono::weekday_indexed{std::chrono::weekday{8}, 0}});
+
+  // XXX what about an index 5 for a non existing day?
+  // January 1970 only has 4 mondays
+  check.template operator()<"{:%F %j}">(
+      SV("January"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                     std::chrono::weekday_indexed{std::chrono::weekday{1}, 5}});
+#endif
+  // *** Invalid weekday ***
+
+  // Weekday name conversion
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+
+  // Weekday conversion
+  check_exception("formatting a weekday needs a valid value", SV("{:%u}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%w}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ou}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ow}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{1},
+                                                     std::chrono::weekday_indexed{std::chrono::weekday{8}, 1}});
+
+  // *** Invalid month ***
+
+  // Weekday name conversion
+  check.template operator()<"{:%a}">(
+      SV("Mon"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%A}">(
+      SV("Monday"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                    std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  // Weekday conversion
+  check.template operator()<"{:%u}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%w}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%Ou}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%Ow}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // Month name conversion
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::year_month_weekday{std::chrono::year{1970}, std::chrono::month{0},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // *** Invalid year ***
+
+  // Weekday name conversion
+  check.template operator()<"{:%a}">(
+      SV("Mon"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%A}">(
+      SV("Monday"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                                    std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // Weekday conversion
+  check.template operator()<"{:%u}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%w}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%Ou}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%Ow}">(
+      SV("1"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                               std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                                  std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                                 std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_weekday{std::chrono::year{-32768}, std::chrono::month{1},
+                                                     std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_invalid_values<CharT>();
+}
+
+int main(int, char**) {
+  test<char>();
+
+  // add test where year wraps to the next year for all fields
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.syn/formatter.year_month_weekday_last.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: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::year_month_weekday_last, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  // Valid
+  check.template operator()<"{}">(SV("1970/Jan/Mon[last]"), std::chrono::year_month_weekday_last{
+                                                                std::chrono::year{1970}, std::chrono::month{1},
+                                                                std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:*^20}">(
+      SV("*1970/Jan/Mon[last]*"),
+      std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                           std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:*>19}">(
+      SV("*1970/Jan/Mon[last]"),
+      std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                           std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // Invalid
+  check.template operator()<"{}">(
+      SV("1970/Jan/8 is not a valid weekday[last]"),
+      std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                           std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check.template operator()<"{}">(
+      SV("1970/0 is not a valid month/Mon[last]"),
+      std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                           std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{}">(
+      SV("-32768 is not a valid year/Jan/Mon[last]"),
+      std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                           std::chrono::weekday_last{std::chrono::weekday{1}}});
+}
+
+template <class CharT>
+static void test_invalid_values() {
+
+  // *** Invalid weekday ***
+
+  // Weekday name conversion
+  check_exception("formatting a weekday name needs a valid value", SV("{:%a}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check_exception("formatting a weekday name needs a valid value", SV("{:%A}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+
+  // Weekday conversion
+  check_exception("formatting a weekday needs a valid value", SV("{:%u}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%w}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ou}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check_exception("formatting a weekday needs a valid value", SV("{:%Ow}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{8}}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                      std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                      std::chrono::weekday_last{std::chrono::weekday{8}}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{1},
+                                                          std::chrono::weekday_last{std::chrono::weekday{8}}});
+
+  // *** Invalid month ***
+
+  // Weekday name conversion
+  check.template operator()<"{:%a}">(
+      SV("Mon"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                      std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%A}">(
+      SV("Monday"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                         std::chrono::weekday_last{std::chrono::weekday{1}}});
+  // Weekday conversion
+  check.template operator()<"{:%u}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%w}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%Ou}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%Ow}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                       std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // Month name conversion
+  check_exception("formatting a month name needs a valid value", SV("{:%b}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                       std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check_exception("formatting a month name needs a valid value", SV("{:%h}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                       std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check_exception("formatting a month name needs a valid value", SV("{:%B}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{1970}, std::chrono::month{0},
+                                                       std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // *** Invalid year ***
+
+  // Weekday name conversion
+  check.template operator()<"{:%a}">(
+      SV("Mon"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                      std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%A}">(
+      SV("Monday"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                         std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // Weekday conversion
+  check.template operator()<"{:%u}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%w}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%Ou}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%Ow}">(
+      SV("1"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                    std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // Day of year field
+  check_exception("formatting a day of year needs a valid value", SV("{:%j}"),
+                  std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                       std::chrono::weekday_last{std::chrono::weekday{1}}});
+
+  // Month name conversion
+  check.template operator()<"{:%b}">(
+      SV("Jan"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                      std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%h}">(
+      SV("Jan"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                      std::chrono::weekday_last{std::chrono::weekday{1}}});
+  check.template operator()<"{:%B}">(
+      SV("January"), std::chrono::year_month_weekday_last{std::chrono::year{-32768}, std::chrono::month{1},
+                                                          std::chrono::weekday_last{std::chrono::weekday{1}}});
+}
+
+template <class CharT>
+static void test() {
+  test_no_chrono_specs<CharT>();
+  test_invalid_values<CharT>();
+}
+
+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_tests.h

+//===----------------------------------------------------------------------===//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "make_string.h"
+#include "string_literal.h"
+
+#include <algorithm>
+#include <cassert>
+#include <set>
+#include <string>
+#include <string_view>
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+inline constexpr auto check = []<string_literal fmt, class CharT, class... Args>(std::basic_string_view<CharT> expected,
+                                                                                 const Args&... args) constexpr {
+  std::basic_string<CharT> out = std::format(fmt.template sv<CharT>(), args...);
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt.template sv<CharT>() << "\nExpected output " << expected
+                << "\nActual output   " << out << '\n';
+  assert(out == expected);
+};
+
+inline constexpr auto lcheck = []<string_literal fmt, class CharT, class... Args>(
+    const std::locale& loc, std::basic_string_view<CharT> expected, const Args&... args) constexpr {
+  std::basic_string<CharT> out = std::format(loc, fmt.template sv<CharT>(), args...);
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt.template sv<CharT>() << "\nExpected output " << expected
+                << "\nActual output   " << out << '\n';
+  assert(out == expected);
+};
+
+inline constexpr auto check_exception = []<class CharT, class... Args>(
+                                            [[maybe_unused]] std::string_view what,
+                                            [[maybe_unused]] std::basic_string_view<CharT> fmt,
+                                            [[maybe_unused]] const Args&... args) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  try {
+    TEST_IGNORE_NODISCARD std::vformat(
+        fmt, std::make_format_args<
+                 std::conditional_t<std::same_as<CharT, char>, std::format_context, std::wformat_context>>(args...));
+    if constexpr (std::same_as<CharT, char>)
+      std::cerr << "\nFormat string   " << fmt << "\nDidn't throw an exception.\n";
+    assert(false);
+  } catch (const std::format_error& e) {
+#  if defined(_LIBCPP_VERSION)
+    if constexpr (std::same_as<CharT, char>)
+      if (e.what() != what)
+        std::cerr << "\nFormat string   " << fmt << "\nExpected exception " << what << "\nActual exception   "
+                  << e.what() << '\n';
+#  endif
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#endif
+};
+
+template <class CharT, class T>
+void check_invalid_type(const std::set<std::basic_string_view<CharT>>& valid_types, std::string_view what,
+                        std::basic_string<CharT> type, const T& arg) {
+  std::basic_string<CharT> fmt{STR("{:%") + type + STR("}")};
+
+  if (valid_types.contains(std::basic_string_view<CharT>{type})) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try {
+#endif
+      TEST_IGNORE_NODISCARD std::vformat(
+          std::basic_string_view<CharT>{fmt},
+          std::make_format_args<
+              std::conditional_t<std::same_as<CharT, char>, std::format_context, std::wformat_context>>(arg));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    } catch (const std::format_error& e) {
+#  if defined(_LIBCPP_VERSION)
+      if constexpr (std::same_as<CharT, char>)
+        std::cerr << "\nFormat string        " << fmt << "\nUnexpected exception " << e.what() << '\n';
+#  endif
+      assert(false);
+    }
+#endif
+  } else
+    check_exception(what, std::basic_string_view<CharT>{fmt}, arg);
+}
+
+template <class CharT, class T>
+void check_invalid_types(const std::set<std::basic_string_view<CharT>>& valid_types, const T& arg) {
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("a"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("A"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("b"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("B"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date and time", STR("c"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("C"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("d"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("D"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("e"), arg);
+  // E - the modifier is checked separately
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("f"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("F"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("g"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("G"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("h"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a hour", STR("H"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("i"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a hour", STR("I"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date or duration", STR("j"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("J"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("k"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("K"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("l"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("L"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("m"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a minute", STR("M"), arg);
+  // n - valid
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("N"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("o"), arg);
+  // O - the modifier is checked separately
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a hour", STR("p"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("P"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a duration", STR("q"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a duration", STR("Q"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("r"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("R"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("s"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a second", STR("S"), arg);
+  // t - valid
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("T"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("u"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("U"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("v"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("V"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("w"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("W"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("x"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("X"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("y"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("y"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("z"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("Z"), arg);
+
+  // *** E modifier
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ea"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EA"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eb"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EB"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date and time", STR("Ec"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("EC"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ed"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ED"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ee"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EE"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ef"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EF"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eg"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EG"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eh"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EH"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ei"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EI"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ej"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EJ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ek"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EK"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("El"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EL"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Em"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EM"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("En"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EN"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eo"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EO"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ep"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EP"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eq"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EQ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Er"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ER"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Es"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ES"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Et"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ET"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eu"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EU"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ev"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EV"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ew"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EW"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("Ex"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("EX"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("Ey"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("EY"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("Ez"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EZ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("E%"), arg);
+
+  // *** O modifier
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oa"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OA"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ob"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OB"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oc"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OC"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("Od"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OD"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("Oe"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OE"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Of"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OF"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Og"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OG"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oh"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a hour", STR("OH"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oi"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a hour", STR("OI"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oj"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OJ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ok"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OK"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ol"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OL"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("Om"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a minute", STR("OM"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("On"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("ON"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oo"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OO"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Op"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OP"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oq"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OQ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Or"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OR"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Os"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a second", STR("OS"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ot"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OT"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("Ou"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("OU"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ov"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("OV"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("Ow"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("OW"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ox"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OX"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("Oy"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OY"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("Oz"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OZ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("O%"), arg);
+}

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
                 || std::same_as<CharT, wchar_t>
 #endif
   )
     static_assert(enabled<T, CharT>);
   else
     assert_formatter_is_disabled<T, CharT>();
 }
 
+// The chrono formatters require localization support.
+// When this isn't available the formatter specialization isn't available
+// and the formatter is disabled.
+template <class T, class CharT>
+void assert_formatter_is_enabled_with_localization_support() {
+#ifndef TEST_HAS_NO_LOCALIZATION
+  assert_formatter_is_enabled<T, CharT>();
+#else
+  assert_formatter_is_disabled<T, CharT>();
+#endif
+}
+
 // Tests for P0645 Text Formatting
 template <class CharT>
 void test_P0645() {
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   // Tests the special formatter that converts a char to a wchar_t.
   assert_formatter_is_enabled<char, wchar_t>();
 #endif
   assert_formatter_is_enabled<CharT, CharT>();

 
 // Tests for P1361 Integration of chrono with text formatting
 //
 // Some tests are commented out since these types haven't been implemented in
 // chrono yet. After P1361 has been implemented these formatters should be all
 // enabled.
 template <class CharT>
 void test_P1361() {
-  assert_formatter_is_disabled<std::chrono::microseconds, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::microseconds, CharT>();
 
-  assert_formatter_is_disabled<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
   //assert_formatter_is_enabled<std::chrono::utc_time<std::chrono::microseconds>, CharT>();
   //assert_formatter_is_enabled<std::chrono::tai_time<std::chrono::microseconds>, CharT>();
   //assert_formatter_is_enabled<std::chrono::gps_time<std::chrono::microseconds>, CharT>();
   assert_formatter_is_disabled<std::chrono::file_time<std::chrono::microseconds>, CharT>();
   assert_formatter_is_disabled<std::chrono::local_time<std::chrono::microseconds>, CharT>();
 
-  assert_formatter_is_disabled<std::chrono::day, CharT>();
-  assert_formatter_is_disabled<std::chrono::month, CharT>();
-  assert_formatter_is_disabled<std::chrono::year, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::weekday, CharT>();
-  assert_formatter_is_disabled<std::chrono::weekday_indexed, CharT>();
-  assert_formatter_is_disabled<std::chrono::weekday_last, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::month_day, CharT>();
-  assert_formatter_is_disabled<std::chrono::month_day_last, CharT>();
-  assert_formatter_is_disabled<std::chrono::month_weekday, CharT>();
-  assert_formatter_is_disabled<std::chrono::month_weekday_last, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::year_month, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_day, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_day_last, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_weekday, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_weekday_last, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::day, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::month, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::year, CharT>();
+
+  assert_formatter_is_enabled_with_localization_support<std::chrono::weekday, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::weekday_indexed, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::weekday_last, CharT>();
+
+  assert_formatter_is_enabled_with_localization_support<std::chrono::month_day, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::month_day_last, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::month_weekday, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::month_weekday_last, CharT>();
+
+  assert_formatter_is_enabled_with_localization_support<std::chrono::year_month, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::year_month_day, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::year_month_day_last, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::year_month_weekday, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::year_month_weekday_last, CharT>();
 
-  assert_formatter_is_disabled<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
+  assert_formatter_is_enabled_with_localization_support<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
 
   //assert_formatter_is_enabled<std::chrono::sys_info, CharT>();
   //assert_formatter_is_enabled<std::chrono::local_info, CharT>();
 
   //assert_formatter_is_enabled<std::chrono::zoned_time, CharT>();
 }
 
 // Tests for P1636 Formatters for library types

libcxx/utils/ci/buildkite-pipeline.yml

 # into scripts. This is critical to being able to reproduce CI issues outside
 # of the CI environment, which is important for debugging.
 #
 # It is also worth noting that this script is split into several sections, the
 # goal being to reduce the load on testers when a commit is known to fail.
 #
 
 steps:
-  #
-  # Light pre-commit tests for things like formatting or when people forget
-  # to update generated files.
-  #
-  - label: "Format"
-    command: "libcxx/utils/ci/run-buildbot check-format"
-    artifact_paths:
-      - "**/clang-format.patch"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    soft_fail:
-        - exit_status: 1
-    timeout_in_minutes: 120
-
   - label: "Generated output"
     command: "libcxx/utils/ci/run-buildbot check-generated-output"
     artifact_paths:
       - "**/generated_output.patch"
       - "**/generated_output.status"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
-  - label: "Documentation"
-    command: "libcxx/utils/ci/run-buildbot documentation"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  #
-  # General testing with the default configuration, under all the supported
-  # Standard modes, with Clang and GCC. This catches most issues upfront.
-  # The goal of this step is to catch most issues while being very fast.
-  #
-  - wait
-
   - label: "C++2b"
     command: "libcxx/utils/ci/run-buildbot generic-cxx2b"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
-  - label: "C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++03"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx03"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Modular build"
-    command: "libcxx/utils/ci/run-buildbot generic-modules"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "GCC 11 / C++latest"
-    command: "libcxx/utils/ci/run-buildbot generic-gcc"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  #
-  # All other supported configurations of libc++.
-  #
-  - wait
-
-  - label: "C++20"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx20"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++17"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx17"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++14"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx14"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with the supported compilers.
-  - label: "GCC 11 / C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-gcc-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Clang 13"
-    command: "libcxx/utils/ci/run-buildbot generic-clang-13"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Clang 14"
-    command: "libcxx/utils/ci/run-buildbot generic-clang-14"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with the sanitizers.
-  - group: "Sanitizers"
-    steps:
-    - label: "ASAN"
-      command: "libcxx/utils/ci/run-buildbot generic-asan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "TSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-tsan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "UBSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-ubsan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-msan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  # Tests with the various supported ways to build libc++.
-  - label: "Bootstrapping build"
-    command: "libcxx/utils/ci/run-buildbot bootstrapping-build"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - group: "Legacy"
-    steps:
-    - label: "Legacy Lit configuration"
-      command: "libcxx/utils/ci/run-buildbot legacy-test-config"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Legacy LLVM_ENABLE_PROJECTS build"
-      command: "libcxx/utils/ci/run-buildbot legacy-project-build"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  # Tests with various build configurations.
-
-  - label: "Static libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-static"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Shared library with merged ABI and unwinder libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-merged"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Assertions enabled"
-    command: "libcxx/utils/ci/run-buildbot generic-assertions"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Debug iterators"
-    command: "libcxx/utils/ci/run-buildbot generic-debug-iterators"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "With LLVM's libunwind"
-    command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - group: "Parts disabled"
-    steps:
-    - label: "No threads"
-      command: "libcxx/utils/ci/run-buildbot generic-no-threads"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No debug mode"
-      command: "libcxx/utils/ci/run-buildbot generic-no-debug"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No filesystem"
-      command: "libcxx/utils/ci/run-buildbot generic-no-filesystem"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No random device"
-      command: "libcxx/utils/ci/run-buildbot generic-no-random_device"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No locale"
-      command: "libcxx/utils/ci/run-buildbot generic-no-localization"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No Unicode"
-      command: "libcxx/utils/ci/run-buildbot generic-no-unicode"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No wide characters"
-      command: "libcxx/utils/ci/run-buildbot generic-no-wide-characters"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No experimental features"
-      command: "libcxx/utils/ci/run-buildbot generic-no-experimental"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No exceptions"
-      command: "libcxx/utils/ci/run-buildbot generic-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - label: "Unstable ABI"
-    command: "libcxx/utils/ci/run-buildbot generic-abi-unstable"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Other non-testing CI jobs
-  - label: "Benchmarks"
-    command: "libcxx/utils/ci/run-buildbot benchmarks"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
   # Tests on non-Unix platforms
   - group: ":windows: Windows"
     steps:
     - label: "Clang-cl (DLL)"
       command: "bash libcxx/utils/ci/run-buildbot clang-cl-dll"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       agents:
         queue: "windows"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "Clang-cl (Static)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-static"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (DLL, x86_64)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-dll"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (Static, x86_64)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-static"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (DLL, i686)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-dll-i686"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - group: ":apple: Apple"
-    steps:
-    - label: "MacOS x86_64"
-      command: "libcxx/utils/ci/run-buildbot generic-cxx20"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MacOS arm64"
-      command: "libcxx/utils/ci/run-buildbot generic-cxx20"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # Build with the configuration we use to generate libc++.dylib on Apple platforms
-    - label: "Apple system"
-      command: "libcxx/utils/ci/run-buildbot apple-system"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64" # This can technically run on any architecture, but we have more resources on arm64 so we pin this job to arm64
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # Test back-deployment to older Apple platforms
-    - label: "Apple back-deployment macosx10.9"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.9"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # We need to use x86_64 for back-deployment CI, since the old dylibs were compiled for x86_64
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Apple back-deployment macosx10.15"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.15"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # We need to use x86_64 for back-deployment CI, since the old dylibs were compiled for x86_64
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Apple back-deployment macosx11.0 arm64"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-11.0"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
   - group: "ARM"
     steps:
     - label: "AArch64"
       command: "libcxx/utils/ci/run-buildbot aarch64"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       agents:
         queue: "libcxx-builders-linaro-arm"
         arch: "aarch64"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
-
-    - label: "AArch64 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot aarch64-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "aarch64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv8"
-      command: "libcxx/utils/ci/run-buildbot armv8"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv8 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot armv8-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv7"
-      command: "libcxx/utils/ci/run-buildbot armv7"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l" # Compiling for v7, running on v8 hardware
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv7 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot armv7-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l" # Compiling for v7, running on v8 hardware
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - group: "AIX"
-    steps:
-    - label: "AIX (32-bit)"
-      command: "libcxx/utils/ci/run-buildbot aix"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          OBJECT_MODE: "32"
-      agents:
-          queue: libcxx-builders
-          os: aix
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "AIX (64-bit)"
-      command: "libcxx/utils/ci/run-buildbot aix"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          OBJECT_MODE: "64"
-      agents:
-          queue: libcxx-builders
-          os: aix
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120