libstdc++: Implement formatters for pair and tuple [PR109162]

This patch implements formatter specializations for pair and tuple form
P2286R8. In addition using 'm` and range_format::map (from P2585R1) for
ranges are now supported.

The formatters for pairs and tuples whose corresponding elements are the same
(after applying remove_cvref_t) derive from the same __tuple_formatter class.
This reduce the code duplication, as most of the parsing and formatting is the
same in such cases. We use a custom reduced implementation of the tuple
(__formatters_storage) to store the elements formatters.

Handling of the padding (width and fill) options, is extracted to
__format::__format_padded function, that is used both by __tuple_formatter and
range_formatter. To reduce number of instantations range_formatter::format
triggers, we cast incoming range to __format::__maybe_const_range<_Rg, _CharT>&,
before formatting it.

As in the case of previous commits, the signatures of the user-facing parse
and format methods of the provided formatters deviate from the standard by
constraining types of parameters:
* _CharT is constrained __formatter::__char
* basic_format_parse_context<_CharT> for parse argument
* basic_format_context<_Out, _CharT> for format second argument
The standard specifies last three of above as unconstrained types.

Finally, test for tuple-like std::array and std::ranges::subrange,
that illustrate that they remain formatted as ranges.

	PR libstdc++/109162

libstdc++-v3/ChangeLog:

	* include/std/format (__formatter_int::_M_format_character_escaped)
	(__formatter_str::format): Use __sink.out() to produce _Sink_iter.
	(__format::__const_formattable_range): Moved closer to range_formatter.
	(__format::__maybe_const_range): Use `__conditional_t` and moved closer
	to range_formatter.
	(__format::__format_padded, __format::maybe_const)
	(__format::__indexed_formatter_storage, __format::__tuple_formatter)
	(std::formatter<pair<_Fp, _Sp>, _CharT>>)
	(std::formatter<tuple<_Tps...>, _CharT): Define.
	(std::formatter<_Rg, _CharT>::format): Cast incoming range to
	__format::__maybe_const_range<_Rg, _CharT>&.
	(std::formatter<_Rg, _CharT>::_M_format): Extracted from format,
	and use __format_padded.
	(std::formatter<_Rg, _CharT>::_M_format_no_padding): Rename...
	(std::formatter<_Rg, _CharT>::_M_format_elems): ...to this.
	(std::formatter<_Rg, _CharT>::_M_format_with_padding): Extracted as
	__format_padded.
	* testsuite/util/testsuite_iterators.h (test_input_range_nocopy):
	Define.
	* testsuite/std/format/ranges/formatter.cc: Tests for `m` specifier.
	* testsuite/std/format/ranges/sequence.cc: Tests for array and subrange.
	* testsuite/std/format/ranges/map.cc: New test.
	* testsuite/std/format/tuple.cc: New test.

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

4 files changed, 507 insertions, 19 deletions

diff --git a/libstdc++-v3/testsuite/std/format/ranges/formatter.cc b/libstdc++-v3/testsuite/std/format/ranges/formatter.cc
index 2045b51..a4f5d92 100644
--- a/libstdc++-v3/testsuite/std/format/ranges/formatter.cc
+++ b/libstdc++-v3/testsuite/std/format/ranges/formatter.cc
@@ -97,6 +97,7 @@ void
 test_override()
 {
   MyVector<_CharT, Formatter> vc{'a', 'b', 'c', 'd'};
+  MyVector<std::pair<int, int>, Formatter> vp{{1, 11}, {2, 21}};
   std::basic_string<_CharT> res;
 
   res = std::format(WIDEN("{:s}"), vc);
@@ -106,7 +107,10 @@ test_override()
   res = std::format(WIDEN("{:+^6s}"), vc);
   VERIFY( res == WIDEN("+abcd+") );
 
-  // TODO test map
+  res = std::format(WIDEN("{:m}"), vp);
+  VERIFY( res == WIDEN("{1: 11, 2: 21}") );
+  res = std::format(WIDEN("{:=^20m}"), vp);
+  VERIFY( res == WIDEN("==={1: 11, 2: 21}===") );
 }
 
 template<template<typename, typename> class Formatter>
diff --git a/libstdc++-v3/testsuite/std/format/ranges/map.cc b/libstdc++-v3/testsuite/std/format/ranges/map.cc
new file mode 100644
index 0000000..34c5ed5
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/format/ranges/map.cc
@@ -0,0 +1,209 @@
+// { dg-do run { target c++23 } }
+
+#include <flat_map>
+#include <format>
+#include <list>
+#include <map>
+#include <span>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+#include <vector>
+
+struct NotFormattable
+{
+  friend auto operator<=>(NotFormattable, NotFormattable) = default;
+};
+
+static_assert( !std::formattable<std::map<int, NotFormattable>, char> );
+static_assert( !std::formattable<std::map<NotFormattable, int>, wchar_t> );
+
+template<typename... Args>
+bool
+is_format_string_for(const char* str, Args&&... args)
+{
+  try {
+    (void) std::vformat(str, std::make_format_args(args...));
+    return true;
+  } catch (const std::format_error&) {
+    return false;
+  }
+}
+
+template<typename... Args>
+bool
+is_format_string_for(const wchar_t* str, Args&&... args)
+{
+  try {
+    (void) std::vformat(str, std::make_wformat_args(args...));
+    return true;
+  } catch (const std::format_error&) {
+    return false;
+  }
+}
+
+template<typename Rg, typename CharT>
+bool is_range_formatter_spec_for(CharT const* spec, Rg&& rg)
+{
+  using V = std::remove_cvref_t<std::ranges::range_reference_t<Rg>>;
+  std::range_formatter<V, CharT> fmt;
+  std::basic_format_parse_context<CharT> pc(spec);
+  try {
+    (void)fmt.parse(pc);
+    return true;
+  } catch (const std::format_error&) {
+    return false;
+  }
+}
+
+#define WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
+#define WIDEN(S) WIDEN_(_CharT, S)
+
+void
+test_format_string()
+{
+  // only pair<T, U> amd tuple<T, U> value types are supported
+  VERIFY( !is_range_formatter_spec_for("m", std::vector<int>()) );
+  VERIFY( !is_format_string_for("{:m}", std::vector<int>()) );
+  VERIFY( !is_range_formatter_spec_for("m", std::vector<std::tuple<int, int, int>>()) );
+  VERIFY( !is_format_string_for("{:m}", std::vector<std::tuple<int, int, int>>()) );
+
+  // invalid format stringss
+  VERIFY( !is_range_formatter_spec_for("?m", std::vector<std::pair<int, int>>()) );
+  VERIFY( !is_format_string_for("{:?m}", std::vector<std::pair<int, int>>()) );
+  VERIFY( !is_range_formatter_spec_for("m:", std::vector<std::pair<int, int>>()) );
+  VERIFY( !is_format_string_for("{:m:}", std::vector<std::pair<int, int>>()) );
+
+  // precision is not supported
+  VERIFY( !is_range_formatter_spec_for(".10m", std::vector<std::pair<int, int>>()) );
+  VERIFY( !is_format_string_for("{:.10m}", std::vector<std::pair<int, int>>()) );
+  VERIFY( !is_format_string_for("{:.{}m}", std::vector<std::pair<int, int>>(), 10) );
+
+  // width needs to be integer type
+  VERIFY( !is_format_string_for("{:{}m}", std::vector<std::pair<int, int>>(), 1.0f) );
+}
+
+template<typename _CharT, typename Range>
+void test_output(bool mapIsDefault)
+{
+  using Sv = std::basic_string_view<_CharT>;
+  using Pt = std::ranges::range_value_t<Range>;
+  using Ft = std::remove_cvref_t<std::tuple_element_t<0, Pt>>;
+  using St = std::remove_cvref_t<std::tuple_element_t<1, Pt>>;
+  auto makeRange = [](std::span<Pt> s) {
+    return Range(s.data(), s.data() + s.size());
+  };
+
+  std::basic_string<_CharT> res;
+  size_t size = 0;
+
+  Ft f1[]{1, 2, 3};
+  St s1[]{11, 22, 33};
+  Pt v1[]{{f1[0], s1[0]}, {f1[1], s1[1]}, {f1[2], s1[2]}};
+
+  res = std::format(WIDEN("{}"), makeRange(v1));
+  if (mapIsDefault)
+    VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}") );
+  else
+    VERIFY( res == WIDEN("[(1, 11), (2, 22), (3, 33)]") );
+
+  res = std::format(WIDEN("{:m}"), makeRange(v1));
+  VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}") );
+  res = std::format(WIDEN("{:nm}"), makeRange(v1));
+  VERIFY( res == WIDEN("1: 11, 2: 22, 3: 33") );
+
+  res = std::format(WIDEN("{:3m}"), makeRange(v1));
+  VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}") );
+
+  res = std::format(WIDEN("{:25m}"), makeRange(v1));
+  VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}    ") );
+
+  res = std::format(WIDEN("{:{}m}"), makeRange(v1), 25);
+  VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}    ") );
+
+  res = std::format(WIDEN("{1:{0}m}"), 25, makeRange(v1));
+  VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}    ") );
+
+  res = std::format(WIDEN("{:25nm}"), makeRange(v1));
+  VERIFY( res == WIDEN("1: 11, 2: 22, 3: 33      ") );
+
+  res = std::format(WIDEN("{:*<23m}"), makeRange(v1));
+  VERIFY( res == WIDEN("{1: 11, 2: 22, 3: 33}**") );
+
+  res = std::format(WIDEN("{:->24m}"), makeRange(v1));
+  VERIFY( res == WIDEN("---{1: 11, 2: 22, 3: 33}") );
+
+  res = std::format(WIDEN("{:=^25m}"), makeRange(v1));
+  VERIFY( res == WIDEN("=={1: 11, 2: 22, 3: 33}==") );
+
+  res = std::format(WIDEN("{:=^25nm}"), makeRange(v1));
+  VERIFY( res == WIDEN("===1: 11, 2: 22, 3: 33===") );
+
+  size = std::formatted_size(WIDEN("{:m}"), makeRange(v1));
+  VERIFY( size == Sv(WIDEN("{1: 11, 2: 22, 3: 33}")).size() );
+
+  size = std::formatted_size(WIDEN("{:3m}"), makeRange(v1));
+  VERIFY( size == Sv(WIDEN("{1: 11, 2: 22, 3: 33}")).size() );
+
+  size = std::formatted_size(WIDEN("{:25m}"), makeRange(v1));
+  VERIFY( size == 25 );
+}
+
+template<class Range>
+void test_output_c(bool mapIsDefault = false)
+{
+  test_output<char, Range>(mapIsDefault);
+  test_output<wchar_t, Range>(mapIsDefault);
+}
+
+template<template<typename> class RangeT>
+void test_output_pc()
+{
+  test_output_c<RangeT<std::pair<int, int>>>();
+  test_output_c<RangeT<std::pair<const int, int>>>();
+  test_output_c<RangeT<std::tuple<const int&, int&>>>();
+}
+
+void
+test_outputs()
+{
+  using namespace __gnu_test;
+  test_output_c<std::map<int, int>>(true);
+  test_output_c<std::flat_map<int, int>>(true);
+
+  test_output_pc<std::vector>();
+  test_output_pc<std::list>();
+  test_output_pc<std::span>();
+
+  test_output_pc<test_forward_range>();
+  test_output_pc<test_input_range>();
+  test_output_pc<test_input_range_nocopy>();
+}
+
+void
+test_nested()
+{
+  std::vector<std::map<int, std::string>> vm{
+    {{1, "one"}, {2, "two"}},
+    {{1, "jeden"}, {2, "dwa"}},
+  };
+  std::string res;
+
+  res = std::format("{}", vm);
+  VERIFY( res == R"([{1: "one", 2: "two"}, {1: "jeden", 2: "dwa"}])" );
+  res = std::format("{:n:n}", vm);
+  VERIFY( res == R"(1: "one", 2: "two", 1: "jeden", 2: "dwa")" );
+
+  std::map<std::string, std::vector<std::string>> mv{
+    {"english", {"zero", "one", "two"}},
+    {"polish", {"zero", "jeden", "dwa"}},
+  };
+  res = std::format("{}", mv);
+  VERIFY( res == R"({"english": ["zero", "one", "two"], "polish": ["zero", "jeden", "dwa"]})" );
+}
+
+int main()
+{
+  test_format_string();
+  test_outputs();
+  test_nested();
+}
diff --git a/libstdc++-v3/testsuite/std/format/ranges/sequence.cc b/libstdc++-v3/testsuite/std/format/ranges/sequence.cc
index 0657437..61fc68e 100644
--- a/libstdc++-v3/testsuite/std/format/ranges/sequence.cc
+++ b/libstdc++-v3/testsuite/std/format/ranges/sequence.cc
@@ -1,7 +1,9 @@
 // { dg-do run { target c++23 } }
 
+#include <array>
 #include <format>
 #include <list>
+#include <ranges>
 #include <span>
 #include <testsuite_hooks.h>
 #include <testsuite_iterators.h>
@@ -73,19 +75,23 @@ test_format_string()
 #define WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
 #define WIDEN(S) WIDEN_(_CharT, S)
 
-template<typename _CharT, typename Range>
+template<typename _CharT, typename Range, typename Storage>
 void test_output()
 {
   using Sv = std::basic_string_view<_CharT>;
   using T = std::ranges::range_value_t<Range>;
-  auto makeRange = [](std::span<T> s) {
-    return Range(s.data(), s.data() + s.size());
+  auto makeRange = [](Storage& s) -> Range {
+    if constexpr (std::is_same_v<std::remove_cvref_t<Range>, Storage>)
+      return s;
+    else
+      return Range(std::ranges::data(s),
+		   std::ranges::data(s) + std::ranges::size(s));
   };
 
   std::basic_string<_CharT> res;
   size_t size = 0;
 
-  T v1[]{1, 2, 3};
+  Storage v1{1, 2, 3};
   res = std::format(WIDEN("{}"), makeRange(v1));
   VERIFY( res == WIDEN("[1, 2, 3]") );
   res = std::format(WIDEN("{:}"), makeRange(v1));
@@ -143,27 +149,37 @@ void test_output()
   VERIFY( size == 25 );
 }
 
-template<typename Range>
-void test_output_c()
+template<typename Cont>
+void test_output_cont()
 {
-  test_output<char, Range>();
-  test_output<wchar_t, Range>();
+  test_output<char, Cont&, Cont>();
+  test_output<wchar_t, Cont const&, Cont>();
+}
+
+template<typename View>
+void test_output_view()
+{
+  test_output<char, View, int[3]>();
+  test_output<wchar_t, View, int[3]>();
 }
 
 void
 test_outputs()
 {
   using namespace __gnu_test;
-  test_output_c<std::vector<int>>();
-  test_output_c<std::list<int>>();
-  test_output_c<std::span<int>>();
-
-  test_output_c<test_forward_range<int>>();
-  test_output_c<test_input_range<int>>();
-  test_output_c<test_range_nocopy<int, input_iterator_wrapper_nocopy>>();
-
-  test_output_c<std::span<const int>>();
-  test_output_c<test_forward_range<const int>>();
+  test_output_cont<std::vector<int>>();
+  test_output_cont<std::list<int>>();
+  test_output_cont<std::array<int, 3>>();
+
+  test_output_view<std::span<int>>();
+  test_output_view<std::ranges::subrange<int*>>();
+  test_output_view<test_forward_range<int>>();
+  test_output_view<test_input_range<int>>();
+  test_output_view<test_input_range_nocopy<int>>();
+
+  test_output_view<std::span<const int>>();
+  test_output_view<std::ranges::subrange<const int*>>();
+  test_output_view<test_forward_range<const int>>();
 }
 
 void
diff --git a/libstdc++-v3/testsuite/std/format/tuple.cc b/libstdc++-v3/testsuite/std/format/tuple.cc
new file mode 100644
index 0000000..62f9d29
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/format/tuple.cc
@@ -0,0 +1,259 @@
+// { dg-do run { target c++23 } }
+
+#include <format>
+#include <string>
+#include <testsuite_hooks.h>
+#include <tuple>
+#include <utility>
+
+struct NotFormattable
+{};
+
+static_assert( !std::formattable<std::pair<int, NotFormattable>, char> );
+static_assert( !std::formattable<std::tuple<int, NotFormattable, int>, wchar_t> );
+
+template<typename... Args>
+bool
+is_format_string_for(const char* str, Args&&... args)
+{
+  try {
+    (void) std::vformat(str, std::make_format_args(args...));
+    return true;
+  } catch (const std::format_error&) {
+    return false;
+  }
+}
+
+template<typename... Args>
+bool
+is_format_string_for(const wchar_t* str, Args&&... args)
+{
+  try {
+    (void) std::vformat(str, std::make_wformat_args(args...));
+    return true;
+  } catch (const std::format_error&) {
+    return false;
+  }
+}
+
+#define WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
+#define WIDEN(S) WIDEN_(_CharT, S)
+
+void
+test_format_string()
+{
+  // invalid format stringss
+  VERIFY( !is_format_string_for("{:p}", std::tuple<>()) );
+  VERIFY( !is_format_string_for("{:nm}", std::tuple<>()) );
+
+  // 'm' is only valid for 2 elemenst
+  VERIFY( !is_format_string_for("{:m}", std::tuple<>()) );
+  VERIFY( !is_format_string_for("{:m}", std::tuple<int, int, int>()) );
+
+  // element specifier is not supported
+  VERIFY( !is_format_string_for("{::}", std::tuple<>()) );
+
+  // precision is not supported
+  VERIFY( !is_format_string_for("{:.10}", std::tuple<>()) );
+
+  // width needs to be integer type
+  VERIFY( !is_format_string_for("{:{}}", std::tuple<>(), 1.0f) );
+}
+
+template<typename _CharT>
+void test_multi()
+{
+  using Sv = std::basic_string_view<_CharT>;
+  using Str = std::basic_string<_CharT>;
+
+  std::basic_string<_CharT> res;
+  std::size_t size = 0;
+  std::tuple<int, Str, float> t1(1, WIDEN("test"), 2.1);
+
+  res = std::format(WIDEN("{}"), t1);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1))") );
+  res = std::format(WIDEN("{:}"), t1);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1))") );
+  res = std::format(WIDEN("{:n}"), t1);
+  VERIFY( res == WIDEN(R"(1, "test", 2.1)") );
+
+  res = std::format(WIDEN("{:3}"), t1);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1))") );
+
+  res = std::format(WIDEN("{:20}"), t1);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1)    )") );
+
+  res = std::format(WIDEN("{:{}}"), t1, 20);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1)    )") );
+
+  res = std::format(WIDEN("{1:{0}}"), 20, t1);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1)    )") );
+
+  res = std::format(WIDEN("{:^>17}"), t1);
+  VERIFY( res == WIDEN(R"(^(1, "test", 2.1))") );
+
+  res = std::format(WIDEN("{:$<18}"), t1);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1)$$)") );
+
+  res = std::format(WIDEN("{:+^19}"), t1);
+  VERIFY( res == WIDEN(R"(+(1, "test", 2.1)++)") );
+
+  res = std::format(WIDEN("{:|^19n}"), t1);
+  VERIFY( res == WIDEN(R"(||1, "test", 2.1|||)") );
+
+  size = std::formatted_size(WIDEN("{}"), t1);
+  VERIFY( size == Sv(WIDEN(R"((1, "test", 2.1))")).size() );
+
+  size = std::formatted_size(WIDEN("{:3}"), t1);
+  VERIFY( size == Sv(WIDEN(R"((1, "test", 2.1))")).size() );
+
+  size = std::formatted_size(WIDEN("{:20}"), t1);
+  VERIFY( size == 20 );
+
+  std::tuple<int&, Str&, float&> t2 = t1;
+  res = std::format(WIDEN("{}"), t2);
+  VERIFY( res == WIDEN(R"((1, "test", 2.1))") );
+
+  std::tuple<int, int, int, int> t3(1, 2, 3, 4);
+  res = std::format(WIDEN("{}"), t3);
+  VERIFY( res == WIDEN(R"((1, 2, 3, 4))") );
+
+}
+
+template<typename _CharT, typename Tuple>
+void test_empty()
+{
+  std::basic_string<_CharT> res;
+
+  Tuple e1;
+  res = std::format(WIDEN("{}"), e1);
+  VERIFY( res == WIDEN(R"(())") );
+
+  res = std::format(WIDEN("{:}"), e1);
+  VERIFY( res == WIDEN(R"(())") );
+
+  res = std::format(WIDEN("{:n}"), e1);
+  VERIFY( res == WIDEN(R"()") );
+
+  res = std::format(WIDEN("{:^>6}"), e1);
+  VERIFY( res == WIDEN(R"(^^^^())") );
+}
+
+template<typename _CharT, typename Pair>
+void test_pair()
+{
+  using Ft = std::remove_cvref_t<std::tuple_element_t<0, Pair>>;
+  using St = std::remove_cvref_t<std::tuple_element_t<1, Pair>>;
+
+  std::basic_string<_CharT> res;
+
+  Ft f1 = 1;
+  St s1 = WIDEN("abc");
+  Pair p1(f1, s1);
+
+  res = std::format(WIDEN("{}"), p1);
+  VERIFY( res == WIDEN(R"((1, "abc"))") );
+
+  res = std::format(WIDEN("{:}"), p1);
+  VERIFY( res == WIDEN(R"((1, "abc"))") );
+
+  res = std::format(WIDEN("{:m}"), p1);
+  VERIFY( res == WIDEN(R"(1: "abc")") );
+
+  res = std::format(WIDEN("{:|^12m}"), p1);
+  VERIFY( res == WIDEN(R"(||1: "abc"||)") );
+}
+
+template<typename CharT, template<typename, typename> class PairT>
+void test_pair_e()
+{
+  test_pair<CharT, PairT<int, std::basic_string<CharT>>>();
+  test_pair<CharT, PairT<int, const CharT*>>();
+  test_pair<CharT, PairT<const int, std::basic_string<CharT>>>();
+  test_pair<CharT, PairT<int&, std::basic_string<CharT>&>>();
+  test_pair<CharT, PairT<const int&, const std::basic_string<CharT>&>>();
+}
+
+template<typename Pair>
+struct MyPair : Pair
+{
+  using Pair::Pair;
+};
+
+template<typename Pair, typename CharT>
+struct std::formatter<MyPair<Pair>, CharT>
+{
+  constexpr formatter() noexcept
+  {
+    using _CharT = CharT;
+    _formatter.set_brackets(WIDEN("<"), WIDEN(">"));
+    _formatter.set_separator(WIDEN("; "));
+  }
+
+  constexpr std::basic_format_parse_context<CharT>::iterator
+  parse(std::basic_format_parse_context<CharT>& pc)
+  { return _formatter.parse(pc);  }
+
+  template<typename Out>
+  typename std::basic_format_context<Out, CharT>::iterator
+  format(const MyPair<Pair>& mp,
+	 std::basic_format_context<Out, CharT>& fc) const
+  { return _formatter.format(mp, fc); }
+
+private:
+  std::formatter<Pair, CharT> _formatter;
+};
+
+template<typename _CharT, template<typename, typename> class PairT>
+void test_custom()
+{
+  std::basic_string<_CharT> res;
+  MyPair<PairT<int, const _CharT*>> c1(1, WIDEN("abc"));
+
+  res = std::format(WIDEN("{}"), c1);
+  VERIFY( res == WIDEN(R"(<1; "abc">)") );
+
+  res = std::format(WIDEN("{:}"), c1);
+  VERIFY( res == WIDEN(R"(<1; "abc">)") );
+
+  res = std::format(WIDEN("{:n}"), c1);
+  VERIFY( res == WIDEN(R"(1; "abc")") );
+
+  res = std::format(WIDEN("{:m}"), c1);
+  VERIFY( res == WIDEN(R"(1: "abc")") );
+
+  res = std::format(WIDEN("{:|^14}"), c1);
+  VERIFY( res == WIDEN(R"(||<1; "abc">||)") );
+}
+
+template<typename CharT>
+void test_outputs()
+{
+  test_multi<CharT>();
+  test_empty<CharT, std::tuple<>>();
+  test_pair_e<CharT, std::pair>();
+  test_pair_e<CharT, std::tuple>();
+  test_custom<CharT, std::pair>();
+  test_custom<CharT, std::tuple>();
+}
+
+void test_nested()
+{
+  std::string res;
+  std::tuple<std::tuple<>, std::pair<int, std::string>> tt{{}, {1, "abc"}};
+
+  res = std::format("{}", tt);
+  VERIFY( res == R"(((), (1, "abc")))" );
+  res = std::format("{:n}", tt);
+  VERIFY( res == R"((), (1, "abc"))" );
+  res = std::format("{:m}", tt);
+  VERIFY( res == R"((): (1, "abc"))" );
+}
+
+int main()
+{
+  test_format_string();
+  test_outputs<char>();
+  test_outputs<wchar_t>();
+  test_nested();
+}