[libc++][format] Implement formatters.

[Mordante]

Summary

This implements the initial version of the std::formatter class and its specializations. It also implements the following formatting functions:

• format
• vformat
• format_to
• vformat_to
• format_to_n
• formatted_size

All functions have a char and wchar_t version. Parsing the format-spec and
using the parsed format-spec hasn't been implemented. The code isn't optimized,
neither for speed, nor for size.

The goal is to have the rudimentary basics working, which can be used as a
basis to improve upon. The formatters used in this commit are simple stubs that
will be replaced by real formatters in later commits.

The formatters that are slated to be replaced in this patch series don't have
an availability macro to avoid merge conflicts.

Note the formatter for bool uses 0 and 1 instead of "false" and
"true". This will be fixed when the stub is replaced with a real
formatter.

Implements parts of:

• P0645 Text Formatting

Completes:

• LWG3539 format_to must not copy models of output_iterator<const charT&>

[Mordante]

Removed iterator_different_t work-around
Use proper constrain in vformat_to (_CharT instead of char)
Polishing

[vitaut]

Overall looks good, some comments inline.

libcxx/include/__format/format_string.h

39

I would recommend using a struct with meaningful field names instead of a pair. In addition to making the code more readable it would remove dependency on utility.

68

Is it even possible to have 1 billion arguments to a function? I don't think so and therefore this should probably be an assert instead of an exception.

92–94

The limit of 999.999.999 is OK for an argument ID but is unnecessarily restrictive for width and precision. {fmt} supports any nonnegative int value and so do common printf implementations (almost, some of them don't handle INT_MAX, but they do handle values >= 1,000,000,000: https://godbolt.org/z/Esb9e6Wxh).

Having such limit will make migration from printf and other formatting facilities more difficult, please remove or make sure that it's only used for argument IDs.

123

I suggest changing "argument" to "character" to avoid confusion with formatting arguments and since individual characters are not really arguments, pointers to them are.

141

nit: format-spec is a syntactic construct (http://eel.is/c++draft/format#string.general-1) so I suggest not capitalizing it or rephrasing the error message altogether (e.g. "Invalid character in arg-id" if it's common to have exception messages capitalized).

libcxx/include/__format/formatter.h

35

"is not conform" -> "does not conform to"

libcxx/include/format

68

string_view should be replaced with format_string<Args...> per http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2216r3.html but I guess it can be done in a separate diff.

345

Why add this instead of implementing parse/format in formatter specialization directly?

612

typo: sequence

626

Looks like the meaning is negated here, this is exactly when we do have format-specifier.

639

Arguments should be passed by value since they are cheap to copy. Then decay_t will probably be unnecessary.

773

What does PoC stand for?

libcxx/test/std/utilities/format/format.functions/tests.inc

114

party -> partly throughout the diff

129–131

You probably know that but the default format is wrong. The output should be 42 without decimal point or trailing zeros.

[vitaut]

libcxx/include/__format/format_string.h

112–114

I don't think this error is correct. For example, you could have a format-spec consisting of a single width passed to formatter::parse function which should handle it without an error.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

13–17 ↗

(On Diff #349177)

I'm not sure how to parse this comment. Is something missing here?

65–66 ↗

(On Diff #349177)

These should be "true" and "false", not "1" and "0".

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

66 ↗

(On Diff #349177)

Might be worth testing a string with embedded NUL to make sure that we format until the first NUL rather than the whole string.

[Mordante]

Thanks for the review! I see two major changes to be done:

• Allowing the format-spec to accept the end-of-input as a valid termination.
• Increment the maximum value for width and precision.

These changes will affect the patches depending on this patch.
Before updating this patch I first want to update all affected patches.

libcxx/include/__format/format_string.h

68

Good point.

92–94

I expected 999.999.999 to be large enough. I still think formatting this number of characters isn't realistic. But since printf supports it I agree it would be good to allow this number here. This change will affect more patches depending on this one.

112–114

I see I originally interpretted http://eel.is/c++draft/format#formatter.requirements-2.7 differently.

Parses format-spec ([format.string]) for type T in the range [pc.begin(), pc.end()) until the first unmatched character.
Throws format_­error unless the whole range is parsed or the unmatched character is }.

I thought throwing here was valid, but rereading it, I agree with your interpretation.

libcxx/include/format

68

Yes P2216 will be done later.

773

Proof-of-concept.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

13–17 ↗

(On Diff #349177)

This is part of the standard wording of the part tested.

65–66 ↗

(On Diff #349177)

Correct, that will be done in D103670. It's part of the commit message that this is a temporary version.

libcxx/test/std/utilities/format/format.functions/tests.inc

129–131

Yes this should be fixed once I add proper floating-point support.

[vitaut]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

13–17 ↗

(On Diff #349177)

The confusing to me part is that "a specialization" appears twice. I suggest replacing a specialization template<> struct formatter<ArithmeticT, charT>; with template<> struct formatter<ArithmeticT, charT>;

[• Quuxplusone]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

13–17 ↗

(On Diff #349177)

Not to mention, "Implemants" on line 16 definitely isn't standard wording, and line 17 seems to be starting a bulleted list with only one item in it. I think this comment is meant to refer to https://eel.is/c++draft/format.formatter.spec#2.3 and so it should say:

// [format.formatter.spec]:
// Each header that declares the template `formatter` provides the following enabled specializations:
// For each `charT`, for each cv-unqualified arithmetic type `ArithmeticT` other than
// char, wchar_­t, char8_­t, char16_­t, or char32_­t, a specialization
//    template<> struct formatter<ArithmeticT, charT>
//
// This file tests with `ArithmeticT=bool`, for each valid `charT`.

29–43 ↗

(On Diff #349177)

I'd find this easier to read:

template <class StringT, class ArithmeticT>
void test(StringT expected, StringT fmt, ArithmeticT arg) {
  using CharT = typename StringT::value_type;
  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
  std::formatter<bool, CharT> formatter;
  formatter.parse(parse_ctx);

  StringT result;
  auto out = std::back_inserter(result);
  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;

  auto format_ctx = FormatCtxT(out, std::make_format_args<FormatCtxT>(arg));
  formatter.format(arg, format_ctx);
  assert(result == expected);
}

And then, if ArithmeticT is always bool, I strongly recommend making the substitution. Otherwise, you're implicitly relying on template type deduction down in main to deduce bool from true and false — which is obviously not-too-bad in this case, but you're going to have to use a different strategy once you reach the formatter for short. So I recommend switching strategies right now, in order to be consistent across all the new test files.

template <class StringT>
void test(StringT expected, StringT fmt, bool arg) {

(and then the rest as above)

59–62 ↗

(On Diff #349177)

These asserts seem non-standard: I mean, I would by default assume there's no legal guarantee that &F::parse compiles at all. parse might be a template or overload set.
@vitaut , what's your understanding and/or intent here? Are user-programmers supposed to be able to take member pointers to the parse and format callables like this? (I hope not!)

[vitaut]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

59–62 ↗

(On Diff #349177)

IIRC users have no right to rely on specific signatures of functions in std so I would recommend deleting these over-specified asserts.

[Mordante]

I'm still working on the removal of the 999.999.999 in the underlaying patches. It causes quite a bit of changes.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

13–17 ↗

(On Diff #349177)

I overlooked the double specialization. I'll adjust the text.

59–62 ↗

(On Diff #349177)

I'll remove them.

[Mordante]

libcxx/include/format

345

Not entirely sure what you mean, but this stub class will be removed in D103466.

626

Good catch.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

29–43 ↗

(On Diff #349177)

I used most of this suggestion and updated the other tests as well. In this case I prefer to not add another layer of indirection, instead I replaced the template argument ArithmeticT with a bool.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

66 ↗

(On Diff #349177)

I like this suggestion. I also added them to the other string types where the NUL is allowed.

[Mordante]

Addresses review comments:

• Increment the allowed width and precision to INT32_MAX
• Improve the unit tests
• Remove usage of std::pair
• Don't require the replacement field to end at a '}'
• Several minor cleanups and fixes

[Mordante]

Disable failing unit tests on GCC.

[• Quuxplusone]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

29–43 ↗

(On Diff #349177)

LGTM! Btw, @vitaut, is this really the most ergonomic way to fit all these puzzle pieces together? I know this isn't the "expected way to use <format>," because the expected way is just std::format("{}", arg)... but this code feels very loop-de-loopy even for internal implementation stuff.

std::formatter<bool, CharT> formatter;
    // ok cool so this knows how to format bools?
auto format_ctx = FormatCtxT(out, std::make_format_args<FormatCtxT>(arg));
    // we're passing in `arg` here, so now it's formatted?
formatter.format(arg, format_ctx);
    // no, ok, pass in `arg` AGAIN, third time's the charm!

52–55 ↗

(On Diff #354742)

This was a vestige of the time when the C++20 concepts weren't in trunk yet, right?
I believe every instance of this pattern should be replaced with a one-liner:

static_assert(std::semiregular<std::formatter<bool, CharT>>);
test(...

In fact, consider moving the assertion up into test, where you already have a variable of the correct type, so you could just say

static_assert(std::semiregular<decltype(formatter)>);

and wouldn't have to worry about typos potentially introduced by faulty cut-and-paste.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

47–55 ↗

(On Diff #354742)

pointer is rightly named but unnecessary; you could just requires is_pointer_v<CharPtr> (or in fact do nothing at all, because this function doesn't need to be constrained for any technical reason). object is misnamed, since it is significantly different from std::is_object_v (but also, it's unused). Write instead:

template<class CStringT>
void test() {
    using CharT = std::remove_cv_t<std::remove_pointer_t<CStringT>>;
        // alternatively, = std::iter_value_t<CStringT>;
    static_assert(std::semiregular<std::formatter<CStringT, CharT>>);
    test<CStringT>(STR(" azAZ09,./<>?"), STR("}"), CSTR(" azAZ09,./<>?"));

    std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
    test<CStringT>(STR("abc"), STR("}"), s.c_str());
}

I think what I've got for the embedded-NUL test ought to work. I have not tried it.

80–88 ↗

(On Diff #354742)

I strongly recommend flattening these:

int main(int, char**) {
  test<char*>();
  test<const char*>();
  test<wchar_t*>();
  test<const wchar_t*>();
}

Even if you don't flatten them, at least use different names for test (the actual test) and test (the thing that calls test twice). I don't know our convention off the top of my head, but I know libcxx/test/ has plenty of examples of this to set naming precedent.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.const_char_array.pass.cpp

55–60 ↗

(On Diff #354742)

I think what you want here is

std::formatter<ArrayT, CharT> formatter;
  [...]
CharT array[N];
std::copy(text, text + N, array);
ArrayT& arg = array;
auto format_ctx = FormatCtxT(std::back_inserter(result), std::make_format_args<FormatCtxT>(arg));
formatter.format(arg, ctx);

Note consistent use of the names FormatCtxT, arg, etc. among all the test cases.
I admit I don't understand why you're doing the weird thing with the class-type NTTP Tester here; couldn't you just hard-code N in the test case? We don't need to "deduce the size of the input" when there is only one input. And then you can get rid of a lot of "magic" — no more CTAD/CNTTPs, no more __builtin_memcpy, etc.

libcxx/test/std/utilities/format/format.functions/tests.inc

28–33

IIUC, these tests are testing the wording of libc++-specific what-strings that are not mandated by the Standard, is that right? If so, they belong in libcxx/test/libcxx/.
Or perhaps it would be better to leave the tests here, but put every instance of assert(e.what() == what) under a libc++-specific #ifdef. That way, on non-libc++ libraries, we'd test that some exception was correctly thrown; we just wouldn't test its what-string.

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

37–42

Please don't provide ==s for library types, not even in .cpp files. In this case your initial size check can be omitted anyway, because std::equal can do it: just change e.g. line 68 to

assert(std::equal(out.begin(), out.end(), expected.begin(), expected.end()));

[Mordante]

Thanks for all the review comments!

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

29–43 ↗

(On Diff #349177)

I agree this example is quite verbose, but in the format function it isn't that ugly. There the parsing and formatting for an argument looks like

formatter<decltype(__arg), _CharT> __formatter;
__parse_ctx.advance_to(__formatter.parse(__parse_ctx));
__ctx.advance_to(__formatter.format(__arg, __ctx));

52–55 ↗

(On Diff #354742)

This was a vestige of the time when the C++20 concepts weren't in trunk yet, right?

Correct!

I believe every instance of this pattern should be replaced with a one-liner:

static_assert(std::semiregular<std::formatter<bool, CharT>>);
test(...

Good point, this indeed seems to be the case.

In fact, consider moving the assertion up into test, where you already have a variable of the correct type, so you could just say

static_assert(std::semiregular<decltype(formatter)>);

and wouldn't have to worry about typos potentially introduced by faulty cut-and-paste.

This seems to be the only one using a hard-coded type instead of template arguments. But avoiding possible copy-paste issues always is a good thing(tm). Especially now the four static_asserts can be replaced by just one.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

47–55 ↗

(On Diff #354742)

pointer is rightly named but unnecessary; you could just requires is_pointer_v<CharPtr> (or in fact do nothing at all, because this function doesn't need to be constrained for any technical reason). object is misnamed, since it is significantly different from std::is_object_v

This point is no longer needed, since I flattened the tests as you suggested in another comment.

(but also, it's unused). Write instead:

template<class CStringT>
void test() {
    using CharT = std::remove_cv_t<std::remove_pointer_t<CStringT>>;
        // alternatively, = std::iter_value_t<CStringT>;
    static_assert(std::semiregular<std::formatter<CStringT, CharT>>);

This one is move to the real tester using the decltype as you suggested.

test<CStringT>(STR(" azAZ09,./<>?"), STR("}"), CSTR(" azAZ09,./<>?"));

std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
test<CStringT>(STR("abc"), STR("}"), s.c_str());

}

I think what I've got for the embedded-NUL test ought to work. I have not tried it.

That's actually a nice looking method, thanks for the suggestion!
I tested it and it passes the tests locally.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.const_char_array.pass.cpp

55–60 ↗

(On Diff #354742)

The formatter type is template<size_t N> struct formatter<const charT[N], charT>; The size of N isn't fixed in this test and future tests in the series add more sizes. Since this works I prefer to keep it like this.

I can have a look at the consistency, but the tests already have some minor differences between them.

libcxx/test/std/utilities/format/format.functions/tests.inc

28–33

I guarded them with #ifdef _LIBCPP_VERSION. I prefer to keep them since they've been a great aid during debugging and verification.

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

37–42

I'm not objecting against this change, but what's the reason you done like operator== for library types?

[Mordante]

Addresses review comments.

[• Quuxplusone]

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

37–42

Combination of two premises:
(1) Users shouldn't add operator== for types they don't own, and users don't own STL types. (If someone filed a bug report and attached this code, saying "libc++ misbehaves if I add my own operator== between vector and string!"— well, we'd just close it as NOTABUG, right?)
(2) The libc++ test suite should contain only such code as our users might legitimately write. Otherwise what would we really be testing here?— we'd be testing that libc++ works if the user provides an operator== between vector and string— but literally no real user ever does that, nor are they allowed to do it, so testing that configuration isn't meaningful. Or at least the test isn't as meaningful as it could be.

I suspect the controversial premise is more likely (2) than (1), but anyway I tried to explain both; and I think you'd agree that if you accept both (1) and (2), then it follows that the libc++ test suite shouldn't add extra operator==s for STL types.

[Mordante]

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

37–42

Thanks for the information. I fully agree with (2). However I wasn't aware that (1) is a rule. I've seen operator overloading for standard library types quite often, for example operator<< for the stream objects.

Even if don't fully agree with (1) I still feel your solution of using a standard algorithm is better then writing the operator overload.

[Mordante]

Rebase.
Use new monostate header.
Use LIBCPP_ASSERT.

[vitaut]

Looks great, just a few nits inline. Accepting the diff mostly as a reminder for myself that I've already looked at it.

libcxx/include/__format/format_string.h

100–101

This could be a static assert.

libcxx/include/__format/formatter.h

37

nit: "conform" -> "conform to"

libcxx/include/format

608

nit: I'd call it __handle_replacement_field for consistency with the standard naming.

687

I would call it something like "unmatched '}'" rather than "an invalid escape sequence" because we don't know whether the intent was to have an escape sequence.

[vitaut]

libcxx/include/format

706

I don't think you need to pass __args.__size() here because it is for compile-time checks only.

820

same here

[vitaut]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

38 ↗

(On Diff #357274)

I'd add a check that the return value points to the end of the format string here and elsewhere.

51–52 ↗

(On Diff #357274)

I'd test that empty string is also parsed correctly which is an important corner case.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.pass.cpp

58 ↗

(On Diff #357274)

Why do you have "}" in other tests and "{}" here?

[Mordante]

Thanks a lot for your review!

libcxx/include/__format/format_string.h

100–101

Good catch!

libcxx/include/format

687

I like your reasoning, I've changed it.

706

But doesn't that mean I need to add it again when I start working on P2216?

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

38 ↗

(On Diff #357274)

AFAIK this doesn't need to point to the end of the format string. Based on earlier comments and wording of http://eel.is/c++draft/format#tab:formatter

Parses format-spec ([format.string]) for type T in the range [pc.begin(), pc.end()) until the first unmatched character.
Throws format_­error unless the whole range is parsed or the unmatched character is }.
[Note 1: This allows formatters to emit meaningful error messages.
— end note]
Stores the parsed format specifiers in *this and returns an iterator past the end of the parsed range.

I made changes to this function. It now either returns an iterator to fmt.end() or an iterator at the closing } of the replacement-field.

51–52 ↗

(On Diff #357274)

In other patches, for example` D103433. I added an extra layer to test both "}" and "" from one tester. I applied the same method to the tests in this directory. I also changed the names of the test functions to not use the overload resolution to pick the proper function. When we're happy with that approach I'll use these improvements for later patches in the series.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.pass.cpp

58 ↗

(On Diff #357274)

This should also be "}", this was an older approach. The floats haven't had as much love as the other implemented types yet. (Mainly since for floats I still need to get std::to_chars working properly.)

[Mordante]

Addresses the review comments.

[Mordante]

Rebase, hopefully fixes Arm builds.
Fixes UB in tests detected by the debug and UBSAN builds.

[vitaut]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

38 ↗

(On Diff #357274)

Good point.

29–43 ↗

(On Diff #349177)

is this really the most ergonomic way to fit all these puzzle pieces together?

Looks OK to me since it's only a test . These are rarely used in user code, mostly when reusing formatters which is much easier.

[Mordante]

rebased
updated to changes in the std::basic_format_context
Mark some test libc++ only
Use private module headers

[Mordante]

Guard unit tests for implementation details

[Mordante]

libcxx/include/__format/format_string.h

47

s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/ here and all other occurrences in this patch.

[Mordante]

s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/
Guard better against ADL
Move internal unit tests
Generate private module tests
Disable the floating-point stub, since the series has no replacement

[• Quuxplusone]

libcxx/include/__format/format_string.h

131

s/values/value/
and please don't line-break

libcxx/include/format

452

s/128 bit/128-bit/g

630–631

Style tip: When you break the line like this, it makes it harder for a maintainer to git grep __throw_format_error.*terminate when they're trying to track down where a given error was thrown. (Although line-breaking in the middle of a string is of course infinitely worse!)
In this case there's no reason to line-break at all; just join lines 630 and 631. Ideally, every single time you throw a format_error, it'll be on a line of the form

[ ]*__throw_format_error(".*");

(Tangent: I would not object if you made it _VSTD::__throw_format_error throughout. You're right that the string literal won't trigger ADL, so ADL-proofing isn't necessary; but it might help visually distinguish this free function from a member function.)

648

/misses the/is missing a/

658–659

• Don't break in the middle of this error message.
• This function is called in only two places; I recommend inlining it in those places. Then you can improve the message by customizing it to the specific situation being parsed.
• If you do keep it as a free function (which I don't recommend), please _VSTD:: its calls, and consider giving it a name that (1) doesn't look so much like the uglified version of std::next, (2) involves the word format.

687

s/charater/character/

692–693

Lines 692, 677, 657: I question the usefulness of these [[unlikely]] attributes. Compilers are generally very good at determining that the throwing path is the unlikely path, already; and this seems like cluttering up our code for no practical purpose.
(Ditto [[nodiscard]] on non-user-visible functions, such as on lines 45, 63, 70, 80; ditto noexcept on non-user-visible functions that are never evaluated for noexceptness; ditto constexpr on non-user-visible-functions that are never called in a constexpr context.)

[Mordante]

Thanks for the review comments!

libcxx/include/format

630–631

This change is automatically done by clang-format since I've still limited it to 80 characters instead of 120 as our official standard is. This since parts of this series were written before the limit was adjusted. After all outstanding patches are merged I want to apply our real coding style with clang-format, this will fix it. I don't want to do that now, since it will result in merge conflicts.

I don't mind using _VSTD::__throw_format_error but currently all calls to __throw_xxx functions use this style. So when I change it here I want to create a separate patch to do the rest of our code base. @ldionne what's your preference?

648

I changed it to 'misses a', this is more in line with the other messages in this file.

658–659

Again this is what clang-format does. When we don't like it we should adjust its settings to the format we want.
Originally this function was used in more places, but addressing other review comments reduced the number of use cases.
With only two users it indeed seems better to inline them. This allows for a small code improvement at the second call site.

692–693

I wasn't aware compilers already optimize the throwing path as unlikely. I tested it on compiler explorer and it indeed seems to be the case.
I like [[nodiscard]] for two reasons:

• It avoids accidental bugs by not evaluating.
• Documents the intended usage.

Even if a function isn't used in constexpr context it can be useful. I've used it during testing and suddenly UB became a compilation error.

So I don't consider [[nodiscard]], noexcept and constexpr as clutter.

[Mordante]

Addresses review comments.

[Mordante]

libcxx/include/format

692–693

I had a talk with @ldionne and he also prefers to remove the extra [[nodiscard]]s. He mention they've also been removed in the ranges code, which previously used the same style as I did here. So we agreed to remove them.

[Mordante]

Rebased on main and updated to work against main.
Remove [[nodiscard]]s

[ldionne]

Got a few comments on the tests, but apart from that this mostly LGTM. I'm assuming that the several TODOs are handled in subsequent patches.

libcxx/include/__format/formatter.h

52

Why is this _LIBCPP_HIDDEN and not _LIBCPP_HIDE_FROM_ABI?

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

12

You can remove mentions of gcc-10 everywhere now.

Also, it would be great to have a comment explaining why this is unsupported on gcc-11 (in all places where you do that).

libcxx/test/std/utilities/format/format.functions/tests.inc

19

Instead of using this inclusion technique, I would rather see this done this way:

// 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...)
template <class CharT, class TestFunction, class ExceptionTest>
void format_tests(TestFunction check, ExceptionTest check_exception) {
  check(STR("hello 01"), STR("hello {0:}{1:}"), false, true);
  // ...
}

Then, from the various tests, you can do:

#include "format_tests.h"

auto test = []<class CharT, class... Args>(std::basic_string<CharT> expected, std::basic_string<CharT> fmt, const Args&... args) {
  // ...
};

auto test_exception = []<class CharT, class... Args>(std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
  // ...
};

int main(int, char**) {
  format_tests<char>(test, test_exception);
  format_tests<wchar_t>(test, test_exception);

  return 0;
}

IMO this is a less surprising way to reuse code and that makes it easier to understand what's happening when you look at the test in isolation. WDYT?

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

43

This should be TEST_HAS_NO_EXCEPTIONS (elsewhere too).

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

25

Those comments are not especially useful IMO, we could remove them altogether.

[Mordante]

In D96664#2975281, @ldionne wrote:

Got a few comments on the tests, but apart from that this mostly LGTM. I'm assuming that the several TODOs are handled in subsequent patches.

Part of them will be done in the patches in this series. Others will be done in not yet finished patches. But the intention is to solve them all before marking the <format> header as complete.

libcxx/include/__format/formatter.h

52

Not sure, but fixed it.

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

12

I need to investigate why gcc-11 doesn't work. I've added a TODO to look at it later. I'll need to update one of my systems so I have gcc-11 locally which makes testing easier.

libcxx/test/std/utilities/format/format.functions/tests.inc

2

This file is obsolete and should be removed. I prefer to keep this file a little bit longer. This will make it a lot easier to migrate the other patches in the series to the new format_tests.h. Once that migration is done this file can be removed.

19

I like this solution a lot! Thanks for the suggestion.

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

25

I feel they are useful due to the usage of the tests.inc. But since that file will be replaced with your suggested format_tests.h I agree that they are not needed.

[Mordante]

Rebased.
Addresses review comments.

[Mordante]

Guard against min/max macros.

[ldionne]

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

12

FWIW, you can use our Docker image to match the CI environment if you'd like:

./libcxx/utils/ci/run-buildbot-container # this will run libc++'s Docker image that we use in CI, which contains GCC 11 amongst other things
$ ./libcxx/utils/ci/run-buildbot generic-gcc # run this from the Docker image

libcxx/test/std/utilities/format/format.functions/tests.inc

2

It's very unusual to approve patches with these sorts of artifacts, let's make this an exception.

[Mordante]

libcxx/test/std/utilities/format/format.functions/tests.inc

2

Thanks. That really helped to migrate the other patches to the new format_tests.h without introducing merge conflicts in the process.

[vitaut]

libcxx/include/format

739

I know this diff has already landed but you definitely don't want to inline the top-level "v" functions such as vformat to reduce per-call code bloat (see e.g. https://godbolt.org/z/f8c1P5bP5).

[Mordante]

libcxx/include/format

739

Correct. I haven't spend much time reducing the the code bloat, but it's on my TODO list. At the moment I'm focusing on implementing the papers and LWG-issues. (Actually I'm working on reducing the code bloat required by P2216 ;-))

I added this remark to my TODO list.

libcxx/docs/ReleaseNotes.rst

 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 13.0.0?
 ============================
 
 New Features
 ------------
 
-- ...
+- There's initial support for the C++20 header ``<format>``. The implementation
+  is incomplete. Some functions are known to be inefficient; both in memory
+  usage and performance. The implementation is considered experimental and isn't
+  considered ABI stable.
 
 API Changes
 -----------
 
 - There has been several changes in the tuple constructors provided by libc++.
   Those changes were made as part of an effort to regularize libc++'s tuple
   implementation, which contained several subtle bugs due to these extensions.
   If you notice a build breakage when initializing a tuple, make sure you

libcxx/include/CMakeLists.txt

set(files
   __debug
   __errc
   __format/format_arg.h
   __format/format_args.h
   __format/format_context.h
   __format/format_error.h
   __format/format_fwd.h
   __format/format_parse_context.h
+  __format/format_string.h
+  __format/formatter.h
   __function_like.h
   __functional_base
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind_front.h
   __functional/bind.h
   __functional/binder1st.h
   __functional/binder2nd.h

libcxx/include/__format/format_string.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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 _LIBCPP___FORMAT_FORMAT_STRING_H
+#define _LIBCPP___FORMAT_FORMAT_STRING_H
+
+#include <__config>
+#include <__debug>
+#include <__format/format_error.h>
+#include <cstddef>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// TODO FMT Remove this once we require compilers with proper C++20 support.
+// If the compiler has no concepts support, the format header will be disabled.
+// Without concepts support enable_if needs to be used and that too much effort
+// to support compilers with partial C++20 support.
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+namespace __format {
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS __parse_number_result {
+  const _CharT* __ptr;
+  uint32_t __value;
+};
+
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
+__parse_number(const _CharT* __begin, const _CharT* __end);
+
+/**
+ * The maximum value of a numeric argument.
+ *
+ * This is used for:
+ * * arg-id
+ * * width as value or arg-id.
+ * * precision as value or arg-id.
+ *
+ * The value is compatible with the maximum formatting width and precision
+ * using the `%*` syntax on a 32-bit system.
+ */
+inline constexpr uint32_t __number_max = INT32_MAX;
+
+namespace __detail {
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
+__parse_zero(const _CharT* __begin, const _CharT*, auto& __parse_ctx) {
+  __parse_ctx.check_arg_id(0);
+  return {++__begin, 0}; // can never be larger than the maximum.
+}
+
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
+__parse_automatic(const _CharT* __begin, const _CharT*, auto& __parse_ctx) {
+  size_t __value = __parse_ctx.next_arg_id();
+  _LIBCPP_ASSERT(__value <= __number_max,
+                 "Compilers don't support this number of arguments");
+
+  return {__begin, uint32_t(__value)};
+}
+
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
+__parse_manual(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
+  __parse_number_result<_CharT> __r = __parse_number(__begin, __end);
+  __parse_ctx.check_arg_id(__r.__value);
+  return __r;
+}
+
+} // namespace __detail
+
+/**
+ * Parses a number.
+ *
+ * The number is used for the 31-bit values @em width and @em precision. This
+ * allows a maximum value of 2147483647.
+ */
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
+__parse_number(const _CharT* __begin, const _CharT* __end_input) {
+  static_assert(__format::__number_max == INT32_MAX,
+                "The algorithm is implemented based on this value.");
+  /*
+   * Limit the input to 9 digits, otherwise we need two checks during every
+   * iteration:
+   * - Are we at the end of the input?
+   * - Does the value exceed width of an uint32_t? (Switching to uint64_t would
+   *   have the same issue, but with a higher maximum.)
+   */
+  const _CharT* __end = __end_input - __begin > 9 ? __begin + 9 : __end_input;
+  uint32_t __value = *__begin - _CharT('0');
+  while (++__begin != __end) {
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      return {__begin, __value};
+
+    __value = __value * 10 + *__begin - _CharT('0');
+  }
+
+  if (__begin != __end_input && *__begin >= _CharT('0') &&
+      *__begin <= _CharT('9')) {
+
+    /*
+     * There are more than 9 digits, do additional validations:
+     * - Does the 10th digit exceed the maximum allowed value?
+     * - Are there more than 10 digits?
+     * (More than 10 digits always overflows the maximum.)
+     */
+    uint64_t __v = uint64_t(__value) * 10 + *__begin++ - _CharT('0');
+    if (__v > __number_max ||
+        (__begin != __end_input && *__begin >= _CharT('0') &&
+         *__begin <= _CharT('9')))
+      __throw_format_error("The numeric value of the format-spec is too large");
+
+    __value = __v;
+  }
+
+  return {__begin, __value};
+}
+
+/**
+ * Multiplexer for all parse functions.
+ *
+ * The parser will return a pointer beyond the last consumed character. This
+ * should be the closing '}' of the arg-id.
+ */
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
+__parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
+  switch (*__begin) {
+  case _CharT('0'):
+    return __detail::__parse_zero(__begin, __end, __parse_ctx);
+
+  case _CharT(':'):
+    // This case is conditionally valid. It's allowed in an arg-id in the
+    // replacement-field, but not in the std-format-spec. The caller can
+    // provide a better diagnostic, so accept it here unconditionally.
+  case _CharT('}'):
+    return __detail::__parse_automatic(__begin, __end, __parse_ctx);
+  }
+  if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+    __throw_format_error(
+        "The arg-id of the format-spec starts with an invalid character");
+
+  return __detail::__parse_manual(__begin, __end, __parse_ctx);
+}
+
+} // namespace __format
+
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FORMAT_FORMAT_STRING_H

libcxx/include/__format/formatter.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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 _LIBCPP___FORMAT_FORMATTER_H
+#define _LIBCPP___FORMAT_FORMATTER_H
+
+#include <__availability>
+#include <__config>
+#include <__format/format_error.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// TODO FMT Remove this once we require compilers with proper C++20 support.
+// If the compiler has no concepts support, the format header will be disabled.
+// Without concepts support enable_if needs to be used and that too much effort
+// to support compilers with partial C++20 support.
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// Currently not implemented specializations throw an exception when used. This
+// does not conform to the Standard. However not all Standard defined formatters
+// have been implemented yet. Until that time the current behavior is intended.
+// TODO FMT Disable the default template.
+template <class _Tp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto parse(auto& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    __throw();
+  }
+
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto format(_Tp, auto& __ctx)
+      -> decltype(__ctx.out()) {
+    __throw();
+  }
+
+private:
+  _LIBCPP_NORETURN _LIBCPP_HIDDEN void __throw() {
+    __throw_format_error("Argument type not implemented yet");
+  }
+};
+
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FORMAT_FORMATTER_H

libcxx/include/format

namespace std {
   };
   using format_args = basic_format_args<format_context>;
   using wformat_args = basic_format_args<wformat_context>;
 
 
   template<class Out, class charT>
     using format_args_t = basic_format_args<basic_format_context<Out, charT>>;
 
+  // [format.functions], formatting functions
+  template<class... Args>
+    string format(string_view fmt, const Args&... args);
+  template<class... Args>
+    wstring format(wstring_view fmt, const Args&... args);
+  template<class... Args>
+    string format(const locale& loc, string_view fmt, const Args&... args);
+  template<class... Args>
+    wstring format(const locale& loc, wstring_view fmt, const Args&... args);
+
+  string vformat(string_view fmt, format_args args);
+  wstring vformat(wstring_view fmt, wformat_args args);
+  string vformat(const locale& loc, string_view fmt, format_args args);
+  wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
+
+  template<class Out, class... Args>
+    Out format_to(Out out, string_view fmt, const Args&... args);
+  template<class Out, class... Args>
+    Out format_to(Out out, wstring_view fmt, const Args&... args);
+  template<class Out, class... Args>
+    Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args);
+  template<class Out, class... Args>
+    Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args);
+
+  template<class Out>
+    Out vformat_to(Out out, string_view fmt,
+                   format_args_t<type_identity_t<Out>, char> args);
+  template<class Out>
+    Out vformat_to(Out out, wstring_view fmt,
+                   format_args_t<type_identity_t<Out>, wchar_t> args);
+  template<class Out>
+    Out vformat_to(Out out, const locale& loc, string_view fmt,
+                   format_args_t<type_identity_t<Out>, char> args);
+  template<class Out>
+    Out vformat_to(Out out, const locale& loc, wstring_view fmt,
+                   format_args_t<type_identity_t<Out>, wchar_t> args);
+
+  template<class Out> struct format_to_n_result {
+    Out out;
+    iter_difference_t<Out> size;
+  };
+
+ template<class Out, class... Args>
+    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+                                        string_view fmt, const Args&... args);
+  template<class Out, class... Args>
+    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+                                        wstring_view 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, string_view 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, wstring_view fmt,
+                                        const Args&... args);
+
+  template<class... Args>
+    size_t formatted_size(string_view fmt, const Args&... args);
+  template<class... Args>
+    size_t formatted_size(wstring_view fmt, const Args&... args);
+  template<class... Args>
+    size_t formatted_size(const locale& loc, string_view fmt, const Args&... args);
+  template<class... Args>
+    size_t formatted_size(const locale& loc, wstring_view fmt, const Args&... args);
+
+  // [format.formatter], formatter
+  template<> struct formatter<char, char>;
+  template<> struct formatter<char, wchar_t>;
+  template<> struct formatter<wchar_t, wchar_t>;
+
+  template<> struct formatter<charT*, charT>;
+  template<> struct formatter<const charT*, charT>;
+  template<size_t N> struct formatter<const charT[N], charT>;
+  template<class traits, class Allocator>
+    struct formatter<basic_string<charT, traits, Allocator>, charT>;
+  template<class traits>
+    struct formatter<basic_string_view<charT, traits>, charT>;
+
   // [format.parse.ctx], class template basic_format_parse_context
   template<class charT>
   class basic_format_parse_context {
   public:
     using char_type = charT;
     using const_iterator = typename basic_string_view<charT>::const_iterator;
     using iterator = const_iterator;
 
template<class Out, class... Args>
   };
   using format_parse_context = basic_format_parse_context<char>;
   using wformat_parse_context = basic_format_parse_context<wchar_t>;
 }
 
 */
 
 #include <__config>
+#include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
+#include <__format/format_string.h>
+#include <__format/formatter.h>
+#include <__variant/monostate.h>
 #include <array>
+#include <concepts>
+#include <string>
+#include <string_view>
+#include <type_traits>
 #include <version>
 
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#include <locale>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD

 }
 
 template <class... _Args>
 _LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...>
 make_wformat_args(const _Args&... __args) {
   return _VSTD::make_format_args<wformat_context>(__args...);
 }
 
+namespace __format {
+template <class _Tp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_char {
+  _LIBCPP_HIDE_FROM_ABI
+  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
+    // TODO FMT Implement this function.
+    return __parse_ctx.begin();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  auto format(_Tp __c, auto& __ctx) -> decltype(__ctx.out()) {
+    // TODO FMT Implement the parsed formatting arguments.
+    auto __out_it = __ctx.out();
+    *__out_it++ = _CharT(__c);
+    return __out_it;
+  }
+};
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_c_string {
+  _LIBCPP_HIDE_FROM_ABI
+  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
+    // TODO FMT Implement this function.
+    return __parse_ctx.begin();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  auto format(const _CharT* __str, auto& __ctx) -> decltype(__ctx.out()) {
+    // TODO FMT Implement the parsed formatting arguments.
+    auto __out_it = __ctx.out();
+    while (*__str)
+      *__out_it++ = *__str++;
+    return __out_it;
+  }
+};
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_string {
+  _LIBCPP_HIDE_FROM_ABI
+  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
+    // TODO FMT Implement this function.
+    return __parse_ctx.begin();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  auto format(basic_string_view<_CharT> __str, auto& __ctx)
+      -> decltype(__ctx.out()) {
+    // TODO FMT Implement the parsed formatting arguments.
+    auto __out_it = __ctx.out();
+    for (const auto __c : __str)
+      *__out_it++ = __c;
+    return __out_it;
+  }
+};
+
+template <class _Tp, class _CharT>
+requires(is_arithmetic_v<_Tp> &&
+         !same_as<_Tp, bool>) struct _LIBCPP_HIDE_FROM_ABI
+    __formatter_arithmetic {
+  _LIBCPP_HIDE_FROM_ABI
+  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
+    // TODO FMT Implement
+    return __parse_ctx.begin();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  auto format(_Tp __value, auto& __ctx) -> decltype(__ctx.out()) {
+    return __handle_format(__value, __ctx);
+  }
+
+private:
+  template <class _Uv>
+  _LIBCPP_HIDDEN static string
+  __convert(_Uv __value) requires(same_as<_CharT, char>) {
+    return _VSTD::to_string(__value);
+  }
+  template <class _Uv>
+  _LIBCPP_HIDDEN static wstring
+  __convert(_Uv __value) requires(same_as<_CharT, wchar_t>) {
+    return _VSTD::to_wstring(__value);
+  }
+
+  template <class _Uv>
+  _LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx)
+      -> decltype(__ctx.out())
+#ifndef _LIBCPP_HAS_NO_INT128
+          requires(!same_as<_Uv, __int128_t> && !same_as<_Uv, __uint128_t>)
+#endif
+  {
+    // TODO FMT Implement using formatting arguments
+    // TODO FMT Improve PoC since using std::to_string is inefficient.
+    // Note the code doesn't use std::string::iterator since the unit tests
+    // test with debug iterators and they fail with strings created from
+    // std::to_string.
+    auto __str = __convert(__value);
+    auto __out_it = __ctx.out();
+    for (size_t __i = 0, __e = __str.size(); __i != __e; ++__i)
+      *__out_it++ = __str[__i];
+    return __out_it;
+  }
+#ifndef _LIBCPP_HAS_NO_INT128
+  template <class _Uv>
+  _LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx)
+      -> decltype(__ctx.out()) requires(same_as<_Uv, __int128_t> ||
+                                        same_as<_Uv, __uint128_t>) {
+    using _To = conditional_t<is_signed_v<_Uv>, long long, unsigned long long>;
+    // TODO FMT Implement full 128-bit support.
+    if (__value < numeric_limits<_To>::min() ||
+        __value > numeric_limits<_To>::max())
+      __throw_format_error("128-bit value is outside of implemented range");
+
+    return __handle_format(static_cast<_To>(__value), __ctx);
+  }
+#endif
+};
+} // namespace __format
+
+// These specializations are helper stubs and not proper formatters.
+// TODO FMT Implement the proper formatter specializations.
+
+// [format.formatter.spec]/2.1 The specializations
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS formatter<char, char>
+    : public __format::__formatter_char<char, char> {};
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS formatter<char, wchar_t>
+    : public __format::__formatter_char<char, wchar_t> {};
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t>
+    : public __format::__formatter_char<wchar_t, wchar_t> {};
+
+// [format.formatter.spec]/2.2 For each charT, the string type specializations
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT>
+    : public __format::__formatter_c_string<_CharT> {
+  using _Base = __format::__formatter_c_string<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx)
+      -> decltype(__ctx.out()) {
+    _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
+                          "prevented an invalid pointer");
+    return _Base::format(__str, __ctx);
+  }
+};
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT>
+    : public __format::__formatter_c_string<_CharT> {};
+
+template <class _CharT, size_t _Size>
+struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT[_Size], _CharT>
+    : public __format::__formatter_string<_CharT> {
+  using _Base = __format::__formatter_string<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx)
+      -> decltype(__ctx.out()) {
+    return _Base::format(_VSTD::basic_string_view<_CharT>(__str, _Size), __ctx);
+  }
+};
+
+template <class _CharT, class _Traits, class _Allocator>
+struct _LIBCPP_TEMPLATE_VIS
+    formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
+    : public __format::__formatter_string<_CharT> {
+  using _Base = __format::__formatter_string<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI auto
+  format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx)
+      -> decltype(__ctx.out()) {
+    return _Base::format(_VSTD::basic_string_view<_CharT>(__str), __ctx);
+  }
+};
+
+template <class _CharT, class _Traits>
+struct _LIBCPP_TEMPLATE_VIS
+    formatter<basic_string_view<_CharT, _Traits>, _CharT>
+    : public __format::__formatter_string<_CharT> {};
+
+// [format.formatter.spec]/2.3
+// For each charT, for each cv-unqualified arithmetic type ArithmeticT other
+// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
+
+// Boolean.
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {
+  _LIBCPP_HIDE_FROM_ABI
+  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
+    // TODO FMT Implement
+    return __parse_ctx.begin();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  auto format(bool __b, auto& __ctx) -> decltype(__ctx.out()) {
+    // TODO FMT Implement using formatting arguments
+    auto __out_it = __ctx.out();
+    *__out_it++ = _CharT('0') + __b;
+    return __out_it;
+  }
+};
+
+// Signed integral types.
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<signed char, _CharT>
+    : public __format::__formatter_arithmetic<signed char, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<short, _CharT>
+    : public __format::__formatter_arithmetic<short, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<int, _CharT>
+    : public __format::__formatter_arithmetic<int, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<long, _CharT>
+    : public __format::__formatter_arithmetic<long, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<long long, _CharT>
+    : public __format::__formatter_arithmetic<long long, _CharT> {};
+#ifndef _LIBCPP_HAS_NO_INT128
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<__int128_t, _CharT>
+    : public __format::__formatter_arithmetic<__int128_t, _CharT> {};
+#endif
+
+// Unsigned integral types.
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned char, _CharT>
+    : public __format::__formatter_arithmetic<unsigned char, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned short, _CharT>
+    : public __format::__formatter_arithmetic<unsigned short, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned, _CharT>
+    : public __format::__formatter_arithmetic<unsigned, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long, _CharT>
+    : public __format::__formatter_arithmetic<unsigned long, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long long, _CharT>
+    : public __format::__formatter_arithmetic<unsigned long long, _CharT> {};
+#ifndef _LIBCPP_HAS_NO_INT128
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<__uint128_t, _CharT>
+    : public __format::__formatter_arithmetic<__uint128_t, _CharT> {};
+#endif
+
+// Floating point types.
+// TODO FMT There are no replacements for the floating point stubs due to not
+// having floating point support in std::to_chars yet. These stubs aren't
+// removed since they are useful for developing the real versions.
+// Ultimately the stubs should be implemented properly and this code can be
+// removed.
+#if 0
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT>
+    : public __format::__formatter_arithmetic<float, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
+    formatter<double, _CharT>
+    : public __format::__formatter_arithmetic<double, _CharT> {};
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
+    formatter<long double, _CharT>
+    : public __format::__formatter_arithmetic<long double, _CharT> {};
+#endif
+
+namespace __format {
+
+template <class _CharT, class _ParseCtx, class _Ctx>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI const _CharT*
+__handle_replacement_field(const _CharT* __begin, const _CharT* __end,
+                           _ParseCtx& __parse_ctx, _Ctx& __ctx) {
+  __format::__parse_number_result __r =
+      __format::__parse_arg_id(__begin, __end, __parse_ctx);
+
+  switch (*__r.__ptr) {
+  case _CharT(':'):
+    // The arg-id has a format-specifier, advance the input to the format-spec.
+    __parse_ctx.advance_to(__r.__ptr + 1);
+    break;
+  case _CharT('}'):
+    // The arg-id has no format-specifier.
+    __parse_ctx.advance_to(__r.__ptr);
+    break;
+  default:
+    __throw_format_error(
+        "The replacement field arg-id should terminate at a ':' or '}'");
+  }
+
+  _VSTD::visit_format_arg(
+      [&](auto __arg) {
+        if constexpr (same_as<decltype(__arg), monostate>)
+          __throw_format_error("Argument index out of bounds");
+        else {
+          formatter<decltype(__arg), _CharT> __formatter;
+          __parse_ctx.advance_to(__formatter.parse(__parse_ctx));
+          __ctx.advance_to(__formatter.format(__arg, __ctx));
+        }
+      },
+      __ctx.arg(__r.__value));
+
+  __begin = __parse_ctx.begin();
+  if (__begin == __end || *__begin != _CharT('}'))
+    __throw_format_error("The replacement field misses a terminating '}'");
+
+  return ++__begin;
+}
+
+template <class _ParseCtx, class _Ctx>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI typename _Ctx::iterator
+__vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
+  using _CharT = typename _ParseCtx::char_type;
+  static_assert(same_as<typename _Ctx::char_type, _CharT>);
+
+  const _CharT* __begin = __parse_ctx.begin();
+  const _CharT* __end = __parse_ctx.end();
+  typename _Ctx::iterator __out_it = __ctx.out();
+  while (__begin != __end) {
+    switch (*__begin) {
+    case _CharT('{'):
+      ++__begin;
+      if (__begin == __end)
+        __throw_format_error("The format string terminates at a '{'");
+
+      if (*__begin != _CharT('{')) [[likely]] {
+        __ctx.advance_to(_VSTD::move(__out_it));
+        __begin =
+            __handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
+        __out_it = __ctx.out();
+
+        // The output is written and __begin points to the next character. So
+        // start the next iteration.
+        continue;
+      }
+      // The string is an escape character.
+      break;
+
+    case _CharT('}'):
+      ++__begin;
+      if (__begin == __end || *__begin != _CharT('}'))
+        __throw_format_error(
+            "The format string contains an invalid escape sequence");
+
+      break;
+    }
+
+    // Copy the character to the output verbatim.
+    *__out_it++ = *__begin++;
+  }
+  return __out_it;
+}
+
+} // namespace __format
+
+template <class _OutIt, class _CharT>
+requires(__output_iterator<_OutIt, const _CharT&>)
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _OutIt
+    __vformat_to(_OutIt __out_it, basic_string_view<_CharT> __fmt,
+                 format_args_t<type_identity_t<_OutIt>, _CharT> __args) {
+  return __format::__vformat_to(
+      basic_format_parse_context{__fmt, __args.__size()},
+      _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
+}
+
+template <__output_iterator<const char&> _OutIt>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
+vformat_to(_OutIt __out_it, string_view __fmt,
+           format_args_t<type_identity_t<_OutIt>, char> __args) {
+  return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
+}
+
+template <__output_iterator<const wchar_t&> _OutIt>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
+vformat_to(_OutIt __out_it, wstring_view __fmt,
+           format_args_t<type_identity_t<_OutIt>, wchar_t> __args) {
+  return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
+}
+
+template <__output_iterator<const char&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
+format_to(_OutIt __out_it, string_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat_to(
+      _VSTD::move(__out_it), __fmt,
+      _VSTD::make_format_args<basic_format_context<_OutIt, char>>(__args...));
+}
+
+template <__output_iterator<const wchar_t&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
+format_to(_OutIt __out_it, wstring_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat_to(
+      _VSTD::move(__out_it), __fmt,
+      _VSTD::make_format_args<basic_format_context<_OutIt, wchar_t>>(
+          __args...));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
+vformat(string_view __fmt, format_args __args) {
+  string __res;
+  _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
+  return __res;
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
+vformat(wstring_view __fmt, wformat_args __args) {
+  wstring __res;
+  _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
+  return __res;
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
+format(string_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...));
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
+format(wstring_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...));
+}
+
+template <class _OutIt>
+struct _LIBCPP_TEMPLATE_VIS format_to_n_result {
+  _OutIt out;
+  iter_difference_t<_OutIt> size;
+};
+
+template <__output_iterator<const char&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
+format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, string_view __fmt,
+            const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  string __str = _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...));
+  iter_difference_t<_OutIt> __s = __str.size();
+  iter_difference_t<_OutIt> __m =
+      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s);
+  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it));
+  return {_VSTD::move(__out_it), __s};
+}
+
+template <__output_iterator<const wchar_t&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
+format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wstring_view __fmt,
+            const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  wstring __str = _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...));
+  iter_difference_t<_OutIt> __s = __str.size();
+  iter_difference_t<_OutIt> __m =
+      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s);
+  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it));
+  return {_VSTD::move(__out_it), __s};
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
+formatted_size(string_view __fmt, const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  return _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)).size();
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
+formatted_size(wstring_view __fmt, const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)).size();
+}
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+
+template <class _OutIt, class _CharT>
+requires(__output_iterator<_OutIt, const _CharT&>)
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _OutIt
+    __vformat_to(_OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
+                 format_args_t<type_identity_t<_OutIt>, _CharT> __args) {
+  return __format::__vformat_to(
+      basic_format_parse_context{__fmt, __args.__size()},
+      _VSTD::__format_context_create(_VSTD::move(__out_it), __args,
+                                     _VSTD::move(__loc)));
+}
+
+template <__output_iterator<const char&> _OutIt>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
+vformat_to(_OutIt __out_it, locale __loc, string_view __fmt,
+           format_args_t<type_identity_t<_OutIt>, char> __args) {
+  return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
+                             __args);
+}
+
+template <__output_iterator<const wchar_t&> _OutIt>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
+vformat_to(_OutIt __out_it, locale __loc, wstring_view __fmt,
+           format_args_t<type_identity_t<_OutIt>, wchar_t> __args) {
+  return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
+                             __args);
+}
+
+template <__output_iterator<const char&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to(
+    _OutIt __out_it, locale __loc, string_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat_to(
+      _VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
+      _VSTD::make_format_args<basic_format_context<_OutIt, char>>(__args...));
+}
+
+template <__output_iterator<const wchar_t&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to(
+    _OutIt __out_it, locale __loc, wstring_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat_to(
+      _VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
+      _VSTD::make_format_args<basic_format_context<_OutIt, wchar_t>>(
+          __args...));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
+vformat(locale __loc, string_view __fmt, format_args __args) {
+  string __res;
+  _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
+                    __args);
+  return __res;
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
+vformat(locale __loc, wstring_view __fmt, wformat_args __args) {
+  wstring __res;
+  _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
+                    __args);
+  return __res;
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
+format(locale __loc, string_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat(_VSTD::move(__loc), __fmt,
+                        _VSTD::make_format_args(__args...));
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
+format(locale __loc, wstring_view __fmt, const _Args&... __args) {
+  return _VSTD::vformat(_VSTD::move(__loc), __fmt,
+                        _VSTD::make_wformat_args(__args...));
+}
+
+template <__output_iterator<const char&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
+format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc,
+            string_view __fmt, const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  string __str = _VSTD::vformat(_VSTD::move(__loc), __fmt,
+                                _VSTD::make_format_args(__args...));
+  iter_difference_t<_OutIt> __s = __str.size();
+  iter_difference_t<_OutIt> __m =
+      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s);
+  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it));
+  return {_VSTD::move(__out_it), __s};
+}
+
+template <__output_iterator<const wchar_t&> _OutIt, class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
+format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc,
+            wstring_view __fmt, const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  wstring __str = _VSTD::vformat(_VSTD::move(__loc), __fmt,
+                                 _VSTD::make_wformat_args(__args...));
+  iter_difference_t<_OutIt> __s = __str.size();
+  iter_difference_t<_OutIt> __m =
+      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s);
+  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it));
+  return {_VSTD::move(__out_it), __s};
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
+formatted_size(locale __loc, string_view __fmt, const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  return _VSTD::vformat(_VSTD::move(__loc), __fmt,
+                        _VSTD::make_format_args(__args...))
+      .size();
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
+formatted_size(locale __loc, wstring_view __fmt, const _Args&... __args) {
+  // TODO FMT Improve PoC: using std::string is inefficient.
+  return _VSTD::vformat(_VSTD::move(__loc), __fmt,
+                        _VSTD::make_wformat_args(__args...))
+      .size();
+}
+
+#endif
+
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_FORMAT

libcxx/include/module.modulemap

module __format {
       module format_context {
         private header "__format/format_context.h"
         export optional
         export locale
       }
       module format_error         { private header "__format/format_error.h"         }
       module format_fwd           { private header "__format/format_fwd.h"           }
       module format_parse_context { private header "__format/format_parse_context.h" }
+      module format_string        { private header "__format/format_string.h"        }
+      module formatter            { private header "__format/formatter.h"            }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {

libcxx/test/libcxx/diagnostics/detail.headers/format/format_string.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__format/format_string.h'}}
+#include <__format/format_string.h>

libcxx/test/libcxx/diagnostics/detail.headers/format/formatter.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__format/formatter.h'}}
+#include <__format/formatter.h>

libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.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-no-concepts
 
 // This test requires the dylib support introduced in D92214.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <format>
 
 // template<class Visitor, class Context>
 //   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
 
 #include <format>
 #include <cassert>
 #include <type_traits>
 
 #include "constexpr_char_traits.h"
 #include "test_macros.h"
 #include "make_string.h"
 #include "min_allocator.h"
 
 template <class Context, class To, class From>
 void test(From value) {
   auto format_args = std::make_format_args<Context>(value);
   assert(format_args.__args.size() == 1);
   assert(format_args.__args[0]);
 
   auto result = std::visit_format_arg(
       [v = To(value)](auto a) -> To {
         if constexpr (std::is_same_v<To, decltype(a)>) {
           assert(v == a);
           return a;
         } else {
           assert(false);
           return 0;
         }
       },
       format_args.__args[0]);
 
   using ct = std::common_type_t<From, To>;
   assert(static_cast<ct>(result) == static_cast<ct>(value));
 }
 
 // Test specific for string and string_view.
 //
 // Since both result in a string_view there's no need to pass this as a
 // template argument.
 template <class Context, class From>
 void test_string_view(From value) {
   auto format_args = std::make_format_args<Context>(value);
   assert(format_args.__args.size() == 1);
   assert(format_args.__args[0]);
 
   using CharT = typename Context::char_type;
   using To = std::basic_string_view<CharT>;
   using V = std::basic_string<CharT>;
   auto result = std::visit_format_arg(
       [v = V(value.begin(), value.end())](auto a) -> To {
         if constexpr (std::is_same_v<To, decltype(a)>) {
           assert(v == a);
           return a;
         } else {
           assert(false);
           return 0;
         }
       },
       format_args.__args[0]);
 
   assert(std::equal(value.begin(), value.end(), result.begin(), result.end()));
 }
 
 template <class CharT>
 void test() {
   using Context = std::basic_format_context<CharT*, CharT>;
   std::basic_string<CharT> empty;
   std::basic_string<CharT> str = MAKE_STRING(CharT, "abc");
 
   // Test boolean types.
 
   test<Context, bool>(true);
   test<Context, bool>(false);
 
   // Test CharT types.
 
   test<Context, CharT, CharT>('a');
   test<Context, CharT, CharT>('z');
   test<Context, CharT, CharT>('0');
   test<Context, CharT, CharT>('9');
 
   // Test char types.
 
   if (std::is_same_v<CharT, char>) {
     // char to char -> char
     test<Context, CharT, char>('a');
     test<Context, CharT, char>('z');
     test<Context, CharT, char>('0');
     test<Context, CharT, char>('9');
   } else {
     if (std::is_same_v<CharT, wchar_t>) {
       // char to wchar_t -> wchar_t
       test<Context, wchar_t, char>('a');
       test<Context, wchar_t, char>('z');
       test<Context, wchar_t, char>('0');
       test<Context, wchar_t, char>('9');
     } else if (std::is_signed_v<char>) {
       // char to CharT -> int
       // This happens when CharT is a char8_t, char16_t, or char32_t and char
       // is a signed type.
       // Note if sizeof(CharT) > sizeof(int) this test fails. If there are
       // platforms where that occurs extra tests need to be added for char32_t
       // testing it against a long long.
       test<Context, int, char>('a');
       test<Context, int, char>('z');
       test<Context, int, char>('0');
       test<Context, int, char>('9');
     } else {
       // char to CharT -> unsigned
       // This happens when CharT is a char8_t, char16_t, or char32_t and char
       // is an unsigned type.
       // Note if sizeof(CharT) > sizeof(unsigned) this test fails. If there are
       // platforms where that occurs extra tests need to be added for char32_t
       // testing it against an unsigned long long.
       test<Context, unsigned, char>('a');
       test<Context, unsigned, char>('z');
       test<Context, unsigned, char>('0');
       test<Context, unsigned, char>('9');
     }
   }
 
   // Test signed integer types.
 
   test<Context, int, signed char>(std::numeric_limits<signed char>::min());
   test<Context, int, signed char>(0);
   test<Context, int, signed char>(std::numeric_limits<signed char>::max());
 
   test<Context, int, short>(std::numeric_limits<short>::min());
   test<Context, int, short>(std::numeric_limits<signed char>::min());
   test<Context, int, short>(0);
   test<Context, int, short>(std::numeric_limits<signed char>::max());
   test<Context, int, short>(std::numeric_limits<short>::max());
 
   test<Context, int, int>(std::numeric_limits<int>::min());
   test<Context, int, int>(std::numeric_limits<short>::min());
   test<Context, int, int>(std::numeric_limits<signed char>::min());
   test<Context, int, int>(0);
   test<Context, int, int>(std::numeric_limits<signed char>::max());
   test<Context, int, int>(std::numeric_limits<short>::max());
   test<Context, int, int>(std::numeric_limits<int>::max());
 
   using LongToType =
       std::conditional_t<sizeof(long) == sizeof(int), int, long long>;
 
   test<Context, LongToType, long>(std::numeric_limits<long>::min());
   test<Context, LongToType, long>(std::numeric_limits<int>::min());
   test<Context, LongToType, long>(std::numeric_limits<short>::min());
   test<Context, LongToType, long>(std::numeric_limits<signed char>::min());
   test<Context, LongToType, long>(0);
   test<Context, LongToType, long>(std::numeric_limits<signed char>::max());
   test<Context, LongToType, long>(std::numeric_limits<short>::max());
   test<Context, LongToType, long>(std::numeric_limits<int>::max());
   test<Context, LongToType, long>(std::numeric_limits<long>::max());
 
   test<Context, long long, long long>(std::numeric_limits<long long>::min());
   test<Context, long long, long long>(std::numeric_limits<long>::min());
   test<Context, long long, long long>(std::numeric_limits<int>::min());
   test<Context, long long, long long>(std::numeric_limits<short>::min());
   test<Context, long long, long long>(std::numeric_limits<signed char>::min());
   test<Context, long long, long long>(0);
   test<Context, long long, long long>(std::numeric_limits<signed char>::max());
   test<Context, long long, long long>(std::numeric_limits<short>::max());
   test<Context, long long, long long>(std::numeric_limits<int>::max());
   test<Context, long long, long long>(std::numeric_limits<long>::max());
   test<Context, long long, long long>(std::numeric_limits<long long>::max());
 
 #ifndef _LIBCPP_HAS_NO_INT128
   test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::min());
   test<Context, __int128_t, __int128_t>(
       std::numeric_limits<signed char>::min());
   test<Context, __int128_t, __int128_t>(0);
   test<Context, __int128_t, __int128_t>(
       std::numeric_limits<signed char>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::max());
 #endif
 
   // Test unsigned integer types.
 
   test<Context, unsigned, unsigned char>(0);
   test<Context, unsigned, unsigned char>(
       std::numeric_limits<unsigned char>::max());
 
   test<Context, unsigned, unsigned short>(0);
   test<Context, unsigned, unsigned short>(
       std::numeric_limits<unsigned char>::max());
   test<Context, unsigned, unsigned short>(
       std::numeric_limits<unsigned short>::max());
 
   test<Context, unsigned, unsigned>(0);
   test<Context, unsigned, unsigned>(std::numeric_limits<unsigned char>::max());
   test<Context, unsigned, unsigned>(std::numeric_limits<unsigned short>::max());
   test<Context, unsigned, unsigned>(std::numeric_limits<unsigned>::max());
 
   using UnsignedLongToType =
       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
                          unsigned long long>;
 
   test<Context, UnsignedLongToType, unsigned long>(0);
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned char>::max());
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned short>::max());
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned>::max());
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned long>::max());
 
   test<Context, unsigned long long, unsigned long long>(0);
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned char>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned short>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long long>::max());
 
 #ifndef _LIBCPP_HAS_NO_INT128
   test<Context, __uint128_t, __uint128_t>(0);
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned char>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned short>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned int>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned long>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned long long>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<__uint128_t>::max());
 #endif
 
   // Test floating point types.
 
   test<Context, float, float>(-std::numeric_limits<float>::max());
   test<Context, float, float>(-std::numeric_limits<float>::min());
   test<Context, float, float>(-0.0);
   test<Context, float, float>(0.0);
   test<Context, float, float>(std::numeric_limits<float>::min());
   test<Context, float, float>(std::numeric_limits<float>::max());
 
   test<Context, double, double>(-std::numeric_limits<double>::max());
   test<Context, double, double>(-std::numeric_limits<double>::min());
   test<Context, double, double>(-0.0);
   test<Context, double, double>(0.0);
   test<Context, double, double>(std::numeric_limits<double>::min());
   test<Context, double, double>(std::numeric_limits<double>::max());
 
   test<Context, long double, long double>(
       -std::numeric_limits<long double>::max());
   test<Context, long double, long double>(
       -std::numeric_limits<long double>::min());
   test<Context, long double, long double>(-0.0);
   test<Context, long double, long double>(0.0);
   test<Context, long double, long double>(
       std::numeric_limits<long double>::min());
   test<Context, long double, long double>(
       std::numeric_limits<long double>::max());
 
   // Test const CharT pointer types.
 
   test<Context, const CharT*, const CharT*>(empty.c_str());
   test<Context, const CharT*, const CharT*>(str.c_str());
 
   // Test string_view types.
 
   {
     using From = std::basic_string_view<CharT>;
 
     test_string_view<Context>(From());
     test_string_view<Context>(From(empty.c_str()));
     test_string_view<Context>(From(str.c_str()));
   }
 
   {
     using From = std::basic_string_view<CharT, constexpr_char_traits<CharT>>;
 
     test_string_view<Context>(From());
     test_string_view<Context>(From(empty.c_str()));
     test_string_view<Context>(From(str.c_str()));
   }
 
   // Test string types.
 
   {
     using From = std::basic_string<CharT>;
 
     test_string_view<Context>(From());
     test_string_view<Context>(From(empty.c_str()));
     test_string_view<Context>(From(str.c_str()));
   }
 
   {
     using From = std::basic_string<CharT, constexpr_char_traits<CharT>,
                                    std::allocator<CharT>>;
 
     test_string_view<Context>(From());
     test_string_view<Context>(From(empty.c_str()));
     test_string_view<Context>(From(str.c_str()));
   }
 
   {
     using From =
         std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT>>;
 
     test_string_view<Context>(From());
     test_string_view<Context>(From(empty.c_str()));
     test_string_view<Context>(From(str.c_str()));
   }
 
   {
     using From = std::basic_string<CharT, constexpr_char_traits<CharT>,
                                    min_allocator<CharT>>;
 
     test_string_view<Context>(From());
     test_string_view<Context>(From(empty.c_str()));
     test_string_view<Context>(From(str.c_str()));
   }
 
   // Test pointer types.
 
   test<Context, const void*>(nullptr);
 }
 
 void test() {
   test<char>();
   test<wchar_t>();
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }

libcxx/test/libcxx/utilities/format/format.arguments/format.args/get.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-no-concepts
 
 // This test requires the dylib support introduced in D92214.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <format>
 
 // basic_format_arg<Context> get(size_t i) const noexcept;
 
 #include <format>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "make_string.h"
 
 template <class Context, class To, class From>
 void test(From value) {
   auto store = std::make_format_args<Context>(value);
   const std::basic_format_args<Context> format_args{store};
 
   std::visit_format_arg(
       [v = To(value)](auto a) {
         if constexpr (std::is_same_v<To, decltype(a)>)
           assert(v == a);
         else
           assert(false);
       },
       format_args.get(0));
 }
 
 // Test specific for string and string_view.
 //
 // Since both result in a string_view there's no need to pass this as a
 // template argument.
 template <class Context, class From>
 void test_string_view(From value) {
   auto store = std::make_format_args<Context>(value);
   const std::basic_format_args<Context> format_args{store};
 
   using CharT = typename Context::char_type;
   using To = std::basic_string_view<CharT>;
   using V = std::basic_string<CharT>;
   std::visit_format_arg(
       [v = V(value.begin(), value.end())](auto a) {
         if constexpr (std::is_same_v<To, decltype(a)>)
           assert(v == a);
         else
           assert(false);
       },
       format_args.get(0));
 }
 
 template <class CharT>
 void test() {
   using Context = std::basic_format_context<CharT*, CharT>;
   {
     const std::basic_format_args<Context> format_args{};
     ASSERT_NOEXCEPT(format_args.get(0));
     assert(!format_args.get(0));
   }
 
   using char_type = typename Context::char_type;
   std::basic_string<char_type> empty;
   std::basic_string<char_type> str = MAKE_STRING(char_type, "abc");
 
   // Test boolean types.
 
   test<Context, bool>(true);
   test<Context, bool>(false);
 
   // Test char_type types.
 
   test<Context, char_type, char_type>('a');
   test<Context, char_type, char_type>('z');
   test<Context, char_type, char_type>('0');
   test<Context, char_type, char_type>('9');
 
   // Test char types.
 
   if (std::is_same_v<char_type, char>) {
     // char to char -> char
     test<Context, char_type, char>('a');
     test<Context, char_type, char>('z');
     test<Context, char_type, char>('0');
     test<Context, char_type, char>('9');
   } else {
     if (std::is_same_v<char_type, wchar_t>) {
       // char to wchar_t -> wchar_t
       test<Context, wchar_t, char>('a');
       test<Context, wchar_t, char>('z');
       test<Context, wchar_t, char>('0');
       test<Context, wchar_t, char>('9');
     } else if (std::is_signed_v<char>) {
       // char to char_type -> int
       // This happens when Context::char_type is a char8_t, char16_t, or
       // char32_t and char is a signed type.
       // Note if sizeof(char_type) > sizeof(int) this test fails. If there are
       // platforms where that occurs extra tests need to be added for char32_t
       // testing it against a long long.
       test<Context, int, char>('a');
       test<Context, int, char>('z');
       test<Context, int, char>('0');
       test<Context, int, char>('9');
     } else {
       // char to char_type -> unsigned
       // This happens when Context::char_type is a char8_t, char16_t, or
       // char32_t and char is an unsigned type.
       // Note if sizeof(char_type) > sizeof(unsigned) this test fails. If there
       // are platforms where that occurs extra tests need to be added for
       // char32_t testing it against an unsigned long long.
       test<Context, unsigned, char>('a');
       test<Context, unsigned, char>('z');
       test<Context, unsigned, char>('0');
       test<Context, unsigned, char>('9');
     }
   }
 
   // Test signed integer types.
 
   test<Context, int, signed char>(std::numeric_limits<signed char>::min());
   test<Context, int, signed char>(0);
   test<Context, int, signed char>(std::numeric_limits<signed char>::max());
 
   test<Context, int, short>(std::numeric_limits<short>::min());
   test<Context, int, short>(std::numeric_limits<signed char>::min());
   test<Context, int, short>(0);
   test<Context, int, short>(std::numeric_limits<signed char>::max());
   test<Context, int, short>(std::numeric_limits<short>::max());
 
   test<Context, int, int>(std::numeric_limits<int>::min());
   test<Context, int, int>(std::numeric_limits<short>::min());
   test<Context, int, int>(std::numeric_limits<signed char>::min());
   test<Context, int, int>(0);
   test<Context, int, int>(std::numeric_limits<signed char>::max());
   test<Context, int, int>(std::numeric_limits<short>::max());
   test<Context, int, int>(std::numeric_limits<int>::max());
 
   using LongToType =
       std::conditional_t<sizeof(long) == sizeof(int), int, long long>;
 
   test<Context, LongToType, long>(std::numeric_limits<long>::min());
   test<Context, LongToType, long>(std::numeric_limits<int>::min());
   test<Context, LongToType, long>(std::numeric_limits<short>::min());
   test<Context, LongToType, long>(std::numeric_limits<signed char>::min());
   test<Context, LongToType, long>(0);
   test<Context, LongToType, long>(std::numeric_limits<signed char>::max());
   test<Context, LongToType, long>(std::numeric_limits<short>::max());
   test<Context, LongToType, long>(std::numeric_limits<int>::max());
   test<Context, LongToType, long>(std::numeric_limits<long>::max());
 
   test<Context, long long, long long>(std::numeric_limits<long long>::min());
   test<Context, long long, long long>(std::numeric_limits<long>::min());
   test<Context, long long, long long>(std::numeric_limits<int>::min());
   test<Context, long long, long long>(std::numeric_limits<short>::min());
   test<Context, long long, long long>(std::numeric_limits<signed char>::min());
   test<Context, long long, long long>(0);
   test<Context, long long, long long>(std::numeric_limits<signed char>::max());
   test<Context, long long, long long>(std::numeric_limits<short>::max());
   test<Context, long long, long long>(std::numeric_limits<int>::max());
   test<Context, long long, long long>(std::numeric_limits<long>::max());
   test<Context, long long, long long>(std::numeric_limits<long long>::max());
 
 #ifndef _LIBCPP_HAS_NO_INT128
   test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::min());
   test<Context, __int128_t, __int128_t>(
       std::numeric_limits<signed char>::min());
   test<Context, __int128_t, __int128_t>(0);
   test<Context, __int128_t, __int128_t>(
       std::numeric_limits<signed char>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::max());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::max());
 #endif
 
   // Test unsigned integer types.
 
   test<Context, unsigned, unsigned char>(0);
   test<Context, unsigned, unsigned char>(
       std::numeric_limits<unsigned char>::max());
 
   test<Context, unsigned, unsigned short>(0);
   test<Context, unsigned, unsigned short>(
       std::numeric_limits<unsigned char>::max());
   test<Context, unsigned, unsigned short>(
       std::numeric_limits<unsigned short>::max());
 
   test<Context, unsigned, unsigned>(0);
   test<Context, unsigned, unsigned>(std::numeric_limits<unsigned char>::max());
   test<Context, unsigned, unsigned>(std::numeric_limits<unsigned short>::max());
   test<Context, unsigned, unsigned>(std::numeric_limits<unsigned>::max());
 
   using UnsignedLongToType =
       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
                          unsigned long long>;
 
   test<Context, UnsignedLongToType, unsigned long>(0);
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned char>::max());
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned short>::max());
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned>::max());
   test<Context, UnsignedLongToType, unsigned long>(
       std::numeric_limits<unsigned long>::max());
 
   test<Context, unsigned long long, unsigned long long>(0);
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned char>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned short>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long long>::max());
 
 #ifndef _LIBCPP_HAS_NO_INT128
   test<Context, __uint128_t, __uint128_t>(0);
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned char>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned short>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned int>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned long>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned long long>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<__uint128_t>::max());
 #endif
 
   // Test floating point types.
 
   test<Context, float, float>(-std::numeric_limits<float>::max());
   test<Context, float, float>(-std::numeric_limits<float>::min());
   test<Context, float, float>(-0.0);
   test<Context, float, float>(0.0);
   test<Context, float, float>(std::numeric_limits<float>::min());
   test<Context, float, float>(std::numeric_limits<float>::max());
 
   test<Context, double, double>(-std::numeric_limits<double>::max());
   test<Context, double, double>(-std::numeric_limits<double>::min());
   test<Context, double, double>(-0.0);
   test<Context, double, double>(0.0);
   test<Context, double, double>(std::numeric_limits<double>::min());
   test<Context, double, double>(std::numeric_limits<double>::max());
 
   test<Context, long double, long double>(
       -std::numeric_limits<long double>::max());
   test<Context, long double, long double>(
       -std::numeric_limits<long double>::min());
   test<Context, long double, long double>(-0.0);
   test<Context, long double, long double>(0.0);
   test<Context, long double, long double>(
       std::numeric_limits<long double>::min());
   test<Context, long double, long double>(
       std::numeric_limits<long double>::max());
 
   // Test const char_type pointer types.
 
   test<Context, const char_type*, const char_type*>(empty.c_str());
   test<Context, const char_type*, const char_type*>(str.c_str());
 
   // Test string_view types.
 
   test<Context, std::basic_string_view<char_type>>(
       std::basic_string_view<char_type>());
   test<Context, std::basic_string_view<char_type>,
        std::basic_string_view<char_type>>(empty);
   test<Context, std::basic_string_view<char_type>,
        std::basic_string_view<char_type>>(str);
 
   // Test string types.
 
   test<Context, std::basic_string_view<char_type>>(
       std::basic_string<char_type>());
   test<Context, std::basic_string_view<char_type>,
        std::basic_string<char_type>>(empty);
   test<Context, std::basic_string_view<char_type>,
        std::basic_string<char_type>>(str);
 
   // Test pointer types.
 
   test<Context, const void*>(nullptr);
 }
 
 void test() {
   test<char>();
   test<wchar_t>();
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.bool.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-no-concepts
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, for each cv-unqualified arithmetic type `ArithmeticT`
+// other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
+//    template<> struct formatter<ArithmeticT, charT>
+//
+// This file tests with `ArithmeticT = bool`, for each valid `charT`.
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class StringT, class StringViewT>
+void test(StringT expected, StringViewT fmt, bool arg) {
+  using CharT = typename StringT::value_type;
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<bool, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  StringT result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class StringT>
+void test_termination_condition(StringT expected, StringT f, bool arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  using CharT = typename StringT::value_type;
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(expected, fmt, arg);
+  fmt.remove_suffix(1);
+  test(expected, fmt, arg);
+}
+
+template <class CharT>
+void test_boolean() {
+  test_termination_condition(STR("1"), STR("}"), true);
+  test_termination_condition(STR("0"), STR("}"), false);
+}
+
+int main(int, char**) {
+  test_boolean<char>();
+  test_boolean<wchar_t>();
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.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-no-concepts
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, the string type specializations
+//   template<> struct formatter<charT*, charT>;
+//   template<> struct formatter<const charT*, charT>;
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define CSTR(S) MAKE_CSTRING(CharT, S)
+
+template <class T, class StringT, class StringViewT, class CharT>
+void test(StringT expected, StringViewT fmt, const CharT* a) {
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<T, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  StringT result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  auto* arg = const_cast<T>(a);
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class ArgumentT, class StringT, class CharT>
+void test_termination_condition(StringT expected, StringT f, const CharT* arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test<ArgumentT>(expected, fmt, arg);
+  fmt.remove_suffix(1);
+  test<ArgumentT>(expected, fmt, arg);
+}
+
+template <class ArgumentT>
+void test_char_pointer() {
+  using CharT = std::remove_cv_t<std::remove_pointer_t<ArgumentT>>;
+
+  test_termination_condition<ArgumentT>(STR(" azAZ09,./<>?"), STR("}"),
+                                        CSTR(" azAZ09,./<>?"));
+
+  std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
+  test_termination_condition<ArgumentT>(STR("abc"), STR("}"), s.c_str());
+}
+
+int main(int, char**) {
+  test_char_pointer<char*>();
+  test_char_pointer<const char*>();
+  test_char_pointer<wchar_t*>();
+  test_char_pointer<const wchar_t*>();
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.char.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-no-concepts
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// The specializations
+//   template<> struct formatter<char, char>;
+//   template<> struct formatter<char, wchar_t>;
+//   template<> struct formatter<wchar_t, wchar_t>;
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class StringT, class StringViewT, class ArgumentT>
+void test(StringT expected, StringViewT fmt, ArgumentT arg) {
+  using CharT = typename StringT::value_type;
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<ArgumentT, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  StringT result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class StringT, class ArgumentT>
+void test_termination_condition(StringT expected, StringT f, ArgumentT arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  using CharT = typename StringT::value_type;
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(expected, fmt, arg);
+  fmt.remove_suffix(1);
+  test(expected, fmt, arg);
+}
+
+template <class ArgumentT, class CharT>
+void test_char_type() {
+  test_termination_condition(STR("a"), STR("}"), ArgumentT('a'));
+  test_termination_condition(STR("z"), STR("}"), ArgumentT('z'));
+  test_termination_condition(STR("A"), STR("}"), ArgumentT('A'));
+  test_termination_condition(STR("Z"), STR("}"), ArgumentT('Z'));
+  test_termination_condition(STR("0"), STR("}"), ArgumentT('0'));
+  test_termination_condition(STR("9"), STR("}"), ArgumentT('9'));
+}
+
+int main(int, char**) {
+  test_char_type<char, char>();
+  test_char_type<char, wchar_t>();
+  test_char_type<wchar_t, wchar_t>();
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.const_char_array.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-no-concepts
+// UNSUPPORTED: clang-10, clang-11
+// UNSUPPORTED: gcc-10, gcc-11
+// UNSUPPORTED: apple-clang-12
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, the string type specializations
+//   template<size_t N> struct formatter<const charT[N], charT>;
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define CSTR(S) MAKE_CSTRING(CharT, S)
+
+// This is based on the method found in
+// clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1-cxx20.cpp
+template <size_t N>
+struct Tester {
+  // This is not part of the real test, but is used the deduce the size of the input.
+  constexpr Tester(const char (&r)[N]) { __builtin_memcpy(text, r, N); }
+  char text[N];
+
+  // The size of the array shouldn't include the NUL character.
+  static const size_t size = N - 1;
+
+  template <class CharT>
+  void test(const std::basic_string<CharT>& expected,
+            const std::basic_string_view<CharT>& fmt) const {
+    using Str = const CharT[size];
+    std::basic_format_parse_context<CharT> parse_ctx{fmt};
+    std::formatter<Str, CharT> formatter;
+    static_assert(std::semiregular<decltype(formatter)>);
+
+    auto it = formatter.parse(parse_ctx);
+    assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+    std::basic_string<CharT> result;
+    auto out = std::back_inserter(result);
+    using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+    std::basic_string<CharT> buffer{text, text + N};
+    // Note not too found of this hack
+    Str* data = reinterpret_cast<Str*>(buffer.c_str());
+
+    auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+        out, std::make_format_args<FormatCtxT>(*data));
+    formatter.format(*data, format_ctx);
+    assert(result == expected);
+  }
+
+  template <class CharT>
+  void test_termination_condition(const std::basic_string<CharT>& expected,
+                                  const std::basic_string<CharT>& f) const {
+    // The format-spec is valid if completely consumed or terminates at a '}'.
+    // The valid inputs all end with a '}'. The test is executed twice:
+    // - first with the terminating '}',
+    // - second consuming the entire input.
+    std::basic_string_view<CharT> fmt{f};
+    assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+    test(expected, fmt);
+    fmt.remove_suffix(1);
+    test(expected, fmt);
+  }
+};
+
+template <Tester t, class CharT>
+void test_helper_wrapper(std::basic_string<CharT> expected,
+                         std::basic_string<CharT> fmt) {
+  t.test_termination_condition(expected, fmt);
+}
+
+template <class CharT>
+void test_array() {
+  test_helper_wrapper<" azAZ09,./<>?">(STR(" azAZ09,./<>?"), STR("}"));
+
+  std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
+  test_helper_wrapper<"abc\0abc">(s, STR("}"));
+}
+
+int main(int, char**) {
+  test_array<char>();
+  test_array<wchar_t>();
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.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-no-concepts
+// UNSUPPORTED: LIBCXX-DEBUG-FIXME
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, for each cv-unqualified arithmetic type `ArithmeticT`
+// other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
+//    template<> struct formatter<ArithmeticT, charT>
+//
+// This file tests with `ArithmeticT = floating-point`, for each valid `charT`.
+// Where `floating-point` is one of:
+// - float
+// - double
+// - long double
+
+// TODO FMT Enable after floating-point support has been enabled
+#if 0
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class StringViewT, class ArithmeticT>
+void test(StringViewT fmt, ArithmeticT arg) {
+  using CharT = typename StringViewT::value_type;
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<ArithmeticT, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  std::basic_string<CharT> result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  std::string expected = std::to_string(arg);
+  assert(result == std::basic_string<CharT>(expected.begin(), expected.end()));
+}
+
+template <class StringT, class ArithmeticT>
+void test_termination_condition(StringT f, ArithmeticT arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  using CharT = typename StringT::value_type;
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(fmt, arg);
+  fmt.remove_suffix(1);
+  test(fmt, arg);
+}
+
+template <class ArithmeticT, class CharT>
+void test_float_type() {
+  using A = ArithmeticT;
+  test_termination_condition(STR("}"), A(-std::numeric_limits<float>::max()));
+  test_termination_condition(STR("}"), A(-std::numeric_limits<float>::min()));
+  test_termination_condition(STR("}"), A(-0.0));
+  test_termination_condition(STR("}"), A(0.0));
+  test_termination_condition(STR("}"), A(std::numeric_limits<float>::min()));
+  test_termination_condition(STR("}"), A(std::numeric_limits<float>::max()));
+  if (sizeof(A) > sizeof(float)) {
+    test_termination_condition(STR("}"),
+                               A(-std::numeric_limits<double>::max()));
+    test_termination_condition(STR("}"),
+                               A(-std::numeric_limits<double>::min()));
+    test_termination_condition(STR("}"), A(std::numeric_limits<double>::min()));
+    test_termination_condition(STR("}"), A(std::numeric_limits<double>::max()));
+  }
+  if (sizeof(A) > sizeof(double)) {
+    test_termination_condition(STR("}"),
+                               A(-std::numeric_limits<long double>::max()));
+    test_termination_condition(STR("}"),
+                               A(-std::numeric_limits<long double>::min()));
+    test_termination_condition(STR("}"),
+                               A(std::numeric_limits<long double>::min()));
+    test_termination_condition(STR("}"),
+                               A(std::numeric_limits<long double>::max()));
+  }
+
+  // TODO FMT Also test with special floating point values: +/-Inf NaN.
+}
+
+template <class CharT>
+void test_all_float_types() {
+  test_float_type<float, CharT>();
+  test_float_type<double, CharT>();
+  test_float_type<long double, CharT>();
+}
+
+int main(int, char**) {
+  test_all_float_types<char>();
+  test_all_float_types<wchar_t>();
+
+  return 0;
+}
+#else
+int main(int, char**) { return 0; }
+#endif

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.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-no-concepts
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, for each cv-unqualified arithmetic type `ArithmeticT`
+// other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
+//    template<> struct formatter<ArithmeticT, charT>
+//
+// This file tests with `ArithmeticT = signed integer`, for each valid `charT`.
+// Where `signed integer` is one of:
+// - signed char
+// - short
+// - int
+// - long
+// - long long
+// - __int128_t
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class StringT, class StringViewT, class ArithmeticT>
+void test(StringT expected, StringViewT fmt, ArithmeticT arg) {
+  using CharT = typename StringT::value_type;
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<ArithmeticT, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  StringT result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class StringT, class ArithmeticT>
+void test_termination_condition(StringT expected, StringT f, ArithmeticT arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  using CharT = typename StringT::value_type;
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(expected, fmt, arg);
+  fmt.remove_suffix(1);
+  test(expected, fmt, arg);
+}
+
+template <class Arithmetic, class CharT>
+void test_signed_integral_type() {
+  using A = Arithmetic;
+  test_termination_condition(STR("-128"), STR("}"), A(-128));
+  test_termination_condition(STR("0"), STR("}"), A(0));
+  test_termination_condition(STR("127"), STR("}"), A(127));
+  if (sizeof(A) > 1) {
+    test_termination_condition(STR("-32768"), STR("}"), A(-32768));
+    test_termination_condition(STR("32767"), STR("}"), A(32767));
+  }
+  if (sizeof(A) > 2) {
+    test_termination_condition(STR("-2147483648"), STR("}"), A(-2147483648));
+    test_termination_condition(STR("2147483647"), STR("}"), A(2147483647));
+  }
+  if (sizeof(A) > 4) {
+    // -9223372036854775808 can't be used directly, it gives the following
+    // diagnostic:
+    // integer literal is too large to be represented in a signed integer type,
+    // interpreting as unsigned [-Werror,-Wimplicitly-unsigned-literal]
+    test_termination_condition(STR("-9223372036854775808"), STR("}"),
+                               A(-9223372036854775807 - 1));
+    test_termination_condition(STR("9223372036854775807"), STR("}"),
+                               A(9223372036854775807));
+  }
+
+  // TODO FMT Implement the __int128_t minimum and maximum once the formatter
+  // can handle these values.
+}
+
+template <class CharT>
+void test_all_signed_integral_types() {
+  test_signed_integral_type<signed char, CharT>();
+  test_signed_integral_type<short, CharT>();
+  test_signed_integral_type<int, CharT>();
+  test_signed_integral_type<long, CharT>();
+  test_signed_integral_type<long long, CharT>();
+#ifndef _LIBCPP_HAS_NO_INT128
+  test_signed_integral_type<__int128_t, CharT>();
+#endif
+}
+
+int main(int, char**) {
+  test_all_signed_integral_types<char>();
+  test_all_signed_integral_types<wchar_t>();
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.string.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-no-concepts
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, the string type specializations
+//   template<class traits, class Allocator>
+//     struct formatter<basic_string<charT, traits, Allocator>, charT>;
+//   template<class traits>
+//     struct formatter<basic_string_view<charT, traits>, charT>;
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define CSTR(S) MAKE_CSTRING(CharT, S)
+
+template <class T, class ArgumentT, class StringT, class StringViewT>
+void test(StringT expected, StringViewT fmt, StringT a) {
+  static_assert(
+      std::same_as<typename T::value_type,
+                   typename std::decay_t<ArgumentT>::value_type> &&
+      std::same_as<typename T::value_type, typename StringT::value_type>);
+  using CharT = typename T::value_type;
+
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<T, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  StringT result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  ArgumentT arg = a;
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(std::forward<ArgumentT>(arg)));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class T, class ArgumentT, class StringT>
+void test_termination_condition(StringT expected, StringT f, StringT arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  using CharT = typename StringT::value_type;
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test<T, ArgumentT>(expected, fmt, arg);
+  fmt.remove_suffix(1);
+  test<T, ArgumentT>(expected, fmt, arg);
+}
+
+template <class T, class ArgumentT>
+void test_string_type() {
+  static_assert(std::same_as<typename T::value_type,
+                             typename std::decay_t<ArgumentT>::value_type>);
+  using CharT = typename T::value_type;
+
+  test_termination_condition<T, ArgumentT>(STR(" azAZ09,./<>?"), STR("}"),
+                                           STR(" azAZ09,./<>?"));
+
+  std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
+  test_termination_condition<T, ArgumentT>(s, STR("}"), s);
+}
+
+template <class CharT>
+void test_all_string_types() {
+  test_string_type<std::basic_string<CharT>, const std::basic_string<CharT>&>();
+  test_string_type<std::basic_string_view<CharT>,
+                   std::basic_string_view<CharT>>();
+}
+
+int main(int, char**) {
+  test_all_string_types<char>();
+  test_all_string_types<wchar_t>();
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formatter.unsigned_integral.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-no-concepts
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// For each `charT`, for each cv-unqualified arithmetic type `ArithmeticT`
+// other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
+//    template<> struct formatter<ArithmeticT, charT>
+//
+// This file tests with `ArithmeticT = unsigned integer`, for each valid `charT`.
+// Where `unsigned integer` is one of:
+// - unsigned char
+// - unsigned short
+// - unsigned
+// - unsigned long
+// - unsigned long long
+// - __uint128_t
+
+#include <format>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class StringT, class StringViewT, class ArithmeticT>
+void test(StringT expected, StringViewT fmt, ArithmeticT arg) {
+  using CharT = typename StringT::value_type;
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<ArithmeticT, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+  StringT result;
+  auto out = std::back_inserter(result);
+  using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+  auto format_ctx = std::__format_context_create<decltype(out), CharT>(
+      out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class StringT, class ArithmeticT>
+void test_termination_condition(StringT expected, StringT f, ArithmeticT arg) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  using CharT = typename StringT::value_type;
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(expected, fmt, arg);
+  fmt.remove_suffix(1);
+  test(expected, fmt, arg);
+}
+
+template <class ArithmeticT, class CharT>
+void test_unsigned_integral_type() {
+  using A = ArithmeticT;
+  test_termination_condition(STR("0"), STR("}"), A(0));
+  test_termination_condition(STR("255"), STR("}"), A(255));
+  if (sizeof(A) > 1)
+    test_termination_condition(STR("65535"), STR("}"), A(65535));
+  if (sizeof(A) > 2)
+    test_termination_condition(STR("4294967295"), STR("}"), A(4294967295));
+  if (sizeof(A) > 4)
+    test_termination_condition(STR("8446744073709551615"), STR("}"),
+                               A(8446744073709551615));
+
+  // TODO FMT Implement the __uint128_t maximum once the formatter can handle
+  // these values.
+}
+
+template <class CharT>
+void test_all_unsigned_integral_types() {
+  test_unsigned_integral_type<unsigned char, CharT>();
+  test_unsigned_integral_type<unsigned short, CharT>();
+  test_unsigned_integral_type<unsigned, CharT>();
+  test_unsigned_integral_type<unsigned long, CharT>();
+  test_unsigned_integral_type<unsigned long long, CharT>();
+#ifndef _LIBCPP_HAS_NO_INT128
+  test_unsigned_integral_type<__uint128_t, CharT>();
+#endif
+}
+
+int main(int, char**) {
+  test_all_unsigned_integral_types<char>();
+  test_all_unsigned_integral_types<wchar_t>();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.arg/operator_bool.pass.cpp

 
 #include <format>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 
 void test(const auto& store) {
+#if _LIBCPP_VERSION
   for (const auto& arg : store.__args) {
     assert(arg);
     assert(static_cast<bool>(arg));
   }
+#else
+  (void)store;
+#endif
 }
 
 template <class CharT>
 void test() {
   using Context = std::basic_format_context<CharT*, CharT>;
   {
     std::basic_format_arg<Context> format_arg{};
     ASSERT_NOEXCEPT(!format_arg);

libcxx/test/std/utilities/format/format.functions/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: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class... Args>
+//   string format(const locale& loc, string_view fmt, const Args&... args);
+// template<class... Args>
+//   wstring format(const locale& loc, wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <cassert>
+#include <iostream>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  std::basic_string<CharT> out = std::format(std::locale(), fmt, args...);
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt << "\nExpected output "
+                << expected << "\nActual output   " << out << '\n';
+  assert(out == expected);
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT> fmt,
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::format(std::locale(), fmt, args...);
+    if constexpr (std::same_as<CharT, char>)
+      std::cerr << "\nFormat string   " << fmt
+                << "\nDidn't throw an exception.\n";
+    assert(false);
+  } catch (std::format_error& e) {
+#ifdef _LIBCPP_VERSION
+    if constexpr (std::same_as<CharT, char>)
+      if (e.what() != what)
+        std::cerr << "\nFormat string   " << fmt << "\nExpected exception "
+                  << what << "\nActual exception   " << e.what() << '\n';
+#endif
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+
+// 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>
+
+// template<class... Args>
+//   string format(string_view fmt, const Args&... args);
+// template<class... Args>
+//   wstring format(wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <cassert>
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#include <iostream>
+#endif
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  std::basic_string<CharT> out = std::format(fmt, args...);
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt << "\nExpected output "
+                << expected << "\nActual output   " << out << '\n';
+#endif
+  assert(out == expected);
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT> fmt,
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::format(fmt, args...);
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+    if constexpr (std::same_as<CharT, char>)
+      std::cerr << "\nFormat string   " << fmt
+                << "\nDidn't throw an exception.\n";
+#endif
+    assert(false);
+  } catch (std::format_error& e) {
+#if defined(_LIBCPP_VERSION) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+    if constexpr (std::same_as<CharT, char>)
+      if (e.what() != what)
+        std::cerr << "\nFormat string   " << fmt << "\nExpected exception "
+                  << what << "\nActual exception   " << e.what() << '\n';
+#endif
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class Out, class... Args>
+//   Out format_to(Out out, const locale& loc,
+//                 string_view fmt, const Args&... args);
+// template<class Out, class... Args>
+//   Out format_to(Out out, const locale& loc,
+//                 wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <algorithm>
+#include <cassert>
+#include <list>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  {
+    std::basic_string<CharT> out(expected.size(), CharT(' '));
+    auto it = std::format_to(out.begin(), std::locale(), fmt, args...);
+    assert(it == out.end());
+    assert(out == expected);
+  }
+  {
+    std::list<CharT> out;
+    std::format_to(std::back_inserter(out), std::locale(), fmt, args...);
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    std::vector<CharT> out;
+    std::format_to(std::back_inserter(out), std::locale(), fmt, args...);
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    assert(expected.size() < 4096 && "Update the size of the buffer.");
+    CharT out[4096];
+    CharT* it = std::format_to(out, std::locale(), fmt, args...);
+    assert(std::distance(out, it) == int(expected.size()));
+    *it = '\0';
+    assert(out == expected);
+  }
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT>(fmt),
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::basic_string<CharT> out;
+    std::format_to(std::back_inserter(out), std::locale(), fmt, args...);
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+
+// The tests write fixed size buffer, make sure it remains in bounds.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
+// UNSUPPORTED: libcxx-no-debug-mode
+
+// <format>
+
+// template<class Out, class... Args>
+//   Out format_to(Out out, string_view fmt, const Args&... args);
+// template<class Out, class... Args>
+//   Out format_to(Out out, wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <algorithm>
+#include <cassert>
+#include <list>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  {
+    std::basic_string<CharT> out(expected.size(), CharT(' '));
+    auto it = std::format_to(out.begin(), fmt, args...);
+    assert(it == out.end());
+    assert(out == expected);
+  }
+  {
+    std::list<CharT> out;
+    std::format_to(std::back_inserter(out), fmt, args...);
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    std::vector<CharT> out;
+    std::format_to(std::back_inserter(out), fmt, args...);
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    assert(expected.size() < 4096 && "Update the size of the buffer.");
+    CharT out[4096];
+    CharT* it = std::format_to(out, fmt, args...);
+    assert(std::distance(out, it) == int(expected.size()));
+    *it = '\0';
+    assert(out == expected);
+  }
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT>(fmt),
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::basic_string<CharT> out;
+    std::format_to(std::back_inserter(out), fmt, args...);
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class Out, class... Args>
+//   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+//                                       const locale& loc, string_view 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, wstring_view fmt,
+//                                       const Args&... args);
+
+#include <format>
+#include <algorithm>
+#include <cassert>
+#include <list>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  {
+    std::list<CharT> out;
+    std::format_to_n_result result = std::format_to_n(
+        std::back_inserter(out), 0, std::locale(), fmt, args...);
+    // To avoid signedness warnings make sure formatted_size uses the same type
+    // as result.size.
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(std::locale(), fmt, args...);
+
+    assert(result.size == formatted_size);
+    assert(out.empty());
+  }
+  {
+    std::vector<CharT> out;
+    std::format_to_n_result result = std::format_to_n(
+        std::back_inserter(out), 5, std::locale(), fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(std::locale(), fmt, args...);
+    diff_type size = std::min<diff_type>(5, formatted_size);
+
+    assert(result.size == formatted_size);
+    assert(std::equal(out.begin(), out.end(), expected.begin(),
+                      expected.begin() + size));
+  }
+  {
+    std::basic_string<CharT> out;
+    std::format_to_n_result result = std::format_to_n(
+        std::back_inserter(out), 1000, std::locale(), fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(std::locale(), fmt, args...);
+    diff_type size = std::min<diff_type>(1000, formatted_size);
+
+    assert(result.size == formatted_size);
+    assert(out == expected.substr(0, size));
+  }
+  {
+    // Test the returned iterator.
+    std::basic_string<CharT> out(10, CharT(' '));
+    std::format_to_n_result result =
+        std::format_to_n(out.begin(), 10, std::locale(), fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(std::locale(), fmt, args...);
+    diff_type size = std::min<diff_type>(10, formatted_size);
+
+    assert(result.size == formatted_size);
+    assert(result.out == out.begin() + size);
+    assert(out.substr(0, size) == expected.substr(0, size));
+  }
+  {
+    static_assert(std::is_signed_v<std::iter_difference_t<CharT*>>,
+                  "If the difference type isn't negative the test will fail "
+                  "due to using a large positive value.");
+    CharT buffer[1] = {CharT(0)};
+    std::format_to_n_result result =
+        std::format_to_n(buffer, -1, std::locale(), fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(std::locale(), fmt, args...);
+
+    assert(result.size == formatted_size);
+    assert(result.out == buffer);
+    assert(buffer[0] == CharT(0));
+  }
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT>(fmt),
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::basic_string<CharT> out;
+    std::format_to_n(std::back_inserter(out), 0, std::locale(), fmt, args...);
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class Out, class... Args>
+//   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+//                                       string_view fmt, const Args&... args);
+// template<class Out, class... Args>
+//   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+//                                       wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <algorithm>
+#include <cassert>
+#include <list>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  {
+    std::list<CharT> out;
+    std::format_to_n_result result =
+        std::format_to_n(std::back_inserter(out), 0, fmt, args...);
+    // To avoid signedness warnings make sure formatted_size uses the same type
+    // as result.size.
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(fmt, args...);
+
+    assert(result.size == formatted_size);
+    assert(out.empty());
+  }
+  {
+    std::vector<CharT> out;
+    std::format_to_n_result result =
+        std::format_to_n(std::back_inserter(out), 5, fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(fmt, args...);
+    diff_type size = std::min<diff_type>(5, formatted_size);
+
+    assert(result.size == formatted_size);
+    assert(std::equal(out.begin(), out.end(), expected.begin(),
+                      expected.begin() + size));
+  }
+  {
+    std::basic_string<CharT> out;
+    std::format_to_n_result result =
+        std::format_to_n(std::back_inserter(out), 1000, fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(fmt, args...);
+    diff_type size = std::min<diff_type>(1000, formatted_size);
+
+    assert(result.size == formatted_size);
+    assert(out == expected.substr(0, size));
+  }
+  {
+    // Test the returned iterator.
+    std::basic_string<CharT> out(10, CharT(' '));
+    std::format_to_n_result result =
+        std::format_to_n(out.begin(), 10, fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(fmt, args...);
+    diff_type size = std::min<diff_type>(10, formatted_size);
+
+    assert(result.size == formatted_size);
+    assert(result.out == out.begin() + size);
+    assert(out.substr(0, size) == expected.substr(0, size));
+  }
+  {
+    static_assert(std::is_signed_v<std::iter_difference_t<CharT*>>,
+                  "If the difference type isn't negative the test will fail "
+                  "due to using a large positive value.");
+    CharT buffer[1] = {CharT(0)};
+    std::format_to_n_result result = std::format_to_n(buffer, -1, fmt, args...);
+    using diff_type = decltype(result.size);
+    diff_type formatted_size = std::formatted_size(fmt, args...);
+
+    assert(result.size == formatted_size);
+    assert(result.out == buffer);
+    assert(buffer[0] == CharT(0));
+  }
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT>(fmt),
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::basic_string<CharT> out;
+    std::format_to_n(std::back_inserter(out), 0, fmt, args...);
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class... Args>
+//   size_t formatted_size(const locale& loc,
+//                         string_view fmt, const Args&... args);
+// template<class... Args>
+//   size_t formatted_size(const locale& loc,
+//                         wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <cassert>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  size_t size = std::formatted_size(std::locale(), fmt, args...);
+  assert(size == expected.size());
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT> fmt,
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::formatted_size(std::locale(), fmt, args...);
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class... Args>
+//   size_t formatted_size(string_view fmt, const Args&... args);
+// template<class... Args>
+//   size_t formatted_size(wstring_view fmt, const Args&... args);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  size_t size = std::formatted_size(fmt, args...);
+  assert(size == expected.size());
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT> fmt,
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::formatted_size(fmt, args...);
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/tests.inc

+//===----------------------------------------------------------------------===//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Contains the test cases for the format functions without locale.
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+void test_char_to_wchar() {
+  using CharT = wchar_t;
+  test(STR("hello 09azA"), STR("hello {}{}{}{}{}"), '0', '9', 'a', 'z', 'A');
+}
+
+template <class CharT>
+void test() {
+  // *** Test escaping  ***
+  test(STR("{"), STR("{{"));
+  test(STR("}"), STR("}}"));
+
+  // *** Test argument ID ***
+  test(STR("hello 01"), STR("hello {0:}{1:}"), false, true);
+  test(STR("hello 10"), STR("hello {1:}{0:}"), false, true);
+
+  // ** Test invalid format strings ***
+  test_exception("The format string terminates at a '{'", STR("{"));
+  test_exception("The replacement field misses a terminating '}'", STR("{:"),
+                 42);
+
+  test_exception("The format string contains an invalid escape sequence",
+                 STR("}"));
+  test_exception("The format string contains an invalid escape sequence",
+                 STR("{:}-}"), 42);
+
+  test_exception("The format string contains an invalid escape sequence",
+                 STR("} "));
+
+  test_exception(
+      "The arg-id of the format-spec starts with an invalid character",
+      STR("{-"), 42);
+  test_exception("Argument index out of bounds", STR("hello {}"));
+  test_exception("Argument index out of bounds", STR("hello {0}"));
+  test_exception("Argument index out of bounds", STR("hello {1}"), 42);
+
+  // *** Test char format argument ***
+  // The `char` to `wchar_t` formatting is tested separately.
+  test(STR("hello 09azAZ!"), STR("hello {}{}{}{}{}{}{}"), CharT('0'),
+       CharT('9'), CharT('a'), CharT('z'), CharT('A'), CharT('Z'), CharT('!'));
+
+  // *** Test string format argument ***
+  {
+    CharT buffer[] = {CharT('0'), CharT('9'), CharT('a'), CharT('z'),
+                      CharT('A'), CharT('Z'), CharT('!'), 0};
+    CharT* data = buffer;
+    test(STR("hello 09azAZ!"), STR("hello {}"), data);
+  }
+  {
+    CharT buffer[] = {CharT('0'), CharT('9'), CharT('a'), CharT('z'),
+                      CharT('A'), CharT('Z'), CharT('!'), 0};
+    const CharT* data = buffer;
+    test(STR("hello 09azAZ!"), STR("hello {}"), data);
+  }
+  {
+    std::basic_string<CharT> data = STR("world");
+    test(STR("hello world"), STR("hello {}"), data);
+  }
+  {
+    std::basic_string<CharT> buffer = STR("world");
+    std::basic_string_view<CharT> data = buffer;
+    test(STR("hello world"), STR("hello {}"), data);
+  }
+
+  // *** Test Boolean format argument ***
+  test(STR("hello 01"), STR("hello {}{}"), false, true);
+
+  // *** Test signed integral format argument ***
+  test(STR("hello 42"), STR("hello {}"), static_cast<signed char>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<short>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<int>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<long>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<long long>(42));
+#ifndef _LIBCPP_HAS_NO_INT128
+  test(STR("hello 42"), STR("hello {}"), static_cast<__int128_t>(42));
+  {
+    // Note 128-bit support is only partly implemented test the range
+    // conditions here.
+    std::basic_string<CharT> min =
+        std::format(STR("{}"), std::numeric_limits<long long>::min());
+    test(min, STR("{}"),
+         static_cast<__int128_t>(std::numeric_limits<long long>::min()));
+    std::basic_string<CharT> max =
+        std::format(STR("{}"), std::numeric_limits<long long>::max());
+    test(max, STR("{}"),
+         static_cast<__int128_t>(std::numeric_limits<long long>::max()));
+    test_exception(
+        "128-bit value is outside of implemented range", STR("{}"),
+        static_cast<__int128_t>(std::numeric_limits<long long>::min()) - 1);
+    test_exception(
+        "128-bit value is outside of implemented range", STR("{}"),
+        static_cast<__int128_t>(std::numeric_limits<long long>::max()) + 1);
+  }
+#endif
+
+  // ** Test unsigned integral format argument ***
+  test(STR("hello 42"), STR("hello {}"), static_cast<unsigned char>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<unsigned short>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<unsigned>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<unsigned long>(42));
+  test(STR("hello 42"), STR("hello {}"), static_cast<unsigned long long>(42));
+#ifndef _LIBCPP_HAS_NO_INT128
+  test(STR("hello 42"), STR("hello {}"), static_cast<__uint128_t>(42));
+  {
+    // Note 128-bit support is only partly implemented test the range
+    // conditions here.
+    std::basic_string<CharT> max =
+        std::format(STR("{}"), std::numeric_limits<unsigned long long>::max());
+    test(max, STR("{}"),
+         static_cast<__uint128_t>(
+             std::numeric_limits<unsigned long long>::max()));
+    test_exception("128-bit value is outside of implemented range", STR("{}"),
+                   static_cast<__uint128_t>(
+                       std::numeric_limits<unsigned long long>::max()) +
+                       1);
+  }
+#endif
+
+  // *** Test floating point format argument ***
+// TODO FMT Enable after floating-point support has been enabled
+#if 0
+  test(STR("hello 42.000000"), STR("hello {}"), static_cast<float>(42));
+  test(STR("hello 42.000000"), STR("hello {}"), static_cast<double>(42));
+  test(STR("hello 42.000000"), STR("hello {}"), static_cast<long double>(42));
+#endif
+}
+
+int main(int, char**) {
+  test_char_to_wchar();
+
+  test<char>();
+  test<wchar_t>();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.functions/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: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// 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 "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  std::basic_string<CharT> out = std::vformat(
+      std::locale(), fmt,
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
+          args...));
+  assert(out == expected);
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT> fmt,
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::vformat(
+        std::locale(), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
+            args...));
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// string vformat(string_view fmt, format_args args);
+// wstring vformat(wstring_view fmt, wformat_args args);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  std::basic_string<CharT> out = std::vformat(
+      fmt, std::make_format_args<std::basic_format_context<
+               std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
+               args...));
+  assert(out == expected);
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT> fmt,
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::vformat(
+        fmt, std::make_format_args<std::basic_format_context<
+                 std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
+                 args...));
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: gcc-10, gcc-11
+
+// <format>
+
+// template<class Out>
+//   Out vformat_to(Out out, const locale& loc, string_view fmt,
+//                  format_args_t<type_identity_t<Out>, char> args);
+// template<class Out>
+//    Out vformat_to(Out out, const locale& loc, wstring_view fmt,
+//                   format_args_t<type_identity_t<Out>, wchar_t> args);
+
+#include <format>
+#include <algorithm>
+#include <cassert>
+#include <list>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  {
+    std::basic_string<CharT> out(expected.size(), CharT(' '));
+    auto it = std::vformat_to(
+        out.begin(), std::locale(), fmt,
+        std::make_format_args<std::basic_format_context<
+            typename std::basic_string<CharT>::iterator, CharT>>(args...));
+    assert(it == out.end());
+    assert(out == expected);
+  }
+  {
+    std::list<CharT> out;
+    std::vformat_to(
+        std::back_inserter(out), std::locale(), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::list<CharT>>, CharT>>(args...));
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    std::vector<CharT> out;
+    std::vformat_to(
+        std::back_inserter(out), std::locale(), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::vector<CharT>>, CharT>>(args...));
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    assert(expected.size() < 4096 && "Update the size of the buffer.");
+    CharT out[4096];
+    CharT* it = std::vformat_to(
+        out, std::locale(), fmt,
+        std::make_format_args<std::basic_format_context<CharT*, CharT>>(
+            args...));
+    assert(std::distance(out, it) == int(expected.size()));
+    *it = '\0';
+    assert(out == expected);
+  }
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT>(fmt),
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::basic_string<CharT> out;
+    std::vformat_to(
+        std::back_inserter(out), std::locale(), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
+            args...));
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"

libcxx/test/std/utilities/format/format.functions/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-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+
+// The tests write fixed size buffer, make sure it remains in bounds.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
+// UNSUPPORTED: libcxx-no-debug-mode
+
+// <format>
+
+// template<class Out>
+//   Out vformat_to(Out out, string_view fmt,
+//                  format_args_t<type_identity_t<Out>, char> args);
+// template<class Out>
+//    Out vformat_to(Out out, wstring_view fmt,
+//                   format_args_t<type_identity_t<Out>, wchar_t> args);
+
+#include <format>
+#include <algorithm>
+#include <cassert>
+#include <list>
+#include <vector>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+// Helper functions for this specific test.
+
+template <class CharT, class... Args>
+void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
+          const Args&... args) {
+  {
+    std::basic_string<CharT> out(expected.size(), CharT(' '));
+    auto it = std::vformat_to(
+        out.begin(), fmt,
+        std::make_format_args<std::basic_format_context<
+            typename std::basic_string<CharT>::iterator, CharT>>(args...));
+    assert(it == out.end());
+    assert(out == expected);
+  }
+  {
+    std::list<CharT> out;
+    std::vformat_to(
+        std::back_inserter(out), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::list<CharT>>, CharT>>(args...));
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    std::vector<CharT> out;
+    std::vformat_to(
+        std::back_inserter(out), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::vector<CharT>>, CharT>>(args...));
+    assert(
+        std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
+  }
+  {
+    assert(expected.size() < 4096 && "Update the size of the buffer.");
+    CharT out[4096];
+    CharT* it = std::vformat_to(
+        out, fmt,
+        std::make_format_args<std::basic_format_context<CharT*, CharT>>(
+            args...));
+    assert(std::distance(out, it) == int(expected.size()));
+    *it = '\0';
+    assert(out == expected);
+  }
+}
+
+template <class CharT, class... Args>
+void test_exception(std::string_view what, std::basic_string<CharT>(fmt),
+                    const Args&... args) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+    std::basic_string<CharT> out;
+    std::vformat_to(
+        std::back_inserter(out), fmt,
+        std::make_format_args<std::basic_format_context<
+            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
+            args...));
+    assert(false);
+  } catch (std::format_error& e) {
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+  assert(false);
+#else
+  (void)what;
+  (void)fmt;
+  (void)sizeof...(args);
+#endif
+}
+
+// Include the generic tests for the format functions without locale.
+#include "tests.inc"