[libc++][format] Improves run-time diagnostics.

[Mordante]

Summary

After parsing a std-format-spec it's validated, depending on the type used some
format options are not allowed. This improves the error messages in the
exceptions thrown upon failure.

Depends on D155364

[Mordante]

CI fixes.

[ldionne]

LGTM w/ comments.

libcxx/include/__format/parser_std_format_spec.h

201

223

inline.

241–247

WDYT about this? Then the consteval overload can be removed and IMO it's a bit more clear what's going on.

440–441

443

445

447

448–449

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

241–247

I like the original code slightly better, but I don't object against the change.

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_ =

libcxx/include/__format/parser_std_format_spec.h

 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h> // iter_value_t
 #include <__memory/addressof.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/is_constant_evaluated.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");
enum class _LIBCPP_ENUM_VIS __sign : uint8_t {
   /// flag. For formatting purposes it behaves the same as \ref __minus.
   __default,
   __minus,
   __plus,
   __space
 };
 
 enum class _LIBCPP_ENUM_VIS __type : uint8_t {
-  __default,
+  __default = 0,
   __string,
   __binary_lower_case,
   __binary_upper_case,
   __octal,
   __decimal,
   __hexadecimal_lower_case,
   __hexadecimal_upper_case,
   __pointer_lower_case,
   __pointer_upper_case,
   __char,
   __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
 };
 
+_LIBCPP_HIDE_FROM_ABI inline 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;
+}
+
+inline constexpr uint32_t __type_mask_integer =
+    __create_type_mask(__type::__binary_lower_case) |      //
+    __create_type_mask(__type::__binary_upper_case) |      //
+    __create_type_mask(__type::__decimal) |                //
+    __create_type_mask(__type::__octal) |                  //
+    __create_type_mask(__type::__hexadecimal_lower_case) | //
+    __create_type_mask(__type::__hexadecimal_upper_case);
+
 struct __std {
   __alignment __alignment_ : 3;
   __sign __sign_ : 2;
   bool __alternate_form_ : 1;
   bool __locale_specific_form_ : 1;
   __type __type_;
 };
 
 struct __chrono {
   __alignment __alignment_ : 3;
   bool __locale_specific_form_ : 1;
   bool __hour_                 : 1;
   bool __weekday_name_ : 1;
   bool __weekday_              : 1;
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator __parse(_ParseContext& __ctx, __fields __fields) {
 
     if (__fields.__type_)
       __parse_type(__begin);
 
     if (!__fields.__consume_all_)
       return __begin;
 
     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 '}'");
 
     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
+  // boolean types.
+  //
+  // Depending on whether the validation is done at compile-time or
+  // run-time the error differs
+  // - run-time the exception is thrown and contains the type of field
+  //   being validated.
+  // - at compile-time the line with `std::__throw_format_error` is shown
+  //   in the output. In that case it's important for the error to be 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 form");
+    }
+
+    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_,
case __format_spec::__type::__debug:
     break;
 
   default:
     std::__throw_format_error("The format-spec type has a type not supported for a string 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);
   }
 }
 
 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:
     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_lower_case:
   case __format_spec::__type::__pointer_upper_case:
     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/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("{::*<{}}"), 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);
 
   // *** 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);
void test_char_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // ***** 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);
void test_bool(TestFunction check, ExceptionTest check_exception, auto&& 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_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);
 
   // *** 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);
void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
#  if 0
   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);
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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);
 
   // *** alternate form ***
   check_exception("The format-spec 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);
 
   // *** precision ***
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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(SV("[0x0000]"), SV("{::06}"), input);
   check(SV("[0x0000]"), SV("{::06p}"), input);
   check(SV("[0X0000]"), SV("{::06P}"), 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>("pP"))
-    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);
void test_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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);
 
   // *** alternate form ***
   check_exception("The format-spec 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);
 
   // *** precision ***
void test_string(TestFunction check, ExceptionTest check_exception, auto&& 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_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);
 
   // *** 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);
 
   // *** 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);
 
   // *** 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);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);

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("{::*<{}}"), 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);
 
   // *** 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);

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

 
 #  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 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);
 #  endif // TEST_SHORT_WCHAR
 #endif   // TEST_HAS_NO_WIDE_CHARACTERS
   }
 }
 

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);
 
   // *** width ***
   // Width 0 allowed, but not useful for string arguments.
   check(SV("hello world"), SV("hello {:{}}"), world, 0);
 
#endif
   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);
 
   // *** 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))
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));
 
   // *** 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, 42);
 }
 
 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));
 
   // *** 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(42));
 
   // *** 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, '*');
 }
 
 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);
 }
void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is ':0x0::'"), SV("answer is '{::^6}'"), P(nullptr));
 
   // Test whether zero padding is ignored
   check(SV("answer is ':::0x0'"), SV("answer is '{::>06}'"), P(nullptr));
   check(SV("answer is '0x0:::'"), SV("answer is '{::<06}'"), P(nullptr));
   check(SV("answer is ':0x0::'"), SV("answer is '{::^06}'"), 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(SV("answer is '0x0000'"), SV("answer is '{:06}'"), P(nullptr));
   check(SV("answer is '0x0000'"), SV("answer is '{:06p}'"), P(nullptr));
   check(SV("answer is '0X0000'"), SV("answer is '{:06P}'"), 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("{:.}"), P(nullptr));
 
   // *** 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>("pP"))
-    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);

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("{::*<{}}"), 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);
 
   // *** 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);
void test_char_string(TestFunction check, [[maybe_unused]] ExceptionTest check_exception) {
   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);
 
   // ***** 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_to_wchar(TestFunction check, ExceptionTest check_exception) {
   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);
 
   // *** 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);
void test_bool(TestFunction check, ExceptionTest check_exception) {
   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);
 
   // *** 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);
void test_bool_multiset(TestFunction check, ExceptionTest check_exception) {
   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);
 
   // *** 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);
void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
#  if 0
   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);
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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(SV("{0x0000}"), SV("{::06}"), input);
   check(SV("{0x0000}"), SV("{::06p}"), input);
   check(SV("{0X0000}"), SV("{::06P}"), 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>("pP"))
-    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);
void test_string(TestFunction check, ExceptionTest check_exception, auto&& 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_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);
 
   // *** 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);
 
   // *** 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);
 
   // *** 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);
 
   // ***** Both have a format-spec
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^{:::Hello, :::world}^^^)"), SV("{:^^{}::>8}"), input, 25);

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("{:*<{}}"), 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);
 
   // *** 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);
 
   // *** 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);
 }
 
void test_range_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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);
 
   // *** alternate form ***
   check_exception("The format-spec 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);
 
   // *** precision ***
void test_range_string(TestFunction check, ExceptionTest check_exception, auto&& 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_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);
 
   // *** 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);
 
   // *** 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);
 
   // *** 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);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);
void test_debug_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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);
 
   // *** 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);
 }
 
void test_range_debug_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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);
 
   // *** alternate form ***
   check_exception("The format-spec 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);
 
   // *** precision ***
void test_range_debug_string(TestFunction check, ExceptionTest check_exception, auto&& 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_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);
 
   // *** 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);
 
   // *** 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);
 
   // *** 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);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^29::>10}"), input);
   check(SV(R"(^^[:::"Hello", :::"world"]^^^)"), SV("{:^^{}::>10}"), input, 29);

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("{::*<{}}"), 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);
 
   // *** 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);
void test_char_string(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // ***** 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);
void test_bool(TestFunction check, ExceptionTest check_exception) {
   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);
 
   // *** 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);
void test_int(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
#  if 0
   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);
void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
   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);
 
   // *** 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(SV("[0x0000]"), SV("{::06}"), input);
   check(SV("[0x0000]"), SV("{::06p}"), input);
   check(SV("[0X0000]"), SV("{::06P}"), 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>("pP"))
-    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);
void test_string(TestFunction check, ExceptionTest check_exception, auto&& 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_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);
 
   // *** 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);
 
   // *** 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);
 
   // *** 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);
 
   // ***** Both have a format-spec
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^25::>8}"), input);
   check(SV(R"(^^[:::Hello, :::world]^^^)"), SV("{:^^{}::>8}"), input, 25);