[lib++][format] Uses the new exception test macros.

[Mordante]

Rebased to test CI.

libcxx/test/std/containers/container.adaptors/container.adaptors.format/format.functions.vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch (const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/vector.bool.fmt/format.functions.vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch (const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat.locale.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch ([[maybe_unused]] const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char, execution_modus::full>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t, execution_modus::full>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch ([[maybe_unused]] const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char, execution_modus::full>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t, execution_modus::full>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat_to.locale.pass.cpp

 //                   wformat_args args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
-#include "test_macros.h"
+#include "assert_macros.h"
+#include "concat_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
 
 auto test = []<class CharT, class... Args>(
                 std::basic_string_view<CharT> expected, std::basic_string_view<CharT> fmt, Args&&... args) constexpr {
   {
     std::basic_string<CharT> out(expected.size(), CharT(' '));
     auto it = std::vformat_to(out.begin(), std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
auto test = []<class CharT, class... Args>(
     CharT out[4096];
     CharT* it = std::vformat_to(out, std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(std::distance(out, it) == int(expected.size()));
     // Convert to std::string since output contains '\0' for boolean tests.
     assert(std::basic_string<CharT>(out, it) == expected);
   }
 };
 
-auto test_exception =
-    []<class CharT, class... Args>(
-        [[maybe_unused]] std::string_view what,
+auto test_exception = []<class CharT, class... Args>([[maybe_unused]] std::string_view what,
                                                      [[maybe_unused]] std::basic_string_view<CharT> fmt,
                                                      [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
+  TEST_VALIDATE_EXCEPTION(
+      std::format_error,
+      [&]([[maybe_unused]] const std::format_error& e) {
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED(
+                "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      [&] {
         std::basic_string<CharT> out;
         std::vformat_to(std::back_inserter(out), std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
-        assert(false);
-      } catch ([[maybe_unused]] const std::format_error& e) {
-        LIBCPP_ASSERT(e.what() == what);
-        return;
-      }
-      assert(false);
-#endif
-    };
+      }());
 
 int main(int, char**) {
   format_tests<char, execution_modus::partial>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t, execution_modus::partial>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat_to.pass.cpp

 //    Out vformat_to(Out out, wstring_view fmt, wformat_args_t args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
+#include "assert_macros.h"
+#include "concat_macros.h"
 #include "test_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
 
 auto test = []<class CharT, class... Args>(
                 std::basic_string_view<CharT> expected, std::basic_string_view<CharT> fmt, Args&&... args) constexpr {
   {
     std::basic_string<CharT> out(expected.size(), CharT(' '));
auto test = []<class CharT, class... Args>(
   }
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
+            TEST_LIBCPP_REQUIRE(
+                e.what() == what,
+                TEST_WRITE_CONCATENATED(
+                    "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+          },
+          [&] {
             std::basic_string<CharT> out;
             std::vformat_to(std::back_inserter(out), fmt, std::make_format_args<context_t<CharT>>(args...));
-        assert(false);
-      } catch ([[maybe_unused]] const std::format_error& e) {
-        LIBCPP_ASSERT(e.what() == what);
-        return;
-      }
-      assert(false);
-#endif
+          }());
     };
 
 int main(int, char**) {
   format_tests<char, execution_modus::partial>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t, execution_modus::partial>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.range/format.range.fmtmap/format.functions.vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch (const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.range/format.range.fmtset/format.functions.vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch (const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.range/format.range.formatter/format.functions.vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch (const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.pass.cpp

TEST_REQUIRE(out == expected,
                    "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(TEST_WRITE_CONCATENATED("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch ([[maybe_unused]] const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
                 TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   run_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   run_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }