[libc++][format] Improves diagnostics.

[Mordante]

Summary

Improves both the compile-time and run-time errors.
At compile-time it does a bit more work to get more specific errors.
This could be done at run-time too, but that has a performance penalty.
Since it's expected most use-cases use format* instead of vformat* the
compile-time errors are more common.

For example when using

std::format_to("{:-c}", 42);

Before compile output would contain

std::__throw_format_error("The format-spec should consume the input or end with a '}'");

Now it contains

std::__throw_format_error("The format specifier does not allow the sign option");

Given a better indication the sign option is not allowed. Note the
output is still not user-friendly; C++ doesn't have good facilities to
generate nice messages from the library.

In general all messages have been reviewed and improved, using a more
consistent style and using less terms used in the standard. For example

format-spec -> format specifier
arg-id -> argument index

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Rebased and minor polishing.

[ldionne]

libcxx/include/__format/format_functions.h

131

Elsewhere too.

[ldionne]

Could you split this patch into a patch that changes the error messages (e.g. reformulation, capitalization, etc), another one that adds additional parsing logic to improve the error messages and one that changes the bracket handling? I feel like there's more than one orthogonal things in this patch, especially since part of it requires an ABI change that goes mostly unnoticed otherwise.

libcxx/include/__format/parser_std_format_spec.h

384–385

Can you use braces consistently after the else? Otherwise it becomes really hard to distinguish what is in the else given the nesting.

444–445

[Mordante]

Addresses review comment and rebased on the patches splitted from this patch.

libcxx/include/__chrono/formatter.h

if constexpr (chrono::__is_duration<_Tp>::value) {
         __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.
       // Note that the behaviour what the precision does isn't specified.
       __specs.__precision_ = -1;
     } else {
       // Test __weekday_name_ before __weekday_ to give a better error.
       if (__specs.__chrono_.__weekday_name_ && !__formatter::__weekday_name_ok(__value))
-        std::__throw_format_error("formatting a weekday name needs a valid weekday");
+        std::__throw_format_error("Formatting a weekday name needs a valid weekday");
 
       if (__specs.__chrono_.__weekday_ && !__formatter::__weekday_ok(__value))
-        std::__throw_format_error("formatting a weekday needs a valid weekday");
+        std::__throw_format_error("Formatting a weekday needs a valid weekday");
 
       if (__specs.__chrono_.__day_of_year_ && !__formatter::__date_ok(__value))
-        std::__throw_format_error("formatting a day of year needs a valid date");
+        std::__throw_format_error("Formatting a day of year needs a valid date");
 
       if (__specs.__chrono_.__week_of_year_ && !__formatter::__date_ok(__value))
-        std::__throw_format_error("formatting a week of year needs a valid date");
+        std::__throw_format_error("Formatting a week of year needs a valid date");
 
       if (__specs.__chrono_.__month_name_ && !__formatter::__month_name_ok(__value))
-        std::__throw_format_error("formatting a month name from an invalid month number");
+        std::__throw_format_error("Formatting a month name from an invalid month number");
 
       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 The wording probably 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 (__specs.__chrono_.__hour_ && __value.hours().count() > 23)
-          std::__throw_format_error("formatting a hour needs a valid value");
+          std::__throw_format_error("Formatting a hour needs a valid value");
 
         if (__value.is_negative())
           __sstr << _CharT('-');
       }
 
       __formatter::__format_chrono_using_chrono_specs(__value, __sstr, __chrono_specs);
     }
   }

libcxx/include/__chrono/parser_std_format_spec.h

 private:
   _LIBCPP_HIDE_FROM_ABI constexpr _ConstIterator
   __parse_chrono_specs(_ConstIterator __begin, _ConstIterator __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('}'))
-      std::__throw_format_error("Expected '%' or '}' in the chrono format-string");
+      std::__throw_format_error("The format specifier expects a '%' or a '}'");
 
     do {
       switch (*__begin) {
       case _CharT('{'):
-        std::__throw_format_error("The chrono-specs contains a '{'");
+        std::__throw_format_error("The chrono specifiers contain a '{'");
 
       case _CharT('}'):
         return __begin;
 
       case _CharT('%'):
         __parse_conversion_spec(__begin, __end, __flags);
         [[fallthrough]];
 
       default:
         // All other literals
         ++__begin;
       }
 
     } while (__begin != __end && *__begin != _CharT('}'));
 
     return __begin;
   }
 
   /// \pre *__begin == '%'
   /// \post __begin points at the end parsed conversion-spec
   _LIBCPP_HIDE_FROM_ABI constexpr void
   __parse_conversion_spec(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
-      std::__throw_format_error("End of input while parsing the modifier chrono conversion-spec");
+      std::__throw_format_error("End of input while parsing a conversion specifier");
 
     switch (*__begin) {
     case _CharT('n'):
     case _CharT('t'):
     case _CharT('%'):
       break;
 
     case _CharT('S'):

libcxx/include/__format/format_functions.h

public:
   struct iterator {
     _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator=(_CharT) { return *this; }
     _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator*() { return *this; }
     _LIBCPP_HIDE_FROM_ABI constexpr iterator operator++(int) { return *this; }
   };
 
   _LIBCPP_HIDE_FROM_ABI constexpr __arg_t arg(size_t __id) const {
     if (__id >= __size_)
-      std::__throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("The argument index value is too larger for the number of arguments supplied");
     return __args_[__id];
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const __compile_time_handle<_CharT>& __handle(size_t __id) const {
     if (__id >= __size_)
-      std::__throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("The argument index value is too larger for the number of arguments supplied");
     return __handles_[__id];
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr iterator out() { return {}; }
   _LIBCPP_HIDE_FROM_ABI constexpr void advance_to(iterator) {}
 
 private:
   const __arg_t* __args_;
case _CharT(':'):
     // The arg-id has a format-specifier, advance the input to the format-spec.
     __parse_ctx.advance_to(__r.__last + 1);
     break;
   case _CharT('}'):
     // The arg-id has no format-specifier.
     __parse_ctx.advance_to(__r.__last);
     break;
   default:
-    std::__throw_format_error("The replacement field arg-id should terminate at a ':' or '}'");
+    std::__throw_format_error("The argument index should end with a ':' or a '}'");
   }
 
   if constexpr (same_as<_Ctx, __compile_time_basic_format_context<_CharT>>) {
     __arg_t __type = __ctx.arg(__r.__value);
     if (__type == __arg_t::__none)
-      std::__throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("The argument index value is too larger for the number of arguments supplied");
     else if (__type == __arg_t::__handle)
       __ctx.__handle(__r.__value).__parse(__parse_ctx);
     else if (__parse)
       __format::__compile_time_visit_format_arg(__parse_ctx, __ctx, __type);
   } else
     _VSTD::__visit_format_arg(
         [&](auto __arg) {
           if constexpr (same_as<decltype(__arg), monostate>)
-            std::__throw_format_error("Argument index out of bounds");
+            std::__throw_format_error("The argument index value is too larger for the number of arguments supplied");
           else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Ctx>::handle>)
             __arg.format(__parse_ctx, __ctx);
           else {
             formatter<decltype(__arg), _CharT> __formatter;
             if (__parse)
               __parse_ctx.advance_to(__formatter.parse(__parse_ctx));
             __ctx.advance_to(__formatter.format(__arg, __ctx));
           }

libcxx/include/__format/format_string.h

if (__begin != __end_input && *__begin >= _CharT('0') &&
      * - Does the 10th digit exceed the maximum allowed value?
      * - Are there more than 10 digits?
      * (More than 10 digits always overflows the maximum.)
      */
     uint64_t __v = uint64_t(__value) * 10 + *__begin++ - _CharT('0');
     if (__v > __number_max ||
         (__begin != __end_input && *__begin >= _CharT('0') &&
          *__begin <= _CharT('9')))
-      std::__throw_format_error("The numeric value of the format-spec is too large");
+      std::__throw_format_error("The numeric value of the format specifier is too large");
 
     __value = __v;
   }
 
   return {__begin, __value};
 }
 
 /**
__parse_arg_id(_Iterator __begin, _Iterator __end, auto& __parse_ctx) {
   case _CharT(':'):
     // This case is conditionally valid. It's allowed in an arg-id in the
     // replacement-field, but not in the std-format-spec. The caller can
     // provide a better diagnostic, so accept it here unconditionally.
   case _CharT('}'):
     return __detail::__parse_automatic(__begin, __end, __parse_ctx);
   }
   if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-    std::__throw_format_error("The arg-id of the format-spec starts with an invalid character");
+    std::__throw_format_error("The argument index starts with an invalid character");
 
   return __detail::__parse_manual(__begin, __end, __parse_ctx);
 }
 
 } // namespace __format
 
 #endif //_LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_STRING_H

libcxx/include/__format/formatter_bool.h

 #if _LIBCPP_STD_VER >= 20
 
 template <__fmt_char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
-    __format_spec::__process_parsed_bool(__parser_);
+    __format_spec::__process_parsed_bool(__parser_, "a bool");
     return __result;
   }
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(bool __value, _FormatContext& __ctx) const {
     switch (__parser_.__type_) {
     case __format_spec::__type::__default:
     case __format_spec::__type::__string:

libcxx/include/__format/formatter_char.h

 #if _LIBCPP_STD_VER >= 20
 
 template <__fmt_char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS __formatter_char {
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
-    __format_spec::__process_parsed_char(__parser_);
+    __format_spec::__process_parsed_char(__parser_, "a character");
     return __result;
   }
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_CharT __value, _FormatContext& __ctx) const {
     if (__parser_.__type_ == __format_spec::__type::__default || __parser_.__type_ == __format_spec::__type::__char)
       return __formatter::__format_char(__value, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx));
 

libcxx/include/__format/formatter_floating_point.h

 } // namespace __formatter
 
 template <__fmt_char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS __formatter_floating_point {
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_floating_point);
-    __format_spec::__process_parsed_floating_point(__parser_);
+    __format_spec::__process_parsed_floating_point(__parser_, "a floating-point");
     return __result;
   }
 
   template <floating_point _Tp, class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_Tp __value, _FormatContext& __ctx) const {
     return __formatter::__format_floating_point(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx));
   }
 

libcxx/include/__format/formatter_integer.h

#if _LIBCPP_STD_VER >= 20
 
     template <__fmt_char_type _CharT>
     struct _LIBCPP_TEMPLATE_VIS __formatter_integer {
 
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
-    __format_spec::__process_parsed_integer(__parser_);
+    __format_spec::__process_parsed_integer(__parser_, "an integer");
     return __result;
   }
 
   template <integral _Tp, class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_Tp __value, _FormatContext& __ctx) const {
     __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
 
     if (__specs.__std_.__type_ == __format_spec::__type::__char)

libcxx/include/__format/formatter_pointer.h

 #if _LIBCPP_STD_VER >= 20
 
 template <__fmt_char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS __formatter_pointer {
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_pointer);
-    __format_spec::__process_display_type_pointer(__parser_.__type_);
+    __format_spec::__process_display_type_pointer(__parser_.__type_, "a pointer");
     return __result;
   }
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const void* __ptr, _FormatContext& __ctx) const {
     __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
     __specs.__std_.__alternate_form_                       = true;
     __specs.__std_.__type_                                 = __format_spec::__type::__hexadecimal_lower_case;

libcxx/include/__format/formatter_tuple.h

set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
     __closing_bracket_ = __closing_bracket;
   }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     auto __begin = __parser_.__parse(__ctx, __format_spec::__fields_tuple);
 
     auto __end = __ctx.end();
-    if (__begin != __end) {
-      if (*__begin == _CharT('m')) {
-        if constexpr (sizeof...(_Args) == 2) {
-          set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ": "));
-          set_brackets({}, {});
-          ++__begin;
-        } else
-          std::__throw_format_error("The format specifier m requires a pair or a two-element tuple");
-      } else if (*__begin == _CharT('n')) {
-        set_brackets({}, {});
-        ++__begin;
-      }
+    // Note 'n' is part of the type here
+    if (__parser_.__clear_brackets_)
+      set_brackets({}, {});
+    else if (__begin != __end && *__begin == _CharT('m')) {
+        std::__throw_format_error("Type m requires a pair or a tuple with two elements");
     }
 
     if (__begin != __end && *__begin != _CharT('}'))
-      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     __ctx.advance_to(__begin);
 
     // [format.tuple]/7
     //   ... For each element e in underlying_, if e.set_debug_format()
     //   is a valid expression, calls e.set_debug_format().
     std::__for_each_index_sequence(make_index_sequence<sizeof...(_Args)>(), [&]<size_t _Index> {
       auto& __formatter = std::get<_Index>(__underlying_);

libcxx/include/__format/parser_std_format_spec.h

 #include <__format/width_estimation_table.h>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h> // iter_value_t
 #include <__memory/addressof.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__variant/monostate.h>
 #include <cstdint>
+#include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace __format_spec {
 
+_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void
+__throw_invalid_option_format_error(const char* __id, const char* __option) {
+  std::__throw_format_error(
+      (string("The format specifier for ") + __id + " does not allow the " + __option + " option").c_str());
+}
+
+_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __throw_invalid_type_format_error(const char* __id) {
+  std::__throw_format_error(
+      (string("The type option contains an invalid value for ") + __id + " formatting argument").c_str());
+}
+
 template <contiguous_iterator _Iterator, class _ParseContext>
 _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result<_Iterator>
 __parse_arg_id(_Iterator __begin, _Iterator __end, _ParseContext& __ctx) {
   using _CharT = iter_value_t<_Iterator>;
   // This function is a wrapper to call the real parser. But it does the
   // validation for the pre-conditions and post-conditions.
   if (__begin == __end)
-    std::__throw_format_error("End of input while parsing format-spec arg-id");
+    std::__throw_format_error("End of input while parsing an argument index");
 
   __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __ctx);
 
   if (__r.__last == __end || *__r.__last != _CharT('}'))
-    std::__throw_format_error("Invalid arg-id");
+    std::__throw_format_error("The argument index is invalid");
 
   ++__r.__last;
   return __r;
 }
 
 template <class _Context>
 _LIBCPP_HIDE_FROM_ABI constexpr uint32_t
 __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
   // [format.string.std]/8
   //   If the corresponding formatting argument is not of integral type...
   // This wording allows char and bool too. LWG-3720 changes the wording to
   //    If the corresponding formatting argument is not of standard signed or
   //    unsigned integer type,
   // This means the 128-bit will not be valid anymore.
   // TODO FMT Verify this resolution is accepted and add a test to verify
   //          128-bit integrals fail and switch to visit_format_arg.
   return _VSTD::__visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
         if constexpr (same_as<_Type, monostate>)
-          std::__throw_format_error("Argument index out of bounds");
+          std::__throw_format_error("The argument index value is too larger for the number of arguments supplied");
 
         // [format.string.std]/8
         // If { arg-idopt } is used in a width or precision, the value of the
         // corresponding formatting argument is used in its place. If the
         // corresponding formatting argument is not of standard signed or unsigned
         // integer type, or its value is negative for precision or non-positive for
         // width, an exception of type format_error is thrown.
         //
         // When an integral is used in a format function, it is stored as one of
         // the types checked below. Other integral types are promoted. For example,
         // a signed char is stored as an int.
         if constexpr (same_as<_Type, int> || same_as<_Type, unsigned int> || //
                       same_as<_Type, long long> || same_as<_Type, unsigned long long>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
-              std::__throw_format_error("A format-spec arg-id replacement shouldn't have a negative value");
+              std::__throw_format_error("An argument index may not have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
           if (static_cast<_CT>(__arg) > static_cast<_CT>(__format::__number_max))
-            std::__throw_format_error("A format-spec arg-id replacement exceeds the maximum supported value");
+            std::__throw_format_error("The value of the argument index exceeds its maximum value");
 
           return __arg;
         } else
           std::__throw_format_error("Replacement argument isn't a standard signed or unsigned integer type");
       },
       __format_arg);
 }
 
 /// These fields are a filter for which elements to parse.
 ///
 /// They default to false so when a new field is added it needs to be opted in
 /// explicitly.
 // TODO FMT Use an ABI tag for this struct.
 struct __fields {
-  uint8_t __sign_ : 1 {false};
-  uint8_t __alternate_form_ : 1 {false};
-  uint8_t __zero_padding_ : 1 {false};
-  uint8_t __precision_ : 1 {false};
-  uint8_t __locale_specific_form_ : 1 {false};
-  uint8_t __type_ : 1 {false};
+  uint16_t __sign_                 : 1 {false};
+  uint16_t __alternate_form_       : 1 {false};
+  uint16_t __zero_padding_         : 1 {false};
+  uint16_t __precision_            : 1 {false};
+  uint16_t __locale_specific_form_ : 1 {false};
+  uint16_t __type_                 : 1 {false};
   // Determines the valid values for fill.
   //
   // Originally the fill could be any character except { and }. Range-based
   // formatters use the colon to mark the beginning of the
   // underlying-format-spec. To avoid parsing ambiguities these formatter
   // specializations prohibit the use of the colon as a fill character.
-  uint8_t __use_range_fill_ : 1 {false};
+  uint16_t __use_range_fill_ : 1 {false};
+  uint16_t __clear_brackets_ : 1 {false};
+  uint16_t __consume_all_    : 1 {false};
 };
 
 // By not placing this constant in the formatter class it's not duplicated for
 // char and wchar_t.
+inline constexpr __fields __fields_bool{.__locale_specific_form_ = true, .__type_ = true, .__consume_all_ = true};
 inline constexpr __fields __fields_integral{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__locale_specific_form_ = true,
-    .__type_                 = true};
+    .__type_                 = true,
+    .__consume_all_          = true};
 inline constexpr __fields __fields_floating_point{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__precision_            = true,
     .__locale_specific_form_ = true,
-    .__type_                 = true};
-inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true};
-inline constexpr __fields __fields_pointer{.__type_ = true};
+    .__type_                 = true,
+    .__consume_all_          = true};
+inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true, .__consume_all_ = true};
+inline constexpr __fields __fields_pointer{.__type_ = true, .__consume_all_ = true};
 
 #  if _LIBCPP_STD_VER >= 23
-inline constexpr __fields __fields_tuple{.__use_range_fill_ = true};
-inline constexpr __fields __fields_range{.__use_range_fill_ = true};
+inline constexpr __fields __fields_tuple{.__use_range_fill_ = true, .__clear_brackets_ = true};
+inline constexpr __fields __fields_range{.__use_range_fill_ = true, .__clear_brackets_ = true};
 inline constexpr __fields __fields_fill_align_width{};
 #  endif
 
 enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
   /// No alignment is set in the format string.
   __default,
   __left,
   __center,
enum class _LIBCPP_ENUM_VIS __type : uint8_t {
   __hexfloat_lower_case,
   __hexfloat_upper_case,
   __scientific_lower_case,
   __scientific_upper_case,
   __fixed_lower_case,
   __fixed_upper_case,
   __general_lower_case,
   __general_upper_case,
-  __debug
+  __debug,
+  __range,
+  __stream_like,
 };
 
+constexpr uint32_t __create_type_mask(__type __t) {
+  uint32_t __shift = static_cast<uint32_t>(__t);
+  if (__shift == 0)
+    return 1;
+
+  if (__shift > 31)
+    std::__throw_format_error("The type does not fit in the mask");
+
+  return 1 << __shift;
+}
+
+template <__type... __types>
+consteval uint32_t __create_type_mask() {
+  uint32_t __result = 0;
+  ([&] { __result |= __create_type_mask(__types); }(), ...);
+  return __result;
+}
+
+inline constexpr uint32_t __type_mask_integer =
+    __create_type_mask<__type::__binary_lower_case,
+                       __type::__binary_upper_case,
+                       __type::__decimal,
+                       __type::__octal,
+                       __type::__hexadecimal_lower_case,
+                       __type::__hexadecimal_upper_case>();
+
 struct __std {
   __alignment __alignment_ : 3;
   __sign __sign_ : 2;
   bool __alternate_form_ : 1;
   bool __locale_specific_form_ : 1;
   __type __type_;
 };
 

 /// expected developers will create their own formatter specializations that
 /// inherit from the std::formatter specializations. This means this class
 /// must be ABI stable. To aid the stability the unused bits in the class are
 /// set to zero. That way they can be repurposed if a future revision of the
 /// Standards adds new fields to std-format-spec.
 template <class _CharT>
 class _LIBCPP_TEMPLATE_VIS __parser {
 public:
+  // Parses the format specification.
+  //
+  // Depending on whether the parsing is done compile-time or run-time
+  // the method slightly differs.
+  // - Only parses a field when it is in the __fields. Accepting all
+  //   fields and then validate the valid ones has a performance impact.
+  //   This is faster but gives slighly worse error messages.
+  // - compile-time when a field is not accepted the parser will still
+  //   parse it and give an error when it's present. This gives a more
+  //   accurate error.
+  // The idea is that most times the format instead of the vformat
+  // functions are used. In that case the error will be detected during
+  // compilation and there is no need to pay for the run-time overhead.
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator __parse(_ParseContext& __ctx, __fields __fields) {
     auto __begin = __ctx.begin();
     auto __end   = __ctx.end();
     if (__begin == __end)
       return __begin;
 
     if (__parse_fill_align(__begin, __end, __fields.__use_range_fill_) && __begin == __end)
       return __begin;
 
-    if (__fields.__sign_ && __parse_sign(__begin) && __begin == __end)
+    if (__fields.__sign_) {
+      if (__parse_sign(__begin) && __begin == __end)
         return __begin;
+    } else if (std::is_constant_evaluated() && __parse_sign(__begin)) {
+      std::__throw_format_error("The format specification does not allow the sign option");
+    }
 
-    if (__fields.__alternate_form_ && __parse_alternate_form(__begin) && __begin == __end)
+    if (__fields.__alternate_form_) {
+      if (__parse_alternate_form(__begin) && __begin == __end)
         return __begin;
+    } else if (std::is_constant_evaluated() && __parse_alternate_form(__begin))
+      std::__throw_format_error("The format specifier does not allow the alternate form option");
 
-    if (__fields.__zero_padding_ && __parse_zero_padding(__begin) && __begin == __end)
+    if (__fields.__zero_padding_) {
+      if (__parse_zero_padding(__begin) && __begin == __end)
         return __begin;
+    } else if (std::is_constant_evaluated() && __parse_zero_padding(__begin))
+      std::__throw_format_error("The format specifier does not allow the zero-padding option");
 
     if (__parse_width(__begin, __end, __ctx) && __begin == __end)
       return __begin;
 
-    if (__fields.__precision_ && __parse_precision(__begin, __end, __ctx) && __begin == __end)
+    if (__fields.__precision_) {
+      if (__parse_precision(__begin, __end, __ctx) && __begin == __end)
         return __begin;
+    } else if (std::is_constant_evaluated() && __parse_precision(__begin, __end, __ctx))
+      std::__throw_format_error("The format specifier does not allow the precision option");
 
-    if (__fields.__locale_specific_form_ && __parse_locale_specific_form(__begin) && __begin == __end)
+    if (__fields.__locale_specific_form_) {
+      if (__parse_locale_specific_form(__begin) && __begin == __end)
         return __begin;
+    } else if (std::is_constant_evaluated() && __parse_locale_specific_form(__begin))
+      std::__throw_format_error("The format specifier does not allow the locale-specific form option");
 
-    if (__fields.__type_) {
+    if (__fields.__clear_brackets_) {
+      if (__parse_clear_brackets(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_clear_brackets(__begin))
+      std::__throw_format_error("The format specifier does not allow the n option");
+
+    if (__fields.__type_)
       __parse_type(__begin);
 
-      // When __type_ is false the calling parser is expected to do additional
-      // parsing. In that case that parser should do the end of format string
-      // validation.
-      if (__begin != __end && *__begin != _CharT('}'))
-        std::__throw_format_error("The format-spec should consume the input or end with a '}'");
-    }
+    if (!__fields.__consume_all_)
+      return __begin;
+
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     return __begin;
   }
 
+  // Validates the selected the parsed data.
+  //
+  // The valid fields in the parser may depend on the display type
+  // selected. But the type is the last optional field, so by the time
+  // it's known an option can't be used, it already has been parsed.
+  // This does the validation again.
+  //
+  // For example an integral may have a sign, zero-padding, or alternate
+  // form when the type option is not 'c'. So the generic approach is:
+  //
+  // typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
+  // if (__parser.__type_ == __format_spec::__type::__char) {
+  //   __parser.__validate((__format_spec::__fields_bool, "an integer");
+  //   ... // more char adjustments
+  // } else {
+  //   ... // validate an integral type.
+  // }
+  //
+  // For some types all valid options need a second validation run, like
+  // a boolean types.
+  //
+  // Depending on whether the validation is done compile-time or
+  // run-time the error differs
+  // - run-time the exception is thrown and contains the type of field
+  //   being validated.
+  // - compile-time the line with `std::__throw_format_error` is shown
+  //   in the output. In that case it's important the error is on one
+  //   line.
+  // Note future versions of C++ may allow better compile-time error
+  // reporting.
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  __validate(__fields __fields, const char* __id, uint32_t __type_mask = -1) const {
+    if (!__fields.__sign_ && __sign_ != __sign::__default) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the sign option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "sign");
+    }
+
+    if (!__fields.__alternate_form_ && __alternate_form_) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the alternate form option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "alternate form");
+    }
+
+    if (!__fields.__zero_padding_ && __alignment_ == __alignment::__zero_padding) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the zero-padding option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "zero-padding");
+    }
+
+    if (!__fields.__precision_ && __precision_ != -1) { // Works both when the precision has a value or an arg-id.
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the precision option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "precision");
+    }
+
+    if (!__fields.__locale_specific_form_ && __locale_specific_form_) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the locale-specific form option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "locale-specific");
+    }
+
+    if ((__create_type_mask(__type_) & __type_mask) == 0) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier uses an invalid value for the type option");
+      else
+        __format_spec::__throw_invalid_type_format_error(__id);
+    }
+  }
+
   /// \returns the `__parsed_specifications` with the resolved dynamic sizes..
   _LIBCPP_HIDE_FROM_ABI
   __parsed_specifications<_CharT> __get_parsed_std_specifications(auto& __ctx) const {
     return __parsed_specifications<_CharT>{
         .__std_ = __std{.__alignment_            = __alignment_,
                         .__sign_                 = __sign_,
                         .__alternate_form_       = __alternate_form_,
                         .__locale_specific_form_ = __locale_specific_form_,
return __parsed_specifications<_CharT>{
         .__precision_{__get_precision(__ctx)},
         .__fill_{__fill_}};
   }
 
   __alignment __alignment_ : 3 {__alignment::__default};
   __sign __sign_ : 2 {__sign::__default};
   bool __alternate_form_ : 1 {false};
   bool __locale_specific_form_ : 1 {false};
-  bool __reserved_0_ : 1 {false};
+  bool __clear_brackets_       : 1 {false};
   __type __type_{__type::__default};
 
   // These flags are only used for formatting chrono. Since the struct has
   // padding space left it's added to this structure.
   bool __hour_ : 1 {false};
 
   bool __weekday_name_ : 1 {false};
   bool __weekday_      : 1 {false};
 
   bool __day_of_year_  : 1 {false};
   bool __week_of_year_ : 1 {false};
 
   bool __month_name_ : 1 {false};
 
-  uint8_t __reserved_1_ : 2 {0};
-  uint8_t __reserved_2_ : 6 {0};
+  uint8_t __reserved_0_ : 2 {0};
+  uint8_t __reserved_1_ : 6 {0};
   // These two flags are only used internally and not part of the
   // __parsed_specifications. Therefore put them at the end.
   bool __width_as_arg_ : 1 {false};
   bool __precision_as_arg_ : 1 {false};
 
   /// The requested width, either the value or the arg-id.
   int32_t __width_{0};
 
_LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alignment(_CharT __c) {
     }
     return false;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void __validate_fill_character(_CharT __fill, bool __use_range_fill) {
     // The forbidden fill characters all code points formed from a single code unit, thus the
     // check can be omitted when more code units are used.
     if (__use_range_fill && (__fill == _CharT('{') || __fill == _CharT('}') || __fill == _CharT(':')))
-      std::__throw_format_error("The format-spec range-fill field contains an invalid character");
+      std::__throw_format_error("The fill option contains an invalid value");
     else if (__fill == _CharT('{') || __fill == _CharT('}'))
-      std::__throw_format_error("The format-spec fill field contains an invalid character");
+      std::__throw_format_error("The fill option contains an invalid value");
   }
 
 #  ifndef _LIBCPP_HAS_NO_UNICODE
   // range-fill and tuple-fill are identical
   template <contiguous_iterator _Iterator>
     requires same_as<_CharT, char>
 #    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
           || (same_as<_CharT, wchar_t> && sizeof(wchar_t) == 2)
 #    endif
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end, bool __use_range_fill) {
     _LIBCPP_ASSERT(__begin != __end,
                    "when called with an empty input the function will cause "
                    "undefined behavior by evaluating data not in the input");
     __unicode::__code_point_view<_CharT> __view{__begin, __end};
     __unicode::__consume_result __consumed = __view.__consume();
     if (__consumed.__status != __unicode::__consume_result::__ok)
-      std::__throw_format_error("The format-spec contains malformed Unicode characters");
+      std::__throw_format_error("The format specifier contains malformed Unicode characters");
 
     if (__view.__position() < __end && __parse_alignment(*__view.__position())) {
       ptrdiff_t __code_units = __view.__position() - __begin;
       if (__code_units == 1)
         // The forbidden fill characters all are code points encoded
         // in one code unit, thus the check can be omitted when more
         // code units are used.
         __validate_fill_character(*__begin, __use_range_fill);
#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   template <contiguous_iterator _Iterator>
     requires(same_as<_CharT, wchar_t> && sizeof(wchar_t) == 4)
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end, bool __use_range_fill) {
     _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 + 1 != __end && __parse_alignment(*(__begin + 1))) {
       if (!__unicode::__is_scalar_value(*__begin))
-        std::__throw_format_error("The fill character contains an invalid value");
+        std::__throw_format_error("The fill option contains an invalid value");
 
       __validate_fill_character(*__begin, __use_range_fill);
 
       __fill_.__data[0] = *__begin;
       __begin += 2;
       return true;
     }
 
if (__alignment_ == __alignment::__default)
       __alignment_ = __alignment::__zero_padding;
     ++__begin;
     return true;
   }
 
   template <contiguous_iterator _Iterator>
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(_Iterator& __begin, _Iterator __end, auto& __ctx) {
     if (*__begin == _CharT('0'))
-      std::__throw_format_error("A format-spec width field shouldn't have a leading zero");
+      std::__throw_format_error("The width option should not have a leading zero");
 
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __ctx);
       __width_as_arg_ = true;
       __width_ = __r.__value;
       __begin = __r.__last;
       return true;
     }
#  endif // _LIBCPP_HAS_NO_UNICODE
 
   template <contiguous_iterator _Iterator>
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(_Iterator& __begin, _Iterator __end, auto& __ctx) {
     if (*__begin != _CharT('.'))
       return false;
 
     ++__begin;
     if (__begin == __end)
-      std::__throw_format_error("End of input while parsing format-spec precision");
+      std::__throw_format_error("End of input while parsing format specifier precision");
 
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __ctx);
       __precision_as_arg_ = true;
       __precision_ = __arg_id.__value;
       __begin = __arg_id.__last;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-      std::__throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
+      std::__throw_format_error("The precision option does not contain a value or argument index");
 
     __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
     __precision_ = __r.__value;
     __precision_as_arg_ = false;
     __begin = __r.__last;
     return true;
   }
 
   template <contiguous_iterator _Iterator>
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_locale_specific_form(_Iterator& __begin) {
     if (*__begin != _CharT('L'))
       return false;
 
     __locale_specific_form_ = true;
     ++__begin;
     return true;
   }
 
   template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_clear_brackets(_Iterator& __begin) {
+    if (*__begin != _CharT('n'))
+      return false;
+
+    __clear_brackets_ = true;
+    ++__begin;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
   _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(_Iterator& __begin) {
     // Determines the type. It does not validate whether the selected type is
     // valid. Most formatters have optional fields that are only allowed for
     // certain types. These parsers need to do validation after the type has
     // been parsed. So its easier to implement the validation for all types in
     // the specific parse function.
     switch (*__begin) {
     case 'A':

 _LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_string(__format_spec::__type __type) {
   switch (__type) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__string:
   case __format_spec::__type::__debug:
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a string argument");
+    std::__throw_format_error("The type option contains an invalid value for a string formatting argument");
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_bool_string(__parser<_CharT>& __parser) {
-  if (__parser.__sign_ != __sign::__default)
-    std::__throw_format_error("A sign field isn't allowed in this format-spec");
-
-  if (__parser.__alternate_form_)
-    std::__throw_format_error("An alternate form field isn't allowed in this format-spec");
-
-  if (__parser.__alignment_ == __alignment::__zero_padding)
-    std::__throw_format_error("A zero-padding field isn't allowed in this format-spec");
-
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_bool_string(__parser<_CharT>& __parser, const char* __id) {
+  __parser.__validate(__format_spec::__fields_bool, __id);
   if (__parser.__alignment_ == __alignment::__default)
     __parser.__alignment_ = __alignment::__left;
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_char(__parser<_CharT>& __parser) {
-  __format_spec::__process_display_type_bool_string(__parser);
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_char(__parser<_CharT>& __parser, const char* __id) {
+  __format_spec::__process_display_type_bool_string(__parser, __id);
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__string:
-    __format_spec::__process_display_type_bool_string(__parser);
+    __format_spec::__process_display_type_bool_string(__parser, __id);
     break;
 
   case __format_spec::__type::__binary_lower_case:
   case __format_spec::__type::__binary_upper_case:
   case __format_spec::__type::__octal:
   case __format_spec::__type::__decimal:
   case __format_spec::__type::__hexadecimal_lower_case:
   case __format_spec::__type::__hexadecimal_upper_case:
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a bool argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__char:
   case __format_spec::__type::__debug:
-    __format_spec::__process_display_type_char(__parser);
+    __format_spec::__process_display_type_char(__parser, __id);
     break;
 
   case __format_spec::__type::__binary_lower_case:
   case __format_spec::__type::__binary_upper_case:
   case __format_spec::__type::__octal:
   case __format_spec::__type::__decimal:
   case __format_spec::__type::__hexadecimal_lower_case:
   case __format_spec::__type::__hexadecimal_upper_case:
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a char argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
+// [format.formatter.spec]/2.3
+//   For each charT, for each cv-unqualified arithmetic type ArithmeticT
+//   other than char, wchar_t, char8_t, char16_t, or char32_t, a
+//   specialization
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__binary_lower_case:
   case __format_spec::__type::__binary_upper_case:
   case __format_spec::__type::__octal:
   case __format_spec::__type::__decimal:
   case __format_spec::__type::__hexadecimal_lower_case:
   case __format_spec::__type::__hexadecimal_upper_case:
+    //__format_spec::__process_display_type_integer(__parser, __id);
     break;
 
   case __format_spec::__type::__char:
-    __format_spec::__process_display_type_char(__parser);
+    __format_spec::__process_display_type_char(__parser, __id);
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for an integer argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__hexfloat_lower_case:
   case __format_spec::__type::__hexfloat_upper_case:
     // Precision specific behavior will be handled later.
     break;
   case __format_spec::__type::__scientific_lower_case:
   case __format_spec::__type::__scientific_upper_case:
   case __format_spec::__type::__fixed_lower_case:
   case __format_spec::__type::__fixed_upper_case:
   case __format_spec::__type::__general_lower_case:
   case __format_spec::__type::__general_upper_case:
     if (!__parser.__precision_as_arg_ && __parser.__precision_ == -1)
       // Set the default precision for the call to to_chars.
       __parser.__precision_ = 6;
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a floating-point argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_pointer(__format_spec::__type __type) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_pointer(__format_spec::__type __type, const char* __id) {
   switch (__type) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__pointer:
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a pointer argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
 template <contiguous_iterator _Iterator>
 struct __column_width_result {
   /// The number of output columns.
   size_t __width_;
   /// One beyond the last code unit used in the estimation.

libcxx/include/__format/range_formatter.h

_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     // replacement-field has no terminating }, or when the parse is manually
     // called with a format-spec. The former is an error and the latter means
     // using a formatter without the format functions or print.
     if (__begin == __end) [[unlikely]]
       return __parse_empty_range_underlying_spec(__ctx, __begin);
 
     // The n field overrides a possible m type, therefore delay applying the
     // effect of n until the type has been procesed.
-    bool __clear_brackets = (*__begin == _CharT('n'));
-    if (__clear_brackets) {
-      ++__begin;
-      if (__begin == __end) [[unlikely]] {
-        // Since there is no more data, clear the brackets before returning.
-        set_brackets({}, {});
-        return __parse_empty_range_underlying_spec(__ctx, __begin);
-      }
-    }
-
     __parse_type(__begin, __end);
-    if (__clear_brackets)
+    if (__parser_.__clear_brackets_)
       set_brackets({}, {});
     if (__begin == __end) [[unlikely]]
       return __parse_empty_range_underlying_spec(__ctx, __begin);
 
     bool __has_range_underlying_spec = *__begin == _CharT(':');
     if (__has_range_underlying_spec) {
       // range-underlying-spec:
       //   :  format-spec
       ++__begin;
     } else if (__begin != __end && *__begin != _CharT('}'))
       // When there is no underlaying range the current parse should have
       // consumed the format-spec. If not, the not consumed input will be
       // processed by the underlying. For example {:-} for a range in invalid,
       // the sign field is not present. Without this check the underlying_ will
       // get -} as input which my be valid.
-      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     __ctx.advance_to(__begin);
     __begin = __underlying_.parse(__ctx);
 
     // This test should not be required if __has_range_underlying_spec is false.
     // However this test makes sure the underlying formatter left the parser in
     // a valid state. (Note this is not a full protection against evil parsers.
     // For example
     //   } this is test for the next argument {}
     //   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
     // could consume more than it should.
     if (__begin != __end && *__begin != _CharT('}'))
-      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     if (__parser_.__type_ != __format_spec::__type::__default) {
       // [format.range.formatter]/6
       //   If the range-type is s or ?s, then there shall be no n option and no
       //   range-underlying-spec.
-      if (__clear_brackets) {
+      if (__parser_.__clear_brackets_) {
         if (__parser_.__type_ == __format_spec::__type::__string)
           std::__throw_format_error("The n option and type s can't be used together");
         std::__throw_format_error("The n option and type ?s can't be used together");
       }
       if (__has_range_underlying_spec) {
         if (__parser_.__type_ == __format_spec::__type::__string)
           std::__throw_format_error("Type s and an underlying format specification can't be used together");
         std::__throw_format_error("Type ?s and an underlying format specification can't be used together");
private:
   _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(_Iterator& __begin, _Iterator __end) {
     switch (*__begin) {
     case _CharT('m'):
       if constexpr (__fmt_pair_like<_Tp>) {
         set_brackets(_LIBCPP_STATICALLY_WIDEN(_CharT, "{"), _LIBCPP_STATICALLY_WIDEN(_CharT, "}"));
         set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ", "));
         ++__begin;
       } else
-        std::__throw_format_error("The range-format-spec type m requires two elements for a pair or tuple");
+        std::__throw_format_error("Type m requires a pair or a tuple with two elements");
       break;
 
     case _CharT('s'):
       if constexpr (same_as<_Tp, _CharT>) {
         __parser_.__type_ = __format_spec::__type::__string;
         ++__begin;
       } else
-        std::__throw_format_error("The range-format-spec type s requires formatting a character type");
+        std::__throw_format_error("Type s requires character type as formatting argument");
       break;
 
     case _CharT('?'):
       ++__begin;
       if (__begin == __end || *__begin != _CharT('s'))
-        std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+        std::__throw_format_error("The format specifier should consume the input or end with a '}'");
       if constexpr (same_as<_Tp, _CharT>) {
         __parser_.__type_ = __format_spec::__type::__debug;
         ++__begin;
       } else
-        std::__throw_format_error("The range-format-spec type ?s requires formatting a character type");
+        std::__throw_format_error("Type ?s requires character type as formatting argument");
     }
   }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator
   __parse_empty_range_underlying_spec(_ParseContext& __ctx, typename _ParseContext::iterator __begin) {
     __ctx.advance_to(__begin);
     [[maybe_unused]] typename _ParseContext::iterator __result = __underlying_.parse(__ctx);

libcxx/test/std/containers/container.adaptors/container.adaptors.format/format.functions.tests.h

void test_char_default(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__['H', 'e', 'l', 'l', 'o']___"), SV("{:_^30}"), input);
   check(SV("#####['H', 'e', 'l', 'l', 'o']"), SV("{:#>30}"), input);
 
   check(SV("['H', 'e', 'l', 'l', 'o']     "), SV("{:{}}"), input, 30);
   check(SV("['H', 'e', 'l', 'l', 'o']*****"), SV("{:*<{}}"), input, 30);
   check(SV("__['H', 'e', 'l', 'l', 'o']___"), SV("{:_^{}}"), input, 30);
   check(SV("#####['H', 'e', 'l', 'l', 'o']"), SV("{:#>{}}"), input, 30);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__'H', 'e', 'l', 'l', 'o'___"), SV("{:_^28n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[H   , e   , l   , l   , o   ]"), SV("{::4}"), input);
   check(SV("[H***, e***, l***, l***, o***]"), SV("{::*<4}"), input);
   check(SV("[_H__, _e__, _l__, _l__, _o__]"), SV("{::_^4}"), input);
   check(SV("[:::H, :::e, :::l, :::l, :::o]"), SV("{:::>4}"), input);
 
   check(SV("[H   , e   , l   , l   , o   ]"), SV("{::{}}"), input, 4);
   check(SV("[H***, e***, l***, l***, o***]"), SV("{::*<{}}"), input, 4);
   check(SV("[_H__, _e__, _l__, _l__, _o__]"), SV("{::_^{}}"), input, 4);
   check(SV("[:::H, :::e, :::l, :::l, :::o]"), SV("{:::>{}}"), input, 4);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:: }"), input);
 
   check(SV("[72, 101, 108, 108, 111]"), SV("{::-d}"), input);
   check(SV("[+72, +101, +108, +108, +111]"), SV("{::+d}"), input);
   check(SV("[ 72,  101,  108,  108,  111]"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a character does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("[0x48, 0x65, 0x6c, 0x6c, 0x6f]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a character does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("[00110, 00145, 00154, 00154, 00157]"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[H, e, l, l, o]"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
-  // ***** Both have a format-spec
+  // ***** Both have a format specifier
   check(SV("^^[:H, :e, :l, :l, :o]^^^"), SV("{:^^25::>2}"), input);
   check(SV("^^[:H, :e, :l, :l, :o]^^^"), SV("{:^^{}::>2}"), input, 25);
   check(SV("^^[:H, :e, :l, :l, :o]^^^"), SV("{:^^{}::>{}}"), input, 25, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 25);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 25);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("Hello"), SV("{:s}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("Hello   "), SV("{:8s}"), input);
   check(SV("Hello***"), SV("{:*<8s}"), input);
   check(SV("_Hello__"), SV("{:_^8s}"), input);
   check(SV("###Hello"), SV("{:#>8s}"), input);
 
   check(SV("Hello   "), SV("{:{}s}"), input, 8);
   check(SV("Hello***"), SV("{:*<{}s}"), input, 8);
   check(SV("_Hello__"), SV("{:_^{}s}"), input, 8);
   check(SV("###Hello"), SV("{:#>{}s}"), input, 8);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<s}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: s}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#s}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0s}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0s}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.s}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:Ls}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:Ls}"), input);
 
   // *** n
   check_exception("The n option and type s can't be used together", SV("{:ns}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check_exception("Type s and an underlying format specification can't be used together", SV("{:s:}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check_exception("Type s and an underlying format specification can't be used together", SV("{:5s:5}"), input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_escaped_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"("Hello")"), SV("{:?s}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV(R"("Hello"   )"), SV("{:10?s}"), input);
   check(SV(R"("Hello"***)"), SV("{:*<10?s}"), input);
   check(SV(R"(_"Hello"__)"), SV("{:_^10?s}"), input);
   check(SV(R"(###"Hello")"), SV("{:#>10?s}"), input);
 
   check(SV(R"("Hello"   )"), SV("{:{}?s}"), input, 10);
   check(SV(R"("Hello"***)"), SV("{:*<{}?s}"), input, 10);
   check(SV(R"(_"Hello"__)"), SV("{:_^{}?s}"), input, 10);
   check(SV(R"(###"Hello")"), SV("{:#>{}?s}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<?s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<?s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<?s}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-?s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+?s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: ?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: ?s}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#?s}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0?s}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0?s}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.?s}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L?s}"), input);
 
   // *** n
   check_exception("The n option and type ?s can't be used together", SV("{:n?s}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check_exception("Type ?s and an underlying format specification can't be used together", SV("{:?s:}"), input);
 
   // ***** Both have a format-spec
   check_exception("Type ?s and an underlying format specification can't be used together", SV("{:5?s:5}"), input);
 }
 
void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
   test_char_default<wchar_t>(check, check_exception, std::stack{input.begin(), input.end()});
 
   // The types s and ?s may only be used when using range_formatter<T, charT>
   // where the types T and charT are the same. This means this can't be used for
   // range_formatter<wchar_t, char> even when formatter<wchar_t, char> has a
   // debug-enabled specialization.
 
   using CharT = wchar_t;
-  check_exception("The range-format-spec type s requires formatting a character type",
-                  SV("{:s}"),
-                  std::queue{input.begin(), input.end()});
-  check_exception("The range-format-spec type s requires formatting a character type",
+  check_exception(
+      "Type s requires character type as formatting argument", SV("{:s}"), std::queue{input.begin(), input.end()});
+  check_exception("Type s requires character type as formatting argument",
                   SV("{:s}"),
                   std::priority_queue{input.begin(), input.end()});
-  check_exception("The range-format-spec type s requires formatting a character type",
-                  SV("{:s}"),
-                  std::stack{input.begin(), input.end()});
-  check_exception("The range-format-spec type ?s requires formatting a character type",
-                  SV("{:?s}"),
-                  std::queue{input.begin(), input.end()});
-  check_exception("The range-format-spec type ?s requires formatting a character type",
+  check_exception(
+      "Type s requires character type as formatting argument", SV("{:s}"), std::stack{input.begin(), input.end()});
+  check_exception(
+      "Type ?s requires character type as formatting argument", SV("{:?s}"), std::queue{input.begin(), input.end()});
+  check_exception("Type ?s requires character type as formatting argument",
                   SV("{:?s}"),
                   std::priority_queue{input.begin(), input.end()});
-  check_exception("The range-format-spec type ?s requires formatting a character type",
-                  SV("{:?s}"),
-                  std::stack{input.begin(), input.end()});
+  check_exception(
+      "Type ?s requires character type as formatting argument", SV("{:?s}"), std::stack{input.begin(), input.end()});
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 //
 // Bool
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_bool(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("[true, true, false]"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("[true, true, false]     "), SV("{:24}"), input);
   check(SV("[true, true, false]*****"), SV("{:*<24}"), input);
   check(SV("__[true, true, false]___"), SV("{:_^24}"), input);
   check(SV("#####[true, true, false]"), SV("{:#>24}"), input);
 
   check(SV("[true, true, false]     "), SV("{:{}}"), input, 24);
   check(SV("[true, true, false]*****"), SV("{:*<{}}"), input, 24);
   check(SV("__[true, true, false]___"), SV("{:_^{}}"), input, 24);
   check(SV("#####[true, true, false]"), SV("{:#>{}}"), input, 24);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__true, true, false___"), SV("{:_^22n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[true   , true   , false  ]"), SV("{::7}"), input);
   check(SV("[true***, true***, false**]"), SV("{::*<7}"), input);
   check(SV("[_true__, _true__, _false_]"), SV("{::_^7}"), input);
   check(SV("[:::true, :::true, ::false]"), SV("{:::>7}"), input);
 
   check(SV("[true   , true   , false  ]"), SV("{::{}}"), input, 7);
   check(SV("[true***, true***, false**]"), SV("{::*<{}}"), input, 7);
   check(SV("[_true__, _true__, _false_]"), SV("{::_^{}}"), input, 7);
   check(SV("[:::true, :::true, ::false]"), SV("{:::>{}}"), input, 7);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:: }"), input);
 
   check(SV("[1, 1, 0]"), SV("{::-d}"), input);
   check(SV("[+1, +1, +0]"), SV("{::+d}"), input);
   check(SV("[ 1,  1,  0]"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("[0x1, 0x1, 0x0]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("[00001, 00001, 00000]"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[true, true, false]"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, input);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^32::>7}"), input);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>7}"), input, 32);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>{}}"), input, 32, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 32);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 32);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_bool(TestFunction check, ExceptionTest check_exception) {
   std::array input{true, true, false};
   test_bool<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
   test_bool<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end()});
   test_bool<CharT>(check, check_exception, std::stack{input.begin(), input.end()});
void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[-42, 1, 2, 42]___"), SV("{:_^20}"), input);
   check(SV("#####[-42, 1, 2, 42]"), SV("{:#>20}"), input);
 
   check(SV("[-42, 1, 2, 42]     "), SV("{:{}}"), input, 20);
   check(SV("[-42, 1, 2, 42]*****"), SV("{:*<{}}"), input, 20);
   check(SV("__[-42, 1, 2, 42]___"), SV("{:_^{}}"), input, 20);
   check(SV("#####[-42, 1, 2, 42]"), SV("{:#>{}}"), input, 20);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42, 1, 2, 42___"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[  -42,     1,     2,    42]"), SV("{::5}"), input);
   check(SV("[-42**, 1****, 2****, 42***]"), SV("{::*<5}"), input);
   check(SV("[_-42_, __1__, __2__, _42__]"), SV("{::_^5}"), input);
   check(SV("[::-42, ::::1, ::::2, :::42]"), SV("{:::>5}"), input);
 
   check(SV("[  -42,     1,     2,    42]"), SV("{::{}}"), input, 5);
   check(SV("[-42**, 1****, 2****, 42***]"), SV("{::*<{}}"), input, 5);
   check(SV("[_-42_, __1__, __2__, _42__]"), SV("{::_^{}}"), input, 5);
   check(SV("[::-42, ::::1, ::::2, :::42]"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
   check(SV("[-42, 1, 2, 42]"), SV("{::-}"), input);
   check(SV("[-42, +1, +2, +42]"), SV("{::+}"), input);
   check(SV("[-42,  1,  2,  42]"), SV("{:: }"), input);
 
   // *** alternate form ***
   check(SV("[-0x2a, 0x1, 0x2, 0x2a]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
   check(SV("[-0042, 00001, 00002, 00042]"), SV("{::05}"), input);
   check(SV("[-002a, 00001, 00002, 0002a]"), SV("{::05x}"), input);
   check(SV("[-0x2a, 0x001, 0x002, 0x02a]"), SV("{::#05x}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[-42, 1, 2, 42]"), SV("{::L}"), input); // does nothing in this test, but is accepted.
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX"))
-    check_exception("The format-spec type has a type not supported for an integer argument", fmt, input);
+    check_exception("The type option contains an invalid value for an integer formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[::-42, ::::1, ::::2, :::42]^^^"), SV("{:^^33::>5}"), input);
   check(SV("^^[::-42, ::::1, ::::2, :::42]^^^"), SV("{:^^{}::>5}"), input, 33);
   check(SV("^^[::-42, ::::1, ::::2, :::42]^^^"), SV("{:^^{}::>{}}"), input, 33, 5);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 33);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 33);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception) {
   std::array input{-42, 1, 2, 42};
   test_int<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
   test_int<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end(), std::greater{}});
   test_int<CharT>(check, check_exception, std::stack{input.begin(), input.end()});
void test_floating_point(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[-42.5, 0, 1.25, 42.5]___"), SV("{:_^27}"), input);
   check(SV("#####[-42.5, 0, 1.25, 42.5]"), SV("{:#>27}"), input);
 
   check(SV("[-42.5, 0, 1.25, 42.5]     "), SV("{:{}}"), input, 27);
   check(SV("[-42.5, 0, 1.25, 42.5]*****"), SV("{:*<{}}"), input, 27);
   check(SV("__[-42.5, 0, 1.25, 42.5]___"), SV("{:_^{}}"), input, 27);
   check(SV("#####[-42.5, 0, 1.25, 42.5]"), SV("{:#>{}}"), input, 27);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42.5, 0, 1.25, 42.5___"), SV("{:_^25n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[-42.5,     0,  1.25,  42.5]"), SV("{::5}"), input);
   check(SV("[-42.5, 0****, 1.25*, 42.5*]"), SV("{::*<5}"), input);
   check(SV("[-42.5, __0__, 1.25_, 42.5_]"), SV("{::_^5}"), input);
   check(SV("[-42.5, ::::0, :1.25, :42.5]"), SV("{:::>5}"), input);
 
   check(SV("[-42.5,     0,  1.25,  42.5]"), SV("{::{}}"), input, 5);
   check(SV("[-42.5, 0****, 1.25*, 42.5*]"), SV("{::*<{}}"), input, 5);
   check(SV("[-42.5, __0__, 1.25_, 42.5_]"), SV("{::_^{}}"), input, 5);
   check(SV("[-42.5, ::::0, :1.25, :42.5]"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
   check(SV("[-42.5, 0, 1.25, 42.5]"), SV("{::-}"), input);
   check(SV("[-42.5, +0, +1.25, +42.5]"), SV("{::+}"), input);
   check(SV("[-42.5,  0,  1.25,  42.5]"), SV("{:: }"), input);
 
   // *** alternate form ***
   check(SV("[-42.5, 0., 1.25, 42.5]"), SV("{::#}"), input);
 
   // *** zero-padding ***
   check(SV("[-42.5, 00000, 01.25, 042.5]"), SV("{::05}"), input);
   check(SV("[-42.5, 0000., 01.25, 042.5]"), SV("{::#05}"), input);
 
   // *** precision ***
   check(SV("[-42, 0, 1.2, 42]"), SV("{::.2}"), input);
   check(SV("[-42.500, 0.000, 1.250, 42.500]"), SV("{::.3f}"), input);
 
   check(SV("[-42, 0, 1.2, 42]"), SV("{::.{}}"), input, 2);
   check(SV("[-42.500, 0.000, 1.250, 42.500]"), SV("{::.{}f}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[-42.5, 0, 1.25, 42.5]"), SV("{::L}"), input); // does not require locales present
 #ifndef TEST_HAS_NO_LOCALIZATION
 // TODO FMT Enable with locale testing active
 #  if 0
   std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
   check(SV("[-42,5, 0, 1,25, 42,5]"), SV("{::L}"), input);
 
   std::locale::global(std::locale(LOCALE_en_US_UTF_8));
   check(SV("[-42.5, 0, 1.25, 42.5]"), SV("{::L}"), input);
 
   std::locale::global(std::locale::classic());
 #  endif
 #endif // TEST_HAS_NO_LOCALIZATION
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("aAeEfFgG"))
-    check_exception("The format-spec type has a type not supported for a floating-point argument", fmt, input);
+    check_exception("The type option contains an invalid value for a floating-point formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[-42.5, ::::0, :1.25, :42.5]^^^"), SV("{:^^33::>5}"), input);
   check(SV("^^[-42.5, ::::0, :1.25, :42.5]^^^"), SV("{:^^{}::>5}"), input, 33);
   check(SV("^^[-42.5, ::::0, :1.25, :42.5]^^^"), SV("{:^^{}::>{}}"), input, 33, 5);
 
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^33::>5.2}"), input);
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^{}::>5.2}"), input, 33);
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^{}::>{}.2}"), input, 33, 5);
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^{}::>{}.{}}"), input, 33, 5, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5.2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}.2}"), input, 33);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}.{}}"), input, 33, 5);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5.2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}.2}"), input, 33);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied",
+      SV("{:^^{}::>{}.{}}"),
+      input,
+      33,
+      5);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_floating_point(TestFunction check, ExceptionTest check_exception) {
   std::array input{-42.5l, 0.0l, 1.25l, 42.5l};
   test_floating_point<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
   test_floating_point<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end(), std::greater{}});
   test_floating_point<CharT>(check, check_exception, std::stack{input.begin(), input.end()});
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[0x0]___"), SV("{:_^10}"), input);
   check(SV("#####[0x0]"), SV("{:#>10}"), input);
 
   check(SV("[0x0]     "), SV("{:{}}"), input, 10);
   check(SV("[0x0]*****"), SV("{:*<{}}"), input, 10);
   check(SV("__[0x0]___"), SV("{:_^{}}"), input, 10);
   check(SV("#####[0x0]"), SV("{:#>{}}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("_0x0_"), SV("{:_^5n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[  0x0]"), SV("{::5}"), input);
   check(SV("[0x0**]"), SV("{::*<5}"), input);
   check(SV("[_0x0_]"), SV("{::_^5}"), input);
   check(SV("[::0x0]"), SV("{:::>5}"), input);
 
   check(SV("[  0x0]"), SV("{::{}}"), input, 5);
   check(SV("[0x0**]"), SV("{::*<{}}"), input, 5);
   check(SV("[_0x0_]"), SV("{::_^{}}"), input, 5);
   check(SV("[::0x0]"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("p"))
-    check_exception("The format-spec type has a type not supported for a pointer argument", fmt, input);
+    check_exception("The type option contains an invalid value for a pointer formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 12);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 12);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_pointer(TestFunction check, ExceptionTest check_exception) {
   std::array input{static_cast<void*>(0)};
   test_pointer<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
   test_pointer<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end()});
   test_pointer<CharT>(check, check_exception, std::stack{input.begin(), input.end()});
void test_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"(__["Hello", "world"]___)"), SV("{:_^23}"), input);
   check(SV(R"(#####["Hello", "world"])"), SV("{:#>23}"), input);
 
   check(SV(R"(["Hello", "world"]     )"), SV("{:{}}"), input, 23);
   check(SV(R"(["Hello", "world"]*****)"), SV("{:*<{}}"), input, 23);
   check(SV(R"(__["Hello", "world"]___)"), SV("{:_^{}}"), input, 23);
   check(SV(R"(#####["Hello", "world"])"), SV("{:#>{}}"), input, 23);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV(R"(_"Hello", "world"_)"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV(R"([Hello   , world   ])"), SV("{::8}"), input);
   check(SV(R"([Hello***, world***])"), SV("{::*<8}"), input);
   check(SV(R"([_Hello__, _world__])"), SV("{::_^8}"), input);
   check(SV(R"([:::Hello, :::world])"), SV("{:::>8}"), input);
 
   check(SV(R"([Hello   , world   ])"), SV("{::{}}"), input, 8);
   check(SV(R"([Hello***, world***])"), SV("{::*<{}}"), input, 8);
   check(SV(R"([_Hello__, _world__])"), SV("{::_^{}}"), input, 8);
   check(SV(R"([:::Hello, :::world])"), SV("{:::>{}}"), input, 8);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
   check(SV(R"([Hel, wor])"), SV("{::.3}"), input);
 
   check(SV(R"([Hel, wor])"), SV("{::.{}}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>8}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 25);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>8}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 25);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
   std::array input{STR("Hello"), STR("world")};
   test_string<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
   test_string<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end(), std::greater{}});
   test_string<CharT>(check, check_exception, std::stack{input.begin(), input.end()});
void test_status(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[0xaaaa, 0x5555, 0xaa55]___"), SV("{:_^29}"), input);
   check(SV("#####[0xaaaa, 0x5555, 0xaa55]"), SV("{:#>29}"), input);
 
   check(SV("[0xaaaa, 0x5555, 0xaa55]     "), SV("{:{}}"), input, 29);
   check(SV("[0xaaaa, 0x5555, 0xaa55]*****"), SV("{:*<{}}"), input, 29);
   check(SV("__[0xaaaa, 0x5555, 0xaa55]___"), SV("{:_^{}}"), input, 29);
   check(SV("#####[0xaaaa, 0x5555, 0xaa55]"), SV("{:#>{}}"), input, 29);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__0xaaaa, 0x5555, 0xaa55___"), SV("{:_^27n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
-  check_exception("The format-spec type has a type not supported for a status argument", SV("{::*<7}"), input);
+  check_exception("The type option contains an invalid value for a status formatting argument", SV("{::*<7}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("sxX"))
-    check_exception("The format-spec type has a type not supported for a status argument", fmt, input);
+    check_exception("The type option contains an invalid value for a status formatting argument", fmt, input);
 
   check(SV("[0xaaaa, 0x5555, 0xaa55]"), SV("{::x}"), input);
   check(SV("[0XAAAA, 0X5555, 0XAA55]"), SV("{::X}"), input);
   check(SV("[foo, bar, foobar]"), SV("{::s}"), input);
 
   // ***** Both have a format-spec
   check(SV("^^[0XAAAA, 0X5555, 0XAA55]^^^"), SV("{:^^29:X}"), input);
   check(SV("^^[0XAAAA, 0X5555, 0XAA55]^^^"), SV("{:^^{}:X}"), input, 29);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:X}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:X}"), input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_status(TestFunction check, ExceptionTest check_exception) {
   std::array input{status::foo, status::bar, status::foobar};
   test_status<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
   test_status<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end(), std::less{}});
   test_status<CharT>(check, check_exception, std::stack{input.begin(), input.end()});

libcxx/test/std/containers/sequences/vector.bool/vector.bool.fmt/format.functions.tests.h

void format_test_vector_bool(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[true, true, false]___"), SV("{:_^24}"), input);
   check(SV("#####[true, true, false]"), SV("{:#>24}"), input);
 
   check(SV("[true, true, false]     "), SV("{:{}}"), input, 24);
   check(SV("[true, true, false]*****"), SV("{:*<{}}"), input, 24);
   check(SV("__[true, true, false]___"), SV("{:_^{}}"), input, 24);
   check(SV("#####[true, true, false]"), SV("{:#>{}}"), input, 24);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__true, true, false___"), SV("{:_^22n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[true   , true   , false  ]"), SV("{::7}"), input);
   check(SV("[true***, true***, false**]"), SV("{::*<7}"), input);
   check(SV("[_true__, _true__, _false_]"), SV("{::_^7}"), input);
   check(SV("[:::true, :::true, ::false]"), SV("{:::>7}"), input);
 
   check(SV("[true   , true   , false  ]"), SV("{::{}}"), input, 7);
   check(SV("[true***, true***, false**]"), SV("{::*<{}}"), input, 7);
   check(SV("[_true__, _true__, _false_]"), SV("{::_^{}}"), input, 7);
   check(SV("[:::true, :::true, ::false]"), SV("{:::>{}}"), input, 7);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:: }"), input);
 
   check(SV("[1, 1, 0]"), SV("{::-d}"), input);
   check(SV("[+1, +1, +0]"), SV("{::+d}"), input);
   check(SV("[ 1,  1,  0]"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("[0x1, 0x1, 0x0]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("[00001, 00001, 00000]"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, input);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^32::>7}"), input);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>7}"), input, 32);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>{}}"), input, 32, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 32);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 32);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_tests(TestFunction check, ExceptionTest check_exception) {
   format_test_vector_bool<CharT>(check, check_exception, std::vector{true, true, false});
 
   // The const_reference shall be a bool.
   // However libc++ uses a __bit_const_reference<vector> when
   // _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL is defined.
   const std::vector input{true, true, false};
   format_test_vector_bool<CharT>(check, check_exception, input);
 }
 
 #endif // TEST_STD_CONTAINERS_SEQUENCES_VECTOR_BOOL_VECTOR_BOOL_FMT_FORMAT_FUNCTIONS_TESTS_H

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/format.functions.tests.h

#else  // !defined(__APPLE__) && !defined(__FreeBSD__)
 
   check(SV("    0x0"), SV("{:{}}"), input, 7);
   check(SV("0x0****"), SV("{:*<{}}"), input, 7);
   check(SV("__0x0__"), SV("{:_^{}}"), input, 7);
   check(SV("####0x0"), SV("{:#>{}}"), input, 7);
 #endif // !defined(__APPLE__) && !defined(__FreeBSD__)
 
   /***** Test the type generic part *****/
-  check_exception("The format-spec fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
 
   // *** sign ***
   check_exception("The replacement field misses a terminating '}'", SV("{:-}"), input);
   check_exception("The replacement field misses a terminating '}'", SV("{:+}"), input);
   check_exception("The replacement field misses a terminating '}'", SV("{: }"), input);
 
   // *** alternate form ***
   check_exception("The replacement field misses a terminating '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
   check_exception("The replacement field misses a terminating '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
   check_exception("The replacement field misses a terminating '}'", SV("{:L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>(""))
     check_exception("The replacement field misses a terminating '}'", fmt, input);
 }
 
 #endif // TEST_STD_THREAD_THREAD_THREADS_THREAD_THREAD_CLASS_THREAD_THREAD_ID_FORMAT_FUNCTIONS_TESTS_H

libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp

 }
 
 template <class CharT>
 static void test_invalid_values() {
   using namespace std::literals::chrono_literals;
 
   // This looks odd, however the 24 hours is not valid for a 24 hour clock.
   // TODO FMT discuss what the "proper" behaviour is.
-  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_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(SV("00"), SV("{:%M}"), std::chrono::hh_mm_ss{24h});
   check(SV("00"), SV("{:%OM}"), std::chrono::hh_mm_ss{24h});
   check(SV("00"), SV("{:%S}"), std::chrono::hh_mm_ss{24h});
   check(SV("00"), SV("{:%OS}"), 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});
+  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});
 }
 
 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("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("The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::hh_mm_ss{0ms});
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::hh_mm_ss{0ms});
+  check_exception("End of input while parsing a conversion specifier", 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});
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::hh_mm_ss{0ms});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.day.pass.cpp

 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("The format specifier expects a '%' or a '}'", SV("{:A"), 0d);
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), 0d);
+  check_exception("End of input while parsing a conversion specifier", 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);
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), 0d);
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.duration.pass.cpp

static void test() {
 
   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("The format specifier expects a '%' or a '}'", SV("{:A"), 0ms);
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), 0ms);
+  check_exception("End of input while parsing a conversion specifier", 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);
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), 0ms);
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.file_time.pass.cpp

static void test() {
   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")},
       file_seconds(0s));
 
-  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), file_seconds(0s));
-  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), file_seconds(0s));
-  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), file_seconds(0s));
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:A"), file_seconds(0s));
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), file_seconds(0s));
+  check_exception("End of input while parsing a conversion specifier", SV("{:%"), file_seconds(0s));
   check_exception("End of input while parsing the modifier E", SV("{:%E"), file_seconds(0s));
   check_exception("End of input while parsing the modifier O", SV("{:%O"), file_seconds(0s));
 
   // Precision not allowed
-  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), file_seconds(0s));
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), file_seconds(0s));
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.local_time.pass.cpp

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("Ec"),
           SV("EC"), SV("Ex"), SV("EX"), SV("Ey"), SV("EY"), 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"),
       },
       std::chrono::local_seconds(0s));
 
-  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), std::chrono::local_seconds(0s));
-  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), std::chrono::local_seconds(0s));
-  check_exception(
-      "End of input while parsing the modifier chrono conversion-spec", SV("{:%"), std::chrono::local_seconds(0s));
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::local_seconds(0s));
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::local_seconds(0s));
+  check_exception("End of input while parsing a conversion specifier", SV("{:%"), std::chrono::local_seconds(0s));
   check_exception("End of input while parsing the modifier E", SV("{:%E"), std::chrono::local_seconds(0s));
   check_exception("End of input while parsing the modifier O", SV("{:%O"), std::chrono::local_seconds(0s));
 
   // Precision not allowed
-  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), std::chrono::local_seconds(0s));
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::local_seconds(0s));
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.month.pass.cpp

static void test_no_chrono_specs() {
   // Invalid month
   check(SV("0 is not a valid month"), SV("{}"), std::chrono::month{0});
   check(SV("*0 is not a valid month*"), SV("{:*^24}"), 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 from an invalid month number", SV("{:%b}"), std::chrono::month{200});
-  check_exception("formatting a month name from an invalid month number", SV("{:%b}"), std::chrono::month{13});
-  check_exception("formatting a month name from an invalid month number", SV("{:%b}"), std::chrono::month{255});
-
-  check_exception("formatting a month name from an invalid month number", SV("{:%h}"), std::chrono::month{0});
-  check_exception("formatting a month name from an invalid month number", SV("{:%h}"), std::chrono::month{13});
-  check_exception("formatting a month name from an invalid month number", SV("{:%h}"), std::chrono::month{255});
-
-  check_exception("formatting a month name from an invalid month number", SV("{:%B}"), std::chrono::month{0});
-  check_exception("formatting a month name from an invalid month number", SV("{:%B}"), std::chrono::month{13});
-  check_exception("formatting a month name from an invalid month number", SV("{:%B}"), std::chrono::month{255});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%b}"), std::chrono::month{200});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%b}"), std::chrono::month{13});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%b}"), std::chrono::month{255});
+
+  check_exception("Formatting a month name from an invalid month number", SV("{:%h}"), std::chrono::month{0});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%h}"), std::chrono::month{13});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%h}"), std::chrono::month{255});
+
+  check_exception("Formatting a month name from an invalid month number", SV("{:%B}"), std::chrono::month{0});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%B}"), std::chrono::month{13});
+  check_exception("Formatting a month name from an invalid month number", SV("{:%B}"), std::chrono::month{255});
 
   constexpr std::basic_string_view<CharT> fmt  = SV("{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}");
   constexpr std::basic_string_view<CharT> lfmt = SV("{: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

 }
 
 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("The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::January);
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::January);
+  check_exception("End of input while parsing a conversion specifier", 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);
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::January);
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.month_day.pass.cpp

static void test_no_chrono_specs() {
   check(SV("*0 is not a valid month/32 is not a valid day*"),
         SV("{:*^46}"),
         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 from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::month_day{std::chrono::month{200}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::month_day{std::chrono::month{13}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::month_day{std::chrono::month{255}, std::chrono::day{31}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::month_day{std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::month_day{std::chrono::month{13}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::month_day{std::chrono::month{255}, std::chrono::day{31}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::month_day{std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::month_day{std::chrono::month{13}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::month_day{std::chrono::month{255}, std::chrono::day{31}});
 
   constexpr std::basic_string_view<CharT> fmt =
       SV("{:%%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 std::basic_string_view<CharT> lfmt =
       SV("{: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}");
 

 
 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",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:A"),
                   std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
-  check_exception("The chrono-specs contains a '{'",
+  check_exception("The chrono specifiers contain 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",
+  check_exception("End of input while parsing a conversion specifier",
                   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",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:.3}"),
                   std::chrono::month_day{std::chrono::January, std::chrono::day{31}});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.month_day_last.pass.cpp

static void test_no_chrono_specs() {
   // Invalid month
   check(SV("0 is not a valid month/last"), SV("{}"), std::chrono::month_day_last{std::chrono::month{0}});
   check(SV("*0 is not a valid month/last*"), SV("{:*^29}"), 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 from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::month_day_last{std::chrono::month{200}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::month_day_last{std::chrono::month{13}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::month_day_last{std::chrono::month{255}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::month_day_last{std::chrono::month{0}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::month_day_last{std::chrono::month{13}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::month_day_last{std::chrono::month{255}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::month_day_last{std::chrono::month{0}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::month_day_last{std::chrono::month{13}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::month_day_last{std::chrono::month{255}});
 
   constexpr std::basic_string_view<CharT> fmt  = SV("{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}");
   constexpr std::basic_string_view<CharT> lfmt = SV("{: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));

 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",
+      "The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::month_day_last{std::chrono::January});
+  check_exception(
+      "The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::month_day_last{std::chrono::January});
+  check_exception("End of input while parsing a conversion specifier",
                   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});
+  check_exception(
+      "The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::month_day_last{std::chrono::January});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.month_weekday.pass.cpp

check(SV("*0 is not a valid month/8 is not a valid weekday[0 is not a valid index]"),
         SV("{:*>72}"),
         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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 std::basic_string_view<CharT> fmt  = SV("{:%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}");
   constexpr std::basic_string_view<CharT> lfmt = SV("{:L%%b='%b'%t%%B='%B'%t%%h='%h'%t%%m='%m'%t%%Om='%Om'%n}");
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",
+      "The format specifier expects a '%' or a '}'",
       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 '{'",
+      "The chrono specifiers contain 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",
+      "End of input while parsing a conversion specifier",
       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",
+      "The format specifier expects a '%' or a '}'",
       SV("{:.3}"),
       std::chrono::month_weekday{std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{0}, 1}});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.sys_time.pass.cpp

static void test() {
   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("The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::sys_seconds(0s));
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::sys_seconds(0s));
+  check_exception("End of input while parsing a conversion specifier", 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));
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::sys_seconds(0s));
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.weekday.pass.cpp

 #endif
 
   std::locale::global(std::locale::classic());
 }
 
 template <class CharT>
 static void test_invalid_values() {
   // Test that %a and %A throw an exception.
-  check_exception("formatting a weekday name needs a valid weekday", SV("{:%a}"), std::chrono::weekday(8));
-  check_exception("formatting a weekday name needs a valid weekday", SV("{:%a}"), std::chrono::weekday(255));
-  check_exception("formatting a weekday name needs a valid weekday", SV("{:%A}"), std::chrono::weekday(8));
-  check_exception("formatting a weekday name needs a valid weekday", SV("{:%A}"), std::chrono::weekday(255));
+  check_exception("Formatting a weekday name needs a valid weekday", SV("{:%a}"), std::chrono::weekday(8));
+  check_exception("Formatting a weekday name needs a valid weekday", SV("{:%a}"), std::chrono::weekday(255));
+  check_exception("Formatting a weekday name needs a valid weekday", SV("{:%A}"), std::chrono::weekday(8));
+  check_exception("Formatting a weekday name needs a valid weekday", SV("{:%A}"), std::chrono::weekday(255));
 
   constexpr std::basic_string_view<CharT> fmt  = SV("{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}");
   constexpr std::basic_string_view<CharT> lfmt = SV("{: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));
 
 #if defined(__APPLE__)

 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("The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::weekday(0));
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::weekday(0));
+  check_exception("End of input while parsing a conversion specifier", 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));
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::weekday(0));
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.weekday_index.pass.cpp

 #endif // defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
 
   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 weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::weekday_indexed{std::chrono::weekday(255), 1});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::weekday_indexed{std::chrono::weekday(8), 1});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   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 std::basic_string_view<CharT> fmt  = SV("{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}");

 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",
+  check_exception("The format specifier expects a '%' or a '}'",
                   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",
+      "The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
+  check_exception("End of input while parsing a conversion specifier",
                   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",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:.3}"),
                   std::chrono::weekday_indexed{std::chrono::weekday(0), 1});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.weekday_last.pass.cpp

 #endif // defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
 
   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 weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::weekday_last{std::chrono::weekday(8)});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::weekday_last{std::chrono::weekday(255)});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::weekday_last{std::chrono::weekday(8)});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::weekday_last{std::chrono::weekday(255)});
 
   constexpr std::basic_string_view<CharT> fmt  = SV("{:%%u='%u'%t%%Ou='%Ou'%t%%w='%w'%t%%Ow='%Ow'%n}");
   constexpr std::basic_string_view<CharT> lfmt = SV("{: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));

 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",
+      "The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::weekday_last{std::chrono::weekday(0)});
+  check_exception(
+      "The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::weekday_last{std::chrono::weekday(0)});
+  check_exception("End of input while parsing a conversion specifier",
                   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)});
+  check_exception(
+      "The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::weekday_last{std::chrono::weekday(0)});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year.pass.cpp

 template <class CharT>
 static void test() {
   test_no_chrono_specs<CharT>();
   test_valid_values<CharT>();
   test_padding<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("The format specifier expects a '%' or a '}'", SV("{:A"), std::chrono::year{1970});
+  check_exception("The chrono specifiers contain a '{'", SV("{:%%{"), std::chrono::year{1970});
+  check_exception("End of input while parsing a conversion specifier", 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});
+  check_exception("The format specifier expects a '%' or a '}'", SV("{:.3}"), std::chrono::year{1970});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year_month.pass.cpp

static void test_no_chrono_specs() {
   check(SV("*1970/0 is not a valid month*"),
         SV("{:*^29}"),
         std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{0}});
 }
 
 template <class CharT>
 static void test_invalid_values() {
   // Test that %b and %B throw an exception.
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{0}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::month{0}});
 }
 
 template <class CharT>
 static void test_valid_values() {
   constexpr std::basic_string_view<CharT> fmt = SV(
       "{:"
static void test() {
   test_no_chrono_specs<CharT>();
   test_invalid_values<CharT>();
   test_valid_values<CharT>();
 
   check_invalid_types<CharT>(
       {SV("b"), SV("B"), SV("C"), SV("EC"), SV("Ey"), SV("EY"), SV("h"), SV("m"), SV("Om"), SV("Oy"), SV("y"), SV("Y")},
       std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
 
-  check_exception("Expected '%' or '}' in the chrono format-string",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:A"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
-  check_exception("The chrono-specs contains a '{'",
+  check_exception("The chrono specifiers contain a '{'",
                   SV("{:%%{"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
-  check_exception("End of input while parsing the modifier chrono conversion-spec",
+  check_exception("End of input while parsing a conversion specifier",
                   SV("{:%"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
   check_exception("End of input while parsing the modifier E",
                   SV("{:%E"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
   check_exception("End of input while parsing the modifier O",
                   SV("{:%O"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
 
   // Precision not allowed
-  check_exception("Expected '%' or '}' in the chrono format-string",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:.3}"),
                   std::chrono::year_month{std::chrono::year{1970}, std::chrono::January});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year_month_day.pass.cpp

check(SV("*-32768-00-32 is not a valid date"),
         SV("{:*>33}"),
         std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{0}, std::chrono::day{32}});
 }
 
 // TODO FMT Should x throw?
 template <class CharT>
 static void test_invalid_values() {
   // Test that %a, %A, %b, %B, %h, %j, %u, %U, %V, %w, %W, %Ou, %OU, %OV, %Ow, and %OW throw an exception.
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   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 weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%A}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   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 weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a weekday name needs a valid weekday",
+  check_exception("Formatting a weekday name needs a valid weekday",
                   SV("{:%a}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{13}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%B}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{255}, std::chrono::day{31}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{200}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{13}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%b}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{255}, std::chrono::day{31}});
 
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{13}, std::chrono::day{31}});
-  check_exception("formatting a month name from an invalid month number",
+  check_exception("Formatting a month name from an invalid month number",
                   SV("{:%h}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{255}, std::chrono::day{31}});
 
-  check_exception("formatting a day of year needs a valid date",
+  check_exception("Formatting a day of year needs a valid date",
                   SV("{:%j}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a day of year needs a valid date",
+  check_exception("Formatting a day of year needs a valid date",
                   SV("{:%j}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a day of year needs a valid date",
+  check_exception("Formatting a day of year needs a valid date",
                   SV("{:%j}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a day of year needs a valid date",
+  check_exception("Formatting a day of year needs a valid date",
                   SV("{:%j}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a day of year needs a valid date",
+  check_exception("Formatting a day of year needs a valid date",
                   SV("{:%j}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   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 weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%u}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%u}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%u}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%u}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%U}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%U}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%U}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%U}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%U}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%V}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%V}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%V}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%V}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%V}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   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 weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%w}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%w}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%w}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%w}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%W}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%W}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%W}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%W}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%W}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   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 weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ou}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ou}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ou}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ou}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OU}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OU}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OU}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OU}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OU}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OV}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OV}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OV}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OV}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OV}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ow}"),
                   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 weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ow}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ow}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ow}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a weekday needs a valid weekday",
+  check_exception("Formatting a weekday needs a valid weekday",
                   SV("{:%Ow}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OW}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{0}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OW}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{1}, std::chrono::day{32}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OW}"),
                   std::chrono::year_month_day{
                       std::chrono::year{1970}, std::chrono::month{2}, std::chrono::day{29}}); // not a leap year
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OW}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::month{0}, std::chrono::day{31}});
-  check_exception("formatting a week of year needs a valid date",
+  check_exception("Formatting a week of year needs a valid date",
                   SV("{:%OW}"),
                   std::chrono::year_month_day{std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::day{31}});
 }
 
 template <class CharT>
 static void test_valid_md_values() {
   constexpr std::basic_string_view<CharT> fmt =
       SV("{:%%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}");
static void test() {
   test_valid_values<CharT>();
   check_invalid_types<CharT>(
       {SV("a"),  SV("A"),  SV("b"),  SV("B"),  SV("C"),  SV("d"),  SV("D"),  SV("e"),  SV("EC"),
        SV("Ex"), SV("Ey"), SV("EY"), SV("F"),  SV("g"),  SV("G"),  SV("h"),  SV("j"),  SV("m"),
        SV("Od"), SV("Oe"), SV("Om"), SV("Ou"), SV("OU"), SV("OV"), SV("Ow"), SV("OW"), SV("Oy"),
        SV("u"),  SV("U"),  SV("V"),  SV("w"),  SV("W"),  SV("x"),  SV("y"),  SV("Y")},
       std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
 
-  check_exception("Expected '%' or '}' in the chrono format-string",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:A"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
-  check_exception("The chrono-specs contains a '{'",
+  check_exception("The chrono specifiers contain a '{'",
                   SV("{:%%{"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
-  check_exception("End of input while parsing the modifier chrono conversion-spec",
+  check_exception("End of input while parsing a conversion specifier",
                   SV("{:%"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
   check_exception("End of input while parsing the modifier E",
                   SV("{:%E"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
   check_exception("End of input while parsing the modifier O",
                   SV("{:%O"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
 
   // Precision not allowed
-  check_exception("Expected '%' or '}' in the chrono format-string",
+  check_exception("The format specifier expects a '%' or a '}'",
                   SV("{:.3}"),
                   std::chrono::year_month_day{std::chrono::year{1970}, std::chrono::January, std::chrono::day{31}});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year_month_day_last.pass.cpp

check(
       std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{0}}});
 }
 
 // TODO FMT Should x throw?
 template <class CharT>
 static void test_invalid_values() {
   // Test that %a, %A, %b, %B, %h, %j, %u, %U, %V, %w, %W, %Ou, %OU, %OV, %Ow, and %OW throw an exception.
   check_exception(
-      "formatting a weekday name needs a valid weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%B}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{13}}});
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%B}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{255}}});
 
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%b}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{200}}});
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%b}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{13}}});
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%b}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{255}}});
 
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%h}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{13}}});
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       SV("{:%h}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{255}}});
 
   check_exception(
-      "formatting a day of year needs a valid date",
+      "Formatting a day of year needs a valid date",
       SV("{:%j}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
   check_exception(
-      "formatting a day of year needs a valid date",
+      "Formatting a day of year needs a valid date",
       SV("{:%j}"),
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%V}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%V}"),
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%OV}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%OV}"),
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       SV("{:%Ow}"),
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       SV("{:%Ow}"),
       std::chrono::year_month_day_last{std::chrono::year{-32768}, std::chrono::month_day_last{std::chrono::month{1}}});
 
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%OW}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::month{0}}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%OW}"),
       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_valid_md_values() {
   constexpr std::basic_string_view<CharT> fmt =
       SV("{:%%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}");
static void test() {
   check_invalid_types<CharT>(
       {SV("a"),  SV("A"),  SV("b"),  SV("B"),  SV("C"),  SV("d"),  SV("D"),  SV("e"),  SV("EC"),
        SV("Ex"), SV("Ey"), SV("EY"), SV("F"),  SV("g"),  SV("G"),  SV("h"),  SV("j"),  SV("m"),
        SV("Od"), SV("Oe"), SV("Om"), SV("Ou"), SV("OU"), SV("OV"), SV("Ow"), SV("OW"), SV("Oy"),
        SV("u"),  SV("U"),  SV("V"),  SV("w"),  SV("W"),  SV("x"),  SV("y"),  SV("Y")},
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
 
   check_exception(
-      "Expected '%' or '}' in the chrono format-string",
+      "The format specifier expects a '%' or a '}'",
       SV("{:A"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
   check_exception(
-      "The chrono-specs contains a '{'",
+      "The chrono specifiers contain a '{'",
       SV("{:%%{"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
   check_exception(
-      "End of input while parsing the modifier chrono conversion-spec",
+      "End of input while parsing a conversion specifier",
       SV("{:%"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
   check_exception(
       "End of input while parsing the modifier E",
       SV("{:%E"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
   check_exception(
       "End of input while parsing the modifier O",
       SV("{:%O"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
 
   // Precision not allowed
   check_exception(
-      "Expected '%' or '}' in the chrono format-string",
+      "The format specifier expects a '%' or a '}'",
       SV("{:.3}"),
       std::chrono::year_month_day_last{std::chrono::year{1970}, std::chrono::month_day_last{std::chrono::January}});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year_month_weekday.pass.cpp

check(
           std::chrono::year{-32768}, std::chrono::month{0}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 7}});
 }
 
 // TODO FMT Should x throw?
 template <class CharT>
 static void test_invalid_values() {
   // Test that %a, %A, %b, %B, %h, %j, %u, %U, %V, %w, %W, %Ou, %OU, %OV, %Ow, and %OW throw an exception.
   check_exception(
-      "formatting a weekday name needs a valid weekday",
+      "Formatting a weekday name needs a valid weekday",
       SV("{:%a}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
 
   check_exception(
-      "formatting a weekday name needs a valid weekday",
+      "Formatting a weekday name needs a valid weekday",
       SV("{:%A}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
 
   check_exception(
-      "formatting a month name from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 day of year needs a valid date",
+      "Formatting a day of year needs a valid date",
       SV("{:%j}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 7}});
   check_exception(
-      "formatting a day of year needs a valid date",
+      "Formatting a day of year needs a valid date",
       SV("{:%j}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
   check_exception(
-      "formatting a day of year needs a valid date",
+      "Formatting a day of year needs a valid date",
       SV("{:%j}"),
       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 day of year needs a valid date",
+      "Formatting a day of year needs a valid date",
       SV("{:%j}"),
       std::chrono::year_month_weekday{
           std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
 
   check_exception(
-      "formatting a weekday needs a valid weekday",
+      "Formatting a weekday needs a valid weekday",
       SV("{:%u}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
 
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%U}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 7}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%U}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%U}"),
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%U}"),
       std::chrono::year_month_weekday{
           std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
 
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%V}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 7}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%V}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%V}"),
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%V}"),
       std::chrono::year_month_weekday{
           std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
 
   check_exception(
-      "formatting a weekday needs a valid weekday",
+      "Formatting a weekday needs a valid weekday",
       SV("{:%w}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
 
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%W}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{1}, 7}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%W}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::month{1}, std::chrono::weekday_indexed{std::chrono::weekday{13}, 1}});
   check_exception(
-      "formatting a week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%W}"),
       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 week of year needs a valid date",
+      "Formatting a week of year needs a valid date",
       SV("{:%W}"),
       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_valid_md_values() {
   constexpr std::basic_string_view<CharT> fmt =
check_invalid_types<CharT>(
       {SV("a"),  SV("A"),  SV("b"),  SV("B"),  SV("C"),  SV("d"),  SV("D"),  SV("e"),  SV("EC"),
        SV("Ex"), SV("Ey"), SV("EY"), SV("F"),  SV("g"),  SV("G"),  SV("h"),  SV("j"),  SV("m"),
        SV("Od"), SV("Oe"), SV("Om"), SV("Ou"), SV("OU"), SV("OV"), SV("Ow"), SV("OW"), SV("Oy"),
        SV("u"),  SV("U"),  SV("V"),  SV("w"),  SV("W"),  SV("x"),  SV("y"),  SV("Y")},
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
 
   check_exception(
-      "Expected '%' or '}' in the chrono format-string",
+      "The format specifier expects a '%' or a '}'",
       SV("{:A"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
   check_exception(
-      "The chrono-specs contains a '{'",
+      "The chrono specifiers contain a '{'",
       SV("{:%%{"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
   check_exception(
-      "End of input while parsing the modifier chrono conversion-spec",
+      "End of input while parsing a conversion specifier",
       SV("{:%"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
   check_exception(
       "End of input while parsing the modifier E",
       SV("{:%E"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
   check_exception(
       "End of input while parsing the modifier O",
       SV("{:%O"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
 
   // Precision not allowed
   check_exception(
-      "Expected '%' or '}' in the chrono format-string",
+      "The format specifier expects a '%' or a '}'",
       SV("{:.3}"),
       std::chrono::year_month_weekday{
           std::chrono::year{1970}, std::chrono::January, std::chrono::weekday_indexed{std::chrono::weekday{1}, 1}});
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/time/time.syn/formatter.year_month_weekday_last.pass.cpp

 }
 
 template <class CharT>
 static void test_invalid_values() {
   // *** Invalid weekday ***
 
   // Weekday name conversion
   check_exception(
-      "formatting a weekday name needs a valid weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday name needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 weekday",
+      "Formatting a weekday needs a valid weekday",
       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 date",
+      "Formatting a day of year needs a valid date",
       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(SV("Jan"),
         SV("{:%b}"),
         std::chrono::year_month_weekday_last{
check(SV("1"),
             std::chrono::year{1970}, std::chrono::month{0}, std::chrono::weekday_last{std::chrono::weekday{1}}});
   check(SV("1"),
         SV("{:%Ow}"),
         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 date",
+      "Formatting a day of year needs a valid date",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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 from an invalid month number",
+      "Formatting a month name from an invalid month number",
       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(SV("Mon"),
check(SV("1"),
             std::chrono::year{-32768}, std::chrono::month{1}, std::chrono::weekday_last{std::chrono::weekday{1}}});
   check(SV("1"),
         SV("{:%Ow}"),
         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 date",
+      "Formatting a day of year needs a valid date",
       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(SV("Jan"),
         SV("{:%b}"),
         std::chrono::year_month_weekday_last{

libcxx/test/std/utilities/format/format.functions/fill.unicode.pass.cpp

void test() {
 
   // Examples of P2572R1
   check(SV("🤡🤡x🤡🤡🤡"), SV("{:🤡^6}"), SV("x"));
   check(SV("🤡🤡🤡"), SV("{:*^6}"), SV("🤡🤡🤡"));
   check(SV("12345678"), SV("{:*>6}"), SV("12345678"));
 
   // Invalid Unicode Scalar Values
   if constexpr (std::same_as<CharT, char>) {
-    check_exception("The format-spec contains malformed Unicode characters", SV("{:\xed\xa0\x80^}"), 42); // U+D800
-    check_exception("The format-spec contains malformed Unicode characters", SV("{:\xed\xa0\xbf^}"), 42); // U+DBFF
-    check_exception("The format-spec contains malformed Unicode characters", SV("{:\xed\xbf\x80^}"), 42); // U+DC00
-    check_exception("The format-spec contains malformed Unicode characters", SV("{:\xed\xbf\xbf^}"), 42); // U+DFFF
+    check_exception("The format specifier contains malformed Unicode characters", SV("{:\xed\xa0\x80^}"), 42); // U+D800
+    check_exception("The format specifier contains malformed Unicode characters", SV("{:\xed\xa0\xbf^}"), 42); // U+DBFF
+    check_exception("The format specifier contains malformed Unicode characters", SV("{:\xed\xbf\x80^}"), 42); // U+DC00
+    check_exception("The format specifier contains malformed Unicode characters", SV("{:\xed\xbf\xbf^}"), 42); // U+DFFF
 
     check_exception(
-        "The format-spec contains malformed Unicode characters", SV("{:\xf4\x90\x80\x80^}"), 42); // U+110000
+        "The format specifier contains malformed Unicode characters", SV("{:\xf4\x90\x80\x80^}"), 42); // U+110000
     check_exception(
-        "The format-spec contains malformed Unicode characters", SV("{:\xf4\x90\xbf\xbf^}"), 42); // U+11FFFF
+        "The format specifier contains malformed Unicode characters", SV("{:\xf4\x90\xbf\xbf^}"), 42); // U+11FFFF
 
-    check_exception("The format-spec contains malformed Unicode characters",
+    check_exception("The format specifier contains malformed Unicode characters",
                     SV("{:\x80^}"),
                     42); // Trailing code unit with no leading one.
-    check_exception(
-        "The format-spec contains malformed Unicode characters", SV("{:\xc0^}"), 42); // Missing trailing code unit.
-    check_exception(
-        "The format-spec contains malformed Unicode characters", SV("{:\xe0\x80^}"), 42); // Missing trailing code unit.
-    check_exception("The format-spec contains malformed Unicode characters",
+    check_exception("The format specifier contains malformed Unicode characters",
+                    SV("{:\xc0^}"),
+                    42); // Missing trailing code unit.
+    check_exception("The format specifier contains malformed Unicode characters",
+                    SV("{:\xe0\x80^}"),
+                    42); // Missing trailing code unit.
+    check_exception("The format specifier contains malformed Unicode characters",
                     SV("{:\xf0\x80^}"),
                     42); // Missing two trailing code units.
-    check_exception("The format-spec contains malformed Unicode characters",
+    check_exception("The format specifier contains malformed Unicode characters",
                     SV("{:\xf0\x80\x80^}"),
                     42); // Missing trailing code unit.
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   } else {
 #  ifdef TEST_SHORT_WCHAR
-    check_exception("The format-spec contains malformed Unicode characters", std::wstring_view{L"{:\xd800^}"}, 42);
-    check_exception("The format-spec contains malformed Unicode characters", std::wstring_view{L"{:\xdbff^}"}, 42);
-    check_exception("The format-spec contains malformed Unicode characters", std::wstring_view{L"{:\xdc00^}"}, 42);
-    check_exception("The format-spec contains malformed Unicode characters", std::wstring_view{L"{:\xddff^}"}, 42);
+    check_exception("The format specifier contains malformed Unicode characters", std::wstring_view{L"{:\xd800^}"}, 42);
+    check_exception("The format specifier contains malformed Unicode characters", std::wstring_view{L"{:\xdbff^}"}, 42);
+    check_exception("The format specifier contains malformed Unicode characters", std::wstring_view{L"{:\xdc00^}"}, 42);
+    check_exception("The format specifier contains malformed Unicode characters", std::wstring_view{L"{:\xddff^}"}, 42);
 
-    check_exception("The format-spec contains malformed Unicode characters",
+    check_exception("The format specifier contains malformed Unicode characters",
                     std::wstring_view{L"{:\xdc00\xd800^}"},
                     42); // Reverted surrogates.
 
 #  else  // TEST_SHORT_WCHAR
-    check_exception("The fill character contains an invalid value", std::wstring_view{L"{:\xd800^}"}, 42);
-    check_exception("The fill character contains an invalid value", std::wstring_view{L"{:\xdbff^}"}, 42);
-    check_exception("The fill character contains an invalid value", std::wstring_view{L"{:\xdc00^}"}, 42);
-    check_exception("The fill character contains an invalid value", std::wstring_view{L"{:\xddff^}"}, 42);
+    check_exception("The fill option contains an invalid value", std::wstring_view{L"{:\xd800^}"}, 42);
+    check_exception("The fill option contains an invalid value", std::wstring_view{L"{:\xdbff^}"}, 42);
+    check_exception("The fill option contains an invalid value", std::wstring_view{L"{:\xdc00^}"}, 42);
+    check_exception("The fill option contains an invalid value", std::wstring_view{L"{:\xddff^}"}, 42);
 
     check_exception(
-        "The format-spec should consume the input or end with a '}'", std::wstring_view{L"{:\xdc00\xd800^}"}, 42);
+        "The format specifier should consume the input or end with a '}'", std::wstring_view{L"{:\xdc00\xd800^}"}, 42);
 
-    check_exception("The fill character contains an invalid value", std::wstring_view{L"{:\x00110000^}"}, 42);
-    check_exception("The fill character contains an invalid value", std::wstring_view{L"{:\x0011ffff^}"}, 42);
+    check_exception("The fill option contains an invalid value", std::wstring_view{L"{:\x00110000^}"}, 42);
+    check_exception("The fill option contains an invalid value", std::wstring_view{L"{:\x0011ffff^}"}, 42);
 #  endif // TEST_SHORT_WCHAR
 #endif   // TEST_HAS_NO_WIDE_CHARACTERS
   }
 }
 
 int main(int, char**) {
   test<char>();
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/format_tests.h

void format_test_string(const W& world, const U& universe, TestFunction check, ExceptionTest check_exception) {
   check(SV("hello univer"), SV("hello {:.{}s}"), universe, 6);
   check(SV("hello %world%"), SV("hello {:%^7.7s}"), world);
 
   check(SV("hello #####uni"), SV("hello {:#>8.3s}"), universe);
   check(SV("hello ##uni###"), SV("hello {:#^8.3s}"), universe);
   check(SV("hello uni#####"), SV("hello {:#<8.3s}"), universe);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("hello {:-}"), world);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("hello {:-}"), world);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("hello {:#}"), world);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("hello {:#}"), world);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("hello {:0}"), world);
+  check_exception("The width option should not have a leading zero", SV("hello {:0}"), world);
 
   // *** width ***
   // Width 0 allowed, but not useful for string arguments.
   check(SV("hello world"), SV("hello {:{}}"), world, 0);
 
 #ifdef _LIBCPP_VERSION
   // This limit isn't specified in the Standard.
   static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  check_exception("The numeric value of the format-spec is too large", SV("{:2147483648}"), world);
-  check_exception("The numeric value of the format-spec is too large", SV("{:5000000000}"), world);
-  check_exception("The numeric value of the format-spec is too large", SV("{:10000000000}"), world);
+  check_exception("The numeric value of the format specifier is too large", SV("{:2147483648}"), world);
+  check_exception("The numeric value of the format specifier is too large", SV("{:5000000000}"), world);
+  check_exception("The numeric value of the format specifier is too large", SV("{:10000000000}"), world);
 #endif
 
-  check_exception("A format-spec arg-id replacement shouldn't have a negative value", SV("hello {:{}}"), world, -1);
-  check_exception("A format-spec arg-id replacement exceeds the maximum supported value", SV("hello {:{}}"), world,
-                  unsigned(-1));
-  check_exception("Argument index out of bounds", SV("hello {:{}}"), world);
+  check_exception("An argument index may not have a negative value", SV("hello {:{}}"), world, -1);
+  check_exception("The value of the argument index exceeds its maximum value", SV("hello {:{}}"), world, unsigned(-1));
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("hello {:{}}"), world);
   check_exception(
       "Replacement argument isn't a standard signed or unsigned integer type", SV("hello {:{}}"), world, universe);
   check_exception("Using manual argument numbering in automatic argument numbering mode", SV("hello {:{0}}"), world, 1);
   check_exception("Using automatic argument numbering in manual argument numbering mode", SV("hello {0:{}}"), world, 1);
   // Arg-id may not have leading zeros.
-  check_exception("Invalid arg-id", SV("hello {0:{01}}"), world, 1);
+  check_exception("The argument index is invalid", SV("hello {0:{01}}"), world, 1);
 
   // *** precision ***
 #ifdef _LIBCPP_VERSION
   // This limit isn't specified in the Standard.
   static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  check_exception("The numeric value of the format-spec is too large", SV("{:.2147483648}"), world);
-  check_exception("The numeric value of the format-spec is too large", SV("{:.5000000000}"), world);
-  check_exception("The numeric value of the format-spec is too large", SV("{:.10000000000}"), world);
+  check_exception("The numeric value of the format specifier is too large", SV("{:.2147483648}"), world);
+  check_exception("The numeric value of the format specifier is too large", SV("{:.5000000000}"), world);
+  check_exception("The numeric value of the format specifier is too large", SV("{:.10000000000}"), world);
 #endif
 
   // Precision 0 allowed, but not useful for string arguments.
   check(SV("hello "), SV("hello {:.{}}"), world, 0);
   // Precision may have leading zeros. Secondly tests the value is still base 10.
   check(SV("hello 0123456789"), SV("hello {:.000010}"), STR("0123456789abcdef"));
-  check_exception("A format-spec arg-id replacement shouldn't have a negative value", SV("hello {:.{}}"), world, -1);
-  check_exception("A format-spec arg-id replacement exceeds the maximum supported value", SV("hello {:.{}}"), world,
-                  ~0u);
-  check_exception("Argument index out of bounds", SV("hello {:.{}}"), world);
+  check_exception("An argument index may not have a negative value", SV("hello {:.{}}"), world, -1);
+  check_exception("The value of the argument index exceeds its maximum value", SV("hello {:.{}}"), world, ~0u);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("hello {:.{}}"), world);
   check_exception(
       "Replacement argument isn't a standard signed or unsigned integer type", SV("hello {:.{}}"), world, universe);
   check_exception("Using manual argument numbering in automatic argument numbering mode", SV("hello {:.{0}}"), world,
                   1);
   check_exception("Using automatic argument numbering in manual argument numbering mode", SV("hello {0:.{}}"), world,
                   1);
   // Arg-id may not have leading zeros.
-  check_exception("Invalid arg-id", SV("hello {0:.{01}}"), world, 1);
+  check_exception("The argument index is invalid", SV("hello {0:.{01}}"), world, 1);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("hello {:L}"), world);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("hello {:L}"), world);
 
   // *** type ***
 #if TEST_STD_VER > 20
   const char* valid_types = "s?";
 #else
   const char* valid_types = "s";
 #endif
   for (const auto& fmt : invalid_types<CharT>(valid_types))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, world);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, world);
 }
 
 template <class CharT, class TestFunction>
 void format_test_string_unicode([[maybe_unused]] TestFunction check) {
   // unicode.pass.cpp and ascii.pass.cpp have additional tests.
 #ifndef TEST_HAS_NO_UNICODE
   // Make sure all possible types are tested. For clarity don't use macros.
   if constexpr (std::same_as<CharT, char>) {
void format_test_bool(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is 'true:::'"), SV("answer is '{::<7}'"), true);
   check(SV("answer is ':true::'"), SV("answer is '{::^7}'"), true);
 
   check(SV("answer is '---false'"), SV("answer is '{:->8s}'"), false);
   check(SV("answer is 'false---'"), SV("answer is '{:-<8s}'"), false);
   check(SV("answer is '-false--'"), SV("answer is '{:-^8s}'"), false);
 
   // *** Sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:-}"), true);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:+}"), true);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{: }"), true);
-
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:-s}"), true);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:+s}"), true);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{: s}"), true);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:-}"), true);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:+}"), true);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{: }"), true);
+
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:-s}"), true);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:+s}"), true);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{: s}"), true);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{:#}"), true);
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{:#s}"), true);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{:#}"), true);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{:#s}"), true);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{:0}"), true);
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{:0s}"), true);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{:0}"), true);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{:0s}"), true);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), true);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0}"), true);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42}"), true);
-
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.s}"), true);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0s}"), true);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42s}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42}"), true);
+
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.s}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0s}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42s}"), true);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("bBdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, true);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, true);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_bool_as_integer(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '1'"), SV("answer is '{:<1d}'"), true);
   check(SV("answer is '1 '"), SV("answer is '{:<2d}'"), true);
   check(SV("answer is '0 '"), SV("answer is '{:<2d}'"), false);
void format_test_bool_as_integer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is 000000000000"), SV("answer is {:012o}"), false);
   check(SV("answer is 000000000000"), SV("answer is {:#012o}"), false);
   check(SV("answer is 000000000000"), SV("answer is {:012x}"), false);
   check(SV("answer is 0x0000000000"), SV("answer is {:#012x}"), false);
   check(SV("answer is 000000000000"), SV("answer is {:012X}"), false);
   check(SV("answer is 0X0000000000"), SV("answer is {:#012X}"), false);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), true);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0}"), true);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0}"), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42}"), true);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("bBcdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, true);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, true);
 }
 
 template <class I, class CharT, class TestFunction, class ExceptionTest>
 void format_test_integer_as_integer(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '42'"), SV("answer is '{:<1}'"), I(42));
   check(SV("answer is '42'"), SV("answer is '{:<2}'"), I(42));
   check(SV("answer is '42 '"), SV("answer is '{:<3}'"), I(42));
void format_test_integer_as_integer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is +00000000052"), SV("answer is {:+012o}"), I(42));
   check(SV("answer is +00000000052"), SV("answer is {:+#012o}"), I(42));
   check(SV("answer is +0000000002a"), SV("answer is {:+012x}"), I(42));
   check(SV("answer is +0x00000002a"), SV("answer is {:+#012x}"), I(42));
   check(SV("answer is +0000000002A"), SV("answer is {:+012X}"), I(42));
   check(SV("answer is +0X00000002A"), SV("answer is {:+#012X}"), I(42));
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), I(0));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0}"), I(0));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42}"), I(0));
+
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}}"), I(0), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}}"), I(0), 1.0);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
-    check_exception("The format-spec type has a type not supported for an integer argument", fmt, 42);
+    check_exception("The type option contains an invalid value for an integer formatting argument", fmt, I(0));
 }
 
 template <class I, class CharT, class TestFunction, class ExceptionTest>
 void format_test_integer_as_char(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '*     '"), SV("answer is '{:6c}'"), I(42));
   check(SV("answer is '     *'"), SV("answer is '{:>6c}'"), I(42));
   check(SV("answer is '*     '"), SV("answer is '{:<6c}'"), I(42));
   check(SV("answer is '  *   '"), SV("answer is '{:^6c}'"), I(42));
 
   // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
   check(SV("answer is ':::::*'"), SV("answer is '{::>6c}'"), I(42));
   check(SV("answer is '*:::::'"), SV("answer is '{::<6c}'"), I(42));
   check(SV("answer is '::*:::'"), SV("answer is '{::^6c}'"), I(42));
 
   // *** Sign ***
   check(SV("answer is *"), SV("answer is {:c}"), I(42));
-  check_exception("A sign field isn't allowed in this format-spec", SV("answer is {:-c}"), I(42));
-  check_exception("A sign field isn't allowed in this format-spec", SV("answer is {:+c}"), I(42));
-  check_exception("A sign field isn't allowed in this format-spec", SV("answer is {: c}"), I(42));
+  check_exception("The format specifier for an integer does not allow the sign option", SV("answer is {:-c}"), I(42));
+  check_exception("The format specifier for an integer does not allow the sign option", SV("answer is {:+c}"), I(42));
+  check_exception("The format specifier for an integer does not allow the sign option", SV("answer is {: c}"), I(42));
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("answer is {:#c}"), I(42));
+  check_exception(
+      "The format specifier for an integer does not allow the alternate form option", SV("answer is {:#c}"), I(42));
 
   // *** zero-padding & width ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("answer is {:01c}"), I(42));
+  check_exception(
+      "The format specifier for an integer does not allow the zero-padding option", SV("answer is {:01c}"), I(42));
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.c}"), I(0));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0c}"), I(0));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42c}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.c}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0c}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42c}"), I(0));
+
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}c}"), I(0));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}c}"), I(0), true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}c}"), I(0), 1.0);
 
   // *** locale-specific form ***
   // Note it has no effect but it's allowed.
   check(SV("answer is '*'"), SV("answer is '{:Lc}'"), I(42));
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
-    check_exception("The format-spec type has a type not supported for an integer argument", fmt, I(42));
+    check_exception("The type option contains an invalid value for an integer formatting argument", fmt, I(0));
 
   // *** Validate range ***
   // The code has some duplications to keep the if statement readable.
   if constexpr (std::signed_integral<CharT>) {
     if constexpr (std::signed_integral<I> && sizeof(I) > sizeof(CharT)) {
       check_exception("Integral value outside the range of the char type", SV("{:c}"), std::numeric_limits<I>::min());
       check_exception("Integral value outside the range of the char type", SV("{:c}"), std::numeric_limits<I>::max());
     } else if constexpr (std::unsigned_integral<I> && sizeof(I) >= sizeof(CharT)) {
void format_test_char(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is '*:::::'"), SV("answer is '{::<6}'"), CharT('*'));
   check(SV("answer is '::*:::'"), SV("answer is '{::^6}'"), CharT('*'));
 
   check(SV("answer is '-----*'"), SV("answer is '{:->6c}'"), CharT('*'));
   check(SV("answer is '*-----'"), SV("answer is '{:-<6c}'"), CharT('*'));
   check(SV("answer is '--*---'"), SV("answer is '{:-^6c}'"), CharT('*'));
 
   // *** Sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:-}"), CharT('*'));
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:+}"), CharT('*'));
-  check_exception("A sign field isn't allowed in this format-spec", SV("{: }"), CharT('*'));
-
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:-c}"), CharT('*'));
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:+c}"), CharT('*'));
-  check_exception("A sign field isn't allowed in this format-spec", SV("{: c}"), CharT('*'));
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:-}"), CharT('*'));
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:+}"), CharT('*'));
+  check_exception("The format specifier for a character does not allow the sign option", SV("{: }"), CharT('*'));
+
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:-c}"), CharT('*'));
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:+c}"), CharT('*'));
+  check_exception("The format specifier for a character does not allow the sign option", SV("{: c}"), CharT('*'));
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{:#}"), CharT('*'));
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{:#c}"), CharT('*'));
+  check_exception(
+      "The format specifier for a character does not allow the alternate form option", SV("{:#}"), CharT('*'));
+  check_exception(
+      "The format specifier for a character does not allow the alternate form option", SV("{:#c}"), CharT('*'));
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{:0}"), CharT('*'));
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{:0c}"), CharT('*'));
+  check_exception(
+      "The format specifier for a character does not allow the zero-padding option", SV("{:0}"), CharT('*'));
+  check_exception(
+      "The format specifier for a character does not allow the zero-padding option", SV("{:0c}"), CharT('*'));
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), CharT('*'));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0}"), CharT('*'));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42}"), CharT('*'));
-
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.c}"), CharT('*'));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0c}"), CharT('*'));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42c}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42}"), CharT('*'));
+
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.c}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0c}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42c}"), CharT('*'));
 
   // *** locale-specific form ***
   // Note it has no effect but it's allowed.
   check(SV("answer is '*'"), SV("answer is '{:L}'"), '*');
   check(SV("answer is '*'"), SV("answer is '{:Lc}'"), '*');
 
   // *** type ***
 #if TEST_STD_VER > 20
   const char* valid_types = "bBcdoxX?";
 #else
   const char* valid_types = "bBcdoxX";
 #endif
   for (const auto& fmt : invalid_types<CharT>(valid_types))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, CharT('*'));
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, CharT('*'));
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_char_as_integer(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '42'"), SV("answer is '{:<1d}'"), CharT('*'));
 
   check(SV("answer is '42'"), SV("answer is '{:<2d}'"), CharT('*'));
void format_test_char_as_integer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is +00000000052"), SV("answer is {:+#012o}"), CharT('*'));
   check(SV("answer is +0000000002a"), SV("answer is {:+012x}"), CharT('*'));
   check(SV("answer is +0x00000002a"), SV("answer is {:+#012x}"), CharT('*'));
   check(SV("answer is +0000000002A"), SV("answer is {:+012X}"), CharT('*'));
 
   check(SV("answer is +0X00000002A"), SV("answer is {:+#012X}"), CharT('*'));
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.d}"), CharT('*'));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.0d}"), CharT('*'));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.42d}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.d}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0d}"), CharT('*'));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42d}"), CharT('*'));
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 
   // *** type ***
 #if TEST_STD_VER > 20
   const char* valid_types = "bBcdoxX?";
 #else
   const char* valid_types = "bBcdoxX";
 #endif
   for (const auto& fmt : invalid_types<CharT>(valid_types))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, '*');
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, CharT('*'));
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_hex_lower_case(TestFunction check) {
   auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
   auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // Test whether the hexadecimal letters are the proper case.
void format_test_floating_point(TestFunction check, ExceptionTest check_exception) {
 
   format_test_floating_point_default<F, CharT>(check);
   format_test_floating_point_default_precision<F, CharT>(check);
 
   format_test_floating_point_PR58714<F, CharT>(check);
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("aAeEfFgG"))
-    check_exception("The format-spec type has a type not supported for a floating-point argument", fmt, F(1));
+    check_exception("The type option contains an invalid value for a floating-point formatting argument", fmt, F(1));
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_floating_point(TestFunction check, ExceptionTest check_exception) {
   format_test_floating_point<float, CharT>(check, check_exception);
   format_test_floating_point<double, CharT>(check, check_exception);
   format_test_floating_point<long double, CharT>(check, check_exception);
 }
 
 template <class P, class CharT, class TestFunction, class ExceptionTest>
 void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '   0x0'"), SV("answer is '{:6}'"), P(nullptr));
   check(SV("answer is '   0x0'"), SV("answer is '{:>6}'"), P(nullptr));
   check(SV("answer is '0x0   '"), SV("answer is '{:<6}'"), P(nullptr));
   check(SV("answer is ' 0x0  '"), SV("answer is '{:^6}'"), P(nullptr));
 
   // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
   check(SV("answer is ':::0x0'"), SV("answer is '{::>6}'"), P(nullptr));
   check(SV("answer is '0x0:::'"), SV("answer is '{::<6}'"), P(nullptr));
   check(SV("answer is ':0x0::'"), SV("answer is '{::^6}'"), P(nullptr));
 
   // *** Sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), P(nullptr));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), P(nullptr));
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), P(nullptr));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), P(nullptr));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), P(nullptr));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), P(nullptr));
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), P(nullptr));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), P(nullptr));
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), P(nullptr));
+  check_exception("The width option should not have a leading zero", SV("{:0}"), P(nullptr));
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), P(nullptr));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), nullptr);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.0}"), nullptr);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.42}"), nullptr);
+
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}}"), nullptr);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}}"), nullptr, true);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.{}}"), nullptr, 1.0);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), P(nullptr));
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), P(nullptr));
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("p"))
-    check_exception("The format-spec type has a type not supported for a pointer argument", fmt, P(nullptr));
+    check_exception("The type option contains an invalid value for a pointer formatting argument", fmt, P(nullptr));
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_handle(TestFunction check, ExceptionTest check_exception) {
   // *** Valid permuatations ***
   check(SV("answer is '0xaaaa'"), SV("answer is '{}'"), status::foo);
   check(SV("answer is '0xaaaa'"), SV("answer is '{:x}'"), status::foo);
   check(SV("answer is '0XAAAA'"), SV("answer is '{:X}'"), status::foo);
void format_test_handle(TestFunction check, ExceptionTest check_exception) {
 
   // P2418 Changed the argument from a const reference to a forwarding reference.
   // This mainly affects handle classes, however since we use an abstraction
   // layer here it's "tricky" to verify whether this test would do the "right"
   // thing. So these tests are done separately.
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("xXs"))
-    check_exception("The format-spec type has a type not supported for a status argument", fmt, status::foo);
+    check_exception("The type option contains an invalid value for a status formatting argument", fmt, status::foo);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   format_test_pointer<std::nullptr_t, CharT>(check, check_exception);
   format_test_pointer<void*, CharT>(check, check_exception);
   format_test_pointer<const void*, CharT>(check, check_exception);
 }
#endif
   check(std::basic_string_view<CharT>{str + fill}, SV("{:*<{}}"), str, str.size() + minimum);
   check(std::basic_string_view<CharT>{fill + str + fill}, SV("{:*^{}}"), str, minimum + str.size() + minimum);
   check(std::basic_string_view<CharT>{fill + str}, SV("{:*>{}}"), str, minimum + str.size());
 }
 
 template <class CharT, execution_modus modus, class TestFunction, class ExceptionTest>
 void format_tests(TestFunction check, ExceptionTest check_exception) {
   // *** Test escaping  ***
-
   check(SV("{"), SV("{{"));
   check(SV("}"), SV("}}"));
   check(SV("{:^}"), SV("{{:^}}"));
   check(SV("{: ^}"), SV("{{:{}^}}"), CharT(' '));
   check(SV("{:{}^}"), SV("{{:{{}}^}}"));
   check(SV("{:{ }^}"), SV("{{:{{{}}}^}}"), CharT(' '));
 
   // *** Test argument ID ***
void format_tests(TestFunction check, ExceptionTest check_exception) {
   // ** Test invalid format strings ***
   check_exception("The format string terminates at a '{'", SV("{"));
   check_exception("The replacement field misses a terminating '}'", SV("{:"), 42);
 
   check_exception("The format string contains an invalid escape sequence", SV("}"));
   check_exception("The format string contains an invalid escape sequence", SV("{:}-}"), 42);
 
   check_exception("The format string contains an invalid escape sequence", SV("} "));
-  check_exception("The arg-id of the format-spec starts with an invalid character", SV("{-"), 42);
-  check_exception("Argument index out of bounds", SV("hello {}"));
-  check_exception("Argument index out of bounds", SV("hello {0}"));
-  check_exception("Argument index out of bounds", SV("hello {1}"), 42);
+  check_exception("The argument index starts with an invalid character", SV("{-"), 42);
+  check_exception("The argument index value is too larger for the number of arguments supplied", SV("hello {}"));
+  check_exception("The argument index value is too larger for the number of arguments supplied", SV("hello {0}"));
+  check_exception("The argument index value is too larger for the number of arguments supplied", SV("hello {1}"), 42);
 
   // *** Test char format argument ***
   // The `char` to `wchar_t` formatting is tested separately.
   check(SV("hello 09azAZ!"),
         SV("hello {}{}{}{}{}{}{}"),
         CharT('0'),
         CharT('9'),
         CharT('a'),
void format_tests(TestFunction check, ExceptionTest check_exception) {
 
   // *** Test Boolean format argument ***
   check(SV("hello false true"), SV("hello {} {}"), false, true);
 
   if constexpr (modus == execution_modus::full) {
     format_test_bool<CharT>(check, check_exception);
     format_test_bool_as_integer<CharT>(check, check_exception);
   }
-
   // *** Test signed integral format argument ***
   check(SV("hello 42"), SV("hello {}"), static_cast<signed char>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<short>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<int>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<long>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<long long>(42));
 #ifndef TEST_HAS_NO_INT128
   check(SV("hello 42"), SV("hello {}"), static_cast<__int128_t>(42));
 #endif
+
   if constexpr (modus == execution_modus::full)
     format_test_signed_integer<CharT>(check, check_exception);
 
   // ** Test unsigned integral format argument ***
   check(SV("hello 42"), SV("hello {}"), static_cast<unsigned char>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<unsigned short>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<unsigned>(42));
   check(SV("hello 42"), SV("hello {}"), static_cast<unsigned long>(42));

libcxx/test/std/utilities/format/format.range/format.range.fmtmap/format.functions.tests.h

void test_char(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{'a': 'A', 'b': 'B', 'c': 'C'}___"), SV("{:_^35}"), input);
   check(SV("#####{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{:#>35}"), input);
 
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}     "), SV("{:{}}"), input, 35);
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}*****"), SV("{:*<{}}"), input, 35);
   check(SV("__{'a': 'A', 'b': 'B', 'c': 'C'}___"), SV("{:_^{}}"), input, 35);
   check(SV("#####{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{:#>{}}"), input, 35);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__'a': 'A', 'b': 'B', 'c': 'C'___"), SV("{:_^33n}"), input);
 
   // *** type ***
   check(SV("__{'a': 'A', 'b': 'B', 'c': 'C'}___"), SV("{:_^35m}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
 
   check(SV("{'a': 'A'     , 'b': 'B'     , 'c': 'C'     }"), SV("{::13}"), input);
   check(SV("{'a': 'A'*****, 'b': 'B'*****, 'c': 'C'*****}"), SV("{::*<13}"), input);
   check(SV("{__'a': 'A'___, __'b': 'B'___, __'c': 'C'___}"), SV("{::_^13}"), input);
   check(SV("{#####'a': 'A', #####'b': 'B', #####'c': 'C'}"), SV("{::#>13}"), input);
 
   check(SV("{'a': 'A'     , 'b': 'B'     , 'c': 'C'     }"), SV("{::{}}"), input, 13);
   check(SV("{'a': 'A'*****, 'b': 'B'*****, 'c': 'C'*****}"), SV("{::*<{}}"), input, 13);
   check(SV("{__'a': 'A'___, __'b': 'B'___, __'c': 'C'___}"), SV("{::_^{}}"), input, 13);
   check(SV("{#####'a': 'A', #####'b': 'B', #####'c': 'C'}"), SV("{::#>{}}"), input, 13);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{::m}"), input);
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{::n}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###'a': 'A', ###'b': 'B', ###'c': 'C'}^^^"), SV("{:^^44:#>11}"), input);
   check(SV("^^{###'a': 'A', ###'b': 'B', ###'c': 'C'}^^^"), SV("{:^^{}:#>11}"), input, 44);
   check(SV("^^{###'a': 'A', ###'b': 'B', ###'c': 'C'}^^^"), SV("{:^^{}:#>{}}"), input, 44, 11);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>11}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 44);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>11}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 44);
 }
 
 //
 // char -> wchar_t
 //
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class TestFunction, class ExceptionTest>
void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{'a': 'A', 'b': 'B', 'c': 'C'}___"), SV("{:_^35}"), input);
   check(SV("#####{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{:#>35}"), input);
 
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}     "), SV("{:{}}"), input, 35);
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}*****"), SV("{:*<{}}"), input, 35);
   check(SV("__{'a': 'A', 'b': 'B', 'c': 'C'}___"), SV("{:_^{}}"), input, 35);
   check(SV("#####{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{:#>{}}"), input, 35);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__'a': 'A', 'b': 'B', 'c': 'C'___"), SV("{:_^33n}"), input);
 
   // *** type ***
   check(SV("__{'a': 'A', 'b': 'B', 'c': 'C'}___"), SV("{:_^35m}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{'a': 'A'     , 'b': 'B'     , 'c': 'C'     }"), SV("{::13}"), input);
   check(SV("{'a': 'A'*****, 'b': 'B'*****, 'c': 'C'*****}"), SV("{::*<13}"), input);
   check(SV("{__'a': 'A'___, __'b': 'B'___, __'c': 'C'___}"), SV("{::_^13}"), input);
   check(SV("{#####'a': 'A', #####'b': 'B', #####'c': 'C'}"), SV("{::#>13}"), input);
 
   check(SV("{'a': 'A'     , 'b': 'B'     , 'c': 'C'     }"), SV("{::{}}"), input, 13);
   check(SV("{'a': 'A'*****, 'b': 'B'*****, 'c': 'C'*****}"), SV("{::*<{}}"), input, 13);
   check(SV("{__'a': 'A'___, __'b': 'B'___, __'c': 'C'___}"), SV("{::_^{}}"), input, 13);
   check(SV("{#####'a': 'A', #####'b': 'B', #####'c': 'C'}"), SV("{::#>{}}"), input, 13);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{::m}"), input);
   check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{::n}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###'a': 'A', ###'b': 'B', ###'c': 'C'}^^^"), SV("{:^^44:#>11}"), input);
   check(SV("^^{###'a': 'A', ###'b': 'B', ###'c': 'C'}^^^"), SV("{:^^{}:#>11}"), input, 44);
   check(SV("^^{###'a': 'A', ###'b': 'B', ###'c': 'C'}^^^"), SV("{:^^{}:#>{}}"), input, 44, 11);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>11}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 44);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>11}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 44);
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 //
 // Bool
 //
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_bool(TestFunction check, ExceptionTest check_exception) {
void test_bool(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{false: 0, true: 42, true: 1}___"), SV("{:_^34}"), input);
   check(SV("#####{false: 0, true: 42, true: 1}"), SV("{:#>34}"), input);
 
   check(SV("{false: 0, true: 42, true: 1}     "), SV("{:{}}"), input, 34);
   check(SV("{false: 0, true: 42, true: 1}*****"), SV("{:*<{}}"), input, 34);
   check(SV("__{false: 0, true: 42, true: 1}___"), SV("{:_^{}}"), input, 34);
   check(SV("#####{false: 0, true: 42, true: 1}"), SV("{:#>{}}"), input, 34);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__false: 0, true: 42, true: 1___"), SV("{:_^32n}"), input);
 
   // *** type ***
   check(SV("__{false: 0, true: 42, true: 1}___"), SV("{:_^34m}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{false: 0  , true: 42  , true: 1   }"), SV("{::10}"), input);
   check(SV("{false: 0**, true: 42**, true: 1***}"), SV("{::*<10}"), input);
   check(SV("{_false: 0_, _true: 42_, _true: 1__}"), SV("{::_^10}"), input);
   check(SV("{##false: 0, ##true: 42, ###true: 1}"), SV("{::#>10}"), input);
 
   check(SV("{false: 0  , true: 42  , true: 1   }"), SV("{::{}}"), input, 10);
   check(SV("{false: 0**, true: 42**, true: 1***}"), SV("{::*<{}}"), input, 10);
   check(SV("{_false: 0_, _true: 42_, _true: 1__}"), SV("{::_^{}}"), input, 10);
   check(SV("{##false: 0, ##true: 42, ###true: 1}"), SV("{::#>{}}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{##false: 0, ##true: 42, ###true: 1}^^^"), SV("{:^^41:#>10}"), input);
   check(SV("^^{##false: 0, ##true: 42, ###true: 1}^^^"), SV("{:^^{}:#>10}"), input, 41);
   check(SV("^^{##false: 0, ##true: 42, ###true: 1}^^^"), SV("{:^^{}:#>{}}"), input, 41, 10);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>10}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 41);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>10}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 41);
 }
 
 //
 // Integral
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("{-42: 42, 1: -1, 42: -42}"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("{-42: 42, 1: -1, 42: -42}     "), SV("{:30}"), input);
   check(SV("{-42: 42, 1: -1, 42: -42}*****"), SV("{:*<30}"), input);
   check(SV("__{-42: 42, 1: -1, 42: -42}___"), SV("{:_^30}"), input);
   check(SV("#####{-42: 42, 1: -1, 42: -42}"), SV("{:#>30}"), input);
 
   check(SV("{-42: 42, 1: -1, 42: -42}     "), SV("{:{}}"), input, 30);
   check(SV("{-42: 42, 1: -1, 42: -42}*****"), SV("{:*<{}}"), input, 30);
   check(SV("__{-42: 42, 1: -1, 42: -42}___"), SV("{:_^{}}"), input, 30);
   check(SV("#####{-42: 42, 1: -1, 42: -42}"), SV("{:#>{}}"), input, 30);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42: 42, 1: -1, 42: -42___"), SV("{:_^28n}"), input);
 
   // *** type ***
   check(SV("__{-42: 42, 1: -1, 42: -42}___"), SV("{:_^30m}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{-42: 42   , 1: -1     , 42: -42   }"), SV("{::10}"), input);
   check(SV("{-42: 42***, 1: -1*****, 42: -42***}"), SV("{::*<10}"), input);
   check(SV("{_-42: 42__, __1: -1___, _42: -42__}"), SV("{::_^10}"), input);
   check(SV("{###-42: 42, #####1: -1, ###42: -42}"), SV("{::#>10}"), input);
 
   check(SV("{-42: 42   , 1: -1     , 42: -42   }"), SV("{::{}}"), input, 10);
   check(SV("{-42: 42***, 1: -1*****, 42: -42***}"), SV("{::*<{}}"), input, 10);
   check(SV("{_-42: 42__, __1: -1___, _42: -42__}"), SV("{::_^{}}"), input, 10);
   check(SV("{###-42: 42, #####1: -1, ###42: -42}"), SV("{::#>{}}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###-42: 42, #####1: -1, ###42: -42}^^^"), SV("{:^^41:#>10}"), input);
   check(SV("^^{###-42: 42, #####1: -1, ###42: -42}^^^"), SV("{:^^{}:#>10}"), input, 41);
   check(SV("^^{###-42: 42, #####1: -1, ###42: -42}^^^"), SV("{:^^{}:#>{}}"), input, 41, 10);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>10}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 41);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>10}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 41);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception) {
   test_int<CharT>(check, check_exception, std::map<int, int>{{1, -1}, {42, -42}, {-42, 42}});
 }
 
 //
void test_floating_point(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{-42: 42, 1: -1}___"), SV("{:_^21}"), input);
   check(SV("#####{-42: 42, 1: -1}"), SV("{:#>21}"), input);
 
   check(SV("{-42: 42, 1: -1}     "), SV("{:{}}"), input, 21);
   check(SV("{-42: 42, 1: -1}*****"), SV("{:*<{}}"), input, 21);
   check(SV("__{-42: 42, 1: -1}___"), SV("{:_^{}}"), input, 21);
   check(SV("#####{-42: 42, 1: -1}"), SV("{:#>{}}"), input, 21);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42: 42, 1: -1___"), SV("{:_^19n}"), input);
 
   // *** type ***
   check(SV("__{-42: 42, 1: -1}___"), SV("{:_^21m}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{-42: 42   , 1: -1     }"), SV("{::10}"), input);
   check(SV("{-42: 42***, 1: -1*****}"), SV("{::*<10}"), input);
   check(SV("{_-42: 42__, __1: -1___}"), SV("{::_^10}"), input);
   check(SV("{###-42: 42, #####1: -1}"), SV("{::#>10}"), input);
 
   check(SV("{-42: 42   , 1: -1     }"), SV("{::{}}"), input, 10);
   check(SV("{-42: 42***, 1: -1*****}"), SV("{::*<{}}"), input, 10);
   check(SV("{_-42: 42__, __1: -1___}"), SV("{::_^{}}"), input, 10);
   check(SV("{###-42: 42, #####1: -1}"), SV("{::#>{}}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^29:#>10}"), input);
   check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^{}:#>10}"), input, 29);
   check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^{}:#>{}}"), input, 29, 10);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>10}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 29);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>10}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 29);
 }
 
 //
 // Pointer
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_pointer(TestFunction check, ExceptionTest check_exception) {
void test_pointer(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{0x0: 0x0}___"), SV("{:_^15}"), input);
   check(SV("#####{0x0: 0x0}"), SV("{:#>15}"), input);
 
   check(SV("{0x0: 0x0}     "), SV("{:{}}"), input, 15);
   check(SV("{0x0: 0x0}*****"), SV("{:*<{}}"), input, 15);
   check(SV("__{0x0: 0x0}___"), SV("{:_^{}}"), input, 15);
   check(SV("#####{0x0: 0x0}"), SV("{:#>{}}"), input, 15);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__0x0: 0x0___"), SV("{:_^13n}"), input);
 
   // *** type ***
   check(SV("__{0x0: 0x0}___"), SV("{:_^15m}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{0x0: 0x0     }"), SV("{::13}"), input);
   check(SV("{0x0: 0x0*****}"), SV("{::*<13}"), input);
   check(SV("{__0x0: 0x0___}"), SV("{::_^13}"), input);
   check(SV("{#####0x0: 0x0}"), SV("{::#>13}"), input);
 
   check(SV("{0x0: 0x0     }"), SV("{::{}}"), input, 13);
   check(SV("{0x0: 0x0*****}"), SV("{::*<{}}"), input, 13);
   check(SV("{__0x0: 0x0___}"), SV("{::_^{}}"), input, 13);
   check(SV("{#####0x0: 0x0}"), SV("{::#>{}}"), input, 13);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###0x0: 0x0}^^^"), SV("{:^^18:#>11}"), input);
   check(SV("^^{###0x0: 0x0}^^^"), SV("{:^^{}:#>11}"), input, 18);
   check(SV("^^{###0x0: 0x0}^^^"), SV("{:^^{}:#>{}}"), input, 18, 11);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>11}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 18);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>11}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 18);
 }
 
 //
 // String
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
void test_string(TestFunction check, ExceptionTest check_exception) {
   check(SV(R"(__{"hello": "HELLO", "world": "WORLD"}___)"), SV("{:_^41}"), input);
   check(SV(R"(#####{"hello": "HELLO", "world": "WORLD"})"), SV("{:#>41}"), input);
 
   check(SV(R"({"hello": "HELLO", "world": "WORLD"}     )"), SV("{:{}}"), input, 41);
   check(SV(R"({"hello": "HELLO", "world": "WORLD"}*****)"), SV("{:*<{}}"), input, 41);
   check(SV(R"(__{"hello": "HELLO", "world": "WORLD"}___)"), SV("{:_^{}}"), input, 41);
   check(SV(R"(#####{"hello": "HELLO", "world": "WORLD"})"), SV("{:#>{}}"), input, 41);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV(R"(__"hello": "HELLO", "world": "WORLD"___)"), SV("{:_^39n}"), input);
 
   // *** type ***
   check(SV(R"(__{"hello": "HELLO", "world": "WORLD"}___)"), SV("{:_^41m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV(R"({"hello": "HELLO"     , "world": "WORLD"     })"), SV("{::21}"), input);
   check(SV(R"({"hello": "HELLO"*****, "world": "WORLD"*****})"), SV("{::*<21}"), input);
   check(SV(R"({__"hello": "HELLO"___, __"world": "WORLD"___})"), SV("{::_^21}"), input);
   check(SV(R"({#####"hello": "HELLO", #####"world": "WORLD"})"), SV("{::#>21}"), input);
 
   check(SV(R"({"hello": "HELLO"     , "world": "WORLD"     })"), SV("{::{}}"), input, 21);
   check(SV(R"({"hello": "HELLO"*****, "world": "WORLD"*****})"), SV("{::*<{}}"), input, 21);
   check(SV(R"({__"hello": "HELLO"___, __"world": "WORLD"___})"), SV("{::_^{}}"), input, 21);
   check(SV(R"({#####"hello": "HELLO", #####"world": "WORLD"})"), SV("{::#>{}}"), input, 21);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
 
   check(SV(R"(^^{#####"hello": "HELLO", #####"world": "WORLD"}^^^)"), SV("{:^^51:#>21}"), input);
   check(SV(R"(^^{#####"hello": "HELLO", #####"world": "WORLD"}^^^)"), SV("{:^^{}:#>21}"), input, 51);
   check(SV(R"(^^{#####"hello": "HELLO", #####"world": "WORLD"}^^^)"), SV("{:^^{}:#>{}}"), input, 51, 21);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>21}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 51);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>21}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 51);
 }
 
 //
 // Handle
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_status(TestFunction check, ExceptionTest check_exception) {
void test_status(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{0xaa55: 0xaaaa, 0xaa55: 0x5555}___"), SV("{:_^37}"), input);
   check(SV("#####{0xaa55: 0xaaaa, 0xaa55: 0x5555}"), SV("{:#>37}"), input);
 
   check(SV("{0xaa55: 0xaaaa, 0xaa55: 0x5555}     "), SV("{:{}}"), input, 37);
   check(SV("{0xaa55: 0xaaaa, 0xaa55: 0x5555}*****"), SV("{:*<{}}"), input, 37);
   check(SV("__{0xaa55: 0xaaaa, 0xaa55: 0x5555}___"), SV("{:_^{}}"), input, 37);
   check(SV("#####{0xaa55: 0xaaaa, 0xaa55: 0x5555}"), SV("{:#>{}}"), input, 37);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__0xaa55: 0xaaaa, 0xaa55: 0x5555___"), SV("{:_^35n}"), input);
 
   // *** type ***
   check(SV("__{0xaa55: 0xaaaa, 0xaa55: 0x5555}___"), SV("{:_^37}"), input); // the m type does the same as the default.
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   // Underlying can't have a format-spec
 }
 
 //
 // Adaptor
 //
 

libcxx/test/std/utilities/format/format.range/format.range.fmtset/format.functions.tests.h

void test_char_default(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{'a', 'b', 'c'}___"), SV("{:_^20}"), input);
   check(SV("#####{'a', 'b', 'c'}"), SV("{:#>20}"), input);
 
   check(SV("{'a', 'b', 'c'}     "), SV("{:{}}"), input, 20);
   check(SV("{'a', 'b', 'c'}*****"), SV("{:*<{}}"), input, 20);
   check(SV("__{'a', 'b', 'c'}___"), SV("{:_^{}}"), input, 20);
   check(SV("#####{'a', 'b', 'c'}"), SV("{:#>{}}"), input, 20);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__'a', 'b', 'c'___"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check(SV("{a   , b   , c   }"), SV("{::4}"), input);
   check(SV("{a***, b***, c***}"), SV("{::*<4}"), input);
   check(SV("{_a__, _b__, _c__}"), SV("{::_^4}"), input);
   check(SV("{:::a, :::b, :::c}"), SV("{:::>4}"), input);
 
   check(SV("{a   , b   , c   }"), SV("{::{}}"), input, 4);
   check(SV("{a***, b***, c***}"), SV("{::*<{}}"), input, 4);
   check(SV("{_a__, _b__, _c__}"), SV("{::_^{}}"), input, 4);
   check(SV("{:::a, :::b, :::c}"), SV("{:::>{}}"), input, 4);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:: }"), input);
 
   check(SV("{97, 98, 99}"), SV("{::-d}"), input);
   check(SV("{+97, +98, +99}"), SV("{::+d}"), input);
   check(SV("{ 97,  98,  99}"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a character does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("{0x61, 0x62, 0x63}"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a character does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("{00141, 00142, 00143}"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("{a, b, c}"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{:a, :b, :c}^^^"), SV("{:^^17::>2}"), input);
   check(SV("^^{:a, :b, :c}^^^"), SV("{:^^{}::>2}"), input, 17);
   check(SV("^^{:a, :b, :c}^^^"), SV("{:^^{}::>{}}"), input, 17, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 17);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 17);
 }
 
 // A set can be written as a string, based on
 //   [tab:formatter.range.type]
 //   s  T shall be charT. ...
 // This does not seem very useful, but it is allowed.
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_string(TestFunction check, [[maybe_unused]] ExceptionTest check_exception) {
void test_char_string(TestFunction check, [[maybe_unused]] ExceptionTest check_exception) {
   check(SV("_abc__"), SV("{:_^6s}"), input);
   check(SV("###abc"), SV("{:#>6s}"), input);
 
   check(SV("abc   "), SV("{:{}s}"), input, 6);
   check(SV("abc***"), SV("{:*<{}s}"), input, 6);
   check(SV("_abc__"), SV("{:_^{}s}"), input, 6);
   check(SV("###abc"), SV("{:#>{}s}"), input, 6);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<s}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: s}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#s}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0s}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0s}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.s}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:Ls}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:Ls}"), input);
 
   // *** n
   check_exception("The n option and type s can't be used together", SV("{:ns}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check_exception("Type s and an underlying format specification can't be used together", SV("{:s:}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check_exception("Type s and an underlying format specification can't be used together", SV("{:5s:5}"), input);
 }
 
 // A set can be written as a debug_string, based on
 //   [tab:formatter.range.type]
 //   ?s T shall be charT. ...
void test_char_escaped_string(TestFunction check, [[maybe_unused]] ExceptionTest check_exception) {
   check(SV(R"(_"abc"__)"), SV("{:_^8?s}"), input);
   check(SV(R"(###"abc")"), SV("{:#>8?s}"), input);
 
   check(SV(R"("abc"   )"), SV("{:{}?s}"), input, 8);
   check(SV(R"("abc"***)"), SV("{:*<{}?s}"), input, 8);
   check(SV(R"(_"abc"__)"), SV("{:_^{}?s}"), input, 8);
   check(SV(R"(###"abc")"), SV("{:#>{}?s}"), input, 8);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<?s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<?s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<?s}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-?s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+?s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: ?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: ?s}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#?s}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0?s}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0?s}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.?s}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L?s}"), input);
 
   // *** n
   check_exception("The n option and type ?s can't be used together", SV("{:n?s}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check_exception("Type ?s and an underlying format specification can't be used together", SV("{:?s:}"), input);
 
   // ***** Both have a format-spec
   check_exception("Type ?s and an underlying format specification can't be used together", SV("{:5?s:5}"), input);
 }
 
void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{'a', 'b', 'c'}___"), SV("{:_^20}"), input);
   check(SV("#####{'a', 'b', 'c'}"), SV("{:#>20}"), input);
 
   check(SV("{'a', 'b', 'c'}     "), SV("{:{}}"), input, 20);
   check(SV("{'a', 'b', 'c'}*****"), SV("{:*<{}}"), input, 20);
   check(SV("__{'a', 'b', 'c'}___"), SV("{:_^{}}"), input, 20);
   check(SV("#####{'a', 'b', 'c'}"), SV("{:#>{}}"), input, 20);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__'a', 'b', 'c'___"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check(SV("{a   , b   , c   }"), SV("{::4}"), input);
   check(SV("{a***, b***, c***}"), SV("{::*<4}"), input);
   check(SV("{_a__, _b__, _c__}"), SV("{::_^4}"), input);
   check(SV("{:::a, :::b, :::c}"), SV("{:::>4}"), input);
 
   check(SV("{a   , b   , c   }"), SV("{::{}}"), input, 4);
   check(SV("{a***, b***, c***}"), SV("{::*<{}}"), input, 4);
   check(SV("{_a__, _b__, _c__}"), SV("{::_^{}}"), input, 4);
   check(SV("{:::a, :::b, :::c}"), SV("{:::>{}}"), input, 4);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:: }"), input);
 
   check(SV("{97, 98, 99}"), SV("{::-d}"), input);
   check(SV("{+97, +98, +99}"), SV("{::+d}"), input);
   check(SV("{ 97,  98,  99}"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a character does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("{0x61, 0x62, 0x63}"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a character does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("{00141, 00142, 00143}"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("{a, b, c}"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{:a, :b, :c}^^^"), SV("{:^^17::>2}"), input);
   check(SV("^^{:a, :b, :c}^^^"), SV("{:^^{}::>2}"), input, 17);
   check(SV("^^{:a, :b, :c}^^^"), SV("{:^^{}::>{}}"), input, 17, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 17);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 17);
 
   // The types s and ?s may only be used when using range_formatter<T, charT>
   // where the types T and charT are the same. This means this can't be used for
   // range_formatter<wchar_t, char> even when formatter<wchar_t, char> has a
   // debug-enabled specialization.
 
   using CharT = wchar_t;
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 }
 #endif //  _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 //
 // Bool
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
void test_bool(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{false, true}___"), SV("{:_^18}"), input);
   check(SV("#####{false, true}"), SV("{:#>18}"), input);
 
   check(SV("{false, true}     "), SV("{:{}}"), input, 18);
   check(SV("{false, true}*****"), SV("{:*<{}}"), input, 18);
   check(SV("__{false, true}___"), SV("{:_^{}}"), input, 18);
   check(SV("#####{false, true}"), SV("{:#>{}}"), input, 18);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__false, true___"), SV("{:_^16n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{false  , true   }"), SV("{::7}"), input);
   check(SV("{false**, true***}"), SV("{::*<7}"), input);
   check(SV("{_false_, _true__}"), SV("{::_^7}"), input);
   check(SV("{::false, :::true}"), SV("{:::>7}"), input);
 
   check(SV("{false  , true   }"), SV("{::{}}"), input, 7);
   check(SV("{false**, true***}"), SV("{::*<{}}"), input, 7);
   check(SV("{_false_, _true__}"), SV("{::_^{}}"), input, 7);
   check(SV("{::false, :::true}"), SV("{:::>{}}"), input, 7);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:: }"), input);
 
   check(SV("{0, 1}"), SV("{::-d}"), input);
   check(SV("{+0, +1}"), SV("{::+d}"), input);
   check(SV("{ 0,  1}"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("{0x0, 0x1}"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("{00000, 00001}"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("{false, true}"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, input);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{::false, :::true}^^^"), SV("{:^^23::>7}"), input);
   check(SV("^^{::false, :::true}^^^"), SV("{:^^{}::>7}"), input, 23);
   check(SV("^^{::false, :::true}^^^"), SV("{:^^{}::>{}}"), input, 23, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 23);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 23);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_bool_multiset(TestFunction check, ExceptionTest check_exception) {
   std::multiset<bool, std::greater<bool>> input{true, false, true}; // unordered
 
   check(SV("{true, true, false}"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("{true, true, false}     "), SV("{:24}"), input);
   check(SV("{true, true, false}*****"), SV("{:*<24}"), input);
   check(SV("__{true, true, false}___"), SV("{:_^24}"), input);
   check(SV("#####{true, true, false}"), SV("{:#>24}"), input);
 
   check(SV("{true, true, false}     "), SV("{:{}}"), input, 24);
   check(SV("{true, true, false}*****"), SV("{:*<{}}"), input, 24);
   check(SV("__{true, true, false}___"), SV("{:_^{}}"), input, 24);
   check(SV("#####{true, true, false}"), SV("{:#>{}}"), input, 24);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__true, true, false___"), SV("{:_^22n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{true   , true   , false  }"), SV("{::7}"), input);
   check(SV("{true***, true***, false**}"), SV("{::*<7}"), input);
   check(SV("{_true__, _true__, _false_}"), SV("{::_^7}"), input);
   check(SV("{:::true, :::true, ::false}"), SV("{:::>7}"), input);
 
   check(SV("{true   , true   , false  }"), SV("{::{}}"), input, 7);
   check(SV("{true***, true***, false**}"), SV("{::*<{}}"), input, 7);
   check(SV("{_true__, _true__, _false_}"), SV("{::_^{}}"), input, 7);
   check(SV("{:::true, :::true, ::false}"), SV("{:::>{}}"), input, 7);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:: }"), input);
 
   check(SV("{1, 1, 0}"), SV("{::-d}"), input);
   check(SV("{+1, +1, +0}"), SV("{::+d}"), input);
   check(SV("{ 1,  1,  0}"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("{0x1, 0x1, 0x0}"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("{00001, 00001, 00000}"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("{true, true, false}"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, input);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{:::true, :::true, ::false}^^^"), SV("{:^^32::>7}"), input);
   check(SV("^^{:::true, :::true, ::false}^^^"), SV("{:^^{}::>7}"), input, 32);
   check(SV("^^{:::true, :::true, ::false}^^^"), SV("{:^^{}::>{}}"), input, 32, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 32);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 32);
 }
 
 //
 // Integral
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("{-42, 1, 2, 42}"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("{-42, 1, 2, 42}     "), SV("{:20}"), input);
   check(SV("{-42, 1, 2, 42}*****"), SV("{:*<20}"), input);
   check(SV("__{-42, 1, 2, 42}___"), SV("{:_^20}"), input);
   check(SV("#####{-42, 1, 2, 42}"), SV("{:#>20}"), input);
 
   check(SV("{-42, 1, 2, 42}     "), SV("{:{}}"), input, 20);
   check(SV("{-42, 1, 2, 42}*****"), SV("{:*<{}}"), input, 20);
   check(SV("__{-42, 1, 2, 42}___"), SV("{:_^{}}"), input, 20);
   check(SV("#####{-42, 1, 2, 42}"), SV("{:#>{}}"), input, 20);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42, 1, 2, 42___"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{  -42,     1,     2,    42}"), SV("{::5}"), input);
   check(SV("{-42**, 1****, 2****, 42***}"), SV("{::*<5}"), input);
   check(SV("{_-42_, __1__, __2__, _42__}"), SV("{::_^5}"), input);
   check(SV("{::-42, ::::1, ::::2, :::42}"), SV("{:::>5}"), input);
 
   check(SV("{  -42,     1,     2,    42}"), SV("{::{}}"), input, 5);
   check(SV("{-42**, 1****, 2****, 42***}"), SV("{::*<{}}"), input, 5);
   check(SV("{_-42_, __1__, __2__, _42__}"), SV("{::_^{}}"), input, 5);
   check(SV("{::-42, ::::1, ::::2, :::42}"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
   check(SV("{-42, 1, 2, 42}"), SV("{::-}"), input);
   check(SV("{-42, +1, +2, +42}"), SV("{::+}"), input);
   check(SV("{-42,  1,  2,  42}"), SV("{:: }"), input);
 
   // *** alternate form ***
   check(SV("{-0x2a, 0x1, 0x2, 0x2a}"), SV("{::#x}"), input);
 
   // *** zero-padding ***
   check(SV("{-0042, 00001, 00002, 00042}"), SV("{::05}"), input);
   check(SV("{-002a, 00001, 00002, 0002a}"), SV("{::05x}"), input);
   check(SV("{-0x2a, 0x001, 0x002, 0x02a}"), SV("{::#05x}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("{-42, 1, 2, 42}"), SV("{::L}"), input); // does nothing in this test, but is accepted.
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX"))
-    check_exception("The format-spec type has a type not supported for an integer argument", fmt, input);
+    check_exception("The type option contains an invalid value for an integer formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{::-42, ::::1, ::::2, :::42}^^^"), SV("{:^^33::>5}"), input);
   check(SV("^^{::-42, ::::1, ::::2, :::42}^^^"), SV("{:^^{}::>5}"), input, 33);
   check(SV("^^{::-42, ::::1, ::::2, :::42}^^^"), SV("{:^^{}::>{}}"), input, 33, 5);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 33);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 33);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception) {
   test_int<CharT>(check, check_exception, std::set{1, 42, 2, -42});      // unsorted
   test_int<CharT>(check, check_exception, std::multiset{1, 42, 2, -42}); // unsorted
 }
 
void test_floating_point(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__{-42.5, 0, 1.25, 42.5}___"), SV("{:_^27}"), input);
   check(SV("#####{-42.5, 0, 1.25, 42.5}"), SV("{:#>27}"), input);
 
   check(SV("{-42.5, 0, 1.25, 42.5}     "), SV("{:{}}"), input, 27);
   check(SV("{-42.5, 0, 1.25, 42.5}*****"), SV("{:*<{}}"), input, 27);
   check(SV("__{-42.5, 0, 1.25, 42.5}___"), SV("{:_^{}}"), input, 27);
   check(SV("#####{-42.5, 0, 1.25, 42.5}"), SV("{:#>{}}"), input, 27);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42.5, 0, 1.25, 42.5___"), SV("{:_^25n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{-42.5,     0,  1.25,  42.5}"), SV("{::5}"), input);
   check(SV("{-42.5, 0****, 1.25*, 42.5*}"), SV("{::*<5}"), input);
   check(SV("{-42.5, __0__, 1.25_, 42.5_}"), SV("{::_^5}"), input);
   check(SV("{-42.5, ::::0, :1.25, :42.5}"), SV("{:::>5}"), input);
 
   check(SV("{-42.5,     0,  1.25,  42.5}"), SV("{::{}}"), input, 5);
   check(SV("{-42.5, 0****, 1.25*, 42.5*}"), SV("{::*<{}}"), input, 5);
   check(SV("{-42.5, __0__, 1.25_, 42.5_}"), SV("{::_^{}}"), input, 5);
   check(SV("{-42.5, ::::0, :1.25, :42.5}"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
   check(SV("{-42.5, 0, 1.25, 42.5}"), SV("{::-}"), input);
   check(SV("{-42.5, +0, +1.25, +42.5}"), SV("{::+}"), input);
   check(SV("{-42.5,  0,  1.25,  42.5}"), SV("{:: }"), input);
 
   // *** alternate form ***
   check(SV("{-42.5, 0., 1.25, 42.5}"), SV("{::#}"), input);
 
   // *** zero-padding ***
   check(SV("{-42.5, 00000, 01.25, 042.5}"), SV("{::05}"), input);
   check(SV("{-42.5, 0000., 01.25, 042.5}"), SV("{::#05}"), input);
 
   // *** precision ***
   check(SV("{-42, 0, 1.2, 42}"), SV("{::.2}"), input);
   check(SV("{-42.500, 0.000, 1.250, 42.500}"), SV("{::.3f}"), input);
 
   check(SV("{-42, 0, 1.2, 42}"), SV("{::.{}}"), input, 2);
   check(SV("{-42.500, 0.000, 1.250, 42.500}"), SV("{::.{}f}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("{-42.5, 0, 1.25, 42.5}"), SV("{::L}"), input); // does not require locales present
 #ifndef TEST_HAS_NO_LOCALIZATION
 // TODO FMT Enable with locale testing active
 #  if 0
   std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
   check(SV("{-42,5, 0, 1,25, 42,5}"), SV("{::L}"), input);
 
   std::locale::global(std::locale(LOCALE_en_US_UTF_8));
   check(SV("{-42.5, 0, 1.25, 42.5}"), SV("{::L}"), input);
 
   std::locale::global(std::locale::classic());
 #  endif
 #endif // TEST_HAS_NO_LOCALIZATION
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("aAeEfFgG"))
-    check_exception("The format-spec type has a type not supported for a floating-point argument", fmt, input);
+    check_exception("The type option contains an invalid value for a floating-point formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{-42.5, ::::0, :1.25, :42.5}^^^"), SV("{:^^33::>5}"), input);
   check(SV("^^{-42.5, ::::0, :1.25, :42.5}^^^"), SV("{:^^{}::>5}"), input, 33);
   check(SV("^^{-42.5, ::::0, :1.25, :42.5}^^^"), SV("{:^^{}::>{}}"), input, 33, 5);
 
   check(SV("^^{::-42, ::::0, ::1.2, :::42}^^^"), SV("{:^^33::>5.2}"), input);
   check(SV("^^{::-42, ::::0, ::1.2, :::42}^^^"), SV("{:^^{}::>5.2}"), input, 33);
   check(SV("^^{::-42, ::::0, ::1.2, :::42}^^^"), SV("{:^^{}::>{}.2}"), input, 33, 5);
   check(SV("^^{::-42, ::::0, ::1.2, :::42}^^^"), SV("{:^^{}::>{}.{}}"), input, 33, 5, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5.2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}.2}"), input, 33);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}.{}}"), input, 33, 5);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5.2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}.2}"), input, 33);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied",
+      SV("{:^^{}::>{}.{}}"),
+      input,
+      33,
+      5);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_floating_point(TestFunction check, ExceptionTest check_exception) {
   test_floating_point<CharT>(check, check_exception, std::set{-42.5f, 0.0f, 1.25f, 42.5f});
   test_floating_point<CharT>(check, check_exception, std::multiset{-42.5, 0.0, 1.25, 42.5});
   test_floating_point<CharT>(check, check_exception, std::set{-42.5l, 0.0l, 1.25l, 42.5l});
 }
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__{0x0}___"), SV("{:_^10}"), input);
   check(SV("#####{0x0}"), SV("{:#>10}"), input);
 
   check(SV("{0x0}     "), SV("{:{}}"), input, 10);
   check(SV("{0x0}*****"), SV("{:*<{}}"), input, 10);
   check(SV("__{0x0}___"), SV("{:_^{}}"), input, 10);
   check(SV("#####{0x0}"), SV("{:#>{}}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("_0x0_"), SV("{:_^5n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{  0x0}"), SV("{::5}"), input);
   check(SV("{0x0**}"), SV("{::*<5}"), input);
   check(SV("{_0x0_}"), SV("{::_^5}"), input);
   check(SV("{::0x0}"), SV("{:::>5}"), input);
 
   check(SV("{  0x0}"), SV("{::{}}"), input, 5);
   check(SV("{0x0**}"), SV("{::*<{}}"), input, 5);
   check(SV("{_0x0_}"), SV("{::_^{}}"), input, 5);
   check(SV("{::0x0}"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("p"))
-    check_exception("The format-spec type has a type not supported for a pointer argument", fmt, input);
+    check_exception("The type option contains an invalid value for a pointer formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{::0x0}^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^{::0x0}^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^{::0x0}^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
   check(SV("^^{::0x0}^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^{::0x0}^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^{::0x0}^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 12);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 12);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_pointer(TestFunction check, ExceptionTest check_exception) {
   // Note nullptr_t can only be equality compared so not used in a set.
   test_pointer<CharT>(check, check_exception, std::unordered_set{static_cast<const void*>(0)});
   test_pointer<CharT>(check, check_exception, std::unordered_multiset{static_cast<void*>(0)});
 }
void test_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"(__{"Hello", "world"}___)"), SV("{:_^23}"), input);
   check(SV(R"(#####{"Hello", "world"})"), SV("{:#>23}"), input);
 
   check(SV(R"({"Hello", "world"}     )"), SV("{:{}}"), input, 23);
   check(SV(R"({"Hello", "world"}*****)"), SV("{:*<{}}"), input, 23);
   check(SV(R"(__{"Hello", "world"}___)"), SV("{:_^{}}"), input, 23);
   check(SV(R"(#####{"Hello", "world"})"), SV("{:#>{}}"), input, 23);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV(R"(_"Hello", "world"_)"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV(R"({Hello   , world   })"), SV("{::8}"), input);
   check(SV(R"({Hello***, world***})"), SV("{::*<8}"), input);
   check(SV(R"({_Hello__, _world__})"), SV("{::_^8}"), input);
   check(SV(R"({:::Hello, :::world})"), SV("{:::>8}"), input);
 
   check(SV(R"({Hello   , world   })"), SV("{::{}}"), input, 8);
   check(SV(R"({Hello***, world***})"), SV("{::*<{}}"), input, 8);
   check(SV(R"({_Hello__, _world__})"), SV("{::_^{}}"), input, 8);
   check(SV(R"({:::Hello, :::world})"), SV("{:::>{}}"), input, 8);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
   check(SV(R"({Hel, wor})"), SV("{::.3}"), input);
 
   check(SV(R"({Hel, wor})"), SV("{::.{}}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>8}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 25);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>8}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 25);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
   test_string<CharT>(check, check_exception, std::set{STR("Hello"), STR("world")});
   test_string<CharT>(check, check_exception, std::set{SV("Hello"), SV("world")});
 }
 
void test_status(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{0x5555, 0xaa55, 0xaaaa}___"), SV("{:_^29}"), input);
   check(SV("#####{0x5555, 0xaa55, 0xaaaa}"), SV("{:#>29}"), input);
 
   check(SV("{0x5555, 0xaa55, 0xaaaa}     "), SV("{:{}}"), input, 29);
   check(SV("{0x5555, 0xaa55, 0xaaaa}*****"), SV("{:*<{}}"), input, 29);
   check(SV("__{0x5555, 0xaa55, 0xaaaa}___"), SV("{:_^{}}"), input, 29);
   check(SV("#####{0x5555, 0xaa55, 0xaaaa}"), SV("{:#>{}}"), input, 29);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__0x5555, 0xaa55, 0xaaaa___"), SV("{:_^27n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
-  check_exception("The format-spec type has a type not supported for a status argument", SV("{::*<7}"), input);
+  check_exception("The type option contains an invalid value for a status formatting argument", SV("{::*<7}"), input);
 
   check(SV("{0x5555, 0xaa55, 0xaaaa}"), SV("{::x}"), input);
   check(SV("{0X5555, 0XAA55, 0XAAAA}"), SV("{::X}"), input);
   check(SV("{bar, foobar, foo}"), SV("{::s}"), input);
 
   // ***** Both have a format-spec
   check(SV("^^{0X5555, 0XAA55, 0XAAAA}^^^"), SV("{:^^29:X}"), input);
   check(SV("^^{0X5555, 0XAA55, 0XAAAA}^^^"), SV("{:^^{}:X}"), input, 29);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:X}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:X}"), input);
 }
 
 //
 // Pair
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_pair_tuple(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("{(1, 'a'), (42, '*')}"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("{(1, 'a'), (42, '*')}     "), SV("{:26}"), input);
   check(SV("{(1, 'a'), (42, '*')}*****"), SV("{:*<26}"), input);
   check(SV("__{(1, 'a'), (42, '*')}___"), SV("{:_^26}"), input);
   check(SV("#####{(1, 'a'), (42, '*')}"), SV("{:#>26}"), input);
 
   check(SV("{(1, 'a'), (42, '*')}     "), SV("{:{}}"), input, 26);
   check(SV("{(1, 'a'), (42, '*')}*****"), SV("{:*<{}}"), input, 26);
   check(SV("__{(1, 'a'), (42, '*')}___"), SV("{:_^{}}"), input, 26);
   check(SV("#####{(1, 'a'), (42, '*')}"), SV("{:#>{}}"), input, 26);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__(1, 'a'), (42, '*')___"), SV("{:_^24n}"), input);
   check(SV("__(1, 'a'), (42, '*')___"), SV("{:_^24nm}"), input); // m should have no effect
 
   // *** type ***
   check(SV("__{(1, 'a'), (42, '*')}___"), SV("{:_^26m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{(1, 'a')   , (42, '*')  }"), SV("{::11}"), input);
   check(SV("{(1, 'a')***, (42, '*')**}"), SV("{::*<11}"), input);
   check(SV("{_(1, 'a')__, _(42, '*')_}"), SV("{::_^11}"), input);
   check(SV("{###(1, 'a'), ##(42, '*')}"), SV("{::#>11}"), input);
 
   check(SV("{(1, 'a')   , (42, '*')  }"), SV("{::{}}"), input, 11);
   check(SV("{(1, 'a')***, (42, '*')**}"), SV("{::*<{}}"), input, 11);
   check(SV("{_(1, 'a')__, _(42, '*')_}"), SV("{::_^{}}"), input, 11);
   check(SV("{###(1, 'a'), ##(42, '*')}"), SV("{::#>{}}"), input, 11);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("{1: 'a', 42: '*'}"), SV("{::m}"), input);
   check(SV("{1, 'a', 42, '*'}"), SV("{::n}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###(1, 'a'), ##(42, '*')}^^^"), SV("{:^^31:#>11}"), input);
   check(SV("^^{###(1, 'a'), ##(42, '*')}^^^"), SV("{:^^31:#>11}"), input);
   check(SV("^^{###(1, 'a'), ##(42, '*')}^^^"), SV("{:^^{}:#>11}"), input, 31);
   check(SV("^^{###(1, 'a'), ##(42, '*')}^^^"), SV("{:^^{}:#>{}}"), input, 31, 11);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 31);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 31);
 
   check(SV("1: 'a', 42: '*'"), SV("{:n:m}"), input);
   check(SV("1, 'a', 42, '*'"), SV("{:n:n}"), input);
   check(SV("{1: 'a', 42: '*'}"), SV("{:m:m}"), input);
   check(SV("{1, 'a', 42, '*'}"), SV("{:m:n}"), input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{(42), (99)}___"), SV("{:_^17}"), input);
   check(SV("#####{(42), (99)}"), SV("{:#>17}"), input);
 
   check(SV("{(42), (99)}     "), SV("{:{}}"), input, 17);
   check(SV("{(42), (99)}*****"), SV("{:*<{}}"), input, 17);
   check(SV("__{(42), (99)}___"), SV("{:_^{}}"), input, 17);
   check(SV("#####{(42), (99)}"), SV("{:#>{}}"), input, 17);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__(42), (99)___"), SV("{:_^15n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{(42)   , (99)   }"), SV("{::7}"), input);
   check(SV("{(42)***, (99)***}"), SV("{::*<7}"), input);
   check(SV("{_(42)__, _(99)__}"), SV("{::_^7}"), input);
   check(SV("{###(42), ###(99)}"), SV("{::#>7}"), input);
 
   check(SV("{(42)   , (99)   }"), SV("{::{}}"), input, 7);
   check(SV("{(42)***, (99)***}"), SV("{::*<{}}"), input, 7);
   check(SV("{_(42)__, _(99)__}"), SV("{::_^{}}"), input, 7);
   check(SV("{###(42), ###(99)}"), SV("{::#>{}}"), input, 7);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("{42, 99}"), SV("{::n}"), input);
-  check_exception("The format specifier m requires a pair or a two-element tuple", SV("{::m}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{::m}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{###(42), ###(99)}^^^"), SV("{:^^23:#>7}"), input);
   check(SV("^^{###(42), ###(99)}^^^"), SV("{:^^23:#>7}"), input);
   check(SV("^^{###(42), ###(99)}^^^"), SV("{:^^{}:#>7}"), input, 23);
   check(SV("^^{###(42), ###(99)}^^^"), SV("{:^^{}:#>{}}"), input, 23, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 23);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 23);
 }
 
 //
 // Tuple 3
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_int_int(TestFunction check, ExceptionTest check_exception) {
void test_tuple_int_int_int(TestFunction check, ExceptionTest check_exception) {
   check(SV("__{(1, 10, 100), (42, 99, 0)}___"), SV("{:_^32}"), input);
   check(SV("#####{(1, 10, 100), (42, 99, 0)}"), SV("{:#>32}"), input);
 
   check(SV("{(1, 10, 100), (42, 99, 0)}     "), SV("{:{}}"), input, 32);
   check(SV("{(1, 10, 100), (42, 99, 0)}*****"), SV("{:*<{}}"), input, 32);
   check(SV("__{(1, 10, 100), (42, 99, 0)}___"), SV("{:_^{}}"), input, 32);
   check(SV("#####{(1, 10, 100), (42, 99, 0)}"), SV("{:#>{}}"), input, 32);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__(1, 10, 100), (42, 99, 0)___"), SV("{:_^30n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("{(1, 10, 100)  , (42, 99, 0)   }"), SV("{::14}"), input);
   check(SV("{(1, 10, 100)**, (42, 99, 0)***}"), SV("{::*<14}"), input);
   check(SV("{_(1, 10, 100)_, _(42, 99, 0)__}"), SV("{::_^14}"), input);
   check(SV("{##(1, 10, 100), ###(42, 99, 0)}"), SV("{::#>14}"), input);
 
   check(SV("{(1, 10, 100)  , (42, 99, 0)   }"), SV("{::{}}"), input, 14);
   check(SV("{(1, 10, 100)**, (42, 99, 0)***}"), SV("{::*<{}}"), input, 14);
   check(SV("{_(1, 10, 100)_, _(42, 99, 0)__}"), SV("{::_^{}}"), input, 14);
   check(SV("{##(1, 10, 100), ###(42, 99, 0)}"), SV("{::#>{}}"), input, 14);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("{1, 10, 100, 42, 99, 0}"), SV("{::n}"), input);
-  check_exception("The format specifier m requires a pair or a two-element tuple", SV("{::m}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{::m}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{##(1, 10, 100), ###(42, 99, 0)}^^^"), SV("{:^^37:#>14}"), input);
   check(SV("^^{##(1, 10, 100), ###(42, 99, 0)}^^^"), SV("{:^^37:#>14}"), input);
   check(SV("^^{##(1, 10, 100), ###(42, 99, 0)}^^^"), SV("{:^^{}:#>14}"), input, 37);
   check(SV("^^{##(1, 10, 100), ###(42, 99, 0)}^^^"), SV("{:^^{}:#>{}}"), input, 37, 14);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 37);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 37);
 }
 
 //
 // Adaptor
 //
 
 class adaptor {
   using adaptee = std::set<int>;

libcxx/test/std/utilities/format/format.range/format.range.fmtstr/format.functions.tests.h

void test_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__hello___"), SV("{:_^10}"), input);
   check(SV(":::::hello"), SV("{::>10}"), input);
 
   check(SV("hello     "), SV("{:{}}"), input, 10);
   check(SV("hello*****"), SV("{:*<{}}"), input, 10);
   check(SV("__hello___"), SV("{:_^{}}"), input, 10);
   check(SV(":::::hello"), SV("{::>{}}"), input, 10);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
   check(SV("hel"), SV("{:.3}"), input);
   check(SV("hel"), SV("{:.{}}"), input, 3);
 
   check(SV("hel  "), SV("{:5.3}"), input);
   check(SV("hel  "), SV("{:{}.{}}"), input, 5, 3);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("hello"), SV("{:s}"), input);
   check(SV("\"hello\""), SV("{:?}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
   // libc++ uses different containers for contiguous and non-contiguous ranges.
   std::basic_string<CharT> input = STR("hello");
   test_string<CharT>(check, check_exception, test_range_format_string<std::basic_string<CharT>>{input});
   test_string<CharT>(check, check_exception, test_range_format_string<std::basic_string_view<CharT>>{input});
void test_range_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"(__[Hello, world]___)"), SV("{:_^19}"), input);
   check(SV(R"(#####[Hello, world])"), SV("{:#>19}"), input);
 
   check(SV(R"([Hello, world]     )"), SV("{:{}}"), input, 19);
   check(SV(R"([Hello, world]*****)"), SV("{:*<{}}"), input, 19);
   check(SV(R"(__[Hello, world]___)"), SV("{:_^{}}"), input, 19);
   check(SV(R"(#####[Hello, world])"), SV("{:#>{}}"), input, 19);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV(R"(_Hello, world_)"), SV("{:_^14n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV(R"([Hello   , world   ])"), SV("{::8}"), input);
   check(SV(R"([Hello***, world***])"), SV("{::*<8}"), input);
   check(SV(R"([_Hello__, _world__])"), SV("{::_^8}"), input);
   check(SV(R"([:::Hello, :::world])"), SV("{:::>8}"), input);
 
   check(SV(R"([Hello   , world   ])"), SV("{::{}}"), input, 8);
   check(SV(R"([Hello***, world***])"), SV("{::*<{}}"), input, 8);
   check(SV(R"([_Hello__, _world__])"), SV("{::_^{}}"), input, 8);
   check(SV(R"([:::Hello, :::world])"), SV("{:::>{}}"), input, 8);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
   check(SV(R"([Hel, wor])"), SV("{::.3}"), input);
 
   check(SV(R"([Hel, wor])"), SV("{::.{}}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>8}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 25);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>8}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 25);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_range_string(TestFunction check, ExceptionTest check_exception) {
   // libc++ uses different containers for contiguous and non-contiguous ranges.
   std::array input{STR("Hello"), STR("world")};
   test_range_string<CharT>(
       check,
void test_debug_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__\"hello\"___"), SV("{:_^12}"), input);
   check(SV(":::::\"hello\""), SV("{::>12}"), input);
 
   check(SV("\"hello\"     "), SV("{:{}}"), input, 12);
   check(SV("\"hello\"*****"), SV("{:*<{}}"), input, 12);
   check(SV("__\"hello\"___"), SV("{:_^{}}"), input, 12);
   check(SV(":::::\"hello\""), SV("{::>{}}"), input, 12);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
   check(SV("\"he"), SV("{:.3}"), input);
   check(SV("\"he"), SV("{:.{}}"), input, 3);
 
   check(SV("\"he  "), SV("{:5.3}"), input);
   check(SV("\"he  "), SV("{:{}.{}}"), input, 5, 3);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("\"hello\""), SV("{:s}"), input); // escape overrides the type option s
   check(SV("\"hello\""), SV("{:?}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_debug_string(TestFunction check, ExceptionTest check_exception) {
   // libc++ uses different containers for contiguous and non-contiguous ranges.
   std::basic_string<CharT> input = STR("hello");
   test_debug_string<CharT>(check, check_exception, test_range_format_debug_string<std::basic_string<CharT>>{input});
   test_debug_string<CharT>(
void test_range_debug_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"(__["Hello", "world"]___)"), SV("{:_^23}"), input);
   check(SV(R"(#####["Hello", "world"])"), SV("{:#>23}"), input);
 
   check(SV(R"(["Hello", "world"]     )"), SV("{:{}}"), input, 23);
   check(SV(R"(["Hello", "world"]*****)"), SV("{:*<{}}"), input, 23);
   check(SV(R"(__["Hello", "world"]___)"), SV("{:_^{}}"), input, 23);
   check(SV(R"(#####["Hello", "world"])"), SV("{:#>{}}"), input, 23);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV(R"(_"Hello", "world"_)"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV(R"(["Hello"   , "world"   ])"), SV("{::10}"), input);
   check(SV(R"(["Hello"***, "world"***])"), SV("{::*<10}"), input);
   check(SV(R"([_"Hello"__, _"world"__])"), SV("{::_^10}"), input);
   check(SV(R"([:::"Hello", :::"world"])"), SV("{:::>10}"), input);
 
   check(SV(R"(["Hello"   , "world"   ])"), SV("{::{}}"), input, 10);
   check(SV(R"(["Hello"***, "world"***])"), SV("{::*<{}}"), input, 10);
   check(SV(R"([_"Hello"__, _"world"__])"), SV("{::_^{}}"), input, 10);
   check(SV(R"([:::"Hello", :::"world"])"), SV("{:::>{}}"), input, 10);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
   check(SV(R"(["He, "wo])"), SV("{::.3}"), input);
 
   check(SV(R"(["He, "wo])"), SV("{::.{}}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^29::>10}"), input);
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^{}::>10}"), input, 29);
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^{}::>{}}"), input, 29, 10);
 
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^29::>10}"), input);
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^{}::>10}"), input, 29);
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^{}::>{}}"), input, 29, 10);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>10}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 29);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>10}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 29);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_range_debug_string(TestFunction check, ExceptionTest check_exception) {
   // libc++ uses different containers for contiguous and non-contiguous ranges.
   std::array input{STR("Hello"), STR("world")};
   test_range_debug_string<CharT>(
       check,

libcxx/test/std/utilities/format/format.range/format.range.formatter/format.functions.tests.h

void test_char_default(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__['H', 'e', 'l', 'l', 'o']___"), SV("{:_^30}"), input);
   check(SV("#####['H', 'e', 'l', 'l', 'o']"), SV("{:#>30}"), input);
 
   check(SV("['H', 'e', 'l', 'l', 'o']     "), SV("{:{}}"), input, 30);
   check(SV("['H', 'e', 'l', 'l', 'o']*****"), SV("{:*<{}}"), input, 30);
   check(SV("__['H', 'e', 'l', 'l', 'o']___"), SV("{:_^{}}"), input, 30);
   check(SV("#####['H', 'e', 'l', 'l', 'o']"), SV("{:#>{}}"), input, 30);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__'H', 'e', 'l', 'l', 'o'___"), SV("{:_^28n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[H   , e   , l   , l   , o   ]"), SV("{::4}"), input);
   check(SV("[H***, e***, l***, l***, o***]"), SV("{::*<4}"), input);
   check(SV("[_H__, _e__, _l__, _l__, _o__]"), SV("{::_^4}"), input);
   check(SV("[:::H, :::e, :::l, :::l, :::o]"), SV("{:::>4}"), input);
 
   check(SV("[H   , e   , l   , l   , o   ]"), SV("{::{}}"), input, 4);
   check(SV("[H***, e***, l***, l***, o***]"), SV("{::*<{}}"), input, 4);
   check(SV("[_H__, _e__, _l__, _l__, _o__]"), SV("{::_^{}}"), input, 4);
   check(SV("[:::H, :::e, :::l, :::l, :::o]"), SV("{:::>{}}"), input, 4);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a character does not allow the sign option", SV("{:: }"), input);
 
   check(SV("[72, 101, 108, 108, 111]"), SV("{::-d}"), input);
   check(SV("[+72, +101, +108, +108, +111]"), SV("{::+d}"), input);
   check(SV("[ 72,  101,  108,  108,  111]"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a character does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("[0x48, 0x65, 0x6c, 0x6c, 0x6f]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a character does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("[00110, 00145, 00154, 00154, 00157]"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[H, e, l, l, o]"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[:H, :e, :l, :l, :o]^^^"), SV("{:^^25::>2}"), input);
   check(SV("^^[:H, :e, :l, :l, :o]^^^"), SV("{:^^{}::>2}"), input, 25);
   check(SV("^^[:H, :e, :l, :l, :o]^^^"), SV("{:^^{}::>{}}"), input, 25, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 25);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 25);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("Hello"), SV("{:s}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("Hello   "), SV("{:8s}"), input);
   check(SV("Hello***"), SV("{:*<8s}"), input);
   check(SV("_Hello__"), SV("{:_^8s}"), input);
   check(SV("###Hello"), SV("{:#>8s}"), input);
 
   check(SV("Hello   "), SV("{:{}s}"), input, 8);
   check(SV("Hello***"), SV("{:*<{}s}"), input, 8);
   check(SV("_Hello__"), SV("{:_^{}s}"), input, 8);
   check(SV("###Hello"), SV("{:#>{}s}"), input, 8);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<s}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: s}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#s}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0s}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0s}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.s}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:Ls}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:Ls}"), input);
 
   // *** n
   check_exception("The n option and type s can't be used together", SV("{:ns}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check_exception("Type s and an underlying format specification can't be used together", SV("{:s:}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX?"))
-    check_exception("The format-spec type has a type not supported for a char argument", fmt, input);
+    check_exception("The type option contains an invalid value for a character formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check_exception("Type s and an underlying format specification can't be used together", SV("{:5s:5}"), input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_escaped_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"("\"Hello'")"), SV("{:?s}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV(R"("\"Hello'"   )"), SV("{:13?s}"), input);
   check(SV(R"("\"Hello'"***)"), SV("{:*<13?s}"), input);
   check(SV(R"(_"\"Hello'"__)"), SV("{:_^13?s}"), input);
   check(SV(R"(###"\"Hello'")"), SV("{:#>13?s}"), input);
 
   check(SV(R"("\"Hello'"   )"), SV("{:{}?s}"), input, 13);
   check(SV(R"("\"Hello'"***)"), SV("{:*<{}?s}"), input, 13);
   check(SV(R"(_"\"Hello'"__)"), SV("{:_^{}?s}"), input, 13);
   check(SV(R"(###"\"Hello'")"), SV("{:#>{}?s}"), input, 13);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<?s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<?s}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<?s}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<?s}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-?s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+?s}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: ?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: ?s}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#?s}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0?s}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0?s}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.?s}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L?s}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L?s}"), input);
 
   // *** n
   check_exception("The n option and type ?s can't be used together", SV("{:n?s}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 
   // ***** Only underlying has a format-spec
   check_exception("Type ?s and an underlying format specification can't be used together", SV("{:?s:}"), input);
 
   // ***** Both have a format-spec
   check_exception("Type ?s and an underlying format specification can't be used together", SV("{:5?s:5}"), input);
 }
 
void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
   test_char_default<wchar_t>(check, check_exception, std::array{'H', 'e', 'l', 'l', 'o'});
 
   // The types s and ?s may only be used when using range_formatter<T, charT>
   // where the types T and charT are the same. This means this can't be used for
   // range_formatter<wchar_t, char> even when formatter<wchar_t, char> has a
   // debug-enabled specialization.
 
   using CharT = wchar_t;
-  check_exception("The range-format-spec type s requires formatting a character type",
-                  SV("{:s}"),
-                  std::array{'H', 'e', 'l', 'l', 'o'});
-  check_exception("The range-format-spec type ?s requires formatting a character type",
-                  SV("{:?s}"),
-                  std::array{'H', 'e', 'l', 'l', 'o'});
+  check_exception(
+      "Type s requires character type as formatting argument", SV("{:s}"), std::array{'H', 'e', 'l', 'l', 'o'});
+  check_exception(
+      "Type ?s requires character type as formatting argument", SV("{:?s}"), std::array{'H', 'e', 'l', 'l', 'o'});
 }
 #endif
 
 //
 // Bool
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
void test_bool(TestFunction check, ExceptionTest check_exception) {
   check(SV("__[true, true, false]___"), SV("{:_^24}"), input);
   check(SV("#####[true, true, false]"), SV("{:#>24}"), input);
 
   check(SV("[true, true, false]     "), SV("{:{}}"), input, 24);
   check(SV("[true, true, false]*****"), SV("{:*<{}}"), input, 24);
   check(SV("__[true, true, false]___"), SV("{:_^{}}"), input, 24);
   check(SV("#####[true, true, false]"), SV("{:#>{}}"), input, 24);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__true, true, false___"), SV("{:_^22n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[true   , true   , false  ]"), SV("{::7}"), input);
   check(SV("[true***, true***, false**]"), SV("{::*<7}"), input);
   check(SV("[_true__, _true__, _false_]"), SV("{::_^7}"), input);
   check(SV("[:::true, :::true, ::false]"), SV("{:::>7}"), input);
 
   check(SV("[true   , true   , false  ]"), SV("{::{}}"), input, 7);
   check(SV("[true***, true***, false**]"), SV("{::*<{}}"), input, 7);
   check(SV("[_true__, _true__, _false_]"), SV("{::_^{}}"), input, 7);
   check(SV("[:::true, :::true, ::false]"), SV("{:::>{}}"), input, 7);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::-}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{::+}"), input);
-  check_exception("A sign field isn't allowed in this format-spec", SV("{:: }"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::-}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{::+}"), input);
+  check_exception("The format specifier for a bool does not allow the sign option", SV("{:: }"), input);
 
   check(SV("[1, 1, 0]"), SV("{::-d}"), input);
   check(SV("[+1, +1, +0]"), SV("{::+d}"), input);
   check(SV("[ 1,  1,  0]"), SV("{:: d}"), input);
 
   // *** alternate form ***
-  check_exception("An alternate form field isn't allowed in this format-spec", SV("{::#}"), input);
+  check_exception("The format specifier for a bool does not allow the alternate form option", SV("{::#}"), input);
 
   check(SV("[0x1, 0x1, 0x0]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
-  check_exception("A zero-padding field isn't allowed in this format-spec", SV("{::05}"), input);
+  check_exception("The format specifier for a bool does not allow the zero-padding option", SV("{::05}"), input);
 
   check(SV("[00001, 00001, 00000]"), SV("{::05o}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[true, true, false]"), SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBdosxX"))
-    check_exception("The format-spec type has a type not supported for a bool argument", fmt, input);
+    check_exception("The type option contains an invalid value for a bool formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^32::>7}"), input);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>7}"), input, 32);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>{}}"), input, 32, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 32);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 32);
 }
 
 //
 // Integral
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("[1, 2, 42, -42]"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("[1, 2, 42, -42]     "), SV("{:20}"), input);
   check(SV("[1, 2, 42, -42]*****"), SV("{:*<20}"), input);
   check(SV("__[1, 2, 42, -42]___"), SV("{:_^20}"), input);
   check(SV("#####[1, 2, 42, -42]"), SV("{:#>20}"), input);
 
   check(SV("[1, 2, 42, -42]     "), SV("{:{}}"), input, 20);
   check(SV("[1, 2, 42, -42]*****"), SV("{:*<{}}"), input, 20);
   check(SV("__[1, 2, 42, -42]___"), SV("{:_^{}}"), input, 20);
   check(SV("#####[1, 2, 42, -42]"), SV("{:#>{}}"), input, 20);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__1, 2, 42, -42___"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[    1,     2,    42,   -42]"), SV("{::5}"), input);
   check(SV("[1****, 2****, 42***, -42**]"), SV("{::*<5}"), input);
   check(SV("[__1__, __2__, _42__, _-42_]"), SV("{::_^5}"), input);
   check(SV("[::::1, ::::2, :::42, ::-42]"), SV("{:::>5}"), input);
 
   check(SV("[    1,     2,    42,   -42]"), SV("{::{}}"), input, 5);
   check(SV("[1****, 2****, 42***, -42**]"), SV("{::*<{}}"), input, 5);
   check(SV("[__1__, __2__, _42__, _-42_]"), SV("{::_^{}}"), input, 5);
   check(SV("[::::1, ::::2, :::42, ::-42]"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
   check(SV("[1, 2, 42, -42]"), SV("{::-}"), input);
   check(SV("[+1, +2, +42, -42]"), SV("{::+}"), input);
   check(SV("[ 1,  2,  42, -42]"), SV("{:: }"), input);
 
   // *** alternate form ***
   check(SV("[0x1, 0x2, 0x2a, -0x2a]"), SV("{::#x}"), input);
 
   // *** zero-padding ***
   check(SV("[00001, 00002, 00042, -0042]"), SV("{::05}"), input);
   check(SV("[00001, 00002, 0002a, -002a]"), SV("{::05x}"), input);
   check(SV("[0x001, 0x002, 0x02a, -0x2a]"), SV("{::#05x}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[1, 2, 42, -42]"), SV("{::L}"), input); // does nothing in this test, but is accepted.
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("bBcdoxX"))
-    check_exception("The format-spec type has a type not supported for an integer argument", fmt, input);
+    check_exception("The type option contains an invalid value for an integer formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[::::1, ::::2, :::42, ::-42]^^^"), SV("{:^^33::>5}"), input);
   check(SV("^^[::::1, ::::2, :::42, ::-42]^^^"), SV("{:^^{}::>5}"), input, 33);
   check(SV("^^[::::1, ::::2, :::42, ::-42]^^^"), SV("{:^^{}::>{}}"), input, 33, 5);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 33);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 33);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception) {
   test_int<CharT>(check, check_exception, std::array{1, 2, 42, -42});
   test_int<CharT>(check, check_exception, std::list{1, 2, 42, -42});
   test_int<CharT>(check, check_exception, std::vector{1, 2, 42, -42});
   std::array input{1, 2, 42, -42};
void test_floating_point(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[-42.5, 0, 1.25, 42.5]___"), SV("{:_^27}"), input);
   check(SV("#####[-42.5, 0, 1.25, 42.5]"), SV("{:#>27}"), input);
 
   check(SV("[-42.5, 0, 1.25, 42.5]     "), SV("{:{}}"), input, 27);
   check(SV("[-42.5, 0, 1.25, 42.5]*****"), SV("{:*<{}}"), input, 27);
   check(SV("__[-42.5, 0, 1.25, 42.5]___"), SV("{:_^{}}"), input, 27);
   check(SV("#####[-42.5, 0, 1.25, 42.5]"), SV("{:#>{}}"), input, 27);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__-42.5, 0, 1.25, 42.5___"), SV("{:_^25n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[-42.5,     0,  1.25,  42.5]"), SV("{::5}"), input);
   check(SV("[-42.5, 0****, 1.25*, 42.5*]"), SV("{::*<5}"), input);
   check(SV("[-42.5, __0__, 1.25_, 42.5_]"), SV("{::_^5}"), input);
   check(SV("[-42.5, ::::0, :1.25, :42.5]"), SV("{:::>5}"), input);
 
   check(SV("[-42.5,     0,  1.25,  42.5]"), SV("{::{}}"), input, 5);
   check(SV("[-42.5, 0****, 1.25*, 42.5*]"), SV("{::*<{}}"), input, 5);
   check(SV("[-42.5, __0__, 1.25_, 42.5_]"), SV("{::_^{}}"), input, 5);
   check(SV("[-42.5, ::::0, :1.25, :42.5]"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
   check(SV("[-42.5, 0, 1.25, 42.5]"), SV("{::-}"), input);
   check(SV("[-42.5, +0, +1.25, +42.5]"), SV("{::+}"), input);
   check(SV("[-42.5,  0,  1.25,  42.5]"), SV("{:: }"), input);
 
   // *** alternate form ***
   check(SV("[-42.5, 0., 1.25, 42.5]"), SV("{::#}"), input);
 
   // *** zero-padding ***
   check(SV("[-42.5, 00000, 01.25, 042.5]"), SV("{::05}"), input);
   check(SV("[-42.5, 0000., 01.25, 042.5]"), SV("{::#05}"), input);
 
   // *** precision ***
   check(SV("[-42, 0, 1.2, 42]"), SV("{::.2}"), input);
   check(SV("[-42.500, 0.000, 1.250, 42.500]"), SV("{::.3f}"), input);
 
   check(SV("[-42, 0, 1.2, 42]"), SV("{::.{}}"), input, 2);
   check(SV("[-42.500, 0.000, 1.250, 42.500]"), SV("{::.{}f}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check(SV("[-42.5, 0, 1.25, 42.5]"), SV("{::L}"), input); // does not require locales present
 #ifndef TEST_HAS_NO_LOCALIZATION
 // TODO FMT Enable with locale testing active
 #  if 0
   std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
   check(SV("[-42,5, 0, 1,25, 42,5]"), SV("{::L}"), input);
 
   std::locale::global(std::locale(LOCALE_en_US_UTF_8));
   check(SV("[-42.5, 0, 1.25, 42.5]"), SV("{::L}"), input);
 
   std::locale::global(std::locale::classic());
 #  endif
 #endif // TEST_HAS_NO_LOCALIZATION
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("aAeEfFgG"))
-    check_exception("The format-spec type has a type not supported for a floating-point argument", fmt, input);
+    check_exception("The type option contains an invalid value for a floating-point formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[-42.5, ::::0, :1.25, :42.5]^^^"), SV("{:^^33::>5}"), input);
   check(SV("^^[-42.5, ::::0, :1.25, :42.5]^^^"), SV("{:^^{}::>5}"), input, 33);
   check(SV("^^[-42.5, ::::0, :1.25, :42.5]^^^"), SV("{:^^{}::>{}}"), input, 33, 5);
 
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^33::>5.2}"), input);
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^{}::>5.2}"), input, 33);
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^{}::>{}.2}"), input, 33, 5);
   check(SV("^^[::-42, ::::0, ::1.2, :::42]^^^"), SV("{:^^{}::>{}.{}}"), input, 33, 5, 2);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5.2}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}.2}"), input, 33);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}.{}}"), input, 33, 5);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5.2}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}.2}"), input, 33);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied",
+      SV("{:^^{}::>{}.{}}"),
+      input,
+      33,
+      5);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_floating_point(TestFunction check, ExceptionTest check_exception) {
   test_floating_point<CharT>(check, check_exception, std::array{-42.5f, 0.0f, 1.25f, 42.5f});
   test_floating_point<CharT>(check, check_exception, std::vector{-42.5, 0.0, 1.25, 42.5});
 
   std::array input{-42.5l, 0.0l, 1.25l, 42.5l};
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[0x0]___"), SV("{:_^10}"), input);
   check(SV("#####[0x0]"), SV("{:#>10}"), input);
 
   check(SV("[0x0]     "), SV("{:{}}"), input, 10);
   check(SV("[0x0]*****"), SV("{:*<{}}"), input, 10);
   check(SV("__[0x0]___"), SV("{:_^{}}"), input, 10);
   check(SV("#####[0x0]"), SV("{:#>{}}"), input, 10);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("_0x0_"), SV("{:_^5n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[  0x0]"), SV("{::5}"), input);
   check(SV("[0x0**]"), SV("{::*<5}"), input);
   check(SV("[_0x0_]"), SV("{::_^5}"), input);
   check(SV("[::0x0]"), SV("{:::>5}"), input);
 
   check(SV("[  0x0]"), SV("{::{}}"), input, 5);
   check(SV("[0x0**]"), SV("{::*<{}}"), input, 5);
   check(SV("[_0x0_]"), SV("{::_^{}}"), input, 5);
   check(SV("[::0x0]"), SV("{:::>{}}"), input, 5);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("p"))
-    check_exception("The format-spec type has a type not supported for a pointer argument", fmt, input);
+    check_exception("The type option contains an invalid value for a pointer formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 12);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 12);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_pointer(TestFunction check, ExceptionTest check_exception) {
   test_pointer<CharT>(check, check_exception, std::array{nullptr});
   test_pointer<CharT>(check, check_exception, std::array{static_cast<const void*>(0)});
   test_pointer<CharT>(check, check_exception, std::array{static_cast<void*>(0)});
 }
void test_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV(R"(__["Hello", "world"]___)"), SV("{:_^23}"), input);
   check(SV(R"(#####["Hello", "world"])"), SV("{:#>23}"), input);
 
   check(SV(R"(["Hello", "world"]     )"), SV("{:{}}"), input, 23);
   check(SV(R"(["Hello", "world"]*****)"), SV("{:*<{}}"), input, 23);
   check(SV(R"(__["Hello", "world"]___)"), SV("{:_^{}}"), input, 23);
   check(SV(R"(#####["Hello", "world"])"), SV("{:#>{}}"), input, 23);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV(R"(_"Hello", "world"_)"), SV("{:_^18n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV(R"([Hello   , world   ])"), SV("{::8}"), input);
   check(SV(R"([Hello***, world***])"), SV("{::*<8}"), input);
   check(SV(R"([_Hello__, _world__])"), SV("{::_^8}"), input);
   check(SV(R"([:::Hello, :::world])"), SV("{:::>8}"), input);
 
   check(SV(R"([Hello   , world   ])"), SV("{::{}}"), input, 8);
   check(SV(R"([Hello***, world***])"), SV("{::*<{}}"), input, 8);
   check(SV(R"([_Hello__, _world__])"), SV("{::_^{}}"), input, 8);
   check(SV(R"([:::Hello, :::world])"), SV("{:::>{}}"), input, 8);
 
-  check_exception("The format-spec fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
   check(SV(R"([Hel, wor])"), SV("{::.3}"), input);
 
   check(SV(R"([Hel, wor])"), SV("{::.{}}"), input, 3);
 
-  check_exception("The format-spec precision field doesn't contain a value or arg-id", SV("{::.}"), input);
+  check_exception("The precision option does not contain a value or argument index", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s?"))
-    check_exception("The format-spec type has a type not supported for a string argument", fmt, input);
+    check_exception("The type option contains an invalid value for a string formatting argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>{}}"), input, 25, 8);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}::>8}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 25);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>8}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}::>{}}"), input, 25);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
   test_string<CharT>(check, check_exception, std::array{CSTR("Hello"), CSTR("world")});
   test_string<CharT>(check, check_exception, std::array{STR("Hello"), STR("world")});
   test_string<CharT>(check, check_exception, std::array{SV("Hello"), SV("world")});
 }
void test_status(TestFunction check, ExceptionTest check_exception) {
   check(SV("__[0xaaaa, 0x5555, 0xaa55]___"), SV("{:_^29}"), input);
   check(SV("#####[0xaaaa, 0x5555, 0xaa55]"), SV("{:#>29}"), input);
 
   check(SV("[0xaaaa, 0x5555, 0xaa55]     "), SV("{:{}}"), input, 29);
   check(SV("[0xaaaa, 0x5555, 0xaa55]*****"), SV("{:*<{}}"), input, 29);
   check(SV("__[0xaaaa, 0x5555, 0xaa55]___"), SV("{:_^{}}"), input, 29);
   check(SV("#####[0xaaaa, 0x5555, 0xaa55]"), SV("{:#>{}}"), input, 29);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__0xaaaa, 0x5555, 0xaa55___"), SV("{:_^27n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
-  check_exception("The format-spec type has a type not supported for a status argument", SV("{::*<7}"), input);
+  check_exception("The type option contains an invalid value for a status formatting argument", SV("{::*<7}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("sxX"))
-    check_exception("The format-spec type has a type not supported for a status argument", fmt, input);
+    check_exception("The type option contains an invalid value for a status formatting argument", fmt, input);
 
   check(SV("[0xaaaa, 0x5555, 0xaa55]"), SV("{::x}"), input);
   check(SV("[0XAAAA, 0X5555, 0XAA55]"), SV("{::X}"), input);
   check(SV("[foo, bar, foobar]"), SV("{::s}"), input);
 
   // ***** Both have a format-spec
   check(SV("^^[0XAAAA, 0X5555, 0XAA55]^^^"), SV("{:^^29:X}"), input);
   check(SV("^^[0XAAAA, 0X5555, 0XAA55]^^^"), SV("{:^^{}:X}"), input, 29);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:X}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:X}"), input);
 }
 
 //
 // Pair
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_pair_tuple(TestFunction check, ExceptionTest check_exception, auto&& input) {
void test_pair_tuple(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("__[(1, 'a'), (42, '*')]___"), SV("{:_^26}"), input);
   check(SV("#####[(1, 'a'), (42, '*')]"), SV("{:#>26}"), input);
 
   check(SV("[(1, 'a'), (42, '*')]     "), SV("{:{}}"), input, 26);
   check(SV("[(1, 'a'), (42, '*')]*****"), SV("{:*<{}}"), input, 26);
   check(SV("__[(1, 'a'), (42, '*')]___"), SV("{:_^{}}"), input, 26);
   check(SV("#####[(1, 'a'), (42, '*')]"), SV("{:#>{}}"), input, 26);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__(1, 'a'), (42, '*')___"), SV("{:_^24n}"), input);
   check(SV("__(1, 'a'), (42, '*')___"), SV("{:_^24nm}"), input); // m should have no effect
 
   // *** type ***
   check(SV("__{(1, 'a'), (42, '*')}___"), SV("{:_^26m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[(1, 'a')   , (42, '*')  ]"), SV("{::11}"), input);
   check(SV("[(1, 'a')***, (42, '*')**]"), SV("{::*<11}"), input);
   check(SV("[_(1, 'a')__, _(42, '*')_]"), SV("{::_^11}"), input);
   check(SV("[###(1, 'a'), ##(42, '*')]"), SV("{::#>11}"), input);
 
   check(SV("[(1, 'a')   , (42, '*')  ]"), SV("{::{}}"), input, 11);
   check(SV("[(1, 'a')***, (42, '*')**]"), SV("{::*<{}}"), input, 11);
   check(SV("[_(1, 'a')__, _(42, '*')_]"), SV("{::_^{}}"), input, 11);
   check(SV("[###(1, 'a'), ##(42, '*')]"), SV("{::#>{}}"), input, 11);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("[1: 'a', 42: '*']"), SV("{::m}"), input);
   check(SV("[1, 'a', 42, '*']"), SV("{::n}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[###(1, 'a'), ##(42, '*')]^^^"), SV("{:^^31:#>11}"), input);
   check(SV("^^[###(1, 'a'), ##(42, '*')]^^^"), SV("{:^^31:#>11}"), input);
   check(SV("^^[###(1, 'a'), ##(42, '*')]^^^"), SV("{:^^{}:#>11}"), input, 31);
   check(SV("^^[###(1, 'a'), ##(42, '*')]^^^"), SV("{:^^{}:#>{}}"), input, 31, 11);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 31);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 31);
 
   check(SV("1: 'a', 42: '*'"), SV("{:n:m}"), input);
   check(SV("1, 'a', 42, '*'"), SV("{:n:n}"), input);
   check(SV("{1: 'a', 42: '*'}"), SV("{:m:m}"), input);
   check(SV("{1, 'a', 42, '*'}"), SV("{:m:n}"), input);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
   check(SV("__[(42), (99)]___"), SV("{:_^17}"), input);
   check(SV("#####[(42), (99)]"), SV("{:#>17}"), input);
 
   check(SV("[(42), (99)]     "), SV("{:{}}"), input, 17);
   check(SV("[(42), (99)]*****"), SV("{:*<{}}"), input, 17);
   check(SV("__[(42), (99)]___"), SV("{:_^{}}"), input, 17);
   check(SV("#####[(42), (99)]"), SV("{:#>{}}"), input, 17);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__(42), (99)___"), SV("{:_^15n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[(42)   , (99)   ]"), SV("{::7}"), input);
   check(SV("[(42)***, (99)***]"), SV("{::*<7}"), input);
   check(SV("[_(42)__, _(99)__]"), SV("{::_^7}"), input);
   check(SV("[###(42), ###(99)]"), SV("{::#>7}"), input);
 
   check(SV("[(42)   , (99)   ]"), SV("{::{}}"), input, 7);
   check(SV("[(42)***, (99)***]"), SV("{::*<{}}"), input, 7);
   check(SV("[_(42)__, _(99)__]"), SV("{::_^{}}"), input, 7);
   check(SV("[###(42), ###(99)]"), SV("{::#>{}}"), input, 7);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("[42, 99]"), SV("{::n}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>(""))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[###(42), ###(99)]^^^"), SV("{:^^23:#>7}"), input);
   check(SV("^^[###(42), ###(99)]^^^"), SV("{:^^23:#>7}"), input);
   check(SV("^^[###(42), ###(99)]^^^"), SV("{:^^{}:#>7}"), input, 23);
   check(SV("^^[###(42), ###(99)]^^^"), SV("{:^^{}:#>{}}"), input, 23, 7);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 23);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 23);
 }
 
 //
 // Tuple 3
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_int_int(TestFunction check, ExceptionTest check_exception) {
void test_tuple_int_int_int(TestFunction check, ExceptionTest check_exception) {
   check(SV("__[(42, 99, 0), (1, 10, 100)]___"), SV("{:_^32}"), input);
   check(SV("#####[(42, 99, 0), (1, 10, 100)]"), SV("{:#>32}"), input);
 
   check(SV("[(42, 99, 0), (1, 10, 100)]     "), SV("{:{}}"), input, 32);
   check(SV("[(42, 99, 0), (1, 10, 100)]*****"), SV("{:*<{}}"), input, 32);
   check(SV("__[(42, 99, 0), (1, 10, 100)]___"), SV("{:_^{}}"), input, 32);
   check(SV("#####[(42, 99, 0), (1, 10, 100)]"), SV("{:#>{}}"), input, 32);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** n
   check(SV("__(42, 99, 0), (1, 10, 100)___"), SV("{:_^30n}"), input);
 
   // *** type ***
-  check_exception("The range-format-spec type m requires two elements for a pair or tuple", SV("{:m}"), input);
-  check_exception("The range-format-spec type s requires formatting a character type", SV("{:s}"), input);
-  check_exception("The range-format-spec type ?s requires formatting a character type", SV("{:?s}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
+  check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
+  check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Only underlying has a format-spec
   check(SV("[(42, 99, 0)   , (1, 10, 100)  ]"), SV("{::14}"), input);
   check(SV("[(42, 99, 0)***, (1, 10, 100)**]"), SV("{::*<14}"), input);
   check(SV("[_(42, 99, 0)__, _(1, 10, 100)_]"), SV("{::_^14}"), input);
   check(SV("[###(42, 99, 0), ##(1, 10, 100)]"), SV("{::#>14}"), input);
 
   check(SV("[(42, 99, 0)   , (1, 10, 100)  ]"), SV("{::{}}"), input, 14);
   check(SV("[(42, 99, 0)***, (1, 10, 100)**]"), SV("{::*<{}}"), input, 14);
   check(SV("[_(42, 99, 0)__, _(1, 10, 100)_]"), SV("{::_^{}}"), input, 14);
   check(SV("[###(42, 99, 0), ##(1, 10, 100)]"), SV("{::#>{}}"), input, 14);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:::<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check_exception("The width option should not have a leading zero", SV("{::05}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
   check(SV("[42, 99, 0, 1, 10, 100]"), SV("{::n}"), input);
   for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("s"))
-    check_exception("The format-spec should consume the input or end with a '}'", fmt, input);
+    check_exception("The format specifier should consume the input or end with a '}'", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[###(42, 99, 0), ##(1, 10, 100)]^^^"), SV("{:^^37:#>14}"), input);
   check(SV("^^[###(42, 99, 0), ##(1, 10, 100)]^^^"), SV("{:^^37:#>14}"), input);
   check(SV("^^[###(42, 99, 0), ##(1, 10, 100)]^^^"), SV("{:^^{}:#>14}"), input, 37);
   check(SV("^^[###(42, 99, 0), ##(1, 10, 100)]^^^"), SV("{:^^{}:#>{}}"), input, 37, 14);
 
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>5}"), input);
-  check_exception("Argument index out of bounds", SV("{:^^{}:#>{}}"), input, 37);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>5}"), input);
+  check_exception(
+      "The argument index value is too larger for the number of arguments supplied", SV("{:^^{}:#>{}}"), input, 37);
 }
 
 //
 // Ranges
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_with_ranges(TestFunction check, ExceptionTest check_exception, auto&& iter) {

libcxx/test/std/utilities/format/format.tuple/format.functions.tests.h

void test_tuple_or_pair_int_int(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
   check(SV("__(42, 99)___"), SV("{:_^13}"), input);
   check(SV("#####(42, 99)"), SV("{:#>13}"), input);
 
   check(SV("(42, 99)     "), SV("{:{}}"), input, 13);
   check(SV("(42, 99)*****"), SV("{:*<{}}"), input, 13);
   check(SV("__(42, 99)___"), SV("{:_^{}}"), input, 13);
   check(SV("#####(42, 99)"), SV("{:#>{}}"), input, 13);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("__42: 99___"), SV("{:_^11m}"), input);
   check(SV("__42, 99___"), SV("{:_^11n}"), input);
 
   for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
-    check_exception("The format-spec should consume the input or end with a '}'",
+    check_exception("The format specifier should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest, class TupleOrPair>
 void test_tuple_or_pair_int_string(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
   check(SV("(42, \"hello\")"), SV("{}"), input);
 
   // *** align-fill & width ***
   check(SV("(42, \"hello\")     "), SV("{:18}"), input);
   check(SV("(42, \"hello\")*****"), SV("{:*<18}"), input);
   check(SV("__(42, \"hello\")___"), SV("{:_^18}"), input);
   check(SV("#####(42, \"hello\")"), SV("{:#>18}"), input);
 
   check(SV("(42, \"hello\")     "), SV("{:{}}"), input, 18);
   check(SV("(42, \"hello\")*****"), SV("{:*<{}}"), input, 18);
   check(SV("__(42, \"hello\")___"), SV("{:_^{}}"), input, 18);
   check(SV("#####(42, \"hello\")"), SV("{:#>{}}"), input, 18);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("__42: \"hello\"___"), SV("{:_^16m}"), input);
   check(SV("__42, \"hello\"___"), SV("{:_^16n}"), input);
 
   for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
-    check_exception("The format-spec should consume the input or end with a '}'",
+    check_exception("The format specifier should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class TupleOrPair>
 void test_escaping(TestFunction check, TupleOrPair&& input) {
   static_assert(std::same_as<std::remove_cvref_t<decltype(std::get<0>(input))>, CharT>);
void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
   check(SV("__(42)___"), SV("{:_^9}"), input);
   check(SV("#####(42)"), SV("{:#>9}"), input);
 
   check(SV("(42)     "), SV("{:{}}"), input, 9);
   check(SV("(42)*****"), SV("{:*<{}}"), input, 9);
   check(SV("__(42)___"), SV("{:_^{}}"), input, 9);
   check(SV("#####(42)"), SV("{:#>{}}"), input, 9);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
-  check_exception("The format specifier m requires a pair or a two-element tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
   check(SV("__42___"), SV("{:_^7n}"), input);
 
   for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
-    check_exception("The format-spec should consume the input or end with a '}'",
+    check_exception("The format specifier should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_string_color(TestFunction check, ExceptionTest check_exception) {
   const auto input = std::make_tuple(42, SV("hello"), color::red);
 
   check(SV("(42, \"hello\", \"red\")"), SV("{}"), input);
 
   // *** align-fill & width ***
   check(SV("(42, \"hello\", \"red\")     "), SV("{:25}"), input);
   check(SV("(42, \"hello\", \"red\")*****"), SV("{:*<25}"), input);
   check(SV("__(42, \"hello\", \"red\")___"), SV("{:_^25}"), input);
   check(SV("#####(42, \"hello\", \"red\")"), SV("{:#>25}"), input);
 
   check(SV("(42, \"hello\", \"red\")     "), SV("{:{}}"), input, 25);
   check(SV("(42, \"hello\", \"red\")*****"), SV("{:*<{}}"), input, 25);
   check(SV("__(42, \"hello\", \"red\")___"), SV("{:_^{}}"), input, 25);
   check(SV("#####(42, \"hello\", \"red\")"), SV("{:#>{}}"), input, 25);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
-  check_exception("The format specifier m requires a pair or a two-element tuple", SV("{:m}"), input);
+  check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
   check(SV("__42, \"hello\", \"red\"___"), SV("{:_^23n}"), input);
 
   for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
-    check_exception("The format-spec should consume the input or end with a '}'",
+    check_exception("The format specifier should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_int(TestFunction check, ExceptionTest check_exception) {
   test_tuple_or_pair_int_int<CharT>(check, check_exception, std::make_tuple(42, 99));
void test_nested(TestFunction check, ExceptionTest check_exception, Nested&& input) {
   check(SV("__(42, (\"hello\", \"red\"))___"), SV("{:_^27}"), input);
   check(SV("#####(42, (\"hello\", \"red\"))"), SV("{:#>27}"), input);
 
   check(SV("(42, (\"hello\", \"red\"))     "), SV("{:{}}"), input, 27);
   check(SV("(42, (\"hello\", \"red\"))*****"), SV("{:*<{}}"), input, 27);
   check(SV("__(42, (\"hello\", \"red\"))___"), SV("{:_^{}}"), input, 27);
   check(SV("#####(42, (\"hello\", \"red\"))"), SV("{:#>{}}"), input, 27);
 
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
-  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
+  check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 
   // *** sign ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 
   // *** alternate form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+  check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 
   // *** precision ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 
   // *** locale-specific form ***
-  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+  check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("__42: (\"hello\", \"red\")___"), SV("{:_^25m}"), input);
   check(SV("__42, (\"hello\", \"red\")___"), SV("{:_^25n}"), input);
 
   for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
-    check_exception("The format-spec should consume the input or end with a '}'",
+    check_exception("The format specifier should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void run_tests(TestFunction check, ExceptionTest check_exception) {
   test_pair_int_int<CharT>(check, check_exception);

libcxx/test/support/format.functions.common.h

case CharT('X'):
       type = 1;
       break;
     case CharT('s'):
       type = 2;
       break;
     case CharT('}'):
       return begin;
     default:
-      throw_format_error("The format-spec type has a type not supported for a status argument");
+      throw_format_error("The type option contains an invalid value for a status formatting argument");
     }
 
     ++begin;
     if (begin != end && *begin != CharT('}'))
-      throw_format_error("The format-spec should consume the input or end with a '}'");
+      throw_format_error("The format specifier should consume the input or end with a '}'");
 
     return begin;
   }
 
   template <class Out>
   auto format(status s, basic_format_context<Out, CharT>& ctx) const -> decltype(ctx.out()) {
     const char* names[] = {"foo", "bar", "foobar"};
     char buffer[7];