[NFC][libc++][format] Rename tests.

[Mordante]

Summary

The number of handle based formatters in the Standard increases with new
papers being added. Ideally these papers have their own tests. This
renames the existing tests and adds a common header with elements used
in all test.

[Mordante]

Retrigger CI.

[Mordante]

CI fix.

[ldionne]

This is unusual for our test suite. We normally test by function, not by paper, and I think there is value in keeping consistency here. Is there a reason why this fundamentally can't be done (or is much more complicated to do) with the current organization?

[Mordante]

In D139561#3982491, @ldionne wrote:

This is unusual for our test suite. We normally test by function, not by paper, and I think there is value in keeping consistency here. Is there a reason why this fundamentally can't be done (or is much more complicated to do) with the current organization?

I know this is unusual. I hoped the explanation in the commit message was enough to clarify it.
When the Standard adds new formatters, these have a parse and format member. These can be tested separately, but there should be a test for the interaction. The easiest way to do so is using std::format and std::vformat. Both are needed since std::format tests the constexpr validation and std::vformat the runtime validation.

The current header with tests is about 3000 lines and the test takes quite a bit of time to execute. Adding a lot more tests for the range-based formatters makes running these tests slower, which is quite annoying during development. The current tests have quite a bit of duplicated testing while not adding a lot of extra test coverage. I can't remove them since all format functions should be tested. For the range-based tests I don't feel they need to do all these extra test. (The extra tests are format_to, formatted_to_n, formatted_size and their 'v' partners.)

Next to the C++23 range-based formatter I expect several new library formatters in C++26.

If you disagree of have other suggestions, maybe discuss it during our next meeting.

[ldionne]

Per our discussion just now, I would suggest testing e.g. container formatters in the section of the standard where they are defined, not in the tests for format itself. You could split out some of the commonality into libcxx/test/support.

[Mordante]

In D139561#3992087, @ldionne wrote:

Per our discussion just now, I would suggest testing e.g. container formatters in the section of the standard where they are defined, not in the tests for format itself. You could split out some of the commonality into libcxx/test/support.

I'll look at that in a separate review, abandoning this one for now.

libcxx/test/std/utilities/format/format.functions/P0645.format.locale.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED:gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   string format(const locale& loc, format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(const locale& loc, wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
 #include <iostream>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 auto test =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) constexpr {
       std::basic_string<CharT> out = std::format(std::locale(), fmt, std::forward<Args>(args)...);
       if constexpr (std::same_as<CharT, char>)

libcxx/test/std/utilities/format/format.functions/P0645.format.locale.verify.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   string format(const locale& loc, format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(const locale& loc, wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <locale>
 

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

 // UNSUPPORTED: gcc-12
 
 // Note this formatter shows additional information when tests are failing.
 // This aids the development. Since other formatters fail in the same fashion
 // they don't have this additional output.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   string format(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <iostream>
 #  include <type_traits>
 #endif
 

libcxx/test/std/utilities/format/format.functions/P0645.format.verify.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   string format(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 
 #include "test_macros.h"

libcxx/test/std/utilities/format/format.functions/P0645.format_to.locale.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   Out format_to(Out out, const locale& loc,
 //                 format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, const locale& loc,
 //                 wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 #include "test_iterators.h"
 
 auto test =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) constexpr {
       {

libcxx/test/std/utilities/format/format.functions/P0645.format_to.locale.verify.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   Out format_to(Out out, const locale& loc,
 //                 format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, const locale& loc,
 //                 wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>

libcxx/test/std/utilities/format/format.functions/P0645.format_to.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   Out format_to(Out out, format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 #include "test_iterators.h"
 
 auto test =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) constexpr {
       {

libcxx/test/std/utilities/format/format.functions/P0645.format_to.verify.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // Basic test to validate ill-formed code is properly detected.
 
 // template<class Out, class... Args>
 //   Out format_to(Out out, format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>

libcxx/test/std/utilities/format/format.functions/P0645.format_to_n.locale.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       const locale& loc, format-string<Args...> fmt,
 //                                       const Args&... args);
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       const locale& loc, wformat-string<Args...> fmt,
 //                                       const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 auto test =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) constexpr {
       {
         std::list<CharT> out;

libcxx/test/std/utilities/format/format.functions/P0645.format_to_n.locale.verify.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       const locale& loc, format-string<Args...> fmt,
 //                                       const Args&... args);
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       const locale& loc, wformat-string<Args...> fmt,
 //                                       const Args&... args);

libcxx/test/std/utilities/format/format.functions/P0645.format_to_n.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 auto test = []<class CharT, class... Args>(
                 std::basic_string_view<CharT> expected,
                 test_format_string<CharT, Args...> fmt,
                 Args&&... args) constexpr {
   {

libcxx/test/std/utilities/format/format.functions/P0645.format_to_n.verify.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>

libcxx/test/std/utilities/format/format.functions/P0645.formatted_size.locale.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   size_t formatted_size(const locale& loc,
 //                         format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   size_t formatted_size(const locale& loc,
 //                         wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 auto test =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) constexpr {
       size_t size = std::formatted_size(std::locale(), fmt, std::forward<Args>(args)...);
       assert(size == expected.size());

libcxx/test/std/utilities/format/format.functions/P0645.formatted_size.locale.verify.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   size_t formatted_size(const locale& loc,
 //                         format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   size_t formatted_size(const locale& loc,
 //                         wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>

libcxx/test/std/utilities/format/format.functions/P0645.formatted_size.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   size_t formatted_size(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   size_t formatted_size(wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 auto test =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) constexpr {
       size_t size = std::formatted_size(fmt, std::forward<Args>(args)...);
       assert(size == expected.size());

libcxx/test/std/utilities/format/format.functions/P0645.formatted_size.verify.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class... Args>
 //   size_t formatted_size(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   size_t formatted_size(wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 
 #include "test_macros.h"

libcxx/test/std/utilities/format/format.functions/P0645.tests.h

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
-#define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
+#ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_P0645_TESTS_H
+#define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_P0645_TESTS_H
 
-#include <format>
+// Contains the test for the formatters introduced in the original paper P0645
+// and minor improvements of this paper. The range based formatters are tested
+// in the P2286 tests.
 
 #include <algorithm>
 #include <cassert>
 #include <charconv>
 #include <cmath>
 #include <cstdint>
 #include <iterator>
 
-#include "make_string.h"
 #include "string_literal.h"
 #include "test_macros.h"
+#include "format.functions.common.h"
 
 // In this file the following template types are used:
 // TestFunction must be callable as check(expected-result, string-to-format, args-to-format...)
 // ExceptionTest must be callable as check_exception(expected-exception, string-to-format, args-to-format...)
 
-#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>
-struct context {};
-
-template <>
-struct context<char> {
-  using type = std::format_context;
-};
-
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-template <>
-struct context<wchar_t> {
-  using type = std::wformat_context;
-};
-#endif
-
-template <class T>
-using context_t = typename context<T>::type;
-
 // A user-defined type used to test the handle formatter.
 enum class status : uint16_t { foo = 0xAAAA, bar = 0x5555, foobar = 0xAA55 };
 
 // The formatter for a user-defined type used to test the handle formatter.
 template <class CharT>
 struct std::formatter<status, CharT> {
   int type = 0;
 

 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 template <class TestFunction>
 void format_tests_char_to_wchar_t(TestFunction check) {
   using CharT = wchar_t;
   check(SV("hello 09azA"), SV("hello {}{}{}{}{}"), '0', '9', 'a', 'z', 'A');
 }
 #endif
 
-#endif
+#endif // TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_P0645_TESTS_H

libcxx/test/std/utilities/format/format.functions/P0645.vformat.locale.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // string vformat(const locale& loc, string_view fmt, format_args args);
 // wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
 
 #include <format>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.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 = std::vformat(std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
   assert(out == expected);
 };
 

libcxx/test/std/utilities/format/format.functions/P0645.vformat.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // string vformat(string_view fmt, format_args args);
 // wstring vformat(wstring_view fmt, wformat_args args);
 
 #include <format>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.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 = std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
   assert(out == expected);
 };
 
 auto test_exception =
     []<class CharT, class... Args>(

libcxx/test/std/utilities/format/format.functions/P0645.vformat_to.locale.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out>
 //   Out vformat_to(Out out, const locale& loc, string_view fmt,
 //                  format_args args);
 // template<class Out>
 //    Out vformat_to(Out out, const locale& loc, wstring_view fmt,
 //                   wformat_args args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.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...));
     assert(it == out.end());

libcxx/test/std/utilities/format/format.functions/P0645.vformat_to.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
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-12 status
 // UNSUPPORTED: gcc-12
 
 // <format>
 
+// This tests the formatters introduced in the original paper P0645 and minor
+// improvements of this paper. The range based formatters are tested in the
+// P2286 tests.
+
 // template<class Out>
 //   Out vformat_to(Out out, string_view fmt, format_args args);
 // template<class Out>
 //    Out vformat_to(Out out, wstring_view fmt, wformat_args_t args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
-#include "format_tests.h"
+#include "P0645.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(), fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(it == out.end());

libcxx/test/std/utilities/format/format.functions/format.functions.common.h

+//===----------------------------------------------------------------------===//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_FUNCTIONS_COMMON_H
+#define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_FUNCTIONS_COMMON_H
+
+// Contains the common part of the formatter tests for different papers.
+
+#include <format>
+
+#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>
+struct context {};
+
+template <>
+struct context<char> {
+  using type = std::format_context;
+};
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+template <>
+struct context<wchar_t> {
+  using type = std::wformat_context;
+};
+#endif
+
+template <class T>
+using context_t = typename context<T>::type;
+
+#endif // TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_FUNCTIONS_COMMON_H

libcxx/test/std/utilities/format/format.functions/locale-specific_form.pass.cpp

 #include <format>
 #include <cassert>
 #include <iostream>
 #include <vector>
 
 #include "test_macros.h"
 #include "make_string.h"
 #include "platform_support.h" // locale name macros
-#include "format_tests.h"
+#include "P0645.tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 struct numpunct;