[libc++][format] Improves tests.

[Mordante]

Summary

This is based on the last open review comment in D144331 and is applied
to all occurrences.

[Mordante]

CI fixes.

libcxx/test/std/containers/container.adaptors/container.adaptors.format/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class Arg, class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<Arg, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
-  test_parse<std::queue<int>>(fmt);
-  test_parse<std::priority_queue<int>>(fmt);
-  test_parse<std::stack<int>>(fmt);
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
+  test_parse<std::queue<int>>(fmt, offset);
+  test_parse<std::priority_queue<int>>(fmt, offset);
+  test_parse<std::stack<int>>(fmt, offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV(":d"));
+  test_parse(SV(""), 0);
+  test_parse(SV(":d"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV(":d}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV(":d}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/containers/sequences/vector.bool/vector.bool.fmt/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<std::vector<bool, std::allocator<bool>>::reference, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV("b"));
+  test_parse(SV(""), 0);
+  test_parse(SV("b"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV("b}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV("b}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<std::thread::id, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV("1"));
+  test_parse(SV(""), 0);
+  test_parse(SV("1"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV("1}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV("1}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.handle.pass.cpp

 
 template <>
 struct std::formatter<color> : std::formatter<const char*> {
   auto format(color c, auto& ctx) const {
     return formatter<const char*>::format(color_names[static_cast<int>(c)], ctx);
   }
 };
 
-void test(std::string expected, std::string_view fmt, color arg) {
+void test(std::string expected, std::string_view fmt, color arg, std::size_t offset) {
   auto parse_ctx = std::format_parse_context(fmt);
   std::formatter<color, char> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   std::string result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), char>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), char>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 void test_termination_condition(std::string expected, std::string f, color arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   std::string_view fmt{f};
   assert(fmt.back() == '}' && "Pre-condition failure");
 
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 0);
 }
 
 int main(int, char**) {
   test_termination_condition("black", "}", color::black);
   test_termination_condition("red", "}", color::red);
   test_termination_condition("gold", "}", color::gold);
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 
 template <class StringT, class StringViewT>
-void test(StringT expected, StringViewT fmt, bool arg) {
+void test(StringT expected, StringViewT fmt, bool arg, std::size_t offset) {
   using CharT = typename StringT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<bool, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT>
 void test_termination_condition(StringT expected, StringT f, bool arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 0);
 }
 
 template <class CharT>
 void test_boolean() {
   test_termination_condition(STR("true"), STR("}"), true);
   test_termination_condition(STR("false"), STR("}"), false);
 }
 
 int main(int, char**) {
   test_boolean<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_boolean<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
 template <class T, class StringT, class StringViewT, class CharT>
-void test(StringT expected, StringViewT fmt, const CharT* a) {
+void test(StringT expected, StringViewT fmt, const CharT* a, std::size_t offset) {
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<T, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   auto* arg = const_cast<T>(a);
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class ArgumentT, class StringT, class CharT>
 void test_termination_condition(StringT expected, StringT f, const CharT* arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test<ArgumentT>(expected, fmt, arg);
+  test<ArgumentT>(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test<ArgumentT>(expected, fmt, arg);
+  test<ArgumentT>(expected, fmt, arg, 0);
 }
 
 #if TEST_STD_VER > 20
 template <class ArgumentT, class CharT>
 constexpr bool test_set_debug_format() {
   std::formatter<ArgumentT, CharT> formatter;
   LIBCPP_ASSERT(formatter.__parser_.__type_ == std::__format_spec::__type::__default);
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.char.pass.cpp

 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringT, class StringViewT, class ArgumentT>
-void test(StringT expected, StringViewT fmt, ArgumentT arg) {
+void test(StringT expected, StringViewT fmt, ArgumentT arg, std::size_t offset) {
   using CharT = typename StringT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<ArgumentT, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT, class ArgumentT>
 void test_termination_condition(StringT expected, StringT f, ArgumentT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 0);
 }
 
 #if TEST_STD_VER > 20
 template <class ArgumentT, class CharT>
 constexpr bool test_set_debug_format() {
   std::formatter<ArgumentT, CharT> formatter;
   LIBCPP_ASSERT(formatter.__parser_.__type_ == std::__format_spec::__type::__default);
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.char_array.pass.cpp

struct Tester {
   // This is not part of the real test, but is used the deduce the size of the input.
   constexpr Tester(const char (&r)[N]) { __builtin_memcpy(text, r, N); }
   char text[N];
 
   // The size of the array shouldn't include the NUL character.
   static const std::size_t size = N - 1;
 
   template <class CharT>
-  void test(const std::basic_string<CharT>& expected, const std::basic_string_view<CharT>& fmt) const {
+  void
+  test(const std::basic_string<CharT>& expected, const std::basic_string_view<CharT>& fmt, std::size_t offset) const {
     using Str = CharT[size];
     std::basic_format_parse_context<CharT> parse_ctx{fmt};
     std::formatter<Str, CharT> formatter;
     static_assert(std::semiregular<decltype(formatter)>);
 
     auto it = formatter.parse(parse_ctx);
-    assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+    assert(it == fmt.end() - offset);
 
     std::basic_string<CharT> result;
     auto out = std::back_inserter(result);
     using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
     std::basic_string<CharT> buffer{text, text + N};
     // Note not too found of this hack
     Str* data = reinterpret_cast<Str*>(const_cast<CharT*>(buffer.c_str()));
 
     FormatCtxT format_ctx =
         test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(*data));
     formatter.format(*data, format_ctx);
     assert(result == expected);
   }
 
   template <class CharT>
   void test_termination_condition(const std::basic_string<CharT>& expected, const std::basic_string<CharT>& f) const {
     // The format-spec is valid if completely consumed or terminates at a '}'.
     // The valid inputs all end with a '}'. The test is executed twice:
     // - first with the terminating '}',
     // - second consuming the entire input.
     std::basic_string_view<CharT> fmt{f};
     assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-    test(expected, fmt);
+    test(expected, fmt, 1);
     fmt.remove_suffix(1);
-    test(expected, fmt);
+    test(expected, fmt, 0);
   }
 };
 
 template <std::size_t N>
 Tester(const char (&)[N]) -> Tester<N>;
 
 template <Tester t, class CharT>
 void test_helper_wrapper(std::basic_string<CharT> expected, std::basic_string<CharT> fmt) {

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 
 template <class CharT, class ArithmeticT>
-void test(std::basic_string_view<CharT> fmt, ArithmeticT arg, std::basic_string<CharT> expected) {
+void test(std::basic_string_view<CharT> fmt, ArithmeticT arg, std::basic_string<CharT> expected, std::size_t offset) {
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<ArithmeticT, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   std::basic_string<CharT> result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
void test_termination_condition(StringT f, ArithmeticT arg, StringT expected = {}) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test(fmt, arg, expected);
+  test(fmt, arg, expected, 1);
   fmt.remove_suffix(1);
-  test(fmt, arg, expected);
+  test(fmt, arg, expected, 0);
 }
 
 template <class CharT, class ArithmeticT>
 void test_hex_lower_case_precision(ArithmeticT value) {
   std::array<char, 25'000> buffer;
   char* end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::hex, 20'000).ptr;
   test_termination_condition(STR(".20000a}"), value, std::basic_string<CharT>{buffer.begin(), end});
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 
 template <class StringT, class StringViewT, class PointerT>
-void test(StringT expected, StringViewT fmt, PointerT arg) {
+void test(StringT expected, StringViewT fmt, PointerT arg, std::size_t offset) {
   using CharT = typename StringT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<PointerT, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
void test_termination_condition(StringT expected, StringT f, PointerT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 0);
 }
 
 template <class CharT>
 void test_nullptr_t() {
   test_termination_condition(STR("0x0"), STR("}"), nullptr);
 }
 
 template <class PointerT, class CharT>

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 
 template <class StringT, class StringViewT, class ArithmeticT>
-void test(StringT expected, StringViewT fmt, ArithmeticT arg) {
+void test(StringT expected, StringViewT fmt, ArithmeticT arg, std::size_t offset) {
   using CharT = typename StringT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<ArithmeticT, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT, class ArithmeticT>
 void test_termination_condition(StringT expected, StringT f, ArithmeticT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 0);
 }
 
 template <class Arithmetic, class CharT>
 void test_signed_integral_type() {
   using A = Arithmetic;
   test_termination_condition(STR("-128"), STR("}"), A(-128));
   test_termination_condition(STR("0"), STR("}"), A(0));
   test_termination_condition(STR("127"), STR("}"), A(127));

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.string.pass.cpp

 #include "test_format_context.h"
 #include "test_macros.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
 template <class T, class ArgumentT, class StringT, class StringViewT>
-void test(StringT expected, StringViewT fmt, StringT a) {
+void test(StringT expected, StringViewT fmt, StringT a, std::size_t offset) {
   static_assert(
       std::same_as<typename T::value_type,
                    typename std::decay_t<ArgumentT>::value_type> &&
       std::same_as<typename T::value_type, typename StringT::value_type>);
   using CharT = typename T::value_type;
 
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<T, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   ArgumentT arg = a;
   FormatCtxT format_ctx = test_format_context_create<decltype(out), CharT>(
       out, std::make_format_args<FormatCtxT>(std::forward<ArgumentT>(arg)));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class T, class ArgumentT, class StringT>
 void test_termination_condition(StringT expected, StringT f, StringT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test<T, ArgumentT>(expected, fmt, arg);
+  test<T, ArgumentT>(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test<T, ArgumentT>(expected, fmt, arg);
+  test<T, ArgumentT>(expected, fmt, arg, 0);
 }
 
 #if TEST_STD_VER > 20
 template <class ArgumentT, class CharT>
 constexpr bool test_set_debug_format() {
   std::formatter<ArgumentT, CharT> formatter;
   LIBCPP_ASSERT(formatter.__parser_.__type_ == std::__format_spec::__type::__default);
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.unsigned_integral.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 
 template <class StringT, class StringViewT, class ArithmeticT>
-void test(StringT expected, StringViewT fmt, ArithmeticT arg) {
+void test(StringT expected, StringViewT fmt, ArithmeticT arg, std::size_t offset) {
   using CharT = typename StringT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<ArithmeticT, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT, class ArithmeticT>
 void test_termination_condition(StringT expected, StringT f, ArithmeticT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:
   // - first with the terminating '}',
   // - second consuming the entire input.
   using CharT = typename StringT::value_type;
   std::basic_string_view<CharT> fmt{f};
   assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 1);
   fmt.remove_suffix(1);
-  test(expected, fmt, arg);
+  test(expected, fmt, arg, 0);
 }
 
 template <class ArithmeticT, class CharT>
 void test_unsigned_integral_type() {
   using A = ArithmeticT;
   test_termination_condition(STR("0"), STR("}"), A(0));
   test_termination_condition(STR("255"), STR("}"), A(255));
   if (sizeof(A) > 1)

libcxx/test/std/utilities/format/format.range/format.range.fmtdef/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<std::array<int, 2>, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV(":5"));
+  test_parse(SV(""), 0);
+  test_parse(SV(":5"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV(":5}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV(":5}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/utilities/format/format.range/format.range.fmtmap/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<std::map<int, int>, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV(":5"));
+  test_parse(SV(""), 0);
+  test_parse(SV(":5"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV(":5}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV(":5}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/utilities/format/format.range/format.range.fmtset/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<std::set<int>, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV(":5"));
+  test_parse(SV(""), 0);
+  test_parse(SV(":5"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV(":5}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV(":5}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/utilities/format/format.range/format.range.fmtstr/parse.pass.cpp

 #include <concepts>
 #include <format>
 
 #include "format.functions.tests.h"
 #include "test_format_context.h"
 #include "test_macros.h"
 
 template <class FormatterT, class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   FormatterT formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class StringViewT>
-constexpr void test_formatters(StringViewT fmt) {
+constexpr void test_formatters(StringViewT fmt, std::size_t offset) {
   using CharT = typename StringViewT::value_type;
-  test_parse<std::formatter<test_range_format_string<std::basic_string<CharT>>, CharT>>(fmt);
-  test_parse<std::formatter<test_range_format_debug_string<std::basic_string<CharT>>, CharT>>(fmt);
+  test_parse<std::formatter<test_range_format_string<std::basic_string<CharT>>, CharT>>(fmt, offset);
+  test_parse<std::formatter<test_range_format_debug_string<std::basic_string<CharT>>, CharT>>(fmt, offset);
 }
 
 template <class CharT>
 constexpr void test_char_type() {
-  test_formatters(SV(""));
-  test_formatters(SV("}"));
+  test_formatters(SV(""), 0);
+  test_formatters(SV("}"), 1);
 }
 
 constexpr bool test() {
   test_char_type<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_char_type<wchar_t>();
 #endif
 

libcxx/test/std/utilities/format/format.range/format.range.formatter/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class StringViewT>
-constexpr void test_parse(StringViewT fmt) {
+constexpr void test_parse(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::range_formatter<int, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT>
 constexpr void test_fmt() {
-  test_parse(SV(""));
-  test_parse(SV(":d"));
+  test_parse(SV(""), 0);
+  test_parse(SV(":d"), 0);
 
-  test_parse(SV("}"));
-  test_parse(SV(":d}"));
+  test_parse(SV("}"), 1);
+  test_parse(SV(":d}"), 1);
 }
 
 constexpr bool test() {
   test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_fmt<wchar_t>();
 #endif
 

libcxx/test/std/utilities/format/format.tuple/parse.pass.cpp

 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class Arg, class StringViewT>
-constexpr void test(StringViewT fmt) {
+constexpr void test(StringViewT fmt, std::size_t offset) {
   using CharT    = typename StringViewT::value_type;
   auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
   std::formatter<Arg, CharT> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
-  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+  assert(it == fmt.end() - offset);
 }
 
 template <class CharT, class Arg>
 constexpr void test() {
-  test<Arg>(SV(""));
-  test<Arg>(SV("42"));
+  test<Arg>(SV(""), 0);
+  test<Arg>(SV("42"), 0);
 
-  test<Arg>(SV("}"));
-  test<Arg>(SV("42}"));
+  test<Arg>(SV("}"), 1);
+  test<Arg>(SV("42}"), 1);
 }
 
 template <class CharT>
 constexpr void test() {
   test<CharT, std::tuple<int>>();
   test<CharT, std::tuple<int, CharT>>();
   test<CharT, std::pair<int, CharT>>();
   test<CharT, std::tuple<int, CharT, bool>>();