libstdc++: Minimalize temporary allocations when width is specified [PR109162]

When width parameter is specified for formatting range, tuple or escaped
presentation of string, we used to format characters to temporary string,
and write produce sequence padded according to the spec. However, once the
estimated width of formatted representation of input is larger than the value
of spec width, it can be written directly to the output. This limits size of
required allocation, especially for large ranges.

Similarly, if precision (maximum) width is provided for string presentation,
only a prefix of sequence with estimated width not greater than precision, needs
to be buffered.

To realize above, this commit implements a new _Padding_sink specialization.
This sink holds an output iterator, a value of padding width, (optionally)
maximum width and a string buffer inherited from _Str_sink.
Then any incoming characters are treated in one of following ways, depending of
estimated width W of written sequence:
* written to string if W is smaller than padding width and maximum width (if present)
* ignored, if W is greater than maximum width
* written to output iterator, if W is greater than padding width

The padding sink is used instead of _Str_sink in __format::__format_padded,
__formatter_str::_M_format_escaped functions.

Furthermore __formatter_str::_M_format implementation was reworked, to:
* reduce number of instantiations by delegating to _Rg& and const _Rg& overloads,
* non-debug presentation is written to _Out directly or via _Padding_sink
* if maximum width is specified for debug format with non-unicode encoding,
  string size is limited to that number.

	PR libstdc++/109162

libstdc++-v3/ChangeLog:

	* include/bits/formatfwd.h (__simply_formattable_range): Moved from
	std/format.
	* include/std/format (__formatter_str::_format): Extracted escaped
	string handling to separate method...
	(__formatter_str::_M_format_escaped): Use __Padding_sink.
	(__formatter_str::_M_format): Adjusted implementation.
	(__formatter_str::_S_trunc): Extracted as namespace function...
	(__format::_truncate): Extracted from __formatter_str::_S_trunc.
	(__format::_Seq_sink): Removed forward declarations, made members
	protected and non-final.
	(_Seq_sink::_M_trim): Define.
	(_Seq_sink::_M_span): Renamed from view.
	(_Seq_sink::view): Returns string_view instead of span.
	(__format::_Str_sink): Moved after _Seq_sink.
	(__format::__format_padded): Use _Padding_sink.
	* testsuite/std/format/debug.cc: Add timeout and new tests.
	* testsuite/std/format/ranges/sequence.cc: Specify unicode as
	encoding and new tests.
	* testsuite/std/format/ranges/string.cc: Likewise.
	* testsuite/std/format/tuple.cc: Likewise.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

4 files changed, 655 insertions, 5 deletions

diff --git a/libstdc++-v3/testsuite/std/format/debug.cc b/libstdc++-v3/testsuite/std/format/debug.cc
index 71bb7f4..d3402f8 100644
--- a/libstdc++-v3/testsuite/std/format/debug.cc
+++ b/libstdc++-v3/testsuite/std/format/debug.cc
@@ -2,6 +2,7 @@
 // { dg-options "-fexec-charset=UTF-8 -fwide-exec-charset=UTF-32BE -DUNICODE_ENC" { target be } }
 // { dg-do run { target c++23 } }
 // { dg-add-options no_pch }
+// { dg-timeout-factor 2 }
 
 #include <format>
 #include <testsuite_hooks.h>
@@ -96,7 +97,7 @@ test_extended_ascii()
   res = fdebug(in);
   VERIFY( res == WIDEN(R"("Åëÿ")") );
 
-  static constexpr bool __test_characters 
+  static constexpr bool __test_characters
 #if UNICODE_ENC
     = sizeof(_CharT) >= 2;
 #else // ISO8859-1
@@ -114,11 +115,11 @@ test_extended_ascii()
   }
 }
 
-#if UNICODE_ENC
 template<typename _CharT>
 void
 test_unicode_escapes()
 {
+#if UNICODE_ENC
   std::basic_string<_CharT> res;
 
   const auto in = WIDEN(
@@ -160,12 +161,14 @@ test_unicode_escapes()
     res = fdebug(in[5]);
     VERIFY( res == WIDEN("'\U0001f984'") );
   }
+#endif // UNICODE_ENC
 }
 
 template<typename _CharT>
 void
 test_grapheme_extend()
 {
+#if UNICODE_ENC
   std::basic_string<_CharT> res;
 
   const auto vin = WIDEN("o\u0302\u0323");
@@ -184,12 +187,14 @@ test_grapheme_extend()
     res = fdebug(in[1]);
     VERIFY( res == WIDEN(R"('\u{302}')") );
   }
+#endif // UNICODE_ENC
 }
 
 template<typename _CharT>
 void
 test_replacement_char()
 {
+#if UNICODE_ENC
   std::basic_string<_CharT> repl = WIDEN("\uFFFD");
   std::basic_string<_CharT> res = fdebug(repl);
   VERIFY( res == WIDEN("\"\uFFFD\"") );
@@ -197,11 +202,13 @@ test_replacement_char()
   repl = WIDEN("\uFFFD\uFFFD");
   res = fdebug(repl);
   VERIFY( res == WIDEN("\"\uFFFD\uFFFD\"") );
+#endif // UNICODE_ENC
 }
 
 void
 test_ill_formed_utf8_seq()
 {
+#if UNICODE_ENC
   std::string_view seq = "\xf0\x9f\xa6\x84"; //  \U0001F984
   std::string res;
 
@@ -233,11 +240,13 @@ test_ill_formed_utf8_seq()
   VERIFY( res == R"('\x{84}')" );
   res = fdebug(seq.substr(3, 1));
   VERIFY( res == R"("\x{84}")" );
+#endif // UNICODE_ENC
 }
 
 void
 test_ill_formed_utf32()
 {
+#if UNICODE_ENC
   std::wstring res;
 
   wchar_t ic1 = static_cast<wchar_t>(0xff'ffff);
@@ -255,8 +264,8 @@ test_ill_formed_utf32()
   std::wstring is2(1, ic2);
   res = fdebug(is2);
   VERIFY( res == LR"("\x{ffffffff}")" );
-}
 #endif // UNICODE_ENC
+}
 
 template<typename _CharT>
 void
@@ -331,6 +340,375 @@ test_prec()
 #endif // UNICODE_ENC
 }
 
+bool strip_quote(std::string_view& v)
+{
+  if (!v.starts_with('"'))
+    return false;
+  v.remove_prefix(1);
+  return true;
+}
+
+bool strip_quotes(std::string_view& v)
+{
+  if (!v.starts_with('"') || !v.ends_with('"'))
+    return false;
+  v.remove_prefix(1);
+  v.remove_suffix(1);
+  return true;
+}
+
+bool strip_prefix(std::string_view& v, size_t n, char c)
+{
+  size_t pos = v.find_first_not_of(c);
+  if (pos == std::string_view::npos)
+    pos = v.size();
+  if (pos != n)
+    return false;
+  v.remove_prefix(n);
+  return true;
+}
+
+void test_padding()
+{
+  std::string res;
+  std::string_view resv;
+
+  // width and size are 26
+  std::string in = "abcdefghijklmnopqrstuvwxyz";
+  in += in; // width and size are 52
+  in += in; // width and size are 104
+  in += in; // width and size are 208
+  in += in; // width and size are 416
+  std::string_view inv = in;
+
+  resv = res = std::format("{}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.500}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.400}", in);
+  VERIFY( resv == inv.substr(0, 400) );
+
+  resv = res = std::format("{:.200}", in);
+  VERIFY( resv == inv.substr(0, 200) );
+
+  resv = res = std::format("{:.10}", in);
+  VERIFY( resv == inv.substr(0, 10) );
+
+  resv = res = std::format("{:.0}", in);
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>20}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>20.500}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>20.400}", in);
+  VERIFY( resv == inv.substr(0, 400) );
+
+  resv = res = std::format("{:*>20.200}", in);
+  VERIFY( resv == inv.substr(0, 200) );
+
+  resv = res = std::format("{:*>20.10}", in);
+  VERIFY( strip_prefix(resv, 10, '*') );
+  VERIFY( resv == inv.substr(0, 10) );
+
+  resv = res = std::format("{:*>20.0}", in);
+  VERIFY( strip_prefix(resv, 20, '*') );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>450}", in);
+  VERIFY( strip_prefix(resv, 34, '*') );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>450.500}", in);
+  VERIFY( strip_prefix(resv, 34, '*') );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>450.420}", in);
+  VERIFY( strip_prefix(resv, 34, '*') );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>450.400}", in);
+  VERIFY( strip_prefix(resv, 50, '*') );
+  VERIFY( resv == inv.substr(0, 400) );
+
+  resv = res = std::format("{:*>450.200}", in);
+  VERIFY( strip_prefix(resv, 250, '*') );
+  VERIFY( resv == inv.substr(0, 200) );
+
+  resv = res = std::format("{:*>450.10}", in);
+  VERIFY( strip_prefix(resv, 440, '*') );
+  VERIFY( resv == inv.substr(0, 10) );
+
+  resv = res = std::format("{:*>450.0}", in);
+  VERIFY( strip_prefix(resv, 450, '*') );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.500?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.400?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 399) );
+
+  resv = res = std::format("{:.200?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 199) );
+
+  resv = res = std::format("{:.10?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 9) );
+
+  resv = res = std::format("{:.1?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:.0?}", in);
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>20?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>20.500?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>20.400?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 399) );
+
+  resv = res = std::format("{:*>20.200?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 199) );
+
+  resv = res = std::format("{:*>20.10?}", in);
+  VERIFY( strip_prefix(resv, 10, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 9) );
+
+  resv = res = std::format("{:*>20.1?}", in);
+  VERIFY( strip_prefix(resv, 19, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>20.0?}", in);
+  VERIFY( strip_prefix(resv, 20, '*') );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>450?}", in);
+  VERIFY( strip_prefix(resv, 32, '*') );
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>450.500?}", in);
+  VERIFY( strip_prefix(resv, 32, '*') );
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>450.420?}", in);
+  VERIFY( strip_prefix(resv, 32, '*') );
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>450.400?}", in);
+  VERIFY( strip_prefix(resv, 50, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 399) );
+
+  resv = res = std::format("{:*>450.200?}", in);
+  VERIFY( strip_prefix(resv, 250, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 199) );
+
+  resv = res = std::format("{:*>450.10?}", in);
+  VERIFY( strip_prefix(resv, 440, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 9) );
+
+  resv = res = std::format("{:*>450.1?}", in);
+  VERIFY( strip_prefix(resv, 449, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>450.0?}", in);
+  VERIFY( strip_prefix(resv, 450, '*') );
+  VERIFY( resv == "" );
+
+#if UNICODE_ENC
+  // width is 3, size is 15
+  in = "o\u0302\u0323i\u0302\u0323u\u0302\u0323";
+  in += in; // width is 6, size is 30
+  in += in; // width is 12, size is 60
+  in += in; // width is 24, size is 120
+  in += in; // width is 48, size is 240
+  in += in; // width is 96, size is 480
+  in += in; // width is 192, size is 960
+  inv = in;
+
+  resv = res = std::format("{:}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.200}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.96}", in);
+  VERIFY( resv == inv.substr(0, 480) );
+
+  resv = res = std::format("{:.12}", in);
+  VERIFY( resv == inv.substr(0, 60) );
+
+  resv = res = std::format("{:.3}", in);
+  VERIFY( resv == inv.substr(0, 15) );
+
+  resv = res = std::format("{:.0}", in);
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>10}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>10.200}", in);
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>10.96}", in);
+  VERIFY( resv == inv.substr(0, 480) );
+
+  resv = res = std::format("{:*>10.12}", in);
+  VERIFY( resv == inv.substr(0, 60) );
+
+  resv = res = std::format("{:*>10.3}", in);
+  VERIFY( strip_prefix(resv, 7, '*') );
+  VERIFY( resv == inv.substr(0, 15) );
+
+  resv = res = std::format("{:*>10.0}", in);
+  VERIFY( strip_prefix(resv, 10, '*') );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>240s}", in);
+  VERIFY( strip_prefix(resv, 48, '*') );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>240.200s}", in);
+  VERIFY( strip_prefix(resv, 48, '*') );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>240.96s}", in);
+  VERIFY( strip_prefix(resv, 144, '*') );
+  VERIFY( resv == inv.substr(0, 480) );
+
+  resv = res = std::format("{:*>240.12}", in);
+  VERIFY( strip_prefix(resv, 228, '*') );
+  VERIFY( resv == inv.substr(0, 60) );
+
+  resv = res = std::format("{:*>240.3s}", in);
+  VERIFY( strip_prefix(resv, 237, '*') );
+  VERIFY( resv == inv.substr(0, 15) );
+
+  resv = res = std::format("{:*>240.0s}", in);
+  VERIFY( strip_prefix(resv, 240, '*') );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.200?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:.97?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 480) );
+
+  resv = res = std::format("{:.13?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 60) );
+
+  resv = res = std::format("{:.4?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 15) );
+
+  resv = res = std::format("{:.1?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:.0?}", in);
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>10?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>10.200?}", in);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>10.97?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 480) );
+
+  resv = res = std::format("{:*>10.13?}", in);
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 60) );
+
+  resv = res = std::format("{:*>10.4?}", in);
+  VERIFY( strip_prefix(resv, 6, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 15) );
+
+  resv = res = std::format("{:*>10.1?}", in);
+  VERIFY( strip_prefix(resv, 9, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>10.0?}", in);
+  VERIFY( strip_prefix(resv, 10, '*') );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>240?}", in);
+  VERIFY( strip_prefix(resv, 46, '*') );
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>240.200?}", in);
+  VERIFY( strip_prefix(resv, 46, '*') );
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == inv );
+
+  resv = res = std::format("{:*>240.97?}", in);
+  VERIFY( strip_prefix(resv, 143, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 480) );
+
+  resv = res = std::format("{:*>240.13?}", in);
+  VERIFY( strip_prefix(resv, 227, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 60) );
+
+  resv = res = std::format("{:*>240.4?}", in);
+  VERIFY( strip_prefix(resv, 236, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == inv.substr(0, 15) );
+
+  resv = res = std::format("{:*>240.1?}", in);
+  VERIFY( strip_prefix(resv, 239, '*') );
+  VERIFY( strip_quote(resv) );
+  VERIFY( resv == "" );
+
+  resv = res = std::format("{:*>240.0?}", in);
+  VERIFY( strip_prefix(resv, 240, '*') );
+  VERIFY( resv == "" );
+#endif // UNICODE_ENC
+}
+
 void test_char_as_wchar()
 {
   std::wstring res;
@@ -435,7 +813,6 @@ int main()
   test_extended_ascii<char>();
   test_extended_ascii<wchar_t>();
 
-#if UNICODE_ENC
   test_unicode_escapes<char>();
   test_unicode_escapes<wchar_t>();
   test_grapheme_extend<char>();
@@ -444,12 +821,13 @@ int main()
   test_replacement_char<wchar_t>();
   test_ill_formed_utf8_seq();
   test_ill_formed_utf32();
-#endif // UNICODE_ENC
 
   test_fill<char>();
   test_fill<wchar_t>();
   test_prec<char>();
   test_prec<wchar_t>();
 
+  test_padding();
+
   test_formatters_c();
 }
diff --git a/libstdc++-v3/testsuite/std/format/ranges/sequence.cc b/libstdc++-v3/testsuite/std/format/ranges/sequence.cc
index f05f6ec..75fe4c1 100644
--- a/libstdc++-v3/testsuite/std/format/ranges/sequence.cc
+++ b/libstdc++-v3/testsuite/std/format/ranges/sequence.cc
@@ -1,4 +1,5 @@
 // { dg-do run { target c++23 } }
+// { dg-options "-fexec-charset=UTF-8" }
 // { dg-timeout-factor 2 }
 
 #include <array>
@@ -6,6 +7,7 @@
 #include <list>
 #include <ranges>
 #include <span>
+#include <string>
 #include <testsuite_hooks.h>
 #include <testsuite_iterators.h>
 #include <vector>
@@ -199,9 +201,123 @@ test_nested()
   VERIFY( res == "+[01, 02, 11, 12]+" );
 }
 
+bool strip_quote(std::string_view& v)
+{
+  if (!v.starts_with('"'))
+    return false;
+  v.remove_prefix(1);
+  return true;
+}
+
+bool strip_prefix(std::string_view& v, std::string_view expected, bool quoted = false)
+{
+  if (quoted && !strip_quote(v))
+    return false;
+  if (!v.starts_with(expected))
+    return false;
+  v.remove_prefix(expected.size());
+  if (quoted && !strip_quote(v))
+    return false;
+  return true;
+}
+
+bool strip_squares(std::string_view& v)
+{
+  if (!v.starts_with('[') || !v.ends_with(']'))
+    return false;
+  v.remove_prefix(1);
+  v.remove_suffix(1);
+  return true;
+}
+
+bool strip_prefix(std::string_view& v, size_t n, char c)
+{
+  size_t pos = v.find_first_not_of(c);
+  if (pos == std::string_view::npos)
+    pos = v.size();
+  if (pos != n)
+    return false;
+  v.remove_prefix(n);
+  return true;
+}
+
+void test_padding()
+{
+  std::string res;
+  std::string_view resv;
+
+  // width is 3, size is 15
+  std::string in = "o\u0302\u0323i\u0302\u0323u\u0302\u0323";
+  in += in; // width is 6, size is 30
+  in += in; // width is 12, size is 60
+  in += in; // width is 24, size is 120
+  in += in; // width is 48, size is 240
+  // width is 192, size is 960
+  std::vector<std::string> const vs{in, in, in, in};
+
+  auto const check_elems = [=](std::string_view& v, bool quoted)
+  {
+    VERIFY( strip_prefix(v, in, quoted) );
+    VERIFY( strip_prefix(v, ", ", false) );
+    VERIFY( strip_prefix(v, in, quoted) );
+    VERIFY( strip_prefix(v, ", ", false) );
+    VERIFY( strip_prefix(v, in, quoted) );
+    VERIFY( strip_prefix(v, ", ", false) );
+    VERIFY( strip_prefix(v, in, quoted) );
+    return v.empty();
+  };
+
+  resv = res = std::format("{}", vs);
+  VERIFY( strip_squares(resv) );
+  VERIFY( check_elems(resv, true) );
+
+  resv = res = std::format("{:n}", vs);
+  VERIFY( check_elems(resv, true) );
+
+  resv = res = std::format("{::}", vs);
+  VERIFY( strip_squares(resv) );
+  VERIFY( check_elems(resv, false) );
+
+  resv = res = std::format("{:n:}", vs);
+  VERIFY( check_elems(resv, false) );
+
+  resv = res = std::format("{:*>10}", vs);
+  VERIFY( strip_squares(resv) );
+  VERIFY( check_elems(resv, true) );
+
+  resv = res = std::format("{:*>10n}", vs);
+  VERIFY( check_elems(resv, true) );
+
+  resv = res = std::format("{:*>10:}", vs);
+  VERIFY( strip_squares(resv) );
+  VERIFY( check_elems(resv, false) );
+
+  resv = res = std::format("{:*>10n:}", vs);
+  VERIFY( check_elems(resv, false) );
+
+  resv = res = std::format("{:*>240}", vs);
+  VERIFY( strip_prefix(resv, 32, '*') );
+  VERIFY( strip_squares(resv) );
+  VERIFY( check_elems(resv, true) );
+
+  resv = res = std::format("{:*>240n}", vs);
+  VERIFY( strip_prefix(resv, 34, '*') );
+  VERIFY( check_elems(resv, true) );
+
+  resv = res = std::format("{:*>240:}", vs);
+  VERIFY( strip_prefix(resv, 40, '*') );
+  VERIFY( strip_squares(resv) );
+  VERIFY( check_elems(resv, false) );
+
+  resv = res = std::format("{:*>240n:}", vs);
+  VERIFY( strip_prefix(resv, 42, '*') );
+  VERIFY( check_elems(resv, false) );
+}
+
 int main()
 {
   test_format_string();
   test_outputs();
   test_nested();
+  test_padding();
 }
diff --git a/libstdc++-v3/testsuite/std/format/ranges/string.cc b/libstdc++-v3/testsuite/std/format/ranges/string.cc
index cf39aa6..cebdd53 100644
--- a/libstdc++-v3/testsuite/std/format/ranges/string.cc
+++ b/libstdc++-v3/testsuite/std/format/ranges/string.cc
@@ -1,7 +1,9 @@
 // { dg-do run { target c++23 } }
+// { dg-options "-fexec-charset=UTF-8" }
 // { dg-timeout-factor 2 }
 
 #include <format>
+#include <forward_list>
 #include <span>
 #include <testsuite_hooks.h>
 #include <testsuite_iterators.h>
@@ -218,6 +220,67 @@ test_nested()
   VERIFY( std::format("{::?s}", vv) == R"(["str1", "str2"])" );
 }
 
+bool strip_quotes(std::string_view& v)
+{
+  if (!v.starts_with('"') || !v.ends_with('"'))
+    return false;
+  v.remove_prefix(1);
+  v.remove_suffix(1);
+  return true;
+}
+
+bool strip_prefix(std::string_view& v, size_t n, char c)
+{
+  size_t pos = v.find_first_not_of(c);
+  if (pos == std::string_view::npos)
+    pos = v.size();
+  if (pos != n)
+    return false;
+  v.remove_prefix(n);
+  return true;
+}
+
+
+void test_padding()
+{
+  std::string res;
+  std::string_view resv;
+
+  // width is 3, size is 15
+  std::string in = "o\u0302\u0323i\u0302\u0323u\u0302\u0323";
+  in += in; // width is 6, size is 30
+  in += in; // width is 12, size is 60
+  in += in; // width is 24, size is 120
+  in += in; // width is 48, size is 240
+  in += in; // width is 96, size is 480
+  in += in; // width is 192, size is 960
+
+  std::forward_list<char> lc(std::from_range, in);
+
+  resv = res = std::format("{:s}", lc);
+  VERIFY( resv == in );
+
+  resv = res = std::format("{:*>10s}", lc);
+  VERIFY( resv == in );
+
+  resv = res = std::format("{:*>240s}", lc);
+  VERIFY( strip_prefix(resv, 48, '*') );
+  VERIFY( resv == in );
+
+  resv = res = std::format("{:?s}", lc);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == in );
+
+  resv = res = std::format("{:*>10?s}", lc);
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == in );
+
+  resv = res = std::format("{:*>240?s}", lc);
+  VERIFY( strip_prefix(resv, 46, '*') );
+  VERIFY( strip_quotes(resv) );
+  VERIFY( resv == in );
+}
+
 int main()
 {
   test_format_string();
diff --git a/libstdc++-v3/testsuite/std/format/tuple.cc b/libstdc++-v3/testsuite/std/format/tuple.cc
index 62f9d29..ff0359b 100644
--- a/libstdc++-v3/testsuite/std/format/tuple.cc
+++ b/libstdc++-v3/testsuite/std/format/tuple.cc
@@ -1,4 +1,6 @@
 // { dg-do run { target c++23 } }
+// { dg-options "-fexec-charset=UTF-8" }
+// { dg-timeout-factor 2 }
 
 #include <format>
 #include <string>
@@ -250,10 +252,101 @@ void test_nested()
   VERIFY( res == R"((): (1, "abc"))" );
 }
 
+bool strip_quote(std::string_view& v)
+{
+  if (!v.starts_with('"'))
+    return false;
+  v.remove_prefix(1);
+  return true;
+}
+
+bool strip_prefix(std::string_view& v, std::string_view expected, bool quoted = false)
+{
+  if (quoted && !strip_quote(v))
+    return false;
+  if (!v.starts_with(expected))
+    return false;
+  v.remove_prefix(expected.size());
+  if (quoted && !strip_quote(v))
+    return false;
+  return true;
+}
+
+bool strip_parens(std::string_view& v)
+{
+  if (!v.starts_with('(') || !v.ends_with(')'))
+    return false;
+  v.remove_prefix(1);
+  v.remove_suffix(1);
+  return true;
+}
+
+bool strip_prefix(std::string_view& v, size_t n, char c)
+{
+  size_t pos = v.find_first_not_of(c);
+  if (pos == std::string_view::npos)
+    pos = v.size();
+  if (pos != n)
+    return false;
+  v.remove_prefix(n);
+  return true;
+}
+
+void test_padding()
+{
+  std::string res;
+  std::string_view resv;
+
+  // width is 3, size is 15
+  std::string in = "o\u0302\u0323i\u0302\u0323u\u0302\u0323";
+  in += in; // width is 6, size is 30
+  in += in; // width is 12, size is 60
+  in += in; // width is 24, size is 120
+  in += in; // width is 48, size is 240
+  // width is 192, size is 960
+  auto const ts = std::make_tuple(in, in, in, in);
+
+  auto const check_elems = [=](std::string_view& v)
+  {
+    VERIFY( strip_prefix(v, in, true) );
+    VERIFY( strip_prefix(v, ", ", false) );
+    VERIFY( strip_prefix(v, in, true) );
+    VERIFY( strip_prefix(v, ", ", false) );
+    VERIFY( strip_prefix(v, in, true) );
+    VERIFY( strip_prefix(v, ", ", false) );
+    VERIFY( strip_prefix(v, in, true) );
+    return v.empty();
+  };
+
+  resv = res = std::format("{}", ts);
+  VERIFY( strip_parens(resv) );
+  VERIFY( check_elems(resv) );
+
+  resv = res = std::format("{:n}", ts);
+  VERIFY( check_elems(resv) );
+
+  resv = res = std::format("{:*>10}", ts);
+  VERIFY( strip_parens(resv) );
+  VERIFY( check_elems(resv) );
+
+  resv = res = std::format("{:*>10n}", ts);
+  VERIFY( check_elems(resv) );
+
+  resv = res = std::format("{:*>240}", ts);
+  VERIFY( strip_prefix(resv, 32, '*') );
+  VERIFY( strip_parens(resv) );
+  VERIFY( check_elems(resv) );
+
+  resv = res = std::format("{:*>240n}", ts);
+  VERIFY( strip_prefix(resv, 34, '*') );
+  VERIFY( check_elems(resv) );
+}
+
 int main()
 {
   test_format_string();
   test_outputs<char>();
   test_outputs<wchar_t>();
   test_nested();
+  test_padding();
 }