[libc++][format] Addresses LWG3839.

[Mordante]

Summary

LWG3839 range_formatter's set_separator, set_brackets, and
underlying functions should be noexcept

Adds tests for:

template<ranges::input_range R, class charT>
   struct range-default-formatter<range_format::sequence, R, charT>

These were missing, the format functions tests for the sequences
are already present.

[ldionne]

libcxx/docs/Status/Cxx2bIssues.csv

259

Commit message typo: sequenences

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

41–42

You could use declval() and perhaps remove the comment about the SV macro (here and everywhere else)?

[Mordante]

Thanks for the review.

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

41–42

I tried it and I'm not to thrilled by the code. I'll keep it as is. I think the comment is useful, originally I wrote
static_assert(noexcept(formatter.set_separator(SV("sep")))); which failed to compile since the SV macro could throw. Personally I like then to add a comment, to avoid the next developer to step in the same trap. In my experience the next developer is me in a couple of months ;-)

libcxx/docs/Status/Cxx2bIssues.csv

 "`3085 <https://wg21.link/LWG3085>`__","``char_traits::copy`` precondition too weak","February 2023","","",""
 "`3664 <https://wg21.link/LWG3664>`__","`LWG 3392 <https://wg21.link/LWG3392>`__ ``broke std::ranges::distance(a, a+3)``","February 2023","","","|ranges|"
 "`3720 <https://wg21.link/LWG3720>`__","Restrict the valid types of ``arg-id`` for width and precision in ``std-format-spec``","February 2023","","","|format|"
 "`3756 <https://wg21.link/LWG3756>`__","Is the ``std::atomic_flag`` class signal-safe?","February 2023","","",""
 "`3769 <https://wg21.link/LWG3769>`__","``basic_const_iterator::operator==`` causes infinite constraint recursion","February 2023","","","|spaceship|"
 "`3807 <https://wg21.link/LWG3807>`__","The feature test macro for ``ranges::find_last`` should be renamed","February 2023","","","|ranges|"
 "`3811 <https://wg21.link/LWG3811>`__","``views::as_const`` on ``ref_view<T>`` should return ``ref_view<const T>``","February 2023","","","|ranges|"
 "`3820 <https://wg21.link/LWG3820>`__","``cartesian_product_view::iterator::prev`` is not quite right","February 2023","","","|ranges|"
 "`3825 <https://wg21.link/LWG3825>`__","Missing compile-time argument ``id`` check in ``basic_format_parse_context::next_arg_id``","February 2023","","","|format|"
 "`3204 <https://wg21.link/LWG3204>`__","``sub_match::swap`` only swaps the base class","February 2023","|Complete|","17.0",""
 "`3733 <https://wg21.link/LWG3733>`__","``ranges::to`` misuses ``cpp17-input-iterator``","February 2023","","","|ranges|"
 "`3742 <https://wg21.link/LWG3742>`__","``deque::prepend_range`` needs to permute","February 2023","","","|ranges|"
 "`3790 <https://wg21.link/LWG3790>`__","`P1467 <https://wg21.link/P1467>`__ accidentally changed ``nexttoward``'s signature","February 2023","","",""
 "`3819 <https://wg21.link/LWG3819>`__","``reference_meows_from_temporary`` should not use ``is_meowible``","February 2023","","",""
 "`3821 <https://wg21.link/LWG3821>`__","``uses_allocator_construction_args`` should have overload for ``pair-like``","February 2023","","",""
 "`3834 <https://wg21.link/LWG3834>`__","Missing ``constexpr`` for ``std::intmax_t`` math functions in ``<cinttypes>``","February 2023","","",""
-"`3839 <https://wg21.link/LWG3839>`__","``range_formatter``'s ``set_separator``, ``set_brackets``, and ``underlying`` functions should be ``noexcept``","February 2023","","","|format|"
+"`3839 <https://wg21.link/LWG3839>`__","``range_formatter``'s ``set_separator``, ``set_brackets``, and ``underlying`` functions should be ``noexcept``","February 2023","|Complete|","17.0","|format|"
 "`3841 <https://wg21.link/LWG3841>`__","``<version>`` should not be ""all freestanding""","February 2023","","",""
 "`3842 <https://wg21.link/LWG3842>`__","Unclear wording for ``precision`` in ``chrono-format-spec``","February 2023","","","|format|"
 "`3848 <https://wg21.link/LWG3848>`__","``adjacent_view``, ``adjacent_transform_view`` and ``slide_view`` missing ``base`` accessor","February 2023","","","|ranges|"
 "`3849 <https://wg21.link/LWG3849>`__","``cartesian_product_view::iterator``'s default constructor is overconstrained","February 2023","","","|ranges|"
 "`3850 <https://wg21.link/LWG3850>`__","``views::as_const`` on ``empty_view<T>`` should return ``empty_view<const T>``","February 2023","","","|ranges|"
 "`3851 <https://wg21.link/LWG3851>`__","``chunk_view::inner-iterator`` missing custom ``iter_move`` and ``iter_swap``","February 2023","","","|ranges|"
 "`3853 <https://wg21.link/LWG3853>`__","``basic_const_iterator<volatile int*>::operator->`` is ill-formed","February 2023","","",""
 "`3857 <https://wg21.link/LWG3857>`__","``basic_string_view`` should allow explicit conversion when only traits vary","February 2023","|Complete|","17.0",""

libcxx/include/__format/formatter_tuple.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 23
 
 template <__fmt_char_type _CharT, class _Tuple, formattable<_CharT>... _Args>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_tuple {
-  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept {
     __separator_ = __separator;
   }
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
+  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
     __opening_bracket_ = __opening_bracket;
     __closing_bracket_ = __closing_bracket;
   }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __parse_ctx) {
     auto __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_tuple);
 

libcxx/include/__format/range_default_formatter.h

 
 template <ranges::input_range _Rp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::sequence, _Rp, _CharT> {
 private:
   using __maybe_const_r = __fmt_maybe_const<_Rp, _CharT>;
   range_formatter<remove_cvref_t<ranges::range_reference_t<__maybe_const_r>>, _CharT> __underlying_;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept {
     __underlying_.set_separator(__separator);
   }
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
+  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
     __underlying_.set_brackets(__opening_bracket, __closing_bracket);
   }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     return __underlying_.parse(__ctx);
   }
 

libcxx/include/__format/range_formatter.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 23
 
 template <class _Tp, class _CharT = char>
   requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT range_formatter {
-  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept {
     __separator_ = __separator;
   }
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
+  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
     __opening_bracket_ = __opening_bracket;
     __closing_bracket_ = __closing_bracket;
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr formatter<_Tp, _CharT>& underlying() { return __underlying_; }
-  _LIBCPP_HIDE_FROM_ABI constexpr const formatter<_Tp, _CharT>& underlying() const { return __underlying_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr formatter<_Tp, _CharT>& underlying() noexcept { return __underlying_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const formatter<_Tp, _CharT>& underlying() const noexcept { return __underlying_; }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __parse_ctx) {
     auto __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_range);
     auto __end   = __parse_ctx.end();
     if (__begin == __end)
       return __begin;
 

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

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// TODO FMT Fix this test using GCC, it currently times out.
+// UNSUPPORTED: gcc-12
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// template<ranges::input_range R, class charT>
+//   struct range-default-formatter<range_format::sequence, R, charT>
+
+// template<class FormatContext>
+//   typename FormatContext::iterator
+//     format(maybe-const-r& elems, FormatContext& ctx) const;
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <format>
+#include <iterator>
+
+#include "test_format_context.h"
+#include "test_macros.h"
+#include "make_string.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class StringViewT>
+void test_format(StringViewT expected, std::array<int, 2> arg) {
+  using CharT      = typename StringViewT::value_type;
+  using String     = std::basic_string<CharT>;
+  using OutIt      = std::back_insert_iterator<String>;
+  using FormatCtxT = std::basic_format_context<OutIt, CharT>;
+
+  std::formatter<std::array<int, 2>, CharT> formatter;
+
+  String result;
+  OutIt out             = std::back_inserter(result);
+  FormatCtxT format_ctx = test_format_context_create<OutIt, CharT>(out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class CharT>
+void test_fmt() {
+  test_format(SV("[1, 42]"), std::array<int, 2>{{1, 42}});
+  test_format(SV("[0, 99]"), std::array<int, 2>{{0, 99}});
+}
+
+void test() {
+  test_fmt<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_fmt<wchar_t>();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

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

 // UNSUPPORTED: gcc-12
 
 // This test requires the dylib support introduced in D92214.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
-// class range_formatter
-// template<class charT, formattable<charT>... Ts>
-//   struct formatter<pair-or-tuple<Ts...>, charT>
-
-// constexpr void set_separator(basic_string_view<charT> sep);
-
-// Note this tests the basics of this function. It's tested in more detail in
-// the format functions tests.
+// template<ranges::input_range R, class charT>
+//   struct range-default-formatter<range_format::sequence, R, charT>
 
+// template<class ParseContext>
+//   constexpr typename ParseContext::iterator
+//     parse(ParseContext& ctx);
+
+#include <array>
+#include <cassert>
+#include <concepts>
 #include <format>
-#include <tuple>
-#include <utility>
 
+#include "test_format_context.h"
+#include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
-template <class CharT, class Arg>
-constexpr void test() {
-  std::formatter<Arg, CharT> formatter;
-  formatter.set_separator(SV("sep"));
+template <class StringViewT>
+constexpr void test_parse(StringViewT fmt) {
+  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)>);
 
-  // Note there is no direct way to validate this function modified the object.
+  std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 }
 
 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, double>>();
+constexpr void test_fmt() {
+  test_parse(SV(""));
+  test_parse(SV(":5"));
+
+  test_parse(SV("}"));
+  test_parse(SV(":5}"));
 }
 
 constexpr bool test() {
-  test<char>();
+  test_fmt<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
+  test_fmt<wchar_t>();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // UNSUPPORTED: gcc-12
 
 // This test requires the dylib support introduced in D92214.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
-// template<class T, class charT = char>
-//   requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
-// class range_formatter
+// template<ranges::input_range R, class charT>
+//   struct range-default-formatter<range_format::sequence, R, charT>
 
 // constexpr void constexpr void set_brackets(basic_string_view<charT> opening,
-//                                            basic_string_view<charT> closing);
-
-// Note this tests the basics of this function. It's tested in more detail in
-// the format functions test.
+//                                            basic_string_view<charT> closing) noexcept;
 
 #include <format>
 #include <cassert>
 #include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "make_string.h"
 #include "test_format_context.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 constexpr void test_setter() {
-  std::range_formatter<int, CharT> formatter;
+  std::formatter<std::vector<int>, CharT> formatter;
   formatter.set_brackets(SV("open"), SV("close"));
+  // Note the SV macro may throw, so can't use it.
+  static_assert(noexcept(formatter.set_brackets(std::basic_string_view<CharT>{}, std::basic_string_view<CharT>{})));
 
   // Note there is no direct way to validate this function modified the object.
   if (!std::is_constant_evaluated()) {
     using String     = std::basic_string<CharT>;
     using OutIt      = std::back_insert_iterator<String>;
     using FormatCtxT = std::basic_format_context<OutIt, CharT>;
 
     String result;

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

 // UNSUPPORTED: gcc-12
 
 // This test requires the dylib support introduced in D92214.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
-// template<class T, class charT = char>
-//   requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
-// class range_formatter
+// template<ranges::input_range R, class charT>
+//   struct range-default-formatter<range_format::sequence, R, charT>
 
-// constexpr void set_separator(basic_string_view<charT> sep);
-
-// Note this tests the basics of this function. It's tested in more detail in
-// the format functions test.
+// constexpr void set_separator(basic_string_view<charT> sep) noexcept;
 
 #include <format>
 #include <cassert>
 #include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "make_string.h"
 #include "test_format_context.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 constexpr void test_setter() {
-  std::range_formatter<int, CharT> formatter;
+  std::formatter<std::vector<int>, CharT> formatter;
   formatter.set_separator(SV("sep"));
+  // Note the SV macro may throw, so can't use it.
+  static_assert(noexcept(formatter.set_separator(std::basic_string_view<CharT>{})));
 
   // Note there is no direct way to validate this function modified the object.
   if (!std::is_constant_evaluated()) {
     using String     = std::basic_string<CharT>;
     using OutIt      = std::back_insert_iterator<String>;
     using FormatCtxT = std::basic_format_context<OutIt, CharT>;
 
     String result;

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

 
 // <format>
 
 // template<class T, class charT = char>
 //   requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
 // class range_formatter
 
 // constexpr void constexpr void set_brackets(basic_string_view<charT> opening,
-//                                            basic_string_view<charT> closing);
+//                                            basic_string_view<charT> closing) noexcept;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions test.
 
 #include <format>
 #include <cassert>
 #include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "make_string.h"
 #include "test_format_context.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 constexpr void test_setter() {
   std::range_formatter<int, CharT> formatter;
   formatter.set_brackets(SV("open"), SV("close"));
+  // Note the SV macro may throw, so can't use it.
+  static_assert(noexcept(formatter.set_brackets(std::basic_string_view<CharT>{}, std::basic_string_view<CharT>{})));
 
   // Note there is no direct way to validate this function modified the object.
   if (!std::is_constant_evaluated()) {
     using String     = std::basic_string<CharT>;
     using OutIt      = std::back_insert_iterator<String>;
     using FormatCtxT = std::basic_format_context<OutIt, CharT>;
 
     String result;

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
 // template<class T, class charT = char>
 //   requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
 // class range_formatter
 
-// constexpr void set_separator(basic_string_view<charT> sep);
+// constexpr void set_separator(basic_string_view<charT> sep) noexcept;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions test.
 
 #include <format>
 #include <cassert>
 #include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "make_string.h"
 #include "test_format_context.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 constexpr void test_setter() {
   std::range_formatter<int, CharT> formatter;
   formatter.set_separator(SV("sep"));
+  // Note the SV macro may throw, so can't use it.
+  static_assert(noexcept(formatter.set_separator(std::basic_string_view<CharT>{})));
 
   // Note there is no direct way to validate this function modified the object.
   if (!std::is_constant_evaluated()) {
     using String     = std::basic_string<CharT>;
     using OutIt      = std::back_insert_iterator<String>;
     using FormatCtxT = std::basic_format_context<OutIt, CharT>;
 
     String result;

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
 // template<class T, class charT = char>
 //   requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
 // class range_formatter
 
-// constexpr formatter<T, charT>& underlying();
-// constexpr const formatter<T, charT>& underlying() const;
+// constexpr formatter<T, charT>& underlying() noexcept;
+// constexpr const formatter<T, charT>& underlying() const noexcept;
 
 #include <concepts>
 #include <format>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test_underlying() {
   {
     std::range_formatter<int, CharT> formatter;
     [[maybe_unused]] std::same_as<std::formatter<int, CharT>&> decltype(auto) underlying = formatter.underlying();
+    static_assert(noexcept(formatter.underlying()));
   }
   {
     const std::range_formatter<int, CharT> formatter;
     [[maybe_unused]] std::same_as<const std::formatter<int, CharT>&> decltype(auto) underlying = formatter.underlying();
+    static_assert(noexcept(formatter.underlying()));
   }
 }
 
 constexpr bool test() {
   test_underlying<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_underlying<wchar_t>();
 #endif

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
 // template<class charT, formattable<charT>... Ts>
 //   struct formatter<pair-or-tuple<Ts...>, charT>
 
 // constexpr void constexpr void set_brackets(basic_string_view<charT> opening,
-//                                            basic_string_view<charT> closing);
+//                                            basic_string_view<charT> closing) noexcept;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions tests.
 
 #include <format>
 #include <tuple>
 #include <utility>
 
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT, class Arg>
 constexpr void test() {
   std::formatter<Arg, CharT> formatter;
   formatter.set_brackets(SV("open"), SV("close"));
+  // Note the SV macro may throw, so can't use it.
+  static_assert(noexcept(formatter.set_brackets(std::basic_string_view<CharT>{}, std::basic_string_view<CharT>{})));
 
   // Note there is no direct way to validate this function modified the object.
 }
 
 template <class CharT>
 constexpr void test() {
   test<CharT, std::tuple<int>>();
   test<CharT, std::tuple<int, CharT>>();

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
 
 // <format>
 
 // class range_formatter
 // template<class charT, formattable<charT>... Ts>
 //   struct formatter<pair-or-tuple<Ts...>, charT>
 
-// constexpr void set_separator(basic_string_view<charT> sep);
+// constexpr void set_separator(basic_string_view<charT> sep) noexcept;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions tests.
 
 #include <format>
 #include <tuple>
 #include <utility>
 
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT, class Arg>
 constexpr void test() {
   std::formatter<Arg, CharT> formatter;
   formatter.set_separator(SV("sep"));
+  // Note the SV macro may throw, so can't use it.
+  static_assert(noexcept(formatter.set_separator(std::basic_string_view<CharT>{})));
 
   // Note there is no direct way to validate this function modified the object.
 }
 
 template <class CharT>
 constexpr void test() {
   test<CharT, std::tuple<int>>();
   test<CharT, std::tuple<int, CharT>>();