diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -135,12 +135,16 @@
   __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
diff --git a/libcxx/include/__chrono/formatter.h b/libcxx/include/__chrono/formatter.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__chrono/formatter.h
@@ -0,0 +1,861 @@
+// -*- 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>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_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};
+  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);
+      gmtime_r(std::addressof(__t), std::addressof(__result));
+#    if __GLIBC__
+      // The timezone is used sometimes, for example %Ec in the fr_FR locale
+      __result.tm_zone = "UTC";
+#    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));
+      gmtime_r(std::addressof(__t), std::addressof(__result));
+
+    } 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));
+      gmtime_r(std::addressof(__t), std::addressof(__result));
+    } 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 year isn't zero
+        // padded by time_put
+        //   1930 昭和5年
+        //   1935 昭和10年
+        //
+        // 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('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
diff --git a/libcxx/include/__chrono/ostream.h b/libcxx/include/__chrono/ostream.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__chrono/ostream.h
@@ -0,0 +1,235 @@
+// -*- 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/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>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_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
diff --git a/libcxx/include/__chrono/parser_std_format_spec.h b/libcxx/include/__chrono/parser_std_format_spec.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__chrono/parser_std_format_spec.h
@@ -0,0 +1,423 @@
+// -*- 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>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_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
diff --git a/libcxx/include/__chrono/statically_widen.h b/libcxx/include/__chrono/statically_widen.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__chrono/statically_widen.h
@@ -0,0 +1,38 @@
+// -*- 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 <__config>
+#include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
+#include <__concepts/same_as.h>
+
+#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
diff --git a/libcxx/include/__format/parser_std_format_spec.h b/libcxx/include/__format/parser_std_format_spec.h
--- a/libcxx/include/__format/parser_std_format_spec.h
+++ b/libcxx/include/__format/parser_std_format_spec.h
@@ -1532,10 +1532,16 @@
   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
diff --git a/libcxx/include/chrono b/libcxx/include/chrono
--- a/libcxx/include/chrono
+++ b/libcxx/include/chrono
@@ -205,7 +205,11 @@
 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>
@@ -276,6 +280,10 @@
 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:
@@ -334,6 +342,9 @@
 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;
@@ -347,6 +358,9 @@
 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;
@@ -360,6 +374,9 @@
 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;
@@ -370,6 +387,9 @@
 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
 
@@ -632,6 +652,10 @@
     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;
@@ -647,7 +671,33 @@
 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
@@ -700,12 +750,15 @@
 #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>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -399,25 +399,29 @@
     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 {
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -169,12 +169,16 @@
 #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'}}
diff --git a/libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp b/libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp
--- a/libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp
+++ b/libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp
@@ -71,6 +71,18 @@
     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() {
@@ -122,35 +134,35 @@
 // 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_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_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_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_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_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_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::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>();
diff --git a/libcxx/test/std/time/time.hms/time.hms.nonmembers/ostream.pass.cpp b/libcxx/test/std/time/time.hms/time.hms.nonmembers/ostream.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.hms/time.hms.nonmembers/ostream.pass.cpp
@@ -0,0 +1,154 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp b/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp
@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/ostream.pass.cpp b/libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/ostream.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/ostream.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/ostream.pass.cpp b/libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/ostream.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/ostream.pass.cpp
@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp b/libcxx/test/std/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
--- a/libcxx/test/std/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
+++ b/libcxx/test/std/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
@@ -52,6 +52,28 @@
     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
     {
diff --git a/libcxx/test/std/time/time.clock/time.clock.file/consistency.pass.cpp b/libcxx/test/std/time/time.clock/time.clock.file/consistency.pass.cpp
--- a/libcxx/test/std/time/time.clock/time.clock.file/consistency.pass.cpp
+++ b/libcxx/test/std/time/time.clock/time.clock.file/consistency.pass.cpp
@@ -10,7 +10,7 @@
 
 // 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>
 
diff --git a/libcxx/test/std/time/time.clock/time.clock.system/ostream.pass.cpp b/libcxx/test/std/time/time.clock/time.clock.system/ostream.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.clock/time.clock.system/ostream.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp b/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp
@@ -0,0 +1,208 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 {
+    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"));
+  }
+
+  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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp b/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
@@ -0,0 +1,437 @@
+//===----------------------------------------------------------------------===//
+// 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"
+                                     "%r='12:00:00 '\t"
+                                     "%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"
+                                     "%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));
+
+  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"
+         "%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))));
+
+  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"
+                                     "%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)));
+
+  // 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.day.pass.cpp b/libcxx/test/std/time/time.syn/formatter.day.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.day.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp b/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp
@@ -0,0 +1,874 @@
+//===----------------------------------------------------------------------===//
+// 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"
+                                     "%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);
+#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"
+                                     "%r='11:59:59 '\t"
+                                     "%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"
+                                     "%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);
+
+#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"
+                                     "%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));
+
+  // 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.month.pass.cpp b/libcxx/test/std/time/time.syn/formatter.month.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.month.pass.cpp
@@ -0,0 +1,147 @@
+//===----------------------------------------------------------------------===//
+// 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);
+  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());
+}
+
+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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.month_day.pass.cpp b/libcxx/test/std/time/time.syn/formatter.month_day.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.month_day.pass.cpp
@@ -0,0 +1,245 @@
+//===----------------------------------------------------------------------===//
+// 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>(
+      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"),
+      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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.month_day_last.pass.cpp b/libcxx/test/std/time/time.syn/formatter.month_day_last.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.month_day_last.pass.cpp
@@ -0,0 +1,189 @@
+//===----------------------------------------------------------------------===//
+// 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>(SV("%b='avril'\t%B='avril'\t%h='avril'\t%m='04'\t%Om='04'\n"),
+                                  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)
+  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});
+
+  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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.month_weekday.pass.cpp b/libcxx/test/std/time/time.syn/formatter.month_weekday.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.month_weekday.pass.cpp
@@ -0,0 +1,421 @@
+//===----------------------------------------------------------------------===//
+// 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>(
+      SV("%b='avril'\t%B='avril'\t%h='avril'\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()<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)
+  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}});
+
+  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.
+  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}});
+
+  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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.sys_time.pass.cpp b/libcxx/test/std/time/time.syn/formatter.sys_time.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.sys_time.pass.cpp
@@ -0,0 +1,588 @@
+//===----------------------------------------------------------------------===//
+// 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.
+  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
+
+  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.
+  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
+
+  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.
+  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
+
+  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"
+                                     "%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
+
+  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"
+                                     "%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
+
+  // 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>(SV("%c='jeu. 01 janv. 1970 00:00:00 UTC'\t%Ec='jeu. 01 janv. 1970 00:00:00 UTC'\n"),
+                                  std::chrono::sys_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+  check.template operator()<lfmt>(SV("%c='ven. 13 févr. 2009 23:31:30 UTC'\t%Ec='ven. 13 févr. 2009 23:31:30 UTC'\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("%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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.weekday.pass.cpp b/libcxx/test/std/time/time.syn/formatter.weekday.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.weekday.pass.cpp
@@ -0,0 +1,198 @@
+//===----------------------------------------------------------------------===//
+// 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.
+  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));
+
+  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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.weekday_index.pass.cpp b/libcxx/test/std/time/time.syn/formatter.weekday_index.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.weekday_index.pass.cpp
@@ -0,0 +1,236 @@
+//===----------------------------------------------------------------------===//
+// 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.
+  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});
+
+  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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.weekday_last.pass.cpp b/libcxx/test/std/time/time.syn/formatter.weekday_last.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.weekday_last.pass.cpp
@@ -0,0 +1,181 @@
+//===----------------------------------------------------------------------===//
+// 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.
+  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)});
+
+  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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.year.pass.cpp b/libcxx/test/std/time/time.syn/formatter.year.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.year.pass.cpp
@@ -0,0 +1,204 @@
+//===----------------------------------------------------------------------===//
+// 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"
+                                      "%Ey='1'\t"
+                                      "%Oy='〇'\t"
+                                      "%Y='0000'\t"
+                                      "%EY='紀元前1年'\t"
+                                      "\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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.year_month.pass.cpp b/libcxx/test/std/time/time.syn/formatter.year_month.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.year_month.pass.cpp
@@ -0,0 +1,154 @@
+//===----------------------------------------------------------------------===//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.year_month_day.pass.cpp b/libcxx/test/std/time/time.syn/formatter.year_month_day.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.year_month_day.pass.cpp
@@ -0,0 +1,170 @@
+//===----------------------------------------------------------------------===//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.year_month_day_last.pass.cpp b/libcxx/test/std/time/time.syn/formatter.year_month_day_last.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.year_month_day_last.pass.cpp
@@ -0,0 +1,189 @@
+//===----------------------------------------------------------------------===//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.year_month_weekday.pass.cpp b/libcxx/test/std/time/time.syn/formatter.year_month_weekday.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.year_month_weekday.pass.cpp
@@ -0,0 +1,255 @@
+//===----------------------------------------------------------------------===//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter.year_month_weekday_last.pass.cpp b/libcxx/test/std/time/time.syn/formatter.year_month_weekday_last.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter.year_month_weekday_last.pass.cpp
@@ -0,0 +1,201 @@
+//===----------------------------------------------------------------------===//
+// 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;
+}
diff --git a/libcxx/test/std/time/time.syn/formatter_tests.h b/libcxx/test/std/time/time.syn/formatter_tests.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/time/time.syn/formatter_tests.h
@@ -0,0 +1,256 @@
+//===----------------------------------------------------------------------===//
+// 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);
+}
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp
--- a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp
@@ -112,6 +112,18 @@
     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() {
@@ -164,35 +176,35 @@
 // 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_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_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_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_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_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_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::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>();
diff --git a/libcxx/utils/ci/buildkite-pipeline.yml b/libcxx/utils/ci/buildkite-pipeline.yml
--- a/libcxx/utils/ci/buildkite-pipeline.yml
+++ b/libcxx/utils/ci/buildkite-pipeline.yml
@@ -18,25 +18,6 @@
 #
 
 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:
@@ -51,26 +32,6 @@
           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:
@@ -85,48 +46,6 @@
           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:
@@ -141,568 +60,26 @@
           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"
+  # Tests on non-Unix platforms
+  - group: ":windows: Windows"
     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"
+    - label: "Clang-cl (DLL)"
+      command: "bash libcxx/utils/ci/run-buildbot clang-cl-dll"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       agents:
-        queue: "libcxx-builders"
-        os: "linux"
+        queue: "windows"
       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: "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"
+  - group: "ARM"
     steps:
-    - label: "No threads"
-      command: "libcxx/utils/ci/run-buildbot generic-singlethreaded"
-      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)"
-      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)"
-      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
-
-  - 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"
+    - label: "AArch64"
+      command: "libcxx/utils/ci/run-buildbot aarch64"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
@@ -715,94 +92,6 @@
             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: