[libc++][print] Adds ostream overloads.

[Mordante]

Summary

Finishes implementation of

• P2093R14 Formatted output
• P2539R4 Should the output of std::print to a terminal be synchronized with the underlying stream?

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI testing.

[Mordante]

Reenable CI.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Reenable complete CI

[Mordante]

Rebased to trigger CI.

[avogelsgesang]

Just skimmed over it. I do not know enough about std::print for an in-depth review, hence just a couple of typos

libcxx/docs/ImplementationDefinedBehavior.rst

19

libcxx/include/__availability

178 ↗

(On Diff #546490)

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/locale-specific_form.pass.cpp

23

There seems to be a verb missing...

[philnik]

libcxx/include/ostream

193–199

I'd rather not start conditionally including headers, since that will make the dependencies we have even more complicated.

1278–1280

Maybe use an __exception_guard instead?

libcxx/include/print

201–205

This seems like a really useful thing to make it an extension to me. E.g. clang has -fcolor-diagnostics, which is essentially what this function is doing.

libcxx/src/ostream.cpp

21–32

No need to make this unreadable.

libcxx/src/std_stream.h

115

I think the inline changes here make sense as their own NFC patch.

[Mordante]

Thanks for the reviews!

libcxx/include/ostream

193–199

Good point, that was part of a test and should have been unconditionally.

1278–1280

I prefer to keep it as is now, this is consistent with the existing code, for example line 1228. Then make that change in one patch for the whole file, <ios> and <iomanip>

libcxx/include/print

201–205

I'm not entirely sure what your suggestion is. Could you elaborate?

libcxx/src/ostream.cpp

21–32

We use uglified code in other places in the dylib too. I prefer to keep it as is. When the code can be more from the dylib to headers there's no need to rename things.

libcxx/src/std_stream.h

115

Agreed, I think it makes sense to just commit this when the CI is happy.

[Mordante]

Rebased and addresses review comments.

[ldionne]

libcxx/docs/ImplementationDefinedBehavior.rst

15

Also I think this entry is not sufficiently clear right now. You should explain what implementation-defined behavior you're talking about. Maybe provide a link to the section of the std you're talking about?

libcxx/include/__availability

177–178 ↗

(On Diff #549592)

180 ↗

(On Diff #549592)

Missing _LIBCPP_AVAILABILITY_HAS_NO_FOO.

356 ↗

(On Diff #549592)

Missing HAS_NO_FOO!

[ldionne]

libcxx/include/ostream

154

General question: do we follow this recommended practice? https://eel.is/c++draft/ostream.formatted.print#4

Recommended practice: For vprint_unicode, if invoking the native Unicode API requires transcoding, implementations should substitute invalid code units with U+FFFD REPLACEMENT CHARACTER per the Unicode Standard, Chapter 3.9 U+FFFD Substitution in Conversion.

1254

1276

Given how long we discussed this line during live review, it might be worth explaining why this flush is correct.

libcxx/include/print

203

Can you explain why this macro is necessary? How did you handle testing the previous print code without having to introduce this macro?

libcxx/src/ostream.cpp

24

We should restore the -fno-rtti CI configuration that we seem to have dropped at some point, and then we can reconsider whether this approach is feasible: https://godbolt.org/z/WzEEz3TP1

IDK if this will be possible to implement without RTTI, since we can't add a new virtual function to basic_streambuf.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp

92

Weird characters here!

183

Can you link to the recommended practice here? https://eel.is/c++draft/ostream.formatted.print#4

[Mordante]

Rebased and addresses parts of the review comments.
Note that Phabricator is quite unresponsive so skipped some comments.

[Zingam]

libcxx/modules/std/ostream.inc

31–35 ↗

(On Diff #556374)

I just skimmed over this patch out of curiosity. Shouldn't these be guarded against C++23 like in print.inc?

[Mordante]

Rebased and partly addresses review comments.

[Mordante]

libcxx/include/ostream

154

Yes we do, this is tested in earlier patches
test/libcxx/input.output/iostream.format/print.fun/transcoding.pass.cpp
test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_windows.pass.cpp

libcxx/include/print

203

In the other tests I found ways around by calling implementation specific functions from test/libcxx. Here that's not possible.

libcxx/modules/std/ostream.inc

31–35 ↗

(On Diff #556374)

Yes they should. When I wrote this patch we didn't allow the std module in C++20 so it was not needed. But now we support them in C++20, thanks for catching this.

[Mordante]

Undoes changes to __availability that were a badly resolved merge conflict. This gave build issues with GCC.
Rebased.

[Mordante]

Since the CI for Phabricator is turned off this review has been replaced by https://github.com/llvm/llvm-project/pull/73262

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_mdspan``                                *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_move_only_function``                    *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_optional``                              ``202110L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_out_ptr``                               *unimplemented*
     --------------------------------------------------- -----------------
-    ``__cpp_lib_print``                                 *unimplemented*
+    ``__cpp_lib_print``                                 ``202207L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_as_rvalue``                      ``202207L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                          *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk_by``                       *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                           *unimplemented*

libcxx/docs/ImplementationDefinedBehavior.rst

+.. _implementation-defined-behavior:
+
+===============================
+Implementation-defined behavior
+===============================
+
+Contains the implementation details of the implementation-defined behavior
+in libc++. The order of the entries matches the entries in the
+`draft of the Standard <http://eel.is/c++draft/impldefindex>`_.
+
+.. note:
+   This page is far from complete.
+
+a terminal capable of displaying Unicode
+----------------------------------------
+
+* First it determines whether the stream's ``rdbuf()`` has an underlying
+  ``FILE*``. this is ``true`` in the following cases:
+
+  * The stream is ``std::cout``, ``std::cerr``, or ``std::clog``.
+
+  * A ``std::basic_filebuf<CharT, Traits>`` derived from ``std::filebuf``.
+
+* The way to determine whether this ``FILE*`` is the same as specified
+  for `void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+  <http://eel.is/c++draft/print.fun#7>`_.
+

libcxx/docs/ReleaseNotes/18.rst

 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 18.0.0?
 ==============================
 
 
 Implemented Papers
 ------------------
+- P2093R14 Formatted output
+- P2539R4  Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?
 
 
 Improvements and New Features
 -----------------------------
 
 
 Deprecations and Removals
 -------------------------

libcxx/docs/Status/Cxx23Papers.csv

 "`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","|In progress| [#note-P0009R18]_|",""
 "`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""
 "`P1169R4 <https://wg21.link/P1169R4>`__","LWG","``static operator()``","July 2022","|Complete|","16.0"
 "`P1222R4 <https://wg21.link/P1222R4>`__","LWG","A Standard ``flat_set``","July 2022","",""
 "`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","","","|ranges|"
 "`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
 "`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""
 "`P1899R3 <https://wg21.link/P1899R3>`__","LWG","``stride_view``","July 2022","","","|ranges|"
-"`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","","|In Progress|"
+"`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","","|Complete|","18.0"
 "`P2165R4 <https://wg21.link/P2165R4>`__","LWG","Compatibility between ``tuple``, ``pair`` and ``tuple-like`` objects","July 2022","",""
 "`P2278R4 <https://wg21.link/P2278R4>`__","LWG","``cbegin`` should always return a constant iterator","July 2022","","","|ranges|"
 "`P2286R8 <https://wg21.link/P2286R8>`__","LWG","Formatting Ranges","July 2022","|Complete|","16.0","|format| |ranges|"
 "`P2291R3 <https://wg21.link/P2291R3>`__","LWG","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","July 2022","|Complete|","16.0"
 "`P2302R4 <https://wg21.link/P2302R4>`__","LWG","``std::ranges::contains``","July 2022","","","|ranges|"
 "`P2322R6 <https://wg21.link/P2322R6>`__","LWG","``ranges::fold``","July 2022","","","|ranges|"
 "`P2374R4 <https://wg21.link/P2374R4>`__","LWG","``views::cartesian_product``","July 2022","","","|ranges|"
 "`P2404R3 <https://wg21.link/P2404R3>`__","LWG","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","July 2022","",""

 "`P2613R1 <https://wg21.link/P2613R1>`__","LWG","Add the missing ``empty`` to ``mdspan``","July 2022","",""
 "","","","","","",""
 "`P1202R5 <https://wg21.link/P1202R5>`__","LWG", "Asymmetric Fences", "November 2022","","","|concurrency TS|"
 "`P1264R2 <https://wg21.link/P1264R2>`__","LWG", "Revising the wording of ``stream`` input operations", "November 2022","|Complete|","9.0",""
 "`P1478R8 <https://wg21.link/P1478R8>`__","LWG", "``Byte-wise`` ``atomic`` ``memcpy``", "November 2022","","","|concurrency TS|"
 "`P2167R3 <https://wg21.link/P2167R3>`__","LWG", "Improved Proposed Wording for LWG 2114", "November 2022","","",""
 "`P2396R1 <https://wg21.link/P2396R1>`__","LWG", "Concurrency TS 2 fixes ", "November 2022","","","|concurrency TS|"
 "`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","|Complete|","17.0",""
-"`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","|In Progress|","","|format|"
+"`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","|Complete|","18.0","|format|"
 "`P2602R2 <https://wg21.link/P2602R2>`__","LWG", "Poison Pills are Too Toxic", "November 2022","","","|ranges|"
 "`P2708R1 <https://wg21.link/P2708R1>`__","LWG", "No Further Fundamentals TSes", "November 2022","|Nothing to do|","",""
 "","","","","","",""
 "`P0290R4 <https://wg21.link/P0290R4>`__","LWG", "``apply()`` for ``synchronized_value<T>``","February 2023","","","|concurrency TS|"
 "`P2770R0 <https://wg21.link/P2770R0>`__","LWG", "Stashing stashing ``iterators`` for proper flattening","February 2023","","","|ranges|"
 "`P2164R9 <https://wg21.link/P2164R9>`__","LWG", "``views::enumerate``","February 2023","","","|ranges|"
 "`P2711R1 <https://wg21.link/P2711R1>`__","LWG", "Making multi-param constructors of ``views`` ``explicit``","February 2023","|Partial| [#note-P2711R1]_","","|ranges|"
 "`P2609R3 <https://wg21.link/P2609R3>`__","LWG", "Relaxing Ranges Just A Smidge","February 2023","","","|ranges|"

libcxx/docs/Status/FormatIssues.csv

 Number,Name,Standard,Assignee,Status,First released version
 `P0645 <https://wg21.link/P0645>`_,"Text Formatting","C++20",Mark de Wever,|Complete|,14.0
 `P1652 <https://wg21.link/P1652>`_,"Printf corner cases in std::format","C++20",Mark de Wever,|Complete|,14.0
 `P1892 <https://wg21.link/P1892>`_,"Extended locale-specific presentation specifiers for std::format","C++20",Mark de Wever,|Complete|,14.0
 `P1868 <https://wg21.link/P1868>`_,"width: clarifying units of width and precision in std::format (Implements the unicode support.)","C++20",Mark de Wever,|Complete|,14.0
 `P2216 <https://wg21.link/P2216>`_,"std::format improvements","C++20",Mark de Wever,|Complete|,15.0
 `P2418 <https://wg21.link/P2418>`__,"Add support for ``std::generator``-like types to ``std::format``","C++20",Mark de Wever,|Complete|,15.0
-"`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output","C++23",Mark de Wever,|In Progress|
+"`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output","C++23",Mark de Wever,|Complete|,"18.0"
 "`P2286R8 <https://wg21.link/P2286R8>`__","Formatting Ranges","C++23","Mark de Wever","|Complete|",16.0
 "`P2508R1 <https://wg21.link/P2508R1>`__","Exposing ``std::basic-format-string``","C++23","Mark de Wever","|Complete|",15.0
 "`P2585R0 <https://wg21.link/P2585R0>`__","Improving default container formatting","C++23","Mark de Wever","|Complete|",17.0
-"`P2539R4 <https://wg21.link/P2539R4>`__","Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?","C++23","Mark de Wever","|In Progress|"
+"`P2539R4 <https://wg21.link/P2539R4>`__","Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?","C++23","Mark de Wever","|Complete|","18.0"
 "`P2713R1 <https://wg21.link/P2713R1>`__","Escaping improvements in ``std::format``","C++23","Mark de Wever",""
 "`P2675R1 <https://wg21.link/P2675R1>`__","``format``'s width estimation is too approximate and not forward compatible","C++23","Mark de Wever","|Complete|",17.0
 "`P2572R1 <https://wg21.link/P2572R1>`__","``std::format`` fill character allowances","C++23","Mark de Wever","|Complete|",17.0
 "`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``","C++23","Mark de Wever","|In Progress|"
 "`P2510R3 <https://wg21.link/P2510R3>`__","Formatting pointers","C++26","Mark de Wever","|Complete|",17.0
 "`P2757R3 <https://wg21.link/P2757R3>`__","Type-checking format args","C++26","","",
 "`P2637R3 <https://wg21.link/P2637R3>`__","Member ``visit``","C++26","","",
 `P1361 <https://wg21.link/P1361>`_,"Integration of chrono with text formatting","C++20",Mark de Wever,|In Progress|,
 `P2372 <https://wg21.link/P2372>`__,"Fixing locale handling in chrono formatters","C++20",Mark de Wever,|In Progress|,
 "`P2419R2 <https://wg21.link/P2419R2>`__","Clarify handling of encodings in localized formatting of chrono types","C++23",

libcxx/docs/Status/FormatPaper.csv

 
 "`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``"
 `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,"Formatting ``thread::id``",,Mark de Wever,|Complete|,17.0
 `[stacktrace.format] <https://wg21.link/stacktrace.format>`_,"Formatting ``stacktrace``",A ``<stacktrace>`` implementation,Mark de Wever,,
 
 "`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output"
 `[print.fun] <https://wg21.link/print.fun>`__,"Output to ``stdout``",,Mark de Wever,|Complete|, 17.0
 `[print.fun] <https://wg21.link/print.fun>`__,"Output to ``FILE*``",,Mark de Wever,|Complete|, 17.0
-`[ostream.formatted.print] <https://wg21.link/ostream.formatted.print>`__,"Output to ``ostream``",,Mark de Wever
+`[ostream.formatted.print] <https://wg21.link/ostream.formatted.print>`__,"Output to ``ostream``",,Mark de Wever,|Complete|, 18.0

libcxx/docs/index.rst

.. toctree::
    :maxdepth: 1
 
    ReleaseNotes/17
    ReleaseNotes/18
    UsingLibcxx
    BuildingLibcxx
    TestingLibcxx
    Contributing
+   ImplementationDefinedBehavior
    Modules
    Hardening
    ReleaseProcedure
    Status/Cxx14
    Status/Cxx17
    Status/Cxx20
    Status/Cxx23
    Status/Cxx2c

libcxx/include/fstream

#endif
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* __open(int __fd, ios_base::openmode __mode);
     basic_filebuf* close();
 
     _LIBCPP_INLINE_VISIBILITY
     inline static const char*
     __make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
 
+    _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI FILE* __file() { return __file_; }
+
   protected:
     // 27.9.1.5 Overridden virtual functions:
     int_type underflow() override;
     int_type pbackfail(int_type __c = traits_type::eof()) override;
     int_type overflow (int_type __c = traits_type::eof()) override;
     basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n) override;
     pos_type seekoff(off_type __off, ios_base::seekdir __way,
                      ios_base::openmode __wch = ios_base::in | ios_base::out) override;

libcxx/include/ostream

 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete;        // since C++20
 template<class traits>
 basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete;        // since C++20
 template<class traits>
 basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char8_t*) = delete;        // since C++20
 template<class traits>
 basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char16_t*) = delete;       // since C++20
 template<class traits>
 basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char32_t*) = delete;       // since C++20
 template<class traits>
 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete;  // since C++20
 template<class traits>
 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete; // since C++20
 template<class traits>
 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
 
+// [ostream.formatted.print], print functions
+template<class... Args>                                                                                // since C++23
+  void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+template<class... Args>                                                                                // since C++23
+  void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+
+void vprint_unicode(ostream& os, string_view fmt, format_args args);                                   // since C++23
+void vprint_nonunicode(ostream& os, string_view fmt, format_args args);                                // since C++23
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__exception/operations.h>
 #include <__fwd/ostream.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__system_error/error_code.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <bitset>
 #include <ios>
 #include <locale>
 #include <new>
 #include <streambuf>
 #include <version>
 
+#if _LIBCPP_STD_VER >= 23
+#  include <__format/format_args.h>
+#  include <__format/format_functions.h>
+#  include <print>
+#  include <string_view>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_ostream

 
 #endif // _LIBCPP_STD_VER >= 20
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
+  ostream::sentry __s(__os);
+  if (__s) {
+    string __o = vformat(__os.getloc(), __fmt, __args);
+    if (__write_nl)
+      __o += '\n';
+
+    const char* __str = __o.data();
+    size_t __len      = __o.size();
+
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      typedef ostreambuf_iterator<char> _Ip;
+      if (std::__pad_and_output(
+              _Ip(__os),
+              __str,
+              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
+              __str + __len,
+              __os,
+              __os.fill())
+              .failed())
+        __os.setstate(ios_base::badbit | ios_base::failbit);
+
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __os.__set_badbit_and_consider_rethrow();
+    }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args) {
+  std::__vprint_nonunicode(__os, __fmt, __args, false);
+}
+
+// Returns the FILE* associated with the __os.
+// Returns a nullptr when no FILE* is accociated with __os.
+// This function is in the dylib since the type of the buffer associated
+// with std::cout, std::cerr, and std::clog is only known in the dylib.
+//
+// This function implements part of the implementation-defined behavior
+// of [ostream.formatted.print]/3
+//   If the function is vprint_unicode and os is a stream that refers to
+//   a terminal capable of displaying Unicode which is determined in an
+//   implementation-defined manner, writes out to the terminal using the
+//   native Unicode API;
+// Whether the returned FILE* is "a terminal capable of displaying Unicode"
+// is determined in the same way as the print(FILE*, ...) overloads.
+_LIBCPP_EXPORTED_FROM_ABI FILE* __get_ostream_file(ostream& __os);
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI void __vprint_unicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
+  FILE* __file = std::__get_ostream_file(__os);
+  if (!__file || !__print::__is_terminal(__file))
+    return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);
+
+  __os.flush();
+
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    ostream::sentry __s(__os);
+    if (__s) {
+#    ifndef _WIN32
+      __print::__vprint_unicode_posix(__file, __fmt, __args, __write_nl, true);
+#    elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+    __print::__vprint_unicode_windows(__file, __fmt, __args, __write_nl, true);
+#    else
+#      error "Windows builds with wchar_t disabled are not supported."
+#    endif
+    }
+
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(ostream& __os, string_view __fmt, format_args __args) {
+  std::__vprint_unicode(__os, __fmt, __args, false);
+}
+#  endif // _LIBCPP_HAS_NO_UNICODE
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void print(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  if constexpr (__print::__use_unicode)
+    std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), false);
+  else
+    std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void println(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  // Note the wording in the Standard is inefficient. The output of
+  // std::format is a std::string which is then copied. This solution
+  // just appends a newline at the end of the output.
+  if constexpr (__print::__use_unicode)
+    std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), true);
+  else
+    std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_OSTREAM

libcxx/include/print

 // This is the same test MSVC STL uses in their implementation of <print>
 // See: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
 inline constexpr bool __use_unicode = _MSVC_EXECUTION_CHARACTER_SET == 65001;
 #  else
 inline constexpr bool __use_unicode = true;
 #  endif
 
 _LIBCPP_HIDE_FROM_ABI inline bool __is_terminal(FILE* __stream) {
-#  ifdef _WIN32
+  // The macro _LIBCPP_TESTING_PRINT_IS_TERMINAL is used to change
+  // the behavior in the test. This is not part of the public API.
+#  ifdef _LIBCPP_TESTING_PRINT_IS_TERMINAL
+  return _LIBCPP_TESTING_PRINT_IS_TERMINAL(__stream);
+#  elif defined(_WIN32)
   return std::__is_windows_terminal(__stream);
 #  elif __has_include(<unistd.h>)
   return isatty(fileno(__stream));
 #  else
 #    error "Provide a way to determine whether a FILE* is a terminal"
 #  endif
 }
 

libcxx/include/version

 # define __cpp_lib_forward_like                         202207L
 # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_mdspan                               202207L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
-// # define __cpp_lib_print                                202207L
+# define __cpp_lib_print                                202207L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # define __cpp_lib_ranges_chunk                         202202L
 // # define __cpp_lib_ranges_chunk_by                      202202L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
 # define __cpp_lib_ranges_repeat                        202207L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L

libcxx/lib/abi/powerpc-ibm-aix.libcxxabi.v1.stable.exceptions.nonew.abilist

 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117bad_function_callD1Ev', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117bad_function_callD2Ev', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117declare_reachableEPv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117iostream_categoryEv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
+{'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__get_ostream_fileERNS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}

 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdaPv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdaPvSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdlPv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdlPvSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_Znam', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZnamSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_Znwm', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZnwmSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 No newline at end of file

libcxx/lib/abi/powerpc64-ibm-aix.libcxxabi.v1.stable.exceptions.nonew.abilist

 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117bad_function_callD1Ev', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117bad_function_callD2Ev', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117declare_reachableEPv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117iostream_categoryEv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
+{'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__get_ostream_fileERNS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'EXP', 'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'storage_mapping_class': 'DS', 'type': 'FUNC'}

 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdaPv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdaPvSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdlPv', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZdlPvSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_Znam', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZnamSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_Znwm', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 {'import_export': 'wIMP', 'is_defined': False, 'name': '_ZnwmSt11align_val_t', 'storage_mapping_class': 'DS', 'type': 'FUNC'}
 No newline at end of file

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.nonew.abilist

 {'is_defined': True, 'name': '_ZNSt3__117bad_function_callD1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117bad_function_callD2Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117declare_reachableEPv', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117iostream_categoryEv', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__get_ostream_fileERNS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'type': 'FUNC'}

 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
 No newline at end of file

libcxx/modules/std/ostream.cppm

 
 #  if 0
   using std::emit_on_flush;
   using std::flush_emit;
   using std::noemit_on_flush;
 #  endif
   using std::operator<<;
 
-#  if 0
   // [ostream.formatted.print], print functions
   using std::print;
   using std::println;
 
   using std::vprint_nonunicode;
   using std::vprint_unicode;
-#  endif
 } // namespace std
 #endif // _LIBCPP_HAS_NO_LOCALIZATION

libcxx/src/CMakeLists.txt

 
 if (LIBCXX_ENABLE_LOCALIZATION)
   list(APPEND LIBCXX_SOURCES
     include/sso_allocator.h
     ios.cpp
     ios.instantiations.cpp
     iostream.cpp
     locale.cpp
+    ostream.cpp
     regex.cpp
     strstream.cpp
     )
 endif()
 
 if(WIN32)
   list(APPEND LIBCXX_SOURCES
     support/win32/locale_win32.cpp

libcxx/src/ostream.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <fstream>
+#include <ostream>
+
+#include "std_stream.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_EXPORTED_FROM_ABI FILE* __get_ostream_file(ostream& __os) {
+  auto* __rdbuf = __os.rdbuf();
+  if (auto* __buffer = dynamic_cast<filebuf*>(__rdbuf))
+    return __buffer->__file();
+
+  if (auto* __buffer = dynamic_cast<__stdoutbuf<char>*>(__rdbuf))
+    return __buffer->__file();
+
+  return nullptr;
+}
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/src/std_stream.h

 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::uflow()
 {
     return __getchar(true);
 }
 
-static bool __do_getc(FILE *__fp, char *__pbuf) {
+inline bool __do_getc(FILE *__fp, char *__pbuf) {
     int __c = getc(__fp);
     if (__c == EOF)
         return false;
     *__pbuf = static_cast<char>(__c);
     return true;
 }
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static bool __do_getc(FILE *__fp, wchar_t *__pbuf) {
+inline bool __do_getc(FILE *__fp, wchar_t *__pbuf) {
     wint_t __c = getwc(__fp);
     if (__c == WEOF)
         return false;
     *__pbuf = static_cast<wchar_t>(__c);
     return true;
 }
 #endif
 
-static bool __do_ungetc(int __c, FILE *__fp, char __dummy) {
+inline bool __do_ungetc(int __c, FILE *__fp, char __dummy) {
     if (ungetc(__c, __fp) == EOF)
         return false;
     return true;
 }
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static bool __do_ungetc(std::wint_t __c, FILE *__fp, wchar_t __dummy) {
+inline bool __do_ungetc(std::wint_t __c, FILE *__fp, wchar_t __dummy) {
     if (ungetwc(__c, __fp) == WEOF)
         return false;
     return true;
 }
 #endif
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
public:
     typedef char_traits<char_type>           traits_type;
     typedef typename traits_type::int_type   int_type;
     typedef typename traits_type::pos_type   pos_type;
     typedef typename traits_type::off_type   off_type;
     typedef typename traits_type::state_type state_type;
 
     __stdoutbuf(FILE* __fp, state_type* __st);
 
+    [[nodiscard]] FILE* __file() { return __file_; }
+
   protected:
     virtual int_type overflow (int_type __c = traits_type::eof());
     virtual streamsize xsputn(const char_type* __s, streamsize __n);
     virtual int sync();
     virtual void imbue(const locale& __loc);
 
 private:
     FILE* __file_;
     const codecvt<char_type, char, state_type>* __cv_;
__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
     // default and assume noconv; this passes wchar_t through unmodified to
     // fputwc, which handles it correctly depending on the actual mode of the
     // output stream. If the user sets a custom locale with imbue(), that
     // gets honored.
     if constexpr (__is_win32api_wide_char)
         __always_noconv_ = true;
 }
 
-static bool __do_fputc(char __c, FILE* __fp) {
+inline bool __do_fputc(char __c, FILE* __fp) {
     if (fwrite(&__c, sizeof(__c), 1, __fp) != 1)
         return false;
     return true;
 }
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static bool __do_fputc(wchar_t __c, FILE* __fp) {
+inline bool __do_fputc(wchar_t __c, FILE* __fp) {
     // fputwc works regardless of wide/narrow mode of stdout, while
     // fwrite of wchar_t only works if the stream actually has been set
     // into wide mode.
     if (fputwc(__c, __fp) == WEOF)
         return false;
     return true;
 }
 #endif

libcxx/test/libcxx/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: availability-fp_to_chars-missing
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// Clang modules do not work with the definiton of _LIBCPP_TESTING_PRINT_IS_TERMINAL
+// XFAIL: modules-build
+// <ostream>
+
+// Tests the implementation of
+//  void __vprint_unicode(ostream& os, string_view fmt,
+//                        format_args args, bool write_nl);
+
+// In the library when the std::cout is redirected to a file it is no
+// longer considered a terminal and the special terminal handling is no
+// longer executed. By testing this function we can "force" emulate a
+// terminal.
+// Note write_nl is tested by the public API.
+
+#include <cstdio>
+bool is_terminal(FILE*);
+#define _LIBCPP_TESTING_PRINT_IS_TERMINAL ::is_terminal
+
+#include "filesystem_test_helper.h"
+#include <cassert>
+#include <fstream>
+#include <iostream>
+#include <ostream>
+#include <sstream>
+
+#include "test_macros.h"
+
+scoped_test_env env;
+std::string filename = env.create_file("output.txt");
+
+int is_terminal_calls        = 0;
+bool should_call_is_terminal = false;
+bool is_terminal_result      = false;
+bool is_terminal(FILE*) {
+  ++is_terminal_calls;
+  assert(should_call_is_terminal);
+  return is_terminal_result;
+}
+
+static void test_is_terminal_not_a_file_stream() {
+  is_terminal_calls       = 0;
+  should_call_is_terminal = false;
+  is_terminal_result      = false;
+  {
+    std::stringstream stream;
+    std::print(stream, "test");
+  }
+  {
+    std::ostringstream stream;
+    std::print(stream, "test");
+  }
+  assert(is_terminal_calls == 0);
+}
+
+static void test_is_terminal_file_stream() {
+  is_terminal_calls       = 0;
+  should_call_is_terminal = true;
+  is_terminal_result      = false;
+  {
+    std::fstream stream(filename);
+    assert(stream.is_open());
+    assert(stream.good());
+    std::print(stream, "test");
+    assert(is_terminal_calls == 1);
+  }
+  {
+    std::ofstream stream(filename);
+    assert(stream.is_open());
+    assert(stream.good());
+    std::print(stream, "test");
+    assert(is_terminal_calls == 2);
+  }
+}
+
+static void test_is_terminal_rdbuf_derived_from_filebuf() {
+  struct my_filebuf : public std::filebuf {};
+
+  is_terminal_calls       = 0;
+  should_call_is_terminal = true;
+  is_terminal_result      = false;
+
+  my_filebuf buf;
+  buf.open(filename, std::ios_base::out);
+  assert(buf.is_open());
+
+  std::ostream stream(&buf);
+  std::print(stream, "test");
+  assert(is_terminal_calls == 1);
+}
+
+static void test_is_terminal_std_cout_cerr_clog() {
+  is_terminal_calls       = 0;
+  should_call_is_terminal = true;
+  is_terminal_result      = false;
+  {
+    std::print(std::cout, "test");
+    assert(is_terminal_calls == 1);
+  }
+  {
+    std::print(std::cerr, "test");
+    assert(is_terminal_calls == 2);
+  }
+  {
+    std::print(std::clog, "test");
+    assert(is_terminal_calls == 3);
+  }
+}
+
+static void test_is_terminal_is_flushed() {
+  struct sync_counter : public std::filebuf {
+    sync_counter() {
+      open(filename, std::ios_base::out);
+      assert(is_open());
+    }
+    int sync_calls = 0;
+
+  protected:
+    int virtual sync() {
+      ++sync_calls;
+      return std::basic_streambuf<char>::sync();
+    }
+  };
+
+  should_call_is_terminal = true;
+  is_terminal_result      = false;
+
+  sync_counter buf;
+  std::ostream stream(&buf);
+
+  // Not a terminal sync is not called.
+  std::print(stream, "");
+  assert(buf.sync_calls == 0);
+
+  // A terminal sync is called.
+  is_terminal_result = true;
+  std::print(stream, "");
+  assert(buf.sync_calls == 1); // only called from the destructor of the sentry
+}
+
+#ifdef _WIN32
+static void test_transcoding() {
+  is_terminal_result = true;
+
+  {
+    std::ofstream stream(filename);
+    // 2 code units UTF-8 0xCC 0x81, should be transcoded to 1 code unit UTF-16 0x0301
+    std::print(stream, "\u0301");
+  }
+
+  FILE* file = std::fopen(filename.c_str(), "r");
+  assert(std::fgetc(file) == 0x03);
+  assert(std::fgetc(file) == 0x01);
+  assert(std::fgetc(file) == EOF);
+}
+#endif
+
+int main(int, char**) {
+  test_is_terminal_not_a_file_stream();
+  test_is_terminal_file_stream();
+  test_is_terminal_rdbuf_derived_from_filebuf();
+  test_is_terminal_std_cout_cerr_clog();
+
+  test_is_terminal_is_flushed();
+
+#ifdef _WIN32
+  test_transcoding();
+#endif
+
+  return 0;
+}

libcxx/test/libcxx/transitive_includes/cxx03.csv

 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
+stop_token cstring
+stop_token ctime
 stop_token limits
+stop_token ratio
 stop_token thread
+stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare

libcxx/test/libcxx/transitive_includes/cxx11.csv

 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
+stop_token cstring
+stop_token ctime
 stop_token limits
+stop_token ratio
 stop_token thread
+stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare

libcxx/test/libcxx/transitive_includes/cxx14.csv

 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
+stop_token cstring
+stop_token ctime
 stop_token limits
+stop_token ratio
 stop_token thread
+stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare

libcxx/test/libcxx/transitive_includes/cxx17.csv

 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
+stop_token cstring
+stop_token ctime
 stop_token limits
+stop_token ratio
 stop_token thread
+stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare

libcxx/test/libcxx/transitive_includes/cxx23.csv

 optional cstddef
 optional cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional version
+ostream array
 ostream bitset
 ostream cerrno
+ostream cmath
 ostream cstddef
 ostream cstdint
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream limits
 ostream locale
 ostream new
+ostream optional
+ostream print
 ostream stdexcept
 ostream streambuf
 ostream string
+ostream string_view
+ostream tuple
 ostream typeinfo
 ostream version
 print array
 print cerrno
 print cmath
 print cstddef
 print cstdint
 print cstdio

libcxx/test/libcxx/transitive_includes/cxx26.csv

 optional cstddef
 optional cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional version
+ostream array
 ostream bitset
 ostream cerrno
+ostream cmath
 ostream cstddef
 ostream cstdint
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream limits
 ostream locale
 ostream new
+ostream optional
+ostream print
 ostream stdexcept
 ostream streambuf
 ostream string
+ostream string_view
+ostream tuple
 ostream typeinfo
 ostream version
 print array
 print cerrno
 print cmath
 print cstddef
 print cstdint
 print cstdio

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/locale-specific_form.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-localization
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// REQUIRES: locale.en_US.UTF-8
+
+// <format>
+
+// This test the locale-specific form for these print functions:
+// template<class... Args>
+//   void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+// template<class... Args>
+//   void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+//
+// void vprint_unicode(ostream& os, string_view fmt, format_args args);
+// void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
+
+#include <cassert>
+#include <ostream>
+
+#include "test_macros.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_format_string.h"
+#include "assert_macros.h"
+#include "concat_macros.h"
+
+template <class CharT>
+struct numpunct;
+
+template <>
+struct numpunct<char> : std::numpunct<char> {
+  string_type do_truename() const override { return "yes"; }
+  string_type do_falsename() const override { return "no"; }
+
+  std::string do_grouping() const override { return "\1\2\3\2\1"; };
+  char do_thousands_sep() const override { return '_'; }
+  char do_decimal_point() const override { return '#'; }
+};
+
+template <class... Args>
+static void
+test(std::stringstream& stream, std::string expected, test_format_string<char, Args...> fmt, Args&&... args) {
+  // *** print ***
+  {
+    std::print(stream, fmt, std::forward<Args>(args)...);
+    std::string out = stream.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  }
+  // *** vprint_unicode ***
+  {
+    stream.str("");
+    ;
+    std::vprint_unicode(stream, fmt.get(), std::make_format_args(args...));
+    std::string out = stream.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  }
+  // *** vprint_nonunicode ***
+  {
+    stream.str("");
+    ;
+    std::vprint_nonunicode(stream, fmt.get(), std::make_format_args(args...));
+    std::string out = stream.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  }
+  // *** println ***
+  {
+    expected += '\n'; // Tested last since it changes the expected value.
+    stream.str("");
+    ;
+    std::println(stream, fmt, std::forward<Args>(args)...);
+    std::string out = stream.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  }
+}
+
+template <class... Args>
+static void test(std::string expected, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::stringstream stream;
+  test(stream, std::move(expected), fmt, std::forward<Args>(args)...);
+}
+
+template <class... Args>
+static void test(std::string expected, std::locale loc, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::stringstream stream;
+  stream.imbue(loc);
+  test(stream, std::move(expected), fmt, std::forward<Args>(args)...);
+}
+
+#ifndef TEST_HAS_NO_UNICODE
+struct numpunct_unicode : std::numpunct<char> {
+  string_type do_truename() const override { return "gültig"; }
+  string_type do_falsename() const override { return "ungültig"; }
+};
+
+#endif // TEST_HAS_NO_UNICODE
+
+static void test_bool() {
+  std::locale loc = std::locale(std::locale(), new numpunct<char>());
+
+  std::locale::global(std::locale(LOCALE_en_US_UTF_8));
+  assert(std::locale().name() == LOCALE_en_US_UTF_8);
+  test("true", "{:L}", true);
+  test("false", "{:L}", false);
+
+  test("yes", loc, "{:L}", true);
+  test("no", loc, "{:L}", false);
+
+  std::locale::global(loc);
+  test("yes", "{:L}", true);
+  test("no", "{:L}", false);
+
+  test("true", std::locale(LOCALE_en_US_UTF_8), "{:L}", true);
+  test("false", std::locale(LOCALE_en_US_UTF_8), "{:L}", false);
+
+#ifndef TEST_HAS_NO_UNICODE
+  std::locale loc_unicode = std::locale(std::locale(), new numpunct_unicode());
+
+  test("gültig", loc_unicode, "{:L}", true);
+  test("ungültig", loc_unicode, "{:L}", false);
+
+  test("gültig   ", loc_unicode, "{:9L}", true);
+  test("gültig!!!", loc_unicode, "{:!<9L}", true);
+  test("_gültig__", loc_unicode, "{:_^9L}", true);
+  test("   gültig", loc_unicode, "{:>9L}", true);
+#endif // TEST_HAS_NO_UNICODE
+}
+
+static void test_integer() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Decimal ***
+  std::locale::global(en_US);
+  test("0", "{:L}", 0);
+  test("1", "{:L}", 1);
+  test("10", "{:L}", 10);
+  test("100", "{:L}", 100);
+  test("1,000", "{:L}", 1'000);
+  test("10,000", "{:L}", 10'000);
+  test("100,000", "{:L}", 100'000);
+  test("1,000,000", "{:L}", 1'000'000);
+  test("10,000,000", "{:L}", 10'000'000);
+  test("100,000,000", "{:L}", 100'000'000);
+  test("1,000,000,000", "{:L}", 1'000'000'000);
+
+  test("-1", "{:L}", -1);
+  test("-10", "{:L}", -10);
+  test("-100", "{:L}", -100);
+  test("-1,000", "{:L}", -1'000);
+  test("-10,000", "{:L}", -10'000);
+  test("-100,000", "{:L}", -100'000);
+  test("-1,000,000", "{:L}", -1'000'000);
+  test("-10,000,000", "{:L}", -10'000'000);
+  test("-100,000,000", "{:L}", -100'000'000);
+  test("-1,000,000,000", "{:L}", -1'000'000'000);
+
+  std::locale::global(loc);
+  test("0", "{:L}", 0);
+  test("1", "{:L}", 1);
+  test("1_0", "{:L}", 10);
+  test("10_0", "{:L}", 100);
+  test("1_00_0", "{:L}", 1'000);
+  test("10_00_0", "{:L}", 10'000);
+  test("100_00_0", "{:L}", 100'000);
+  test("1_000_00_0", "{:L}", 1'000'000);
+  test("10_000_00_0", "{:L}", 10'000'000);
+  test("1_00_000_00_0", "{:L}", 100'000'000);
+  test("1_0_00_000_00_0", "{:L}", 1'000'000'000);
+
+  test("-1", "{:L}", -1);
+  test("-1_0", "{:L}", -10);
+  test("-10_0", "{:L}", -100);
+  test("-1_00_0", "{:L}", -1'000);
+  test("-10_00_0", "{:L}", -10'000);
+  test("-100_00_0", "{:L}", -100'000);
+  test("-1_000_00_0", "{:L}", -1'000'000);
+  test("-10_000_00_0", "{:L}", -10'000'000);
+  test("-1_00_000_00_0", "{:L}", -100'000'000);
+  test("-1_0_00_000_00_0", "{:L}", -1'000'000'000);
+
+  test("0", en_US, "{:L}", 0);
+  test("1", en_US, "{:L}", 1);
+  test("10", en_US, "{:L}", 10);
+  test("100", en_US, "{:L}", 100);
+  test("1,000", en_US, "{:L}", 1'000);
+  test("10,000", en_US, "{:L}", 10'000);
+  test("100,000", en_US, "{:L}", 100'000);
+  test("1,000,000", en_US, "{:L}", 1'000'000);
+  test("10,000,000", en_US, "{:L}", 10'000'000);
+  test("100,000,000", en_US, "{:L}", 100'000'000);
+  test("1,000,000,000", en_US, "{:L}", 1'000'000'000);
+
+  test("-1", en_US, "{:L}", -1);
+  test("-10", en_US, "{:L}", -10);
+  test("-100", en_US, "{:L}", -100);
+  test("-1,000", en_US, "{:L}", -1'000);
+  test("-10,000", en_US, "{:L}", -10'000);
+  test("-100,000", en_US, "{:L}", -100'000);
+  test("-1,000,000", en_US, "{:L}", -1'000'000);
+  test("-10,000,000", en_US, "{:L}", -10'000'000);
+  test("-100,000,000", en_US, "{:L}", -100'000'000);
+  test("-1,000,000,000", en_US, "{:L}", -1'000'000'000);
+
+  std::locale::global(en_US);
+  test("0", loc, "{:L}", 0);
+  test("1", loc, "{:L}", 1);
+  test("1_0", loc, "{:L}", 10);
+  test("10_0", loc, "{:L}", 100);
+  test("1_00_0", loc, "{:L}", 1'000);
+  test("10_00_0", loc, "{:L}", 10'000);
+  test("100_00_0", loc, "{:L}", 100'000);
+  test("1_000_00_0", loc, "{:L}", 1'000'000);
+  test("10_000_00_0", loc, "{:L}", 10'000'000);
+  test("1_00_000_00_0", loc, "{:L}", 100'000'000);
+  test("1_0_00_000_00_0", loc, "{:L}", 1'000'000'000);
+
+  test("-1", loc, "{:L}", -1);
+  test("-1_0", loc, "{:L}", -10);
+  test("-10_0", loc, "{:L}", -100);
+  test("-1_00_0", loc, "{:L}", -1'000);
+  test("-10_00_0", loc, "{:L}", -10'000);
+  test("-100_00_0", loc, "{:L}", -100'000);
+  test("-1_000_00_0", loc, "{:L}", -1'000'000);
+  test("-10_000_00_0", loc, "{:L}", -10'000'000);
+  test("-1_00_000_00_0", loc, "{:L}", -100'000'000);
+  test("-1_0_00_000_00_0", loc, "{:L}", -1'000'000'000);
+
+  // *** Binary ***
+  std::locale::global(en_US);
+  test("0", "{:Lb}", 0b0);
+  test("1", "{:Lb}", 0b1);
+  test("1,000,000,000", "{:Lb}", 0b1'000'000'000);
+
+  test("0b0", "{:#Lb}", 0b0);
+  test("0b1", "{:#Lb}", 0b1);
+  test("0b1,000,000,000", "{:#Lb}", 0b1'000'000'000);
+
+  test("-1", "{:LB}", -0b1);
+  test("-1,000,000,000", "{:LB}", -0b1'000'000'000);
+
+  test("-0B1", "{:#LB}", -0b1);
+  test("-0B1,000,000,000", "{:#LB}", -0b1'000'000'000);
+
+  std::locale::global(loc);
+  test("0", "{:Lb}", 0b0);
+  test("1", "{:Lb}", 0b1);
+  test("1_0_00_000_00_0", "{:Lb}", 0b1'000'000'000);
+
+  test("0b0", "{:#Lb}", 0b0);
+  test("0b1", "{:#Lb}", 0b1);
+  test("0b1_0_00_000_00_0", "{:#Lb}", 0b1'000'000'000);
+
+  test("-1", "{:LB}", -0b1);
+  test("-1_0_00_000_00_0", "{:LB}", -0b1'000'000'000);
+
+  test("-0B1", "{:#LB}", -0b1);
+  test("-0B1_0_00_000_00_0", "{:#LB}", -0b1'000'000'000);
+
+  test("0", en_US, "{:Lb}", 0b0);
+  test("1", en_US, "{:Lb}", 0b1);
+  test("1,000,000,000", en_US, "{:Lb}", 0b1'000'000'000);
+
+  test("0b0", en_US, "{:#Lb}", 0b0);
+  test("0b1", en_US, "{:#Lb}", 0b1);
+  test("0b1,000,000,000", en_US, "{:#Lb}", 0b1'000'000'000);
+
+  test("-1", en_US, "{:LB}", -0b1);
+  test("-1,000,000,000", en_US, "{:LB}", -0b1'000'000'000);
+
+  test("-0B1", en_US, "{:#LB}", -0b1);
+  test("-0B1,000,000,000", en_US, "{:#LB}", -0b1'000'000'000);
+
+  std::locale::global(en_US);
+  test("0", loc, "{:Lb}", 0b0);
+  test("1", loc, "{:Lb}", 0b1);
+  test("1_0_00_000_00_0", loc, "{:Lb}", 0b1'000'000'000);
+
+  test("0b0", loc, "{:#Lb}", 0b0);
+  test("0b1", loc, "{:#Lb}", 0b1);
+  test("0b1_0_00_000_00_0", loc, "{:#Lb}", 0b1'000'000'000);
+
+  test("-1", loc, "{:LB}", -0b1);
+  test("-1_0_00_000_00_0", loc, "{:LB}", -0b1'000'000'000);
+
+  test("-0B1", loc, "{:#LB}", -0b1);
+  test("-0B1_0_00_000_00_0", loc, "{:#LB}", -0b1'000'000'000);
+
+  // *** Octal ***
+  std::locale::global(en_US);
+  test("0", "{:Lo}", 00);
+  test("1", "{:Lo}", 01);
+  test("1,000,000,000", "{:Lo}", 01'000'000'000);
+
+  test("0", "{:#Lo}", 00);
+  test("01", "{:#Lo}", 01);
+  test("01,000,000,000", "{:#Lo}", 01'000'000'000);
+
+  test("-1", "{:Lo}", -01);
+  test("-1,000,000,000", "{:Lo}", -01'000'000'000);
+
+  test("-01", "{:#Lo}", -01);
+  test("-01,000,000,000", "{:#Lo}", -01'000'000'000);
+
+  std::locale::global(loc);
+  test("0", "{:Lo}", 00);
+  test("1", "{:Lo}", 01);
+  test("1_0_00_000_00_0", "{:Lo}", 01'000'000'000);
+
+  test("0", "{:#Lo}", 00);
+  test("01", "{:#Lo}", 01);
+  test("01_0_00_000_00_0", "{:#Lo}", 01'000'000'000);
+
+  test("-1", "{:Lo}", -01);
+  test("-1_0_00_000_00_0", "{:Lo}", -01'000'000'000);
+
+  test("-01", "{:#Lo}", -01);
+  test("-01_0_00_000_00_0", "{:#Lo}", -01'000'000'000);
+
+  test("0", en_US, "{:Lo}", 00);
+  test("1", en_US, "{:Lo}", 01);
+  test("1,000,000,000", en_US, "{:Lo}", 01'000'000'000);
+
+  test("0", en_US, "{:#Lo}", 00);
+  test("01", en_US, "{:#Lo}", 01);
+  test("01,000,000,000", en_US, "{:#Lo}", 01'000'000'000);
+
+  test("-1", en_US, "{:Lo}", -01);
+  test("-1,000,000,000", en_US, "{:Lo}", -01'000'000'000);
+
+  test("-01", en_US, "{:#Lo}", -01);
+  test("-01,000,000,000", en_US, "{:#Lo}", -01'000'000'000);
+
+  std::locale::global(en_US);
+  test("0", loc, "{:Lo}", 00);
+  test("1", loc, "{:Lo}", 01);
+  test("1_0_00_000_00_0", loc, "{:Lo}", 01'000'000'000);
+
+  test("0", loc, "{:#Lo}", 00);
+  test("01", loc, "{:#Lo}", 01);
+  test("01_0_00_000_00_0", loc, "{:#Lo}", 01'000'000'000);
+
+  test("-1", loc, "{:Lo}", -01);
+  test("-1_0_00_000_00_0", loc, "{:Lo}", -01'000'000'000);
+
+  test("-01", loc, "{:#Lo}", -01);
+  test("-01_0_00_000_00_0", loc, "{:#Lo}", -01'000'000'000);
+
+  // *** Hexadecimal ***
+  std::locale::global(en_US);
+  test("0", "{:Lx}", 0x0);
+  test("1", "{:Lx}", 0x1);
+  test("1,000,000,000", "{:Lx}", 0x1'000'000'000);
+
+  test("0x0", "{:#Lx}", 0x0);
+  test("0x1", "{:#Lx}", 0x1);
+  test("0x1,000,000,000", "{:#Lx}", 0x1'000'000'000);
+
+  test("-1", "{:LX}", -0x1);
+  test("-1,000,000,000", "{:LX}", -0x1'000'000'000);
+
+  test("-0X1", "{:#LX}", -0x1);
+  test("-0X1,000,000,000", "{:#LX}", -0x1'000'000'000);
+
+  std::locale::global(loc);
+  test("0", "{:Lx}", 0x0);
+  test("1", "{:Lx}", 0x1);
+  test("1_0_00_000_00_0", "{:Lx}", 0x1'000'000'000);
+
+  test("0x0", "{:#Lx}", 0x0);
+  test("0x1", "{:#Lx}", 0x1);
+  test("0x1_0_00_000_00_0", "{:#Lx}", 0x1'000'000'000);
+
+  test("-1", "{:LX}", -0x1);
+  test("-1_0_00_000_00_0", "{:LX}", -0x1'000'000'000);
+
+  test("-0X1", "{:#LX}", -0x1);
+  test("-0X1_0_00_000_00_0", "{:#LX}", -0x1'000'000'000);
+
+  test("0", en_US, "{:Lx}", 0x0);
+  test("1", en_US, "{:Lx}", 0x1);
+  test("1,000,000,000", en_US, "{:Lx}", 0x1'000'000'000);
+
+  test("0x0", en_US, "{:#Lx}", 0x0);
+  test("0x1", en_US, "{:#Lx}", 0x1);
+  test("0x1,000,000,000", en_US, "{:#Lx}", 0x1'000'000'000);
+
+  test("-1", en_US, "{:LX}", -0x1);
+  test("-1,000,000,000", en_US, "{:LX}", -0x1'000'000'000);
+
+  test("-0X1", en_US, "{:#LX}", -0x1);
+  test("-0X1,000,000,000", en_US, "{:#LX}", -0x1'000'000'000);
+
+  std::locale::global(en_US);
+  test("0", loc, "{:Lx}", 0x0);
+  test("1", loc, "{:Lx}", 0x1);
+  test("1_0_00_000_00_0", loc, "{:Lx}", 0x1'000'000'000);
+
+  test("0x0", loc, "{:#Lx}", 0x0);
+  test("0x1", loc, "{:#Lx}", 0x1);
+  test("0x1_0_00_000_00_0", loc, "{:#Lx}", 0x1'000'000'000);
+
+  test("-1", loc, "{:LX}", -0x1);
+  test("-1_0_00_000_00_0", loc, "{:LX}", -0x1'000'000'000);
+
+  test("-0X1", loc, "{:#LX}", -0x1);
+  test("-0X1_0_00_000_00_0", loc, "{:#LX}", -0x1'000'000'000);
+
+  // *** align-fill & width ***
+  test("4_2", loc, "{:L}", 42);
+
+  test("   4_2", loc, "{:6L}", 42);
+  test("4_2   ", loc, "{:<6L}", 42);
+  test(" 4_2  ", loc, "{:^6L}", 42);
+  test("   4_2", loc, "{:>6L}", 42);
+
+  test("4_2***", loc, "{:*<6L}", 42);
+  test("*4_2**", loc, "{:*^6L}", 42);
+  test("***4_2", loc, "{:*>6L}", 42);
+
+  test("4_a*****", loc, "{:*<8Lx}", 0x4a);
+  test("**4_a***", loc, "{:*^8Lx}", 0x4a);
+  test("*****4_a", loc, "{:*>8Lx}", 0x4a);
+
+  test("0x4_a***", loc, "{:*<#8Lx}", 0x4a);
+  test("*0x4_a**", loc, "{:*^#8Lx}", 0x4a);
+  test("***0x4_a", loc, "{:*>#8Lx}", 0x4a);
+
+  test("4_A*****", loc, "{:*<8LX}", 0x4a);
+  test("**4_A***", loc, "{:*^8LX}", 0x4a);
+  test("*****4_A", loc, "{:*>8LX}", 0x4a);
+
+  test("0X4_A***", loc, "{:*<#8LX}", 0x4a);
+  test("*0X4_A**", loc, "{:*^#8LX}", 0x4a);
+  test("***0X4_A", loc, "{:*>#8LX}", 0x4a);
+
+  // Test whether zero padding is ignored
+  test("4_2   ", loc, "{:<06L}", 42);
+  test(" 4_2  ", loc, "{:^06L}", 42);
+  test("   4_2", loc, "{:>06L}", 42);
+
+  // *** zero-padding & width ***
+  test("   4_2", loc, "{:6L}", 42);
+  test("0004_2", loc, "{:06L}", 42);
+  test("-004_2", loc, "{:06L}", -42);
+
+  test("000004_a", loc, "{:08Lx}", 0x4a);
+  test("0x0004_a", loc, "{:#08Lx}", 0x4a);
+  test("0X0004_A", loc, "{:#08LX}", 0x4a);
+
+  test("-00004_a", loc, "{:08Lx}", -0x4a);
+  test("-0x004_a", loc, "{:#08Lx}", -0x4a);
+  test("-0X004_A", loc, "{:#08LX}", -0x4a);
+}
+
+template <class F>
+static void test_floating_point_hex_lower_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.23456p-3", "{:La}", F(0x1.23456p-3));
+  test("1.23456p-2", "{:La}", F(0x1.23456p-2));
+  test("1.23456p-1", "{:La}", F(0x1.23456p-1));
+  test("1.23456p+0", "{:La}", F(0x1.23456p0));
+  test("1.23456p+1", "{:La}", F(0x1.23456p+1));
+  test("1.23456p+2", "{:La}", F(0x1.23456p+2));
+  test("1.23456p+3", "{:La}", F(0x1.23456p+3));
+  test("1.23456p+20", "{:La}", F(0x1.23456p+20));
+
+  std::locale::global(loc);
+  test("1#23456p-3", "{:La}", F(0x1.23456p-3));
+  test("1#23456p-2", "{:La}", F(0x1.23456p-2));
+  test("1#23456p-1", "{:La}", F(0x1.23456p-1));
+  test("1#23456p+0", "{:La}", F(0x1.23456p0));
+  test("1#23456p+1", "{:La}", F(0x1.23456p+1));
+  test("1#23456p+2", "{:La}", F(0x1.23456p+2));
+  test("1#23456p+3", "{:La}", F(0x1.23456p+3));
+  test("1#23456p+20", "{:La}", F(0x1.23456p+20));
+
+  test("1.23456p-3", en_US, "{:La}", F(0x1.23456p-3));
+  test("1.23456p-2", en_US, "{:La}", F(0x1.23456p-2));
+  test("1.23456p-1", en_US, "{:La}", F(0x1.23456p-1));
+  test("1.23456p+0", en_US, "{:La}", F(0x1.23456p0));
+  test("1.23456p+1", en_US, "{:La}", F(0x1.23456p+1));
+  test("1.23456p+2", en_US, "{:La}", F(0x1.23456p+2));
+  test("1.23456p+3", en_US, "{:La}", F(0x1.23456p+3));
+  test("1.23456p+20", en_US, "{:La}", F(0x1.23456p+20));
+
+  std::locale::global(en_US);
+  test("1#23456p-3", loc, "{:La}", F(0x1.23456p-3));
+  test("1#23456p-2", loc, "{:La}", F(0x1.23456p-2));
+  test("1#23456p-1", loc, "{:La}", F(0x1.23456p-1));
+  test("1#23456p+0", loc, "{:La}", F(0x1.23456p0));
+  test("1#23456p+1", loc, "{:La}", F(0x1.23456p+1));
+  test("1#23456p+2", loc, "{:La}", F(0x1.23456p+2));
+  test("1#23456p+3", loc, "{:La}", F(0x1.23456p+3));
+  test("1#23456p+20", loc, "{:La}", F(0x1.23456p+20));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1.23456p+3$$$", "{:$<13La}", F(0x1.23456p3));
+  test("$$$1.23456p+3", "{:$>13La}", F(0x1.23456p3));
+  test("$1.23456p+3$$", "{:$^13La}", F(0x1.23456p3));
+  test("0001.23456p+3", "{:013La}", F(0x1.23456p3));
+  test("-1.23456p+3$$$", "{:$<14La}", F(-0x1.23456p3));
+  test("$$$-1.23456p+3", "{:$>14La}", F(-0x1.23456p3));
+  test("$-1.23456p+3$$", "{:$^14La}", F(-0x1.23456p3));
+  test("-0001.23456p+3", "{:014La}", F(-0x1.23456p3));
+
+  std::locale::global(loc);
+  test("1#23456p+3$$$", "{:$<13La}", F(0x1.23456p3));
+  test("$$$1#23456p+3", "{:$>13La}", F(0x1.23456p3));
+  test("$1#23456p+3$$", "{:$^13La}", F(0x1.23456p3));
+  test("0001#23456p+3", "{:013La}", F(0x1.23456p3));
+  test("-1#23456p+3$$$", "{:$<14La}", F(-0x1.23456p3));
+  test("$$$-1#23456p+3", "{:$>14La}", F(-0x1.23456p3));
+  test("$-1#23456p+3$$", "{:$^14La}", F(-0x1.23456p3));
+  test("-0001#23456p+3", "{:014La}", F(-0x1.23456p3));
+
+  test("1.23456p+3$$$", en_US, "{:$<13La}", F(0x1.23456p3));
+  test("$$$1.23456p+3", en_US, "{:$>13La}", F(0x1.23456p3));
+  test("$1.23456p+3$$", en_US, "{:$^13La}", F(0x1.23456p3));
+  test("0001.23456p+3", en_US, "{:013La}", F(0x1.23456p3));
+  test("-1.23456p+3$$$", en_US, "{:$<14La}", F(-0x1.23456p3));
+  test("$$$-1.23456p+3", en_US, "{:$>14La}", F(-0x1.23456p3));
+  test("$-1.23456p+3$$", en_US, "{:$^14La}", F(-0x1.23456p3));
+  test("-0001.23456p+3", en_US, "{:014La}", F(-0x1.23456p3));
+
+  std::locale::global(en_US);
+  test("1#23456p+3$$$", loc, "{:$<13La}", F(0x1.23456p3));
+  test("$$$1#23456p+3", loc, "{:$>13La}", F(0x1.23456p3));
+  test("$1#23456p+3$$", loc, "{:$^13La}", F(0x1.23456p3));
+  test("0001#23456p+3", loc, "{:013La}", F(0x1.23456p3));
+  test("-1#23456p+3$$$", loc, "{:$<14La}", F(-0x1.23456p3));
+  test("$$$-1#23456p+3", loc, "{:$>14La}", F(-0x1.23456p3));
+  test("$-1#23456p+3$$", loc, "{:$^14La}", F(-0x1.23456p3));
+  test("-0001#23456p+3", loc, "{:014La}", F(-0x1.23456p3));
+}
+
+template <class F>
+static void test_floating_point_hex_upper_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.23456P-3", "{:LA}", F(0x1.23456p-3));
+  test("1.23456P-2", "{:LA}", F(0x1.23456p-2));
+  test("1.23456P-1", "{:LA}", F(0x1.23456p-1));
+  test("1.23456P+0", "{:LA}", F(0x1.23456p0));
+  test("1.23456P+1", "{:LA}", F(0x1.23456p+1));
+  test("1.23456P+2", "{:LA}", F(0x1.23456p+2));
+  test("1.23456P+3", "{:LA}", F(0x1.23456p+3));
+  test("1.23456P+20", "{:LA}", F(0x1.23456p+20));
+
+  std::locale::global(loc);
+  test("1#23456P-3", "{:LA}", F(0x1.23456p-3));
+  test("1#23456P-2", "{:LA}", F(0x1.23456p-2));
+  test("1#23456P-1", "{:LA}", F(0x1.23456p-1));
+  test("1#23456P+0", "{:LA}", F(0x1.23456p0));
+  test("1#23456P+1", "{:LA}", F(0x1.23456p+1));
+  test("1#23456P+2", "{:LA}", F(0x1.23456p+2));
+  test("1#23456P+3", "{:LA}", F(0x1.23456p+3));
+  test("1#23456P+20", "{:LA}", F(0x1.23456p+20));
+
+  test("1.23456P-3", en_US, "{:LA}", F(0x1.23456p-3));
+  test("1.23456P-2", en_US, "{:LA}", F(0x1.23456p-2));
+  test("1.23456P-1", en_US, "{:LA}", F(0x1.23456p-1));
+  test("1.23456P+0", en_US, "{:LA}", F(0x1.23456p0));
+  test("1.23456P+1", en_US, "{:LA}", F(0x1.23456p+1));
+  test("1.23456P+2", en_US, "{:LA}", F(0x1.23456p+2));
+  test("1.23456P+3", en_US, "{:LA}", F(0x1.23456p+3));
+  test("1.23456P+20", en_US, "{:LA}", F(0x1.23456p+20));
+
+  std::locale::global(en_US);
+  test("1#23456P-3", loc, "{:LA}", F(0x1.23456p-3));
+  test("1#23456P-2", loc, "{:LA}", F(0x1.23456p-2));
+  test("1#23456P-1", loc, "{:LA}", F(0x1.23456p-1));
+  test("1#23456P+0", loc, "{:LA}", F(0x1.23456p0));
+  test("1#23456P+1", loc, "{:LA}", F(0x1.23456p+1));
+  test("1#23456P+2", loc, "{:LA}", F(0x1.23456p+2));
+  test("1#23456P+3", loc, "{:LA}", F(0x1.23456p+3));
+  test("1#23456P+20", loc, "{:LA}", F(0x1.23456p+20));
+
+  // *** Fill, align, zero Padding ***
+  std::locale::global(en_US);
+  test("1.23456P+3$$$", "{:$<13LA}", F(0x1.23456p3));
+  test("$$$1.23456P+3", "{:$>13LA}", F(0x1.23456p3));
+  test("$1.23456P+3$$", "{:$^13LA}", F(0x1.23456p3));
+  test("0001.23456P+3", "{:013LA}", F(0x1.23456p3));
+  test("-1.23456P+3$$$", "{:$<14LA}", F(-0x1.23456p3));
+  test("$$$-1.23456P+3", "{:$>14LA}", F(-0x1.23456p3));
+  test("$-1.23456P+3$$", "{:$^14LA}", F(-0x1.23456p3));
+  test("-0001.23456P+3", "{:014LA}", F(-0x1.23456p3));
+
+  std::locale::global(loc);
+  test("1#23456P+3$$$", "{:$<13LA}", F(0x1.23456p3));
+  test("$$$1#23456P+3", "{:$>13LA}", F(0x1.23456p3));
+  test("$1#23456P+3$$", "{:$^13LA}", F(0x1.23456p3));
+  test("0001#23456P+3", "{:013LA}", F(0x1.23456p3));
+  test("-1#23456P+3$$$", "{:$<14LA}", F(-0x1.23456p3));
+  test("$$$-1#23456P+3", "{:$>14LA}", F(-0x1.23456p3));
+  test("$-1#23456P+3$$", "{:$^14LA}", F(-0x1.23456p3));
+  test("-0001#23456P+3", "{:014LA}", F(-0x1.23456p3));
+
+  test("1.23456P+3$$$", en_US, "{:$<13LA}", F(0x1.23456p3));
+  test("$$$1.23456P+3", en_US, "{:$>13LA}", F(0x1.23456p3));
+  test("$1.23456P+3$$", en_US, "{:$^13LA}", F(0x1.23456p3));
+  test("0001.23456P+3", en_US, "{:013LA}", F(0x1.23456p3));
+  test("-1.23456P+3$$$", en_US, "{:$<14LA}", F(-0x1.23456p3));
+  test("$$$-1.23456P+3", en_US, "{:$>14LA}", F(-0x1.23456p3));
+  test("$-1.23456P+3$$", en_US, "{:$^14LA}", F(-0x1.23456p3));
+  test("-0001.23456P+3", en_US, "{:014LA}", F(-0x1.23456p3));
+
+  std::locale::global(en_US);
+  test("1#23456P+3$$$", loc, "{:$<13LA}", F(0x1.23456p3));
+  test("$$$1#23456P+3", loc, "{:$>13LA}", F(0x1.23456p3));
+  test("$1#23456P+3$$", loc, "{:$^13LA}", F(0x1.23456p3));
+  test("0001#23456P+3", loc, "{:013LA}", F(0x1.23456p3));
+  test("-1#23456P+3$$$", loc, "{:$<14LA}", F(-0x1.23456p3));
+  test("$$$-1#23456P+3", loc, "{:$>14LA}", F(-0x1.23456p3));
+  test("$-1#23456P+3$$", loc, "{:$^14LA}", F(-0x1.23456p3));
+  test("-0001#23456P+3", loc, "{:014LA}", F(-0x1.23456p3));
+}
+
+template <class F>
+static void test_floating_point_hex_lower_case_precision() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.234560p-3", "{:.6La}", F(0x1.23456p-3));
+  test("1.234560p-2", "{:.6La}", F(0x1.23456p-2));
+  test("1.234560p-1", "{:.6La}", F(0x1.23456p-1));
+  test("1.234560p+0", "{:.6La}", F(0x1.23456p0));
+  test("1.234560p+1", "{:.6La}", F(0x1.23456p+1));
+  test("1.234560p+2", "{:.6La}", F(0x1.23456p+2));
+  test("1.234560p+3", "{:.6La}", F(0x1.23456p+3));
+  test("1.234560p+20", "{:.6La}", F(0x1.23456p+20));
+
+  std::locale::global(loc);
+  test("1#234560p-3", "{:.6La}", F(0x1.23456p-3));
+  test("1#234560p-2", "{:.6La}", F(0x1.23456p-2));
+  test("1#234560p-1", "{:.6La}", F(0x1.23456p-1));
+  test("1#234560p+0", "{:.6La}", F(0x1.23456p0));
+  test("1#234560p+1", "{:.6La}", F(0x1.23456p+1));
+  test("1#234560p+2", "{:.6La}", F(0x1.23456p+2));
+  test("1#234560p+3", "{:.6La}", F(0x1.23456p+3));
+  test("1#234560p+20", "{:.6La}", F(0x1.23456p+20));
+
+  test("1.234560p-3", en_US, "{:.6La}", F(0x1.23456p-3));
+  test("1.234560p-2", en_US, "{:.6La}", F(0x1.23456p-2));
+  test("1.234560p-1", en_US, "{:.6La}", F(0x1.23456p-1));
+  test("1.234560p+0", en_US, "{:.6La}", F(0x1.23456p0));
+  test("1.234560p+1", en_US, "{:.6La}", F(0x1.23456p+1));
+  test("1.234560p+2", en_US, "{:.6La}", F(0x1.23456p+2));
+  test("1.234560p+3", en_US, "{:.6La}", F(0x1.23456p+3));
+  test("1.234560p+20", en_US, "{:.6La}", F(0x1.23456p+20));
+
+  std::locale::global(en_US);
+  test("1#234560p-3", loc, "{:.6La}", F(0x1.23456p-3));
+  test("1#234560p-2", loc, "{:.6La}", F(0x1.23456p-2));
+  test("1#234560p-1", loc, "{:.6La}", F(0x1.23456p-1));
+  test("1#234560p+0", loc, "{:.6La}", F(0x1.23456p0));
+  test("1#234560p+1", loc, "{:.6La}", F(0x1.23456p+1));
+  test("1#234560p+2", loc, "{:.6La}", F(0x1.23456p+2));
+  test("1#234560p+3", loc, "{:.6La}", F(0x1.23456p+3));
+  test("1#234560p+20", loc, "{:.6La}", F(0x1.23456p+20));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1.234560p+3$$$", "{:$<14.6La}", F(0x1.23456p3));
+  test("$$$1.234560p+3", "{:$>14.6La}", F(0x1.23456p3));
+  test("$1.234560p+3$$", "{:$^14.6La}", F(0x1.23456p3));
+  test("0001.234560p+3", "{:014.6La}", F(0x1.23456p3));
+  test("-1.234560p+3$$$", "{:$<15.6La}", F(-0x1.23456p3));
+  test("$$$-1.234560p+3", "{:$>15.6La}", F(-0x1.23456p3));
+  test("$-1.234560p+3$$", "{:$^15.6La}", F(-0x1.23456p3));
+  test("-0001.234560p+3", "{:015.6La}", F(-0x1.23456p3));
+
+  std::locale::global(loc);
+  test("1#234560p+3$$$", "{:$<14.6La}", F(0x1.23456p3));
+  test("$$$1#234560p+3", "{:$>14.6La}", F(0x1.23456p3));
+  test("$1#234560p+3$$", "{:$^14.6La}", F(0x1.23456p3));
+  test("0001#234560p+3", "{:014.6La}", F(0x1.23456p3));
+  test("-1#234560p+3$$$", "{:$<15.6La}", F(-0x1.23456p3));
+  test("$$$-1#234560p+3", "{:$>15.6La}", F(-0x1.23456p3));
+  test("$-1#234560p+3$$", "{:$^15.6La}", F(-0x1.23456p3));
+  test("-0001#234560p+3", "{:015.6La}", F(-0x1.23456p3));
+
+  test("1.234560p+3$$$", en_US, "{:$<14.6La}", F(0x1.23456p3));
+  test("$$$1.234560p+3", en_US, "{:$>14.6La}", F(0x1.23456p3));
+  test("$1.234560p+3$$", en_US, "{:$^14.6La}", F(0x1.23456p3));
+  test("0001.234560p+3", en_US, "{:014.6La}", F(0x1.23456p3));
+  test("-1.234560p+3$$$", en_US, "{:$<15.6La}", F(-0x1.23456p3));
+  test("$$$-1.234560p+3", en_US, "{:$>15.6La}", F(-0x1.23456p3));
+  test("$-1.234560p+3$$", en_US, "{:$^15.6La}", F(-0x1.23456p3));
+  test("-0001.234560p+3", en_US, "{:015.6La}", F(-0x1.23456p3));
+
+  std::locale::global(en_US);
+  test("1#234560p+3$$$", loc, "{:$<14.6La}", F(0x1.23456p3));
+  test("$$$1#234560p+3", loc, "{:$>14.6La}", F(0x1.23456p3));
+  test("$1#234560p+3$$", loc, "{:$^14.6La}", F(0x1.23456p3));
+  test("0001#234560p+3", loc, "{:014.6La}", F(0x1.23456p3));
+  test("-1#234560p+3$$$", loc, "{:$<15.6La}", F(-0x1.23456p3));
+  test("$$$-1#234560p+3", loc, "{:$>15.6La}", F(-0x1.23456p3));
+  test("$-1#234560p+3$$", loc, "{:$^15.6La}", F(-0x1.23456p3));
+  test("-0001#234560p+3", loc, "{:015.6La}", F(-0x1.23456p3));
+}
+
+template <class F>
+static void test_floating_point_hex_upper_case_precision() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.234560P-3", "{:.6LA}", F(0x1.23456p-3));
+  test("1.234560P-2", "{:.6LA}", F(0x1.23456p-2));
+  test("1.234560P-1", "{:.6LA}", F(0x1.23456p-1));
+  test("1.234560P+0", "{:.6LA}", F(0x1.23456p0));
+  test("1.234560P+1", "{:.6LA}", F(0x1.23456p+1));
+  test("1.234560P+2", "{:.6LA}", F(0x1.23456p+2));
+  test("1.234560P+3", "{:.6LA}", F(0x1.23456p+3));
+  test("1.234560P+20", "{:.6LA}", F(0x1.23456p+20));
+
+  std::locale::global(loc);
+  test("1#234560P-3", "{:.6LA}", F(0x1.23456p-3));
+  test("1#234560P-2", "{:.6LA}", F(0x1.23456p-2));
+  test("1#234560P-1", "{:.6LA}", F(0x1.23456p-1));
+  test("1#234560P+0", "{:.6LA}", F(0x1.23456p0));
+  test("1#234560P+1", "{:.6LA}", F(0x1.23456p+1));
+  test("1#234560P+2", "{:.6LA}", F(0x1.23456p+2));
+  test("1#234560P+3", "{:.6LA}", F(0x1.23456p+3));
+  test("1#234560P+20", "{:.6LA}", F(0x1.23456p+20));
+
+  test("1.234560P-3", en_US, "{:.6LA}", F(0x1.23456p-3));
+  test("1.234560P-2", en_US, "{:.6LA}", F(0x1.23456p-2));
+  test("1.234560P-1", en_US, "{:.6LA}", F(0x1.23456p-1));
+  test("1.234560P+0", en_US, "{:.6LA}", F(0x1.23456p0));
+  test("1.234560P+1", en_US, "{:.6LA}", F(0x1.23456p+1));
+  test("1.234560P+2", en_US, "{:.6LA}", F(0x1.23456p+2));
+  test("1.234560P+3", en_US, "{:.6LA}", F(0x1.23456p+3));
+  test("1.234560P+20", en_US, "{:.6LA}", F(0x1.23456p+20));
+
+  std::locale::global(en_US);
+  test("1#234560P-3", loc, "{:.6LA}", F(0x1.23456p-3));
+  test("1#234560P-2", loc, "{:.6LA}", F(0x1.23456p-2));
+  test("1#234560P-1", loc, "{:.6LA}", F(0x1.23456p-1));
+  test("1#234560P+0", loc, "{:.6LA}", F(0x1.23456p0));
+  test("1#234560P+1", loc, "{:.6LA}", F(0x1.23456p+1));
+  test("1#234560P+2", loc, "{:.6LA}", F(0x1.23456p+2));
+  test("1#234560P+3", loc, "{:.6LA}", F(0x1.23456p+3));
+  test("1#234560P+20", loc, "{:.6LA}", F(0x1.23456p+20));
+
+  // *** Fill, align, zero Padding ***
+  std::locale::global(en_US);
+  test("1.234560P+3$$$", "{:$<14.6LA}", F(0x1.23456p3));
+  test("$$$1.234560P+3", "{:$>14.6LA}", F(0x1.23456p3));
+  test("$1.234560P+3$$", "{:$^14.6LA}", F(0x1.23456p3));
+  test("0001.234560P+3", "{:014.6LA}", F(0x1.23456p3));
+  test("-1.234560P+3$$$", "{:$<15.6LA}", F(-0x1.23456p3));
+  test("$$$-1.234560P+3", "{:$>15.6LA}", F(-0x1.23456p3));
+  test("$-1.234560P+3$$", "{:$^15.6LA}", F(-0x1.23456p3));
+  test("-0001.234560P+3", "{:015.6LA}", F(-0x1.23456p3));
+
+  std::locale::global(loc);
+  test("1#234560P+3$$$", "{:$<14.6LA}", F(0x1.23456p3));
+  test("$$$1#234560P+3", "{:$>14.6LA}", F(0x1.23456p3));
+  test("$1#234560P+3$$", "{:$^14.6LA}", F(0x1.23456p3));
+  test("0001#234560P+3", "{:014.6LA}", F(0x1.23456p3));
+  test("-1#234560P+3$$$", "{:$<15.6LA}", F(-0x1.23456p3));
+  test("$$$-1#234560P+3", "{:$>15.6LA}", F(-0x1.23456p3));
+  test("$-1#234560P+3$$", "{:$^15.6LA}", F(-0x1.23456p3));
+  test("-0001#234560P+3", "{:015.6LA}", F(-0x1.23456p3));
+
+  test("1.234560P+3$$$", en_US, "{:$<14.6LA}", F(0x1.23456p3));
+  test("$$$1.234560P+3", en_US, "{:$>14.6LA}", F(0x1.23456p3));
+  test("$1.234560P+3$$", en_US, "{:$^14.6LA}", F(0x1.23456p3));
+  test("0001.234560P+3", en_US, "{:014.6LA}", F(0x1.23456p3));
+  test("-1.234560P+3$$$", en_US, "{:$<15.6LA}", F(-0x1.23456p3));
+  test("$$$-1.234560P+3", en_US, "{:$>15.6LA}", F(-0x1.23456p3));
+  test("$-1.234560P+3$$", en_US, "{:$^15.6LA}", F(-0x1.23456p3));
+  test("-0001.234560P+3", en_US, "{:015.6LA}", F(-0x1.23456p3));
+
+  std::locale::global(en_US);
+  test("1#234560P+3$$$", loc, "{:$<14.6LA}", F(0x1.23456p3));
+  test("$$$1#234560P+3", loc, "{:$>14.6LA}", F(0x1.23456p3));
+  test("$1#234560P+3$$", loc, "{:$^14.6LA}", F(0x1.23456p3));
+  test("0001#234560P+3", loc, "{:014.6LA}", F(0x1.23456p3));
+  test("-1#234560P+3$$$", loc, "{:$<15.6LA}", F(-0x1.23456p3));
+  test("$$$-1#234560P+3", loc, "{:$>15.6LA}", F(-0x1.23456p3));
+  test("$-1#234560P+3$$", loc, "{:$^15.6LA}", F(-0x1.23456p3));
+  test("-0001#234560P+3", loc, "{:015.6LA}", F(-0x1.23456p3));
+}
+
+template <class F>
+static void test_floating_point_scientific_lower_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.234567e-03", "{:.6Le}", F(1.234567e-3));
+  test("1.234567e-02", "{:.6Le}", F(1.234567e-2));
+  test("1.234567e-01", "{:.6Le}", F(1.234567e-1));
+  test("1.234567e+00", "{:.6Le}", F(1.234567e0));
+  test("1.234567e+01", "{:.6Le}", F(1.234567e1));
+  test("1.234567e+02", "{:.6Le}", F(1.234567e2));
+  test("1.234567e+03", "{:.6Le}", F(1.234567e3));
+  test("1.234567e+20", "{:.6Le}", F(1.234567e20));
+  test("-1.234567e-03", "{:.6Le}", F(-1.234567e-3));
+  test("-1.234567e-02", "{:.6Le}", F(-1.234567e-2));
+  test("-1.234567e-01", "{:.6Le}", F(-1.234567e-1));
+  test("-1.234567e+00", "{:.6Le}", F(-1.234567e0));
+  test("-1.234567e+01", "{:.6Le}", F(-1.234567e1));
+  test("-1.234567e+02", "{:.6Le}", F(-1.234567e2));
+  test("-1.234567e+03", "{:.6Le}", F(-1.234567e3));
+  test("-1.234567e+20", "{:.6Le}", F(-1.234567e20));
+
+  std::locale::global(loc);
+  test("1#234567e-03", "{:.6Le}", F(1.234567e-3));
+  test("1#234567e-02", "{:.6Le}", F(1.234567e-2));
+  test("1#234567e-01", "{:.6Le}", F(1.234567e-1));
+  test("1#234567e+00", "{:.6Le}", F(1.234567e0));
+  test("1#234567e+01", "{:.6Le}", F(1.234567e1));
+  test("1#234567e+02", "{:.6Le}", F(1.234567e2));
+  test("1#234567e+03", "{:.6Le}", F(1.234567e3));
+  test("1#234567e+20", "{:.6Le}", F(1.234567e20));
+  test("-1#234567e-03", "{:.6Le}", F(-1.234567e-3));
+  test("-1#234567e-02", "{:.6Le}", F(-1.234567e-2));
+  test("-1#234567e-01", "{:.6Le}", F(-1.234567e-1));
+  test("-1#234567e+00", "{:.6Le}", F(-1.234567e0));
+  test("-1#234567e+01", "{:.6Le}", F(-1.234567e1));
+  test("-1#234567e+02", "{:.6Le}", F(-1.234567e2));
+  test("-1#234567e+03", "{:.6Le}", F(-1.234567e3));
+  test("-1#234567e+20", "{:.6Le}", F(-1.234567e20));
+
+  test("1.234567e-03", en_US, "{:.6Le}", F(1.234567e-3));
+  test("1.234567e-02", en_US, "{:.6Le}", F(1.234567e-2));
+  test("1.234567e-01", en_US, "{:.6Le}", F(1.234567e-1));
+  test("1.234567e+00", en_US, "{:.6Le}", F(1.234567e0));
+  test("1.234567e+01", en_US, "{:.6Le}", F(1.234567e1));
+  test("1.234567e+02", en_US, "{:.6Le}", F(1.234567e2));
+  test("1.234567e+03", en_US, "{:.6Le}", F(1.234567e3));
+  test("1.234567e+20", en_US, "{:.6Le}", F(1.234567e20));
+  test("-1.234567e-03", en_US, "{:.6Le}", F(-1.234567e-3));
+  test("-1.234567e-02", en_US, "{:.6Le}", F(-1.234567e-2));
+  test("-1.234567e-01", en_US, "{:.6Le}", F(-1.234567e-1));
+  test("-1.234567e+00", en_US, "{:.6Le}", F(-1.234567e0));
+  test("-1.234567e+01", en_US, "{:.6Le}", F(-1.234567e1));
+  test("-1.234567e+02", en_US, "{:.6Le}", F(-1.234567e2));
+  test("-1.234567e+03", en_US, "{:.6Le}", F(-1.234567e3));
+  test("-1.234567e+20", en_US, "{:.6Le}", F(-1.234567e20));
+
+  std::locale::global(en_US);
+  test("1#234567e-03", loc, "{:.6Le}", F(1.234567e-3));
+  test("1#234567e-02", loc, "{:.6Le}", F(1.234567e-2));
+  test("1#234567e-01", loc, "{:.6Le}", F(1.234567e-1));
+  test("1#234567e+00", loc, "{:.6Le}", F(1.234567e0));
+  test("1#234567e+01", loc, "{:.6Le}", F(1.234567e1));
+  test("1#234567e+02", loc, "{:.6Le}", F(1.234567e2));
+  test("1#234567e+03", loc, "{:.6Le}", F(1.234567e3));
+  test("1#234567e+20", loc, "{:.6Le}", F(1.234567e20));
+  test("-1#234567e-03", loc, "{:.6Le}", F(-1.234567e-3));
+  test("-1#234567e-02", loc, "{:.6Le}", F(-1.234567e-2));
+  test("-1#234567e-01", loc, "{:.6Le}", F(-1.234567e-1));
+  test("-1#234567e+00", loc, "{:.6Le}", F(-1.234567e0));
+  test("-1#234567e+01", loc, "{:.6Le}", F(-1.234567e1));
+  test("-1#234567e+02", loc, "{:.6Le}", F(-1.234567e2));
+  test("-1#234567e+03", loc, "{:.6Le}", F(-1.234567e3));
+  test("-1#234567e+20", loc, "{:.6Le}", F(-1.234567e20));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1.234567e+03$$$", "{:$<15.6Le}", F(1.234567e3));
+  test("$$$1.234567e+03", "{:$>15.6Le}", F(1.234567e3));
+  test("$1.234567e+03$$", "{:$^15.6Le}", F(1.234567e3));
+  test("0001.234567e+03", "{:015.6Le}", F(1.234567e3));
+  test("-1.234567e+03$$$", "{:$<16.6Le}", F(-1.234567e3));
+  test("$$$-1.234567e+03", "{:$>16.6Le}", F(-1.234567e3));
+  test("$-1.234567e+03$$", "{:$^16.6Le}", F(-1.234567e3));
+  test("-0001.234567e+03", "{:016.6Le}", F(-1.234567e3));
+
+  std::locale::global(loc);
+  test("1#234567e+03$$$", "{:$<15.6Le}", F(1.234567e3));
+  test("$$$1#234567e+03", "{:$>15.6Le}", F(1.234567e3));
+  test("$1#234567e+03$$", "{:$^15.6Le}", F(1.234567e3));
+  test("0001#234567e+03", "{:015.6Le}", F(1.234567e3));
+  test("-1#234567e+03$$$", "{:$<16.6Le}", F(-1.234567e3));
+  test("$$$-1#234567e+03", "{:$>16.6Le}", F(-1.234567e3));
+  test("$-1#234567e+03$$", "{:$^16.6Le}", F(-1.234567e3));
+  test("-0001#234567e+03", "{:016.6Le}", F(-1.234567e3));
+
+  test("1.234567e+03$$$", en_US, "{:$<15.6Le}", F(1.234567e3));
+  test("$$$1.234567e+03", en_US, "{:$>15.6Le}", F(1.234567e3));
+  test("$1.234567e+03$$", en_US, "{:$^15.6Le}", F(1.234567e3));
+  test("0001.234567e+03", en_US, "{:015.6Le}", F(1.234567e3));
+  test("-1.234567e+03$$$", en_US, "{:$<16.6Le}", F(-1.234567e3));
+  test("$$$-1.234567e+03", en_US, "{:$>16.6Le}", F(-1.234567e3));
+  test("$-1.234567e+03$$", en_US, "{:$^16.6Le}", F(-1.234567e3));
+  test("-0001.234567e+03", en_US, "{:016.6Le}", F(-1.234567e3));
+
+  std::locale::global(en_US);
+  test("1#234567e+03$$$", loc, "{:$<15.6Le}", F(1.234567e3));
+  test("$$$1#234567e+03", loc, "{:$>15.6Le}", F(1.234567e3));
+  test("$1#234567e+03$$", loc, "{:$^15.6Le}", F(1.234567e3));
+  test("0001#234567e+03", loc, "{:015.6Le}", F(1.234567e3));
+  test("-1#234567e+03$$$", loc, "{:$<16.6Le}", F(-1.234567e3));
+  test("$$$-1#234567e+03", loc, "{:$>16.6Le}", F(-1.234567e3));
+  test("$-1#234567e+03$$", loc, "{:$^16.6Le}", F(-1.234567e3));
+  test("-0001#234567e+03", loc, "{:016.6Le}", F(-1.234567e3));
+}
+
+template <class F>
+static void test_floating_point_scientific_upper_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.234567E-03", "{:.6LE}", F(1.234567e-3));
+  test("1.234567E-02", "{:.6LE}", F(1.234567e-2));
+  test("1.234567E-01", "{:.6LE}", F(1.234567e-1));
+  test("1.234567E+00", "{:.6LE}", F(1.234567e0));
+  test("1.234567E+01", "{:.6LE}", F(1.234567e1));
+  test("1.234567E+02", "{:.6LE}", F(1.234567e2));
+  test("1.234567E+03", "{:.6LE}", F(1.234567e3));
+  test("1.234567E+20", "{:.6LE}", F(1.234567e20));
+  test("-1.234567E-03", "{:.6LE}", F(-1.234567e-3));
+  test("-1.234567E-02", "{:.6LE}", F(-1.234567e-2));
+  test("-1.234567E-01", "{:.6LE}", F(-1.234567e-1));
+  test("-1.234567E+00", "{:.6LE}", F(-1.234567e0));
+  test("-1.234567E+01", "{:.6LE}", F(-1.234567e1));
+  test("-1.234567E+02", "{:.6LE}", F(-1.234567e2));
+  test("-1.234567E+03", "{:.6LE}", F(-1.234567e3));
+  test("-1.234567E+20", "{:.6LE}", F(-1.234567e20));
+
+  std::locale::global(loc);
+  test("1#234567E-03", "{:.6LE}", F(1.234567e-3));
+  test("1#234567E-02", "{:.6LE}", F(1.234567e-2));
+  test("1#234567E-01", "{:.6LE}", F(1.234567e-1));
+  test("1#234567E+00", "{:.6LE}", F(1.234567e0));
+  test("1#234567E+01", "{:.6LE}", F(1.234567e1));
+  test("1#234567E+02", "{:.6LE}", F(1.234567e2));
+  test("1#234567E+03", "{:.6LE}", F(1.234567e3));
+  test("1#234567E+20", "{:.6LE}", F(1.234567e20));
+  test("-1#234567E-03", "{:.6LE}", F(-1.234567e-3));
+  test("-1#234567E-02", "{:.6LE}", F(-1.234567e-2));
+  test("-1#234567E-01", "{:.6LE}", F(-1.234567e-1));
+  test("-1#234567E+00", "{:.6LE}", F(-1.234567e0));
+  test("-1#234567E+01", "{:.6LE}", F(-1.234567e1));
+  test("-1#234567E+02", "{:.6LE}", F(-1.234567e2));
+  test("-1#234567E+03", "{:.6LE}", F(-1.234567e3));
+  test("-1#234567E+20", "{:.6LE}", F(-1.234567e20));
+
+  test("1.234567E-03", en_US, "{:.6LE}", F(1.234567e-3));
+  test("1.234567E-02", en_US, "{:.6LE}", F(1.234567e-2));
+  test("1.234567E-01", en_US, "{:.6LE}", F(1.234567e-1));
+  test("1.234567E+00", en_US, "{:.6LE}", F(1.234567e0));
+  test("1.234567E+01", en_US, "{:.6LE}", F(1.234567e1));
+  test("1.234567E+02", en_US, "{:.6LE}", F(1.234567e2));
+  test("1.234567E+03", en_US, "{:.6LE}", F(1.234567e3));
+  test("1.234567E+20", en_US, "{:.6LE}", F(1.234567e20));
+  test("-1.234567E-03", en_US, "{:.6LE}", F(-1.234567e-3));
+  test("-1.234567E-02", en_US, "{:.6LE}", F(-1.234567e-2));
+  test("-1.234567E-01", en_US, "{:.6LE}", F(-1.234567e-1));
+  test("-1.234567E+00", en_US, "{:.6LE}", F(-1.234567e0));
+  test("-1.234567E+01", en_US, "{:.6LE}", F(-1.234567e1));
+  test("-1.234567E+02", en_US, "{:.6LE}", F(-1.234567e2));
+  test("-1.234567E+03", en_US, "{:.6LE}", F(-1.234567e3));
+  test("-1.234567E+20", en_US, "{:.6LE}", F(-1.234567e20));
+
+  std::locale::global(en_US);
+  test("1#234567E-03", loc, "{:.6LE}", F(1.234567e-3));
+  test("1#234567E-02", loc, "{:.6LE}", F(1.234567e-2));
+  test("1#234567E-01", loc, "{:.6LE}", F(1.234567e-1));
+  test("1#234567E+00", loc, "{:.6LE}", F(1.234567e0));
+  test("1#234567E+01", loc, "{:.6LE}", F(1.234567e1));
+  test("1#234567E+02", loc, "{:.6LE}", F(1.234567e2));
+  test("1#234567E+03", loc, "{:.6LE}", F(1.234567e3));
+  test("1#234567E+20", loc, "{:.6LE}", F(1.234567e20));
+  test("-1#234567E-03", loc, "{:.6LE}", F(-1.234567e-3));
+  test("-1#234567E-02", loc, "{:.6LE}", F(-1.234567e-2));
+  test("-1#234567E-01", loc, "{:.6LE}", F(-1.234567e-1));
+  test("-1#234567E+00", loc, "{:.6LE}", F(-1.234567e0));
+  test("-1#234567E+01", loc, "{:.6LE}", F(-1.234567e1));
+  test("-1#234567E+02", loc, "{:.6LE}", F(-1.234567e2));
+  test("-1#234567E+03", loc, "{:.6LE}", F(-1.234567e3));
+  test("-1#234567E+20", loc, "{:.6LE}", F(-1.234567e20));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1.234567E+03$$$", "{:$<15.6LE}", F(1.234567e3));
+  test("$$$1.234567E+03", "{:$>15.6LE}", F(1.234567e3));
+  test("$1.234567E+03$$", "{:$^15.6LE}", F(1.234567e3));
+  test("0001.234567E+03", "{:015.6LE}", F(1.234567e3));
+  test("-1.234567E+03$$$", "{:$<16.6LE}", F(-1.234567e3));
+  test("$$$-1.234567E+03", "{:$>16.6LE}", F(-1.234567e3));
+  test("$-1.234567E+03$$", "{:$^16.6LE}", F(-1.234567e3));
+  test("-0001.234567E+03", "{:016.6LE}", F(-1.234567e3));
+
+  std::locale::global(loc);
+  test("1#234567E+03$$$", "{:$<15.6LE}", F(1.234567e3));
+  test("$$$1#234567E+03", "{:$>15.6LE}", F(1.234567e3));
+  test("$1#234567E+03$$", "{:$^15.6LE}", F(1.234567e3));
+  test("0001#234567E+03", "{:015.6LE}", F(1.234567e3));
+  test("-1#234567E+03$$$", "{:$<16.6LE}", F(-1.234567e3));
+  test("$$$-1#234567E+03", "{:$>16.6LE}", F(-1.234567e3));
+  test("$-1#234567E+03$$", "{:$^16.6LE}", F(-1.234567e3));
+  test("-0001#234567E+03", "{:016.6LE}", F(-1.234567e3));
+
+  test("1.234567E+03$$$", en_US, "{:$<15.6LE}", F(1.234567e3));
+  test("$$$1.234567E+03", en_US, "{:$>15.6LE}", F(1.234567e3));
+  test("$1.234567E+03$$", en_US, "{:$^15.6LE}", F(1.234567e3));
+  test("0001.234567E+03", en_US, "{:015.6LE}", F(1.234567e3));
+  test("-1.234567E+03$$$", en_US, "{:$<16.6LE}", F(-1.234567e3));
+  test("$$$-1.234567E+03", en_US, "{:$>16.6LE}", F(-1.234567e3));
+  test("$-1.234567E+03$$", en_US, "{:$^16.6LE}", F(-1.234567e3));
+  test("-0001.234567E+03", en_US, "{:016.6LE}", F(-1.234567e3));
+
+  std::locale::global(en_US);
+  test("1#234567E+03$$$", loc, "{:$<15.6LE}", F(1.234567e3));
+  test("$$$1#234567E+03", loc, "{:$>15.6LE}", F(1.234567e3));
+  test("$1#234567E+03$$", loc, "{:$^15.6LE}", F(1.234567e3));
+  test("0001#234567E+03", loc, "{:015.6LE}", F(1.234567e3));
+  test("-1#234567E+03$$$", loc, "{:$<16.6LE}", F(-1.234567e3));
+  test("$$$-1#234567E+03", loc, "{:$>16.6LE}", F(-1.234567e3));
+  test("$-1#234567E+03$$", loc, "{:$^16.6LE}", F(-1.234567e3));
+  test("-0001#234567E+03", loc, "{:016.6LE}", F(-1.234567e3));
+}
+
+template <class F>
+static void test_floating_point_fixed_lower_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("0.000001", "{:.6Lf}", F(1.234567e-6));
+  test("0.000012", "{:.6Lf}", F(1.234567e-5));
+  test("0.000123", "{:.6Lf}", F(1.234567e-4));
+  test("0.001235", "{:.6Lf}", F(1.234567e-3));
+  test("0.012346", "{:.6Lf}", F(1.234567e-2));
+  test("0.123457", "{:.6Lf}", F(1.234567e-1));
+  test("1.234567", "{:.6Lf}", F(1.234567e0));
+  test("12.345670", "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("123.456700", "{:.6Lf}", F(1.234567e2));
+    test("1,234.567000", "{:.6Lf}", F(1.234567e3));
+    test("12,345.670000", "{:.6Lf}", F(1.234567e4));
+    test("123,456.700000", "{:.6Lf}", F(1.234567e5));
+    test("1,234,567.000000", "{:.6Lf}", F(1.234567e6));
+    test("12,345,670.000000", "{:.6Lf}", F(1.234567e7));
+    test("123,456,700,000,000,000,000.000000", "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0.000001", "{:.6Lf}", F(-1.234567e-6));
+  test("-0.000012", "{:.6Lf}", F(-1.234567e-5));
+  test("-0.000123", "{:.6Lf}", F(-1.234567e-4));
+  test("-0.001235", "{:.6Lf}", F(-1.234567e-3));
+  test("-0.012346", "{:.6Lf}", F(-1.234567e-2));
+  test("-0.123457", "{:.6Lf}", F(-1.234567e-1));
+  test("-1.234567", "{:.6Lf}", F(-1.234567e0));
+  test("-12.345670", "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-123.456700", "{:.6Lf}", F(-1.234567e2));
+    test("-1,234.567000", "{:.6Lf}", F(-1.234567e3));
+    test("-12,345.670000", "{:.6Lf}", F(-1.234567e4));
+    test("-123,456.700000", "{:.6Lf}", F(-1.234567e5));
+    test("-1,234,567.000000", "{:.6Lf}", F(-1.234567e6));
+    test("-12,345,670.000000", "{:.6Lf}", F(-1.234567e7));
+    test("-123,456,700,000,000,000,000.000000", "{:.6Lf}", F(-1.234567e20));
+  }
+
+  std::locale::global(loc);
+  test("0#000001", "{:.6Lf}", F(1.234567e-6));
+  test("0#000012", "{:.6Lf}", F(1.234567e-5));
+  test("0#000123", "{:.6Lf}", F(1.234567e-4));
+  test("0#001235", "{:.6Lf}", F(1.234567e-3));
+  test("0#012346", "{:.6Lf}", F(1.234567e-2));
+  test("0#123457", "{:.6Lf}", F(1.234567e-1));
+  test("1#234567", "{:.6Lf}", F(1.234567e0));
+  test("1_2#345670", "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("12_3#456700", "{:.6Lf}", F(1.234567e2));
+    test("1_23_4#567000", "{:.6Lf}", F(1.234567e3));
+    test("12_34_5#670000", "{:.6Lf}", F(1.234567e4));
+    test("123_45_6#700000", "{:.6Lf}", F(1.234567e5));
+    test("1_234_56_7#000000", "{:.6Lf}", F(1.234567e6));
+    test("12_345_67_0#000000", "{:.6Lf}", F(1.234567e7));
+    test("1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0#000001", "{:.6Lf}", F(-1.234567e-6));
+  test("-0#000012", "{:.6Lf}", F(-1.234567e-5));
+  test("-0#000123", "{:.6Lf}", F(-1.234567e-4));
+  test("-0#001235", "{:.6Lf}", F(-1.234567e-3));
+  test("-0#012346", "{:.6Lf}", F(-1.234567e-2));
+  test("-0#123457", "{:.6Lf}", F(-1.234567e-1));
+  test("-1#234567", "{:.6Lf}", F(-1.234567e0));
+  test("-1_2#345670", "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-12_3#456700", "{:.6Lf}", F(-1.234567e2));
+    test("-1_23_4#567000", "{:.6Lf}", F(-1.234567e3));
+    test("-12_34_5#670000", "{:.6Lf}", F(-1.234567e4));
+    test("-123_45_6#700000", "{:.6Lf}", F(-1.234567e5));
+    test("-1_234_56_7#000000", "{:.6Lf}", F(-1.234567e6));
+    test("-12_345_67_0#000000", "{:.6Lf}", F(-1.234567e7));
+    test("-1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", "{:.6Lf}", F(-1.234567e20));
+  }
+
+  test("0.000001", en_US, "{:.6Lf}", F(1.234567e-6));
+  test("0.000012", en_US, "{:.6Lf}", F(1.234567e-5));
+  test("0.000123", en_US, "{:.6Lf}", F(1.234567e-4));
+  test("0.001235", en_US, "{:.6Lf}", F(1.234567e-3));
+  test("0.012346", en_US, "{:.6Lf}", F(1.234567e-2));
+  test("0.123457", en_US, "{:.6Lf}", F(1.234567e-1));
+  test("1.234567", en_US, "{:.6Lf}", F(1.234567e0));
+  test("12.345670", en_US, "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("123.456700", en_US, "{:.6Lf}", F(1.234567e2));
+    test("1,234.567000", en_US, "{:.6Lf}", F(1.234567e3));
+    test("12,345.670000", en_US, "{:.6Lf}", F(1.234567e4));
+    test("123,456.700000", en_US, "{:.6Lf}", F(1.234567e5));
+    test("1,234,567.000000", en_US, "{:.6Lf}", F(1.234567e6));
+    test("12,345,670.000000", en_US, "{:.6Lf}", F(1.234567e7));
+    test("123,456,700,000,000,000,000.000000", en_US, "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0.000001", en_US, "{:.6Lf}", F(-1.234567e-6));
+  test("-0.000012", en_US, "{:.6Lf}", F(-1.234567e-5));
+  test("-0.000123", en_US, "{:.6Lf}", F(-1.234567e-4));
+  test("-0.001235", en_US, "{:.6Lf}", F(-1.234567e-3));
+  test("-0.012346", en_US, "{:.6Lf}", F(-1.234567e-2));
+  test("-0.123457", en_US, "{:.6Lf}", F(-1.234567e-1));
+  test("-1.234567", en_US, "{:.6Lf}", F(-1.234567e0));
+  test("-12.345670", en_US, "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-123.456700", en_US, "{:.6Lf}", F(-1.234567e2));
+    test("-1,234.567000", en_US, "{:.6Lf}", F(-1.234567e3));
+    test("-12,345.670000", en_US, "{:.6Lf}", F(-1.234567e4));
+    test("-123,456.700000", en_US, "{:.6Lf}", F(-1.234567e5));
+    test("-1,234,567.000000", en_US, "{:.6Lf}", F(-1.234567e6));
+    test("-12,345,670.000000", en_US, "{:.6Lf}", F(-1.234567e7));
+    test("-123,456,700,000,000,000,000.000000", en_US, "{:.6Lf}", F(-1.234567e20));
+  }
+
+  std::locale::global(en_US);
+  test("0#000001", loc, "{:.6Lf}", F(1.234567e-6));
+  test("0#000012", loc, "{:.6Lf}", F(1.234567e-5));
+  test("0#000123", loc, "{:.6Lf}", F(1.234567e-4));
+  test("0#001235", loc, "{:.6Lf}", F(1.234567e-3));
+  test("0#012346", loc, "{:.6Lf}", F(1.234567e-2));
+  test("0#123457", loc, "{:.6Lf}", F(1.234567e-1));
+  test("1#234567", loc, "{:.6Lf}", F(1.234567e0));
+  test("1_2#345670", loc, "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("12_3#456700", loc, "{:.6Lf}", F(1.234567e2));
+    test("1_23_4#567000", loc, "{:.6Lf}", F(1.234567e3));
+    test("12_34_5#670000", loc, "{:.6Lf}", F(1.234567e4));
+    test("123_45_6#700000", loc, "{:.6Lf}", F(1.234567e5));
+    test("1_234_56_7#000000", loc, "{:.6Lf}", F(1.234567e6));
+    test("12_345_67_0#000000", loc, "{:.6Lf}", F(1.234567e7));
+    test("1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", loc, "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0#000001", loc, "{:.6Lf}", F(-1.234567e-6));
+  test("-0#000012", loc, "{:.6Lf}", F(-1.234567e-5));
+  test("-0#000123", loc, "{:.6Lf}", F(-1.234567e-4));
+  test("-0#001235", loc, "{:.6Lf}", F(-1.234567e-3));
+  test("-0#012346", loc, "{:.6Lf}", F(-1.234567e-2));
+  test("-0#123457", loc, "{:.6Lf}", F(-1.234567e-1));
+  test("-1#234567", loc, "{:.6Lf}", F(-1.234567e0));
+  test("-1_2#345670", loc, "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-12_3#456700", loc, "{:.6Lf}", F(-1.234567e2));
+    test("-1_23_4#567000", loc, "{:.6Lf}", F(-1.234567e3));
+    test("-12_34_5#670000", loc, "{:.6Lf}", F(-1.234567e4));
+    test("-123_45_6#700000", loc, "{:.6Lf}", F(-1.234567e5));
+    test("-1_234_56_7#000000", loc, "{:.6Lf}", F(-1.234567e6));
+    test("-12_345_67_0#000000", loc, "{:.6Lf}", F(-1.234567e7));
+    test("-1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", loc, "{:.6Lf}", F(-1.234567e20));
+  }
+
+  // *** Fill, align, zero padding ***
+  if constexpr (sizeof(F) > sizeof(float)) {
+    std::locale::global(en_US);
+    test("1,234.567000$$$", "{:$<15.6Lf}", F(1.234567e3));
+    test("$$$1,234.567000", "{:$>15.6Lf}", F(1.234567e3));
+    test("$1,234.567000$$", "{:$^15.6Lf}", F(1.234567e3));
+    test("0001,234.567000", "{:015.6Lf}", F(1.234567e3));
+    test("-1,234.567000$$$", "{:$<16.6Lf}", F(-1.234567e3));
+    test("$$$-1,234.567000", "{:$>16.6Lf}", F(-1.234567e3));
+    test("$-1,234.567000$$", "{:$^16.6Lf}", F(-1.234567e3));
+    test("-0001,234.567000", "{:016.6Lf}", F(-1.234567e3));
+
+    std::locale::global(loc);
+    test("1_23_4#567000$$$", "{:$<16.6Lf}", F(1.234567e3));
+    test("$$$1_23_4#567000", "{:$>16.6Lf}", F(1.234567e3));
+    test("$1_23_4#567000$$", "{:$^16.6Lf}", F(1.234567e3));
+    test("0001_23_4#567000", "{:016.6Lf}", F(1.234567e3));
+    test("-1_23_4#567000$$$", "{:$<17.6Lf}", F(-1.234567e3));
+    test("$$$-1_23_4#567000", "{:$>17.6Lf}", F(-1.234567e3));
+    test("$-1_23_4#567000$$", "{:$^17.6Lf}", F(-1.234567e3));
+    test("-0001_23_4#567000", "{:017.6Lf}", F(-1.234567e3));
+
+    test("1,234.567000$$$", en_US, "{:$<15.6Lf}", F(1.234567e3));
+    test("$$$1,234.567000", en_US, "{:$>15.6Lf}", F(1.234567e3));
+    test("$1,234.567000$$", en_US, "{:$^15.6Lf}", F(1.234567e3));
+    test("0001,234.567000", en_US, "{:015.6Lf}", F(1.234567e3));
+    test("-1,234.567000$$$", en_US, "{:$<16.6Lf}", F(-1.234567e3));
+    test("$$$-1,234.567000", en_US, "{:$>16.6Lf}", F(-1.234567e3));
+    test("$-1,234.567000$$", en_US, "{:$^16.6Lf}", F(-1.234567e3));
+    test("-0001,234.567000", en_US, "{:016.6Lf}", F(-1.234567e3));
+
+    std::locale::global(en_US);
+    test("1_23_4#567000$$$", loc, "{:$<16.6Lf}", F(1.234567e3));
+    test("$$$1_23_4#567000", loc, "{:$>16.6Lf}", F(1.234567e3));
+    test("$1_23_4#567000$$", loc, "{:$^16.6Lf}", F(1.234567e3));
+    test("0001_23_4#567000", loc, "{:016.6Lf}", F(1.234567e3));
+    test("-1_23_4#567000$$$", loc, "{:$<17.6Lf}", F(-1.234567e3));
+    test("$$$-1_23_4#567000", loc, "{:$>17.6Lf}", F(-1.234567e3));
+    test("$-1_23_4#567000$$", loc, "{:$^17.6Lf}", F(-1.234567e3));
+    test("-0001_23_4#567000", loc, "{:017.6Lf}", F(-1.234567e3));
+  }
+}
+
+template <class F>
+static void test_floating_point_fixed_upper_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("0.000001", "{:.6Lf}", F(1.234567e-6));
+  test("0.000012", "{:.6Lf}", F(1.234567e-5));
+  test("0.000123", "{:.6Lf}", F(1.234567e-4));
+  test("0.001235", "{:.6Lf}", F(1.234567e-3));
+  test("0.012346", "{:.6Lf}", F(1.234567e-2));
+  test("0.123457", "{:.6Lf}", F(1.234567e-1));
+  test("1.234567", "{:.6Lf}", F(1.234567e0));
+  test("12.345670", "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("123.456700", "{:.6Lf}", F(1.234567e2));
+    test("1,234.567000", "{:.6Lf}", F(1.234567e3));
+    test("12,345.670000", "{:.6Lf}", F(1.234567e4));
+    test("123,456.700000", "{:.6Lf}", F(1.234567e5));
+    test("1,234,567.000000", "{:.6Lf}", F(1.234567e6));
+    test("12,345,670.000000", "{:.6Lf}", F(1.234567e7));
+    test("123,456,700,000,000,000,000.000000", "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0.000001", "{:.6Lf}", F(-1.234567e-6));
+  test("-0.000012", "{:.6Lf}", F(-1.234567e-5));
+  test("-0.000123", "{:.6Lf}", F(-1.234567e-4));
+  test("-0.001235", "{:.6Lf}", F(-1.234567e-3));
+  test("-0.012346", "{:.6Lf}", F(-1.234567e-2));
+  test("-0.123457", "{:.6Lf}", F(-1.234567e-1));
+  test("-1.234567", "{:.6Lf}", F(-1.234567e0));
+  test("-12.345670", "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-123.456700", "{:.6Lf}", F(-1.234567e2));
+    test("-1,234.567000", "{:.6Lf}", F(-1.234567e3));
+    test("-12,345.670000", "{:.6Lf}", F(-1.234567e4));
+    test("-123,456.700000", "{:.6Lf}", F(-1.234567e5));
+    test("-1,234,567.000000", "{:.6Lf}", F(-1.234567e6));
+    test("-12,345,670.000000", "{:.6Lf}", F(-1.234567e7));
+    test("-123,456,700,000,000,000,000.000000", "{:.6Lf}", F(-1.234567e20));
+  }
+
+  std::locale::global(loc);
+  test("0#000001", "{:.6Lf}", F(1.234567e-6));
+  test("0#000012", "{:.6Lf}", F(1.234567e-5));
+  test("0#000123", "{:.6Lf}", F(1.234567e-4));
+  test("0#001235", "{:.6Lf}", F(1.234567e-3));
+  test("0#012346", "{:.6Lf}", F(1.234567e-2));
+  test("0#123457", "{:.6Lf}", F(1.234567e-1));
+  test("1#234567", "{:.6Lf}", F(1.234567e0));
+  test("1_2#345670", "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("12_3#456700", "{:.6Lf}", F(1.234567e2));
+    test("1_23_4#567000", "{:.6Lf}", F(1.234567e3));
+    test("12_34_5#670000", "{:.6Lf}", F(1.234567e4));
+    test("123_45_6#700000", "{:.6Lf}", F(1.234567e5));
+    test("1_234_56_7#000000", "{:.6Lf}", F(1.234567e6));
+    test("12_345_67_0#000000", "{:.6Lf}", F(1.234567e7));
+    test("1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0#000001", "{:.6Lf}", F(-1.234567e-6));
+  test("-0#000012", "{:.6Lf}", F(-1.234567e-5));
+  test("-0#000123", "{:.6Lf}", F(-1.234567e-4));
+  test("-0#001235", "{:.6Lf}", F(-1.234567e-3));
+  test("-0#012346", "{:.6Lf}", F(-1.234567e-2));
+  test("-0#123457", "{:.6Lf}", F(-1.234567e-1));
+  test("-1#234567", "{:.6Lf}", F(-1.234567e0));
+  test("-1_2#345670", "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-12_3#456700", "{:.6Lf}", F(-1.234567e2));
+    test("-1_23_4#567000", "{:.6Lf}", F(-1.234567e3));
+    test("-12_34_5#670000", "{:.6Lf}", F(-1.234567e4));
+    test("-123_45_6#700000", "{:.6Lf}", F(-1.234567e5));
+    test("-1_234_56_7#000000", "{:.6Lf}", F(-1.234567e6));
+    test("-12_345_67_0#000000", "{:.6Lf}", F(-1.234567e7));
+    test("-1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", "{:.6Lf}", F(-1.234567e20));
+  }
+
+  test("0.000001", en_US, "{:.6Lf}", F(1.234567e-6));
+  test("0.000012", en_US, "{:.6Lf}", F(1.234567e-5));
+  test("0.000123", en_US, "{:.6Lf}", F(1.234567e-4));
+  test("0.001235", en_US, "{:.6Lf}", F(1.234567e-3));
+  test("0.012346", en_US, "{:.6Lf}", F(1.234567e-2));
+  test("0.123457", en_US, "{:.6Lf}", F(1.234567e-1));
+  test("1.234567", en_US, "{:.6Lf}", F(1.234567e0));
+  test("12.345670", en_US, "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("123.456700", en_US, "{:.6Lf}", F(1.234567e2));
+    test("1,234.567000", en_US, "{:.6Lf}", F(1.234567e3));
+    test("12,345.670000", en_US, "{:.6Lf}", F(1.234567e4));
+    test("123,456.700000", en_US, "{:.6Lf}", F(1.234567e5));
+    test("1,234,567.000000", en_US, "{:.6Lf}", F(1.234567e6));
+    test("12,345,670.000000", en_US, "{:.6Lf}", F(1.234567e7));
+    test("123,456,700,000,000,000,000.000000", en_US, "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0.000001", en_US, "{:.6Lf}", F(-1.234567e-6));
+  test("-0.000012", en_US, "{:.6Lf}", F(-1.234567e-5));
+  test("-0.000123", en_US, "{:.6Lf}", F(-1.234567e-4));
+  test("-0.001235", en_US, "{:.6Lf}", F(-1.234567e-3));
+  test("-0.012346", en_US, "{:.6Lf}", F(-1.234567e-2));
+  test("-0.123457", en_US, "{:.6Lf}", F(-1.234567e-1));
+  test("-1.234567", en_US, "{:.6Lf}", F(-1.234567e0));
+  test("-12.345670", en_US, "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-123.456700", en_US, "{:.6Lf}", F(-1.234567e2));
+    test("-1,234.567000", en_US, "{:.6Lf}", F(-1.234567e3));
+    test("-12,345.670000", en_US, "{:.6Lf}", F(-1.234567e4));
+    test("-123,456.700000", en_US, "{:.6Lf}", F(-1.234567e5));
+    test("-1,234,567.000000", en_US, "{:.6Lf}", F(-1.234567e6));
+    test("-12,345,670.000000", en_US, "{:.6Lf}", F(-1.234567e7));
+    test("-123,456,700,000,000,000,000.000000", en_US, "{:.6Lf}", F(-1.234567e20));
+  }
+
+  std::locale::global(en_US);
+  test("0#000001", loc, "{:.6Lf}", F(1.234567e-6));
+  test("0#000012", loc, "{:.6Lf}", F(1.234567e-5));
+  test("0#000123", loc, "{:.6Lf}", F(1.234567e-4));
+  test("0#001235", loc, "{:.6Lf}", F(1.234567e-3));
+  test("0#012346", loc, "{:.6Lf}", F(1.234567e-2));
+  test("0#123457", loc, "{:.6Lf}", F(1.234567e-1));
+  test("1#234567", loc, "{:.6Lf}", F(1.234567e0));
+  test("1_2#345670", loc, "{:.6Lf}", F(1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("12_3#456700", loc, "{:.6Lf}", F(1.234567e2));
+    test("1_23_4#567000", loc, "{:.6Lf}", F(1.234567e3));
+    test("12_34_5#670000", loc, "{:.6Lf}", F(1.234567e4));
+    test("123_45_6#700000", loc, "{:.6Lf}", F(1.234567e5));
+    test("1_234_56_7#000000", loc, "{:.6Lf}", F(1.234567e6));
+    test("12_345_67_0#000000", loc, "{:.6Lf}", F(1.234567e7));
+    test("1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", loc, "{:.6Lf}", F(1.234567e20));
+  }
+  test("-0#000001", loc, "{:.6Lf}", F(-1.234567e-6));
+  test("-0#000012", loc, "{:.6Lf}", F(-1.234567e-5));
+  test("-0#000123", loc, "{:.6Lf}", F(-1.234567e-4));
+  test("-0#001235", loc, "{:.6Lf}", F(-1.234567e-3));
+  test("-0#012346", loc, "{:.6Lf}", F(-1.234567e-2));
+  test("-0#123457", loc, "{:.6Lf}", F(-1.234567e-1));
+  test("-1#234567", loc, "{:.6Lf}", F(-1.234567e0));
+  test("-1_2#345670", loc, "{:.6Lf}", F(-1.234567e1));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-12_3#456700", loc, "{:.6Lf}", F(-1.234567e2));
+    test("-1_23_4#567000", loc, "{:.6Lf}", F(-1.234567e3));
+    test("-12_34_5#670000", loc, "{:.6Lf}", F(-1.234567e4));
+    test("-123_45_6#700000", loc, "{:.6Lf}", F(-1.234567e5));
+    test("-1_234_56_7#000000", loc, "{:.6Lf}", F(-1.234567e6));
+    test("-12_345_67_0#000000", loc, "{:.6Lf}", F(-1.234567e7));
+    test("-1_2_3_4_5_6_7_0_0_0_0_0_0_00_000_00_0#000000", loc, "{:.6Lf}", F(-1.234567e20));
+  }
+
+  // *** Fill, align, zero padding ***
+  if constexpr (sizeof(F) > sizeof(float)) {
+    std::locale::global(en_US);
+    test("1,234.567000$$$", "{:$<15.6Lf}", F(1.234567e3));
+    test("$$$1,234.567000", "{:$>15.6Lf}", F(1.234567e3));
+    test("$1,234.567000$$", "{:$^15.6Lf}", F(1.234567e3));
+    test("0001,234.567000", "{:015.6Lf}", F(1.234567e3));
+    test("-1,234.567000$$$", "{:$<16.6Lf}", F(-1.234567e3));
+    test("$$$-1,234.567000", "{:$>16.6Lf}", F(-1.234567e3));
+    test("$-1,234.567000$$", "{:$^16.6Lf}", F(-1.234567e3));
+    test("-0001,234.567000", "{:016.6Lf}", F(-1.234567e3));
+
+    std::locale::global(loc);
+    test("1_23_4#567000$$$", "{:$<16.6Lf}", F(1.234567e3));
+    test("$$$1_23_4#567000", "{:$>16.6Lf}", F(1.234567e3));
+    test("$1_23_4#567000$$", "{:$^16.6Lf}", F(1.234567e3));
+    test("0001_23_4#567000", "{:016.6Lf}", F(1.234567e3));
+    test("-1_23_4#567000$$$", "{:$<17.6Lf}", F(-1.234567e3));
+    test("$$$-1_23_4#567000", "{:$>17.6Lf}", F(-1.234567e3));
+    test("$-1_23_4#567000$$", "{:$^17.6Lf}", F(-1.234567e3));
+    test("-0001_23_4#567000", "{:017.6Lf}", F(-1.234567e3));
+
+    test("1,234.567000$$$", en_US, "{:$<15.6Lf}", F(1.234567e3));
+    test("$$$1,234.567000", en_US, "{:$>15.6Lf}", F(1.234567e3));
+    test("$1,234.567000$$", en_US, "{:$^15.6Lf}", F(1.234567e3));
+    test("0001,234.567000", en_US, "{:015.6Lf}", F(1.234567e3));
+    test("-1,234.567000$$$", en_US, "{:$<16.6Lf}", F(-1.234567e3));
+    test("$$$-1,234.567000", en_US, "{:$>16.6Lf}", F(-1.234567e3));
+    test("$-1,234.567000$$", en_US, "{:$^16.6Lf}", F(-1.234567e3));
+    test("-0001,234.567000", en_US, "{:016.6Lf}", F(-1.234567e3));
+
+    std::locale::global(en_US);
+    test("1_23_4#567000$$$", loc, "{:$<16.6Lf}", F(1.234567e3));
+    test("$$$1_23_4#567000", loc, "{:$>16.6Lf}", F(1.234567e3));
+    test("$1_23_4#567000$$", loc, "{:$^16.6Lf}", F(1.234567e3));
+    test("0001_23_4#567000", loc, "{:016.6Lf}", F(1.234567e3));
+    test("-1_23_4#567000$$$", loc, "{:$<17.6Lf}", F(-1.234567e3));
+    test("$$$-1_23_4#567000", loc, "{:$>17.6Lf}", F(-1.234567e3));
+    test("$-1_23_4#567000$$", loc, "{:$^17.6Lf}", F(-1.234567e3));
+    test("-0001_23_4#567000", loc, "{:017.6Lf}", F(-1.234567e3));
+  }
+}
+
+template <class F>
+static void test_floating_point_general_lower_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.23457e-06", "{:.6Lg}", F(1.234567e-6));
+  test("1.23457e-05", "{:.6Lg}", F(1.234567e-5));
+  test("0.000123457", "{:.6Lg}", F(1.234567e-4));
+  test("0.00123457", "{:.6Lg}", F(1.234567e-3));
+  test("0.0123457", "{:.6Lg}", F(1.234567e-2));
+  test("0.123457", "{:.6Lg}", F(1.234567e-1));
+  test("1.23457", "{:.6Lg}", F(1.234567e0));
+  test("12.3457", "{:.6Lg}", F(1.234567e1));
+  test("123.457", "{:.6Lg}", F(1.234567e2));
+  test("1,234.57", "{:.6Lg}", F(1.234567e3));
+  test("12,345.7", "{:.6Lg}", F(1.234567e4));
+  test("123,457", "{:.6Lg}", F(1.234567e5));
+  test("1.23457e+06", "{:.6Lg}", F(1.234567e6));
+  test("1.23457e+07", "{:.6Lg}", F(1.234567e7));
+  test("-1.23457e-06", "{:.6Lg}", F(-1.234567e-6));
+  test("-1.23457e-05", "{:.6Lg}", F(-1.234567e-5));
+  test("-0.000123457", "{:.6Lg}", F(-1.234567e-4));
+  test("-0.00123457", "{:.6Lg}", F(-1.234567e-3));
+  test("-0.0123457", "{:.6Lg}", F(-1.234567e-2));
+  test("-0.123457", "{:.6Lg}", F(-1.234567e-1));
+  test("-1.23457", "{:.6Lg}", F(-1.234567e0));
+  test("-12.3457", "{:.6Lg}", F(-1.234567e1));
+  test("-123.457", "{:.6Lg}", F(-1.234567e2));
+  test("-1,234.57", "{:.6Lg}", F(-1.234567e3));
+  test("-12,345.7", "{:.6Lg}", F(-1.234567e4));
+  test("-123,457", "{:.6Lg}", F(-1.234567e5));
+  test("-1.23457e+06", "{:.6Lg}", F(-1.234567e6));
+  test("-1.23457e+07", "{:.6Lg}", F(-1.234567e7));
+
+  std::locale::global(loc);
+  test("1#23457e-06", "{:.6Lg}", F(1.234567e-6));
+  test("1#23457e-05", "{:.6Lg}", F(1.234567e-5));
+  test("0#000123457", "{:.6Lg}", F(1.234567e-4));
+  test("0#00123457", "{:.6Lg}", F(1.234567e-3));
+  test("0#0123457", "{:.6Lg}", F(1.234567e-2));
+  test("0#123457", "{:.6Lg}", F(1.234567e-1));
+  test("1#23457", "{:.6Lg}", F(1.234567e0));
+  test("1_2#3457", "{:.6Lg}", F(1.234567e1));
+  test("12_3#457", "{:.6Lg}", F(1.234567e2));
+  test("1_23_4#57", "{:.6Lg}", F(1.234567e3));
+  test("12_34_5#7", "{:.6Lg}", F(1.234567e4));
+  test("123_45_7", "{:.6Lg}", F(1.234567e5));
+  test("1#23457e+06", "{:.6Lg}", F(1.234567e6));
+  test("1#23457e+07", "{:.6Lg}", F(1.234567e7));
+  test("-1#23457e-06", "{:.6Lg}", F(-1.234567e-6));
+  test("-1#23457e-05", "{:.6Lg}", F(-1.234567e-5));
+  test("-0#000123457", "{:.6Lg}", F(-1.234567e-4));
+  test("-0#00123457", "{:.6Lg}", F(-1.234567e-3));
+  test("-0#0123457", "{:.6Lg}", F(-1.234567e-2));
+  test("-0#123457", "{:.6Lg}", F(-1.234567e-1));
+  test("-1#23457", "{:.6Lg}", F(-1.234567e0));
+  test("-1_2#3457", "{:.6Lg}", F(-1.234567e1));
+  test("-12_3#457", "{:.6Lg}", F(-1.234567e2));
+  test("-1_23_4#57", "{:.6Lg}", F(-1.234567e3));
+  test("-12_34_5#7", "{:.6Lg}", F(-1.234567e4));
+  test("-123_45_7", "{:.6Lg}", F(-1.234567e5));
+  test("-1#23457e+06", "{:.6Lg}", F(-1.234567e6));
+  test("-1#23457e+07", "{:.6Lg}", F(-1.234567e7));
+
+  test("1.23457e-06", en_US, "{:.6Lg}", F(1.234567e-6));
+  test("1.23457e-05", en_US, "{:.6Lg}", F(1.234567e-5));
+  test("0.000123457", en_US, "{:.6Lg}", F(1.234567e-4));
+  test("0.00123457", en_US, "{:.6Lg}", F(1.234567e-3));
+  test("0.0123457", en_US, "{:.6Lg}", F(1.234567e-2));
+  test("0.123457", en_US, "{:.6Lg}", F(1.234567e-1));
+  test("1.23457", en_US, "{:.6Lg}", F(1.234567e0));
+  test("12.3457", en_US, "{:.6Lg}", F(1.234567e1));
+  test("123.457", en_US, "{:.6Lg}", F(1.234567e2));
+  test("1,234.57", en_US, "{:.6Lg}", F(1.234567e3));
+  test("12,345.7", en_US, "{:.6Lg}", F(1.234567e4));
+  test("123,457", en_US, "{:.6Lg}", F(1.234567e5));
+  test("1.23457e+06", en_US, "{:.6Lg}", F(1.234567e6));
+  test("1.23457e+07", en_US, "{:.6Lg}", F(1.234567e7));
+  test("-1.23457e-06", en_US, "{:.6Lg}", F(-1.234567e-6));
+  test("-1.23457e-05", en_US, "{:.6Lg}", F(-1.234567e-5));
+  test("-0.000123457", en_US, "{:.6Lg}", F(-1.234567e-4));
+  test("-0.00123457", en_US, "{:.6Lg}", F(-1.234567e-3));
+  test("-0.0123457", en_US, "{:.6Lg}", F(-1.234567e-2));
+  test("-0.123457", en_US, "{:.6Lg}", F(-1.234567e-1));
+  test("-1.23457", en_US, "{:.6Lg}", F(-1.234567e0));
+  test("-12.3457", en_US, "{:.6Lg}", F(-1.234567e1));
+  test("-123.457", en_US, "{:.6Lg}", F(-1.234567e2));
+  test("-1,234.57", en_US, "{:.6Lg}", F(-1.234567e3));
+  test("-12,345.7", en_US, "{:.6Lg}", F(-1.234567e4));
+  test("-123,457", en_US, "{:.6Lg}", F(-1.234567e5));
+  test("-1.23457e+06", en_US, "{:.6Lg}", F(-1.234567e6));
+  test("-1.23457e+07", en_US, "{:.6Lg}", F(-1.234567e7));
+
+  std::locale::global(en_US);
+  test("1#23457e-06", loc, "{:.6Lg}", F(1.234567e-6));
+  test("1#23457e-05", loc, "{:.6Lg}", F(1.234567e-5));
+  test("0#000123457", loc, "{:.6Lg}", F(1.234567e-4));
+  test("0#00123457", loc, "{:.6Lg}", F(1.234567e-3));
+  test("0#0123457", loc, "{:.6Lg}", F(1.234567e-2));
+  test("0#123457", loc, "{:.6Lg}", F(1.234567e-1));
+  test("1#23457", loc, "{:.6Lg}", F(1.234567e0));
+  test("1_2#3457", loc, "{:.6Lg}", F(1.234567e1));
+  test("12_3#457", loc, "{:.6Lg}", F(1.234567e2));
+  test("1_23_4#57", loc, "{:.6Lg}", F(1.234567e3));
+  test("12_34_5#7", loc, "{:.6Lg}", F(1.234567e4));
+  test("123_45_7", loc, "{:.6Lg}", F(1.234567e5));
+  test("1#23457e+06", loc, "{:.6Lg}", F(1.234567e6));
+  test("1#23457e+07", loc, "{:.6Lg}", F(1.234567e7));
+  test("-1#23457e-06", loc, "{:.6Lg}", F(-1.234567e-6));
+  test("-1#23457e-05", loc, "{:.6Lg}", F(-1.234567e-5));
+  test("-0#000123457", loc, "{:.6Lg}", F(-1.234567e-4));
+  test("-0#00123457", loc, "{:.6Lg}", F(-1.234567e-3));
+  test("-0#0123457", loc, "{:.6Lg}", F(-1.234567e-2));
+  test("-0#123457", loc, "{:.6Lg}", F(-1.234567e-1));
+  test("-1#23457", loc, "{:.6Lg}", F(-1.234567e0));
+  test("-1_2#3457", loc, "{:.6Lg}", F(-1.234567e1));
+  test("-12_3#457", loc, "{:.6Lg}", F(-1.234567e2));
+  test("-1_23_4#57", loc, "{:.6Lg}", F(-1.234567e3));
+  test("-12_34_5#7", loc, "{:.6Lg}", F(-1.234567e4));
+  test("-123_45_7", loc, "{:.6Lg}", F(-1.234567e5));
+  test("-1#23457e+06", loc, "{:.6Lg}", F(-1.234567e6));
+  test("-1#23457e+07", loc, "{:.6Lg}", F(-1.234567e7));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1,234.57$$$", "{:$<11.6Lg}", F(1.234567e3));
+  test("$$$1,234.57", "{:$>11.6Lg}", F(1.234567e3));
+  test("$1,234.57$$", "{:$^11.6Lg}", F(1.234567e3));
+  test("0001,234.57", "{:011.6Lg}", F(1.234567e3));
+  test("-1,234.57$$$", "{:$<12.6Lg}", F(-1.234567e3));
+  test("$$$-1,234.57", "{:$>12.6Lg}", F(-1.234567e3));
+  test("$-1,234.57$$", "{:$^12.6Lg}", F(-1.234567e3));
+  test("-0001,234.57", "{:012.6Lg}", F(-1.234567e3));
+
+  std::locale::global(loc);
+  test("1_23_4#57$$$", "{:$<12.6Lg}", F(1.234567e3));
+  test("$$$1_23_4#57", "{:$>12.6Lg}", F(1.234567e3));
+  test("$1_23_4#57$$", "{:$^12.6Lg}", F(1.234567e3));
+  test("0001_23_4#57", "{:012.6Lg}", F(1.234567e3));
+  test("-1_23_4#57$$$", "{:$<13.6Lg}", F(-1.234567e3));
+  test("$$$-1_23_4#57", "{:$>13.6Lg}", F(-1.234567e3));
+  test("$-1_23_4#57$$", "{:$^13.6Lg}", F(-1.234567e3));
+  test("-0001_23_4#57", "{:013.6Lg}", F(-1.234567e3));
+
+  test("1,234.57$$$", en_US, "{:$<11.6Lg}", F(1.234567e3));
+  test("$$$1,234.57", en_US, "{:$>11.6Lg}", F(1.234567e3));
+  test("$1,234.57$$", en_US, "{:$^11.6Lg}", F(1.234567e3));
+  test("0001,234.57", en_US, "{:011.6Lg}", F(1.234567e3));
+  test("-1,234.57$$$", en_US, "{:$<12.6Lg}", F(-1.234567e3));
+  test("$$$-1,234.57", en_US, "{:$>12.6Lg}", F(-1.234567e3));
+  test("$-1,234.57$$", en_US, "{:$^12.6Lg}", F(-1.234567e3));
+  test("-0001,234.57", en_US, "{:012.6Lg}", F(-1.234567e3));
+
+  std::locale::global(en_US);
+  test("1_23_4#57$$$", loc, "{:$<12.6Lg}", F(1.234567e3));
+  test("$$$1_23_4#57", loc, "{:$>12.6Lg}", F(1.234567e3));
+  test("$1_23_4#57$$", loc, "{:$^12.6Lg}", F(1.234567e3));
+  test("0001_23_4#57", loc, "{:012.6Lg}", F(1.234567e3));
+  test("-1_23_4#57$$$", loc, "{:$<13.6Lg}", F(-1.234567e3));
+  test("$$$-1_23_4#57", loc, "{:$>13.6Lg}", F(-1.234567e3));
+  test("$-1_23_4#57$$", loc, "{:$^13.6Lg}", F(-1.234567e3));
+  test("-0001_23_4#57", loc, "{:013.6Lg}", F(-1.234567e3));
+}
+
+template <class F>
+static void test_floating_point_general_upper_case() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.23457E-06", "{:.6LG}", F(1.234567e-6));
+  test("1.23457E-05", "{:.6LG}", F(1.234567e-5));
+  test("0.000123457", "{:.6LG}", F(1.234567e-4));
+  test("0.00123457", "{:.6LG}", F(1.234567e-3));
+  test("0.0123457", "{:.6LG}", F(1.234567e-2));
+  test("0.123457", "{:.6LG}", F(1.234567e-1));
+  test("1.23457", "{:.6LG}", F(1.234567e0));
+  test("12.3457", "{:.6LG}", F(1.234567e1));
+  test("123.457", "{:.6LG}", F(1.234567e2));
+  test("1,234.57", "{:.6LG}", F(1.234567e3));
+  test("12,345.7", "{:.6LG}", F(1.234567e4));
+  test("123,457", "{:.6LG}", F(1.234567e5));
+  test("1.23457E+06", "{:.6LG}", F(1.234567e6));
+  test("1.23457E+07", "{:.6LG}", F(1.234567e7));
+  test("-1.23457E-06", "{:.6LG}", F(-1.234567e-6));
+  test("-1.23457E-05", "{:.6LG}", F(-1.234567e-5));
+  test("-0.000123457", "{:.6LG}", F(-1.234567e-4));
+  test("-0.00123457", "{:.6LG}", F(-1.234567e-3));
+  test("-0.0123457", "{:.6LG}", F(-1.234567e-2));
+  test("-0.123457", "{:.6LG}", F(-1.234567e-1));
+  test("-1.23457", "{:.6LG}", F(-1.234567e0));
+  test("-12.3457", "{:.6LG}", F(-1.234567e1));
+  test("-123.457", "{:.6LG}", F(-1.234567e2));
+  test("-1,234.57", "{:.6LG}", F(-1.234567e3));
+  test("-12,345.7", "{:.6LG}", F(-1.234567e4));
+  test("-123,457", "{:.6LG}", F(-1.234567e5));
+  test("-1.23457E+06", "{:.6LG}", F(-1.234567e6));
+  test("-1.23457E+07", "{:.6LG}", F(-1.234567e7));
+
+  std::locale::global(loc);
+  test("1#23457E-06", "{:.6LG}", F(1.234567e-6));
+  test("1#23457E-05", "{:.6LG}", F(1.234567e-5));
+  test("0#000123457", "{:.6LG}", F(1.234567e-4));
+  test("0#00123457", "{:.6LG}", F(1.234567e-3));
+  test("0#0123457", "{:.6LG}", F(1.234567e-2));
+  test("0#123457", "{:.6LG}", F(1.234567e-1));
+  test("1#23457", "{:.6LG}", F(1.234567e0));
+  test("1_2#3457", "{:.6LG}", F(1.234567e1));
+  test("12_3#457", "{:.6LG}", F(1.234567e2));
+  test("1_23_4#57", "{:.6LG}", F(1.234567e3));
+  test("12_34_5#7", "{:.6LG}", F(1.234567e4));
+  test("123_45_7", "{:.6LG}", F(1.234567e5));
+  test("1#23457E+06", "{:.6LG}", F(1.234567e6));
+  test("1#23457E+07", "{:.6LG}", F(1.234567e7));
+  test("-1#23457E-06", "{:.6LG}", F(-1.234567e-6));
+  test("-1#23457E-05", "{:.6LG}", F(-1.234567e-5));
+  test("-0#000123457", "{:.6LG}", F(-1.234567e-4));
+  test("-0#00123457", "{:.6LG}", F(-1.234567e-3));
+  test("-0#0123457", "{:.6LG}", F(-1.234567e-2));
+  test("-0#123457", "{:.6LG}", F(-1.234567e-1));
+  test("-1#23457", "{:.6LG}", F(-1.234567e0));
+  test("-1_2#3457", "{:.6LG}", F(-1.234567e1));
+  test("-12_3#457", "{:.6LG}", F(-1.234567e2));
+  test("-1_23_4#57", "{:.6LG}", F(-1.234567e3));
+  test("-12_34_5#7", "{:.6LG}", F(-1.234567e4));
+  test("-123_45_7", "{:.6LG}", F(-1.234567e5));
+  test("-1#23457E+06", "{:.6LG}", F(-1.234567e6));
+  test("-1#23457E+07", "{:.6LG}", F(-1.234567e7));
+
+  test("1.23457E-06", en_US, "{:.6LG}", F(1.234567e-6));
+  test("1.23457E-05", en_US, "{:.6LG}", F(1.234567e-5));
+  test("0.000123457", en_US, "{:.6LG}", F(1.234567e-4));
+  test("0.00123457", en_US, "{:.6LG}", F(1.234567e-3));
+  test("0.0123457", en_US, "{:.6LG}", F(1.234567e-2));
+  test("0.123457", en_US, "{:.6LG}", F(1.234567e-1));
+  test("1.23457", en_US, "{:.6LG}", F(1.234567e0));
+  test("12.3457", en_US, "{:.6LG}", F(1.234567e1));
+  test("123.457", en_US, "{:.6LG}", F(1.234567e2));
+  test("1,234.57", en_US, "{:.6LG}", F(1.234567e3));
+  test("12,345.7", en_US, "{:.6LG}", F(1.234567e4));
+  test("123,457", en_US, "{:.6LG}", F(1.234567e5));
+  test("1.23457E+06", en_US, "{:.6LG}", F(1.234567e6));
+  test("1.23457E+07", en_US, "{:.6LG}", F(1.234567e7));
+  test("-1.23457E-06", en_US, "{:.6LG}", F(-1.234567e-6));
+  test("-1.23457E-05", en_US, "{:.6LG}", F(-1.234567e-5));
+  test("-0.000123457", en_US, "{:.6LG}", F(-1.234567e-4));
+  test("-0.00123457", en_US, "{:.6LG}", F(-1.234567e-3));
+  test("-0.0123457", en_US, "{:.6LG}", F(-1.234567e-2));
+  test("-0.123457", en_US, "{:.6LG}", F(-1.234567e-1));
+  test("-1.23457", en_US, "{:.6LG}", F(-1.234567e0));
+  test("-12.3457", en_US, "{:.6LG}", F(-1.234567e1));
+  test("-123.457", en_US, "{:.6LG}", F(-1.234567e2));
+  test("-1,234.57", en_US, "{:.6LG}", F(-1.234567e3));
+  test("-12,345.7", en_US, "{:.6LG}", F(-1.234567e4));
+  test("-123,457", en_US, "{:.6LG}", F(-1.234567e5));
+  test("-1.23457E+06", en_US, "{:.6LG}", F(-1.234567e6));
+  test("-1.23457E+07", en_US, "{:.6LG}", F(-1.234567e7));
+
+  std::locale::global(en_US);
+  test("1#23457E-06", loc, "{:.6LG}", F(1.234567e-6));
+  test("1#23457E-05", loc, "{:.6LG}", F(1.234567e-5));
+  test("0#000123457", loc, "{:.6LG}", F(1.234567e-4));
+  test("0#00123457", loc, "{:.6LG}", F(1.234567e-3));
+  test("0#0123457", loc, "{:.6LG}", F(1.234567e-2));
+  test("0#123457", loc, "{:.6LG}", F(1.234567e-1));
+  test("1#23457", loc, "{:.6LG}", F(1.234567e0));
+  test("1_2#3457", loc, "{:.6LG}", F(1.234567e1));
+  test("12_3#457", loc, "{:.6LG}", F(1.234567e2));
+  test("1_23_4#57", loc, "{:.6LG}", F(1.234567e3));
+  test("12_34_5#7", loc, "{:.6LG}", F(1.234567e4));
+  test("123_45_7", loc, "{:.6LG}", F(1.234567e5));
+  test("1#23457E+06", loc, "{:.6LG}", F(1.234567e6));
+  test("1#23457E+07", loc, "{:.6LG}", F(1.234567e7));
+  test("-1#23457E-06", loc, "{:.6LG}", F(-1.234567e-6));
+  test("-1#23457E-05", loc, "{:.6LG}", F(-1.234567e-5));
+  test("-0#000123457", loc, "{:.6LG}", F(-1.234567e-4));
+  test("-0#00123457", loc, "{:.6LG}", F(-1.234567e-3));
+  test("-0#0123457", loc, "{:.6LG}", F(-1.234567e-2));
+  test("-0#123457", loc, "{:.6LG}", F(-1.234567e-1));
+  test("-1#23457", loc, "{:.6LG}", F(-1.234567e0));
+  test("-1_2#3457", loc, "{:.6LG}", F(-1.234567e1));
+  test("-12_3#457", loc, "{:.6LG}", F(-1.234567e2));
+  test("-1_23_4#57", loc, "{:.6LG}", F(-1.234567e3));
+  test("-12_34_5#7", loc, "{:.6LG}", F(-1.234567e4));
+  test("-123_45_7", loc, "{:.6LG}", F(-1.234567e5));
+  test("-1#23457E+06", loc, "{:.6LG}", F(-1.234567e6));
+  test("-1#23457E+07", loc, "{:.6LG}", F(-1.234567e7));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1,234.57$$$", "{:$<11.6LG}", F(1.234567e3));
+  test("$$$1,234.57", "{:$>11.6LG}", F(1.234567e3));
+  test("$1,234.57$$", "{:$^11.6LG}", F(1.234567e3));
+  test("0001,234.57", "{:011.6LG}", F(1.234567e3));
+  test("-1,234.57$$$", "{:$<12.6LG}", F(-1.234567e3));
+  test("$$$-1,234.57", "{:$>12.6LG}", F(-1.234567e3));
+  test("$-1,234.57$$", "{:$^12.6LG}", F(-1.234567e3));
+  test("-0001,234.57", "{:012.6LG}", F(-1.234567e3));
+
+  std::locale::global(loc);
+  test("1_23_4#57$$$", "{:$<12.6LG}", F(1.234567e3));
+  test("$$$1_23_4#57", "{:$>12.6LG}", F(1.234567e3));
+  test("$1_23_4#57$$", "{:$^12.6LG}", F(1.234567e3));
+  test("0001_23_4#57", "{:012.6LG}", F(1.234567e3));
+  test("-1_23_4#57$$$", "{:$<13.6LG}", F(-1.234567e3));
+  test("$$$-1_23_4#57", "{:$>13.6LG}", F(-1.234567e3));
+  test("$-1_23_4#57$$", "{:$^13.6LG}", F(-1.234567e3));
+  test("-0001_23_4#57", "{:013.6LG}", F(-1.234567e3));
+
+  test("1,234.57$$$", en_US, "{:$<11.6LG}", F(1.234567e3));
+  test("$$$1,234.57", en_US, "{:$>11.6LG}", F(1.234567e3));
+  test("$1,234.57$$", en_US, "{:$^11.6LG}", F(1.234567e3));
+  test("0001,234.57", en_US, "{:011.6LG}", F(1.234567e3));
+  test("-1,234.57$$$", en_US, "{:$<12.6LG}", F(-1.234567e3));
+  test("$$$-1,234.57", en_US, "{:$>12.6LG}", F(-1.234567e3));
+  test("$-1,234.57$$", en_US, "{:$^12.6LG}", F(-1.234567e3));
+  test("-0001,234.57", en_US, "{:012.6LG}", F(-1.234567e3));
+
+  std::locale::global(en_US);
+  test("1_23_4#57$$$", loc, "{:$<12.6LG}", F(1.234567e3));
+  test("$$$1_23_4#57", loc, "{:$>12.6LG}", F(1.234567e3));
+  test("$1_23_4#57$$", loc, "{:$^12.6LG}", F(1.234567e3));
+  test("0001_23_4#57", loc, "{:012.6LG}", F(1.234567e3));
+  test("-1_23_4#57$$$", loc, "{:$<13.6LG}", F(-1.234567e3));
+  test("$$$-1_23_4#57", loc, "{:$>13.6LG}", F(-1.234567e3));
+  test("$-1_23_4#57$$", loc, "{:$^13.6LG}", F(-1.234567e3));
+  test("-0001_23_4#57", loc, "{:013.6LG}", F(-1.234567e3));
+}
+
+template <class F>
+static void test_floating_point_default() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.234567e-06", "{:L}", F(1.234567e-6));
+  test("1.234567e-05", "{:L}", F(1.234567e-5));
+  test("0.0001234567", "{:L}", F(1.234567e-4));
+  test("0.001234567", "{:L}", F(1.234567e-3));
+  test("0.01234567", "{:L}", F(1.234567e-2));
+  test("0.1234567", "{:L}", F(1.234567e-1));
+  test("1.234567", "{:L}", F(1.234567e0));
+  test("12.34567", "{:L}", F(1.234567e1));
+  test("123.4567", "{:L}", F(1.234567e2));
+  test("1,234.567", "{:L}", F(1.234567e3));
+  test("12,345.67", "{:L}", F(1.234567e4));
+  test("123,456.7", "{:L}", F(1.234567e5));
+  test("1,234,567", "{:L}", F(1.234567e6));
+  test("12,345,670", "{:L}", F(1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("123,456,700", "{:L}", F(1.234567e8));
+    test("1,234,567,000", "{:L}", F(1.234567e9));
+    test("12,345,670,000", "{:L}", F(1.234567e10));
+    test("123,456,700,000", "{:L}", F(1.234567e11));
+    test("1.234567e+12", "{:L}", F(1.234567e12));
+    test("1.234567e+13", "{:L}", F(1.234567e13));
+  }
+  test("-1.234567e-06", "{:L}", F(-1.234567e-6));
+  test("-1.234567e-05", "{:L}", F(-1.234567e-5));
+  test("-0.0001234567", "{:L}", F(-1.234567e-4));
+  test("-0.001234567", "{:L}", F(-1.234567e-3));
+  test("-0.01234567", "{:L}", F(-1.234567e-2));
+  test("-0.1234567", "{:L}", F(-1.234567e-1));
+  test("-1.234567", "{:L}", F(-1.234567e0));
+  test("-12.34567", "{:L}", F(-1.234567e1));
+  test("-123.4567", "{:L}", F(-1.234567e2));
+  test("-1,234.567", "{:L}", F(-1.234567e3));
+  test("-12,345.67", "{:L}", F(-1.234567e4));
+  test("-123,456.7", "{:L}", F(-1.234567e5));
+  test("-1,234,567", "{:L}", F(-1.234567e6));
+  test("-12,345,670", "{:L}", F(-1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-123,456,700", "{:L}", F(-1.234567e8));
+    test("-1,234,567,000", "{:L}", F(-1.234567e9));
+    test("-12,345,670,000", "{:L}", F(-1.234567e10));
+    test("-123,456,700,000", "{:L}", F(-1.234567e11));
+    test("-1.234567e+12", "{:L}", F(-1.234567e12));
+    test("-1.234567e+13", "{:L}", F(-1.234567e13));
+  }
+
+  std::locale::global(loc);
+  test("1#234567e-06", "{:L}", F(1.234567e-6));
+  test("1#234567e-05", "{:L}", F(1.234567e-5));
+  test("0#0001234567", "{:L}", F(1.234567e-4));
+  test("0#001234567", "{:L}", F(1.234567e-3));
+  test("0#01234567", "{:L}", F(1.234567e-2));
+  test("0#1234567", "{:L}", F(1.234567e-1));
+  test("1#234567", "{:L}", F(1.234567e0));
+  test("1_2#34567", "{:L}", F(1.234567e1));
+  test("12_3#4567", "{:L}", F(1.234567e2));
+  test("1_23_4#567", "{:L}", F(1.234567e3));
+  test("12_34_5#67", "{:L}", F(1.234567e4));
+  test("123_45_6#7", "{:L}", F(1.234567e5));
+  test("1_234_56_7", "{:L}", F(1.234567e6));
+  test("12_345_67_0", "{:L}", F(1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("1_23_456_70_0", "{:L}", F(1.234567e8));
+    test("1_2_34_567_00_0", "{:L}", F(1.234567e9));
+    test("1_2_3_45_670_00_0", "{:L}", F(1.234567e10));
+    test("1_2_3_4_56_700_00_0", "{:L}", F(1.234567e11));
+    test("1#234567e+12", "{:L}", F(1.234567e12));
+    test("1#234567e+13", "{:L}", F(1.234567e13));
+  }
+  test("-1#234567e-06", "{:L}", F(-1.234567e-6));
+  test("-1#234567e-05", "{:L}", F(-1.234567e-5));
+  test("-0#0001234567", "{:L}", F(-1.234567e-4));
+  test("-0#001234567", "{:L}", F(-1.234567e-3));
+  test("-0#01234567", "{:L}", F(-1.234567e-2));
+  test("-0#1234567", "{:L}", F(-1.234567e-1));
+  test("-1#234567", "{:L}", F(-1.234567e0));
+  test("-1_2#34567", "{:L}", F(-1.234567e1));
+  test("-12_3#4567", "{:L}", F(-1.234567e2));
+  test("-1_23_4#567", "{:L}", F(-1.234567e3));
+  test("-12_34_5#67", "{:L}", F(-1.234567e4));
+  test("-123_45_6#7", "{:L}", F(-1.234567e5));
+  test("-1_234_56_7", "{:L}", F(-1.234567e6));
+  test("-12_345_67_0", "{:L}", F(-1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-1_23_456_70_0", "{:L}", F(-1.234567e8));
+    test("-1_2_34_567_00_0", "{:L}", F(-1.234567e9));
+    test("-1_2_3_45_670_00_0", "{:L}", F(-1.234567e10));
+    test("-1_2_3_4_56_700_00_0", "{:L}", F(-1.234567e11));
+    test("-1#234567e+12", "{:L}", F(-1.234567e12));
+    test("-1#234567e+13", "{:L}", F(-1.234567e13));
+  }
+
+  test("1.234567e-06", en_US, "{:L}", F(1.234567e-6));
+  test("1.234567e-05", en_US, "{:L}", F(1.234567e-5));
+  test("0.0001234567", en_US, "{:L}", F(1.234567e-4));
+  test("0.001234567", en_US, "{:L}", F(1.234567e-3));
+  test("0.01234567", en_US, "{:L}", F(1.234567e-2));
+  test("0.1234567", en_US, "{:L}", F(1.234567e-1));
+  test("1.234567", en_US, "{:L}", F(1.234567e0));
+  test("12.34567", en_US, "{:L}", F(1.234567e1));
+  test("123.4567", en_US, "{:L}", F(1.234567e2));
+  test("1,234.567", en_US, "{:L}", F(1.234567e3));
+  test("12,345.67", en_US, "{:L}", F(1.234567e4));
+  test("123,456.7", en_US, "{:L}", F(1.234567e5));
+  test("1,234,567", en_US, "{:L}", F(1.234567e6));
+  test("12,345,670", en_US, "{:L}", F(1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("123,456,700", en_US, "{:L}", F(1.234567e8));
+    test("1,234,567,000", en_US, "{:L}", F(1.234567e9));
+    test("12,345,670,000", en_US, "{:L}", F(1.234567e10));
+    test("123,456,700,000", en_US, "{:L}", F(1.234567e11));
+    test("1.234567e+12", en_US, "{:L}", F(1.234567e12));
+    test("1.234567e+13", en_US, "{:L}", F(1.234567e13));
+  }
+  test("-1.234567e-06", en_US, "{:L}", F(-1.234567e-6));
+  test("-1.234567e-05", en_US, "{:L}", F(-1.234567e-5));
+  test("-0.0001234567", en_US, "{:L}", F(-1.234567e-4));
+  test("-0.001234567", en_US, "{:L}", F(-1.234567e-3));
+  test("-0.01234567", en_US, "{:L}", F(-1.234567e-2));
+  test("-0.1234567", en_US, "{:L}", F(-1.234567e-1));
+  test("-1.234567", en_US, "{:L}", F(-1.234567e0));
+  test("-12.34567", en_US, "{:L}", F(-1.234567e1));
+  test("-123.4567", en_US, "{:L}", F(-1.234567e2));
+  test("-1,234.567", en_US, "{:L}", F(-1.234567e3));
+  test("-12,345.67", en_US, "{:L}", F(-1.234567e4));
+  test("-123,456.7", en_US, "{:L}", F(-1.234567e5));
+  test("-1,234,567", en_US, "{:L}", F(-1.234567e6));
+  test("-12,345,670", en_US, "{:L}", F(-1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-123,456,700", en_US, "{:L}", F(-1.234567e8));
+    test("-1,234,567,000", en_US, "{:L}", F(-1.234567e9));
+    test("-12,345,670,000", en_US, "{:L}", F(-1.234567e10));
+    test("-123,456,700,000", en_US, "{:L}", F(-1.234567e11));
+    test("-1.234567e+12", en_US, "{:L}", F(-1.234567e12));
+    test("-1.234567e+13", en_US, "{:L}", F(-1.234567e13));
+  }
+
+  std::locale::global(en_US);
+  test("1#234567e-06", loc, "{:L}", F(1.234567e-6));
+  test("1#234567e-05", loc, "{:L}", F(1.234567e-5));
+  test("0#0001234567", loc, "{:L}", F(1.234567e-4));
+  test("0#001234567", loc, "{:L}", F(1.234567e-3));
+  test("0#01234567", loc, "{:L}", F(1.234567e-2));
+  test("0#1234567", loc, "{:L}", F(1.234567e-1));
+  test("1#234567", loc, "{:L}", F(1.234567e0));
+  test("1_2#34567", loc, "{:L}", F(1.234567e1));
+  test("12_3#4567", loc, "{:L}", F(1.234567e2));
+  test("1_23_4#567", loc, "{:L}", F(1.234567e3));
+  test("12_34_5#67", loc, "{:L}", F(1.234567e4));
+  test("123_45_6#7", loc, "{:L}", F(1.234567e5));
+  test("1_234_56_7", loc, "{:L}", F(1.234567e6));
+  test("12_345_67_0", loc, "{:L}", F(1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("1_23_456_70_0", loc, "{:L}", F(1.234567e8));
+    test("1_2_34_567_00_0", loc, "{:L}", F(1.234567e9));
+    test("1_2_3_45_670_00_0", loc, "{:L}", F(1.234567e10));
+    test("1_2_3_4_56_700_00_0", loc, "{:L}", F(1.234567e11));
+    test("1#234567e+12", loc, "{:L}", F(1.234567e12));
+    test("1#234567e+13", loc, "{:L}", F(1.234567e13));
+  }
+  test("-1#234567e-06", loc, "{:L}", F(-1.234567e-6));
+  test("-1#234567e-05", loc, "{:L}", F(-1.234567e-5));
+  test("-0#0001234567", loc, "{:L}", F(-1.234567e-4));
+  test("-0#001234567", loc, "{:L}", F(-1.234567e-3));
+  test("-0#01234567", loc, "{:L}", F(-1.234567e-2));
+  test("-0#1234567", loc, "{:L}", F(-1.234567e-1));
+  test("-1#234567", loc, "{:L}", F(-1.234567e0));
+  test("-1_2#34567", loc, "{:L}", F(-1.234567e1));
+  test("-12_3#4567", loc, "{:L}", F(-1.234567e2));
+  test("-1_23_4#567", loc, "{:L}", F(-1.234567e3));
+  test("-12_34_5#67", loc, "{:L}", F(-1.234567e4));
+  test("-123_45_6#7", loc, "{:L}", F(-1.234567e5));
+  test("-1_234_56_7", loc, "{:L}", F(-1.234567e6));
+  test("-12_345_67_0", loc, "{:L}", F(-1.234567e7));
+  if constexpr (sizeof(F) > sizeof(float)) {
+    test("-1_23_456_70_0", loc, "{:L}", F(-1.234567e8));
+    test("-1_2_34_567_00_0", loc, "{:L}", F(-1.234567e9));
+    test("-1_2_3_45_670_00_0", loc, "{:L}", F(-1.234567e10));
+    test("-1_2_3_4_56_700_00_0", loc, "{:L}", F(-1.234567e11));
+    test("-1#234567e+12", loc, "{:L}", F(-1.234567e12));
+    test("-1#234567e+13", loc, "{:L}", F(-1.234567e13));
+  }
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1,234.567$$$", "{:$<12L}", F(1.234567e3));
+  test("$$$1,234.567", "{:$>12L}", F(1.234567e3));
+  test("$1,234.567$$", "{:$^12L}", F(1.234567e3));
+  test("0001,234.567", "{:012L}", F(1.234567e3));
+  test("-1,234.567$$$", "{:$<13L}", F(-1.234567e3));
+  test("$$$-1,234.567", "{:$>13L}", F(-1.234567e3));
+  test("$-1,234.567$$", "{:$^13L}", F(-1.234567e3));
+  test("-0001,234.567", "{:013L}", F(-1.234567e3));
+
+  std::locale::global(loc);
+  test("1_23_4#567$$$", "{:$<13L}", F(1.234567e3));
+  test("$$$1_23_4#567", "{:$>13L}", F(1.234567e3));
+  test("$1_23_4#567$$", "{:$^13L}", F(1.234567e3));
+  test("0001_23_4#567", "{:013L}", F(1.234567e3));
+  test("-1_23_4#567$$$", "{:$<14L}", F(-1.234567e3));
+  test("$$$-1_23_4#567", "{:$>14L}", F(-1.234567e3));
+  test("$-1_23_4#567$$", "{:$^14L}", F(-1.234567e3));
+  test("-0001_23_4#567", "{:014L}", F(-1.234567e3));
+
+  test("1,234.567$$$", en_US, "{:$<12L}", F(1.234567e3));
+  test("$$$1,234.567", en_US, "{:$>12L}", F(1.234567e3));
+  test("$1,234.567$$", en_US, "{:$^12L}", F(1.234567e3));
+  test("0001,234.567", en_US, "{:012L}", F(1.234567e3));
+  test("-1,234.567$$$", en_US, "{:$<13L}", F(-1.234567e3));
+  test("$$$-1,234.567", en_US, "{:$>13L}", F(-1.234567e3));
+  test("$-1,234.567$$", en_US, "{:$^13L}", F(-1.234567e3));
+  test("-0001,234.567", en_US, "{:013L}", F(-1.234567e3));
+
+  std::locale::global(en_US);
+  test("1_23_4#567$$$", loc, "{:$<13L}", F(1.234567e3));
+  test("$$$1_23_4#567", loc, "{:$>13L}", F(1.234567e3));
+  test("$1_23_4#567$$", loc, "{:$^13L}", F(1.234567e3));
+  test("0001_23_4#567", loc, "{:013L}", F(1.234567e3));
+  test("-1_23_4#567$$$", loc, "{:$<14L}", F(-1.234567e3));
+  test("$$$-1_23_4#567", loc, "{:$>14L}", F(-1.234567e3));
+  test("$-1_23_4#567$$", loc, "{:$^14L}", F(-1.234567e3));
+  test("-0001_23_4#567", loc, "{:014L}", F(-1.234567e3));
+}
+
+template <class F>
+static void test_floating_point_default_precision() {
+  std::locale loc   = std::locale(std::locale(), new numpunct<char>());
+  std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
+
+  // *** Basic ***
+  std::locale::global(en_US);
+  test("1.23457e-06", "{:.6L}", F(1.234567e-6));
+  test("1.23457e-05", "{:.6L}", F(1.234567e-5));
+  test("0.000123457", "{:.6L}", F(1.234567e-4));
+  test("0.00123457", "{:.6L}", F(1.234567e-3));
+  test("0.0123457", "{:.6L}", F(1.234567e-2));
+  test("0.123457", "{:.6L}", F(1.234567e-1));
+  test("1.23457", "{:.6L}", F(1.234567e0));
+  test("12.3457", "{:.6L}", F(1.234567e1));
+  test("123.457", "{:.6L}", F(1.234567e2));
+  test("1,234.57", "{:.6L}", F(1.234567e3));
+  test("12,345.7", "{:.6L}", F(1.234567e4));
+  test("123,457", "{:.6L}", F(1.234567e5));
+  test("1.23457e+06", "{:.6L}", F(1.234567e6));
+  test("1.23457e+07", "{:.6L}", F(1.234567e7));
+  test("-1.23457e-06", "{:.6L}", F(-1.234567e-6));
+  test("-1.23457e-05", "{:.6L}", F(-1.234567e-5));
+  test("-0.000123457", "{:.6L}", F(-1.234567e-4));
+  test("-0.00123457", "{:.6L}", F(-1.234567e-3));
+  test("-0.0123457", "{:.6L}", F(-1.234567e-2));
+  test("-0.123457", "{:.6L}", F(-1.234567e-1));
+  test("-1.23457", "{:.6L}", F(-1.234567e0));
+  test("-12.3457", "{:.6L}", F(-1.234567e1));
+  test("-123.457", "{:.6L}", F(-1.234567e2));
+  test("-1,234.57", "{:.6L}", F(-1.234567e3));
+  test("-12,345.7", "{:.6L}", F(-1.234567e4));
+  test("-123,457", "{:.6L}", F(-1.234567e5));
+  test("-1.23457e+06", "{:.6L}", F(-1.234567e6));
+  test("-1.23457e+07", "{:.6L}", F(-1.234567e7));
+
+  std::locale::global(loc);
+  test("1#23457e-06", "{:.6L}", F(1.234567e-6));
+  test("1#23457e-05", "{:.6L}", F(1.234567e-5));
+  test("0#000123457", "{:.6L}", F(1.234567e-4));
+  test("0#00123457", "{:.6L}", F(1.234567e-3));
+  test("0#0123457", "{:.6L}", F(1.234567e-2));
+  test("0#123457", "{:.6L}", F(1.234567e-1));
+  test("1#23457", "{:.6L}", F(1.234567e0));
+  test("1_2#3457", "{:.6L}", F(1.234567e1));
+  test("12_3#457", "{:.6L}", F(1.234567e2));
+  test("1_23_4#57", "{:.6L}", F(1.234567e3));
+  test("12_34_5#7", "{:.6L}", F(1.234567e4));
+  test("123_45_7", "{:.6L}", F(1.234567e5));
+  test("1#23457e+06", "{:.6L}", F(1.234567e6));
+  test("1#23457e+07", "{:.6L}", F(1.234567e7));
+  test("-1#23457e-06", "{:.6L}", F(-1.234567e-6));
+  test("-1#23457e-05", "{:.6L}", F(-1.234567e-5));
+  test("-0#000123457", "{:.6L}", F(-1.234567e-4));
+  test("-0#00123457", "{:.6L}", F(-1.234567e-3));
+  test("-0#0123457", "{:.6L}", F(-1.234567e-2));
+  test("-0#123457", "{:.6L}", F(-1.234567e-1));
+  test("-1#23457", "{:.6L}", F(-1.234567e0));
+  test("-1_2#3457", "{:.6L}", F(-1.234567e1));
+  test("-12_3#457", "{:.6L}", F(-1.234567e2));
+  test("-1_23_4#57", "{:.6L}", F(-1.234567e3));
+  test("-12_34_5#7", "{:.6L}", F(-1.234567e4));
+  test("-123_45_7", "{:.6L}", F(-1.234567e5));
+  test("-1#23457e+06", "{:.6L}", F(-1.234567e6));
+  test("-1#23457e+07", "{:.6L}", F(-1.234567e7));
+
+  test("1.23457e-06", en_US, "{:.6L}", F(1.234567e-6));
+  test("1.23457e-05", en_US, "{:.6L}", F(1.234567e-5));
+  test("0.000123457", en_US, "{:.6L}", F(1.234567e-4));
+  test("0.00123457", en_US, "{:.6L}", F(1.234567e-3));
+  test("0.0123457", en_US, "{:.6L}", F(1.234567e-2));
+  test("0.123457", en_US, "{:.6L}", F(1.234567e-1));
+  test("1.23457", en_US, "{:.6L}", F(1.234567e0));
+  test("12.3457", en_US, "{:.6L}", F(1.234567e1));
+  test("123.457", en_US, "{:.6L}", F(1.234567e2));
+  test("1,234.57", en_US, "{:.6L}", F(1.234567e3));
+  test("12,345.7", en_US, "{:.6L}", F(1.234567e4));
+  test("123,457", en_US, "{:.6L}", F(1.234567e5));
+  test("1.23457e+06", en_US, "{:.6L}", F(1.234567e6));
+  test("1.23457e+07", en_US, "{:.6L}", F(1.234567e7));
+  test("-1.23457e-06", en_US, "{:.6L}", F(-1.234567e-6));
+  test("-1.23457e-05", en_US, "{:.6L}", F(-1.234567e-5));
+  test("-0.000123457", en_US, "{:.6L}", F(-1.234567e-4));
+  test("-0.00123457", en_US, "{:.6L}", F(-1.234567e-3));
+  test("-0.0123457", en_US, "{:.6L}", F(-1.234567e-2));
+  test("-0.123457", en_US, "{:.6L}", F(-1.234567e-1));
+  test("-1.23457", en_US, "{:.6L}", F(-1.234567e0));
+  test("-12.3457", en_US, "{:.6L}", F(-1.234567e1));
+  test("-123.457", en_US, "{:.6L}", F(-1.234567e2));
+  test("-1,234.57", en_US, "{:.6L}", F(-1.234567e3));
+  test("-12,345.7", en_US, "{:.6L}", F(-1.234567e4));
+  test("-123,457", en_US, "{:.6L}", F(-1.234567e5));
+  test("-1.23457e+06", en_US, "{:.6L}", F(-1.234567e6));
+  test("-1.23457e+07", en_US, "{:.6L}", F(-1.234567e7));
+
+  std::locale::global(en_US);
+  test("1#23457e-06", loc, "{:.6L}", F(1.234567e-6));
+  test("1#23457e-05", loc, "{:.6L}", F(1.234567e-5));
+  test("0#000123457", loc, "{:.6L}", F(1.234567e-4));
+  test("0#00123457", loc, "{:.6L}", F(1.234567e-3));
+  test("0#0123457", loc, "{:.6L}", F(1.234567e-2));
+  test("0#123457", loc, "{:.6L}", F(1.234567e-1));
+  test("1#23457", loc, "{:.6L}", F(1.234567e0));
+  test("1_2#3457", loc, "{:.6L}", F(1.234567e1));
+  test("12_3#457", loc, "{:.6L}", F(1.234567e2));
+  test("1_23_4#57", loc, "{:.6L}", F(1.234567e3));
+  test("12_34_5#7", loc, "{:.6L}", F(1.234567e4));
+  test("123_45_7", loc, "{:.6L}", F(1.234567e5));
+  test("1#23457e+06", loc, "{:.6L}", F(1.234567e6));
+  test("1#23457e+07", loc, "{:.6L}", F(1.234567e7));
+  test("-1#23457e-06", loc, "{:.6L}", F(-1.234567e-6));
+  test("-1#23457e-05", loc, "{:.6L}", F(-1.234567e-5));
+  test("-0#000123457", loc, "{:.6L}", F(-1.234567e-4));
+  test("-0#00123457", loc, "{:.6L}", F(-1.234567e-3));
+  test("-0#0123457", loc, "{:.6L}", F(-1.234567e-2));
+  test("-0#123457", loc, "{:.6L}", F(-1.234567e-1));
+  test("-1#23457", loc, "{:.6L}", F(-1.234567e0));
+  test("-1_2#3457", loc, "{:.6L}", F(-1.234567e1));
+  test("-12_3#457", loc, "{:.6L}", F(-1.234567e2));
+  test("-1_23_4#57", loc, "{:.6L}", F(-1.234567e3));
+  test("-12_34_5#7", loc, "{:.6L}", F(-1.234567e4));
+  test("-123_45_7", loc, "{:.6L}", F(-1.234567e5));
+  test("-1#23457e+06", loc, "{:.6L}", F(-1.234567e6));
+  test("-1#23457e+07", loc, "{:.6L}", F(-1.234567e7));
+
+  // *** Fill, align, zero padding ***
+  std::locale::global(en_US);
+  test("1,234.57$$$", "{:$<11.6L}", F(1.234567e3));
+  test("$$$1,234.57", "{:$>11.6L}", F(1.234567e3));
+  test("$1,234.57$$", "{:$^11.6L}", F(1.234567e3));
+  test("0001,234.57", "{:011.6L}", F(1.234567e3));
+  test("-1,234.57$$$", "{:$<12.6L}", F(-1.234567e3));
+  test("$$$-1,234.57", "{:$>12.6L}", F(-1.234567e3));
+  test("$-1,234.57$$", "{:$^12.6L}", F(-1.234567e3));
+  test("-0001,234.57", "{:012.6L}", F(-1.234567e3));
+
+  std::locale::global(loc);
+  test("1_23_4#57$$$", "{:$<12.6L}", F(1.234567e3));
+  test("$$$1_23_4#57", "{:$>12.6L}", F(1.234567e3));
+  test("$1_23_4#57$$", "{:$^12.6L}", F(1.234567e3));
+  test("0001_23_4#57", "{:012.6L}", F(1.234567e3));
+  test("-1_23_4#57$$$", "{:$<13.6L}", F(-1.234567e3));
+  test("$$$-1_23_4#57", "{:$>13.6L}", F(-1.234567e3));
+  test("$-1_23_4#57$$", "{:$^13.6L}", F(-1.234567e3));
+  test("-0001_23_4#57", "{:013.6L}", F(-1.234567e3));
+
+  test("1,234.57$$$", en_US, "{:$<11.6L}", F(1.234567e3));
+  test("$$$1,234.57", en_US, "{:$>11.6L}", F(1.234567e3));
+  test("$1,234.57$$", en_US, "{:$^11.6L}", F(1.234567e3));
+  test("0001,234.57", en_US, "{:011.6L}", F(1.234567e3));
+  test("-1,234.57$$$", en_US, "{:$<12.6L}", F(-1.234567e3));
+  test("$$$-1,234.57", en_US, "{:$>12.6L}", F(-1.234567e3));
+  test("$-1,234.57$$", en_US, "{:$^12.6L}", F(-1.234567e3));
+  test("-0001,234.57", en_US, "{:012.6L}", F(-1.234567e3));
+
+  std::locale::global(en_US);
+  test("1_23_4#57$$$", loc, "{:$<12.6L}", F(1.234567e3));
+  test("$$$1_23_4#57", loc, "{:$>12.6L}", F(1.234567e3));
+  test("$1_23_4#57$$", loc, "{:$^12.6L}", F(1.234567e3));
+  test("0001_23_4#57", loc, "{:012.6L}", F(1.234567e3));
+  test("-1_23_4#57$$$", loc, "{:$<13.6L}", F(-1.234567e3));
+  test("$$$-1_23_4#57", loc, "{:$>13.6L}", F(-1.234567e3));
+  test("$-1_23_4#57$$", loc, "{:$^13.6L}", F(-1.234567e3));
+  test("-0001_23_4#57", loc, "{:013.6L}", F(-1.234567e3));
+}
+
+template <class F>
+static void test_floating_point() {
+  test_floating_point_hex_lower_case<F>();
+  test_floating_point_hex_upper_case<F>();
+  test_floating_point_hex_lower_case_precision<F>();
+  test_floating_point_hex_upper_case_precision<F>();
+
+  test_floating_point_scientific_lower_case<F>();
+  test_floating_point_scientific_upper_case<F>();
+
+  test_floating_point_fixed_lower_case<F>();
+  test_floating_point_fixed_upper_case<F>();
+
+  test_floating_point_general_lower_case<F>();
+  test_floating_point_general_upper_case<F>();
+
+  test_floating_point_default<F>();
+  test_floating_point_default_precision<F>();
+}
+
+int main(int, char**) {
+  test_bool();
+  test_integer();
+  test_floating_point<float>();
+  test_floating_point<double>();
+  test_floating_point<long double>();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/print.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <ostream>
+
+// template<class... Args>
+//   void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+
+// [ostream.formatted.print]/3
+//   If the function is vprint_unicode and os is a stream that refers to
+//   a terminal capable of displaying Unicode which is determined in an
+//   implementation-defined manner, writes out to the terminal using the
+//   native Unicode API;
+// This is tested in
+// test/libcxx/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "print_tests.h"
+#include "test_format_string.h"
+#include "test_macros.h"
+
+auto test_file = []<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::stringstream sstr;
+  std::print(sstr, fmt, std::forward<Args>(args)...);
+
+  std::string out = sstr.str();
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>(std::string_view, std::string_view, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+// [ostream.formatted.print]/3.2
+//   ...
+//   After constructing a sentry object, the function initializes an automatic variable via
+//     string out = vformat(os.getloc(), fmt, args);
+// This means if both
+// - creating a sentry fails
+// - the formatting fails
+// the first one "wins" and the format_error is not thrown.
+static void test_sentry_failure() {
+  // In order for the creation of a sentry to fail a tied stream's
+  // sync operation should fail.
+  struct sync_failure : public std::basic_streambuf<char> {
+  protected:
+    int virtual sync() { return -1; }
+  };
+  sync_failure buf_tied;
+  std::ostream os_tied(&buf_tied);
+  os_tied.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  std::stringstream os;
+  os.tie(&os_tied);
+  os.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  TEST_THROWS_TYPE(std::ios_base::failure, std::print(os, "valid"));
+  os_tied.clear();
+  TEST_THROWS_TYPE(std::ios_base::failure, std::print(os, "throws exception at run-time {0:{0}}", -10));
+
+  os.exceptions(std::stringstream::goodbit);
+  os.setstate(std::stringstream::failbit);
+  std::print(os, "not called when the os.good() is false, so no exception is thrown {0:{0}}", -10);
+}
+
+// [ostream.formatted.print]/3.2
+//   any exception thrown by the call to vformat is propagated without
+//   regard to the value of os.exceptions() and without turning on
+//   ios_base::badbit in the error state of os.
+// Most invalid format strings are checked at compile-time. An invalid
+// value for the width can only be tested run-time.
+static void test_format_exception() {
+  std::stringstream sstr;
+  assert(sstr.good());
+
+  TEST_THROWS_TYPE(std::format_error, std::print(sstr, "no output {0:{0}}", -10));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+
+  sstr.exceptions(std::stringstream::goodbit);
+  TEST_THROWS_TYPE(std::format_error, std::print(sstr, "no output {0:{0}}", -10));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+
+  sstr.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+  TEST_THROWS_TYPE(std::format_error, std::print(sstr, "no output {0:{0}}", -10));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+}
+
+static void test_write_failure() {
+  // Stream that fails to write a single character.
+  struct overflow_failure : public std::basic_streambuf<char> {
+  protected:
+    int virtual overflow(int) { return std::char_traits<char>::eof(); }
+  };
+  overflow_failure buf;
+  std::ostream os(&buf);
+  os.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  TEST_THROWS_TYPE(std::ios_base::failure, std::print(os, "valid"));
+  os.clear();
+  // When the parser would directly write to the output instead of
+  // formatting first it would fail writing the first character 't' of
+  // the string and result in a std::ios_base::failure exception.
+  TEST_THROWS_TYPE(std::format_error, std::print(os, "throws exception at run-time {0:{0}}", -10));
+
+  os.exceptions(std::stringstream::goodbit);
+  os.clear();
+  std::print(os, "valid");
+  assert(os.fail());
+}
+
+static void test_stream_formatting() {
+  std::stringstream sstr;
+  auto test = [&]<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+    sstr.str("");
+    std::print(sstr, fmt, std::forward<Args>(args)...);
+
+    std::string out = sstr.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  };
+
+  test("hello", "{}", "hello");
+
+  sstr.width(10);
+  test("     hello", "{}", "hello");
+
+  sstr.fill('+');
+
+  sstr.width(10);
+  test("+++++hello", "{}", "hello");
+
+  // *** Test embedded NUL character ***
+  using namespace std::literals;
+  sstr.width(15);
+  test("++++hello\0world"sv, "hello{}{}", '\0', "world");
+
+  // *** Test Unicode ***
+  // Streams count code units not code points
+  // 2-byte code points
+  sstr.width(5);
+  test("+++\u00a1", "{}", "\u00a1"); // INVERTED EXCLAMATION MARK
+  sstr.width(5);
+  test("+++\u07ff", "{}", "\u07ff"); // NKO TAMAN SIGN
+
+  // 3-byte code points
+  sstr.width(5);
+  test("++\u0800", "{}", "\u0800"); // SAMARITAN LETTER ALAF
+  sstr.width(5);
+  test("++\ufffd", "{}", "\ufffd"); // REPLACEMENT CHARACTER
+
+  // 4-byte code points
+  sstr.width(5);
+  test("+\U00010000", "{}", "\U00010000"); // LINEAR B SYLLABLE B008 A
+  sstr.width(5);
+  test("+\U0010FFFF", "{}", "\U0010FFFF"); // Undefined Character
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+  test_sentry_failure();
+  test_format_exception();
+  test_write_failure();
+  test_stream_formatting();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/print_tests.h

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_STD_INPUT_OUTPUT_IOSTREAM_FORMAT_PRINT_FUN_PRINT_TESTS_H
+#define TEST_STD_INPUT_OUTPUT_IOSTREAM_FORMAT_PRINT_FUN_PRINT_TESTS_H
+
+template <class TestFunction, class ExceptionTest>
+void print_tests(TestFunction check, ExceptionTest check_exception) {
+  // *** Test escaping  ***
+
+  check("{", "{{");
+  check("{:^}", "{{:^}}");
+  check("{: ^}", "{{:{}^}}", ' ');
+  check("{:{}^}", "{{:{{}}^}}");
+  check("{:{ }^}", "{{:{{{}}}^}}", ' ');
+
+  // *** Test argument ID ***
+  check("hello false true", "hello {0:} {1:}", false, true);
+  check("hello true false", "hello {1:} {0:}", false, true);
+
+  // *** Test many arguments ***
+  check(
+      "1234567890\t1234567890",
+      "{}{}{}{}{}{}{}{}{}{}\t{}{}{}{}{}{}{}{}{}{}",
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      0);
+
+  // *** Test embedded NUL character ***
+  using namespace std::literals;
+  check("hello\0world"sv, "hello{}{}", '\0', "world");
+  check("hello\0world"sv, "hello\0{}"sv, "world");
+  check("hello\0world"sv, "hello{}", "\0world"sv);
+
+  // *** Test Unicode ***
+  // 2-byte code points
+  check("\u00a1"sv, "{}"sv, "\u00a1");  // INVERTED EXCLAMATION MARK
+  check("\u07ff"sv, "{:}"sv, "\u07ff"); // NKO TAMAN SIGN
+
+  // 3-byte code points
+  check("\u0800"sv, "{}"sv, "\u0800"); // SAMARITAN LETTER ALAF
+  check("\ufffd"sv, "{}"sv, "\ufffd"); // REPLACEMENT CHARACTER
+
+  // 4-byte code points
+  check("\U00010000"sv, "{}"sv, "\U00010000"); // LINEAR B SYLLABLE B008 A
+  check("\U0010FFFF"sv, "{}"sv, "\U0010FFFF"); // Undefined Character
+
+  // *** Test invalid format strings ***
+  check_exception("The format string terminates at a '{'", "{");
+  check_exception("The replacement field misses a terminating '}'", "{:", 42);
+
+  check_exception("The format string contains an invalid escape sequence", "}");
+  check_exception("The format string contains an invalid escape sequence", "{:}-}", 42);
+
+  check_exception("The format string contains an invalid escape sequence", "} ");
+  check_exception("The argument index starts with an invalid character", "{-", 42);
+  check_exception("The argument index value is too large for the number of arguments supplied", "hello {}");
+  check_exception("The argument index value is too large for the number of arguments supplied", "hello {0}");
+  check_exception("The argument index value is too large for the number of arguments supplied", "hello {1}", 42);
+}
+
+#endif // TEST_STD_INPUT_OUTPUT_IOSTREAM_FORMAT_PRINT_FUN_PRINT_TESTS_H

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/println.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <ostream>
+
+// template<class... Args>
+//   void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+
+// [ostream.formatted.print]/3
+//   If the function is vprint_unicode and os is a stream that refers to
+//   a terminal capable of displaying Unicode which is determined in an
+//   implementation-defined manner, writes out to the terminal using the
+//   native Unicode API;
+// This is tested in
+// test/libcxx/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "print_tests.h"
+#include "test_format_string.h"
+#include "test_macros.h"
+
+auto test_file = []<class... Args>(std::string_view e, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::string expected = std::string{e} + '\n';
+
+  std::stringstream sstr;
+  std::println(sstr, fmt, std::forward<Args>(args)...);
+
+  std::string out = sstr.str();
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>(std::string_view, std::string_view, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_nonunicode.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <ostream>
+
+// void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
+
+// [ostream.formatted.print]/3
+//   If the function is vprint_unicode and os is a stream that refers to
+//   a terminal capable of displaying Unicode which is determined in an
+//   implementation-defined manner, writes out to the terminal using the
+//   native Unicode API;
+// This is tested in
+// test/libcxx/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "print_tests.h"
+#include "test_format_string.h"
+#include "test_macros.h"
+
+auto test_file = []<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::stringstream sstr;
+  std::vprint_nonunicode(sstr, fmt.get(), std::make_format_args(args...));
+
+  std::string out = sstr.str();
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>(std::string_view, std::string_view, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+// [ostream.formatted.print]/3.2
+//   ...
+//   After constructing a sentry object, the function initializes an automatic variable via
+//     string out = vformat(os.getloc(), fmt, args);
+// This means if both
+// - creating a sentry fails
+// - the formatting fails
+// the first one "wins" and the format_error is not thrown.
+static void test_sentry_failure() {
+  // In order for the creation of a sentry to fail a tied stream's
+  // sync operation should fail.
+  struct sync_failure : public std::basic_streambuf<char> {
+  protected:
+    int virtual sync() { return -1; }
+  };
+  sync_failure buf_tied;
+  std::ostream os_tied(&buf_tied);
+  os_tied.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  std::stringstream os;
+  os.tie(&os_tied);
+  os.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  TEST_THROWS_TYPE(std::ios_base::failure, std::vprint_nonunicode(os, "valid", std::make_format_args()));
+  os_tied.clear();
+  TEST_THROWS_TYPE(std::ios_base::failure,
+                   std::vprint_nonunicode(os, "throws exception at run-time {0:{0}}", std::make_format_args(-10)));
+
+  os.exceptions(std::stringstream::goodbit);
+  os.setstate(std::stringstream::failbit);
+  std::vprint_nonunicode(
+      os, "not called when the os.good() is false, so no exception is thrown {0:{0}}", std::make_format_args(-10));
+}
+
+// [ostream.formatted.print]/3.2
+//   any exception thrown by the call to vformat is propagated without
+//   regard to the value of os.exceptions() and without turning on
+//   ios_base!::!badbit in the error state of os.
+// Most invalid format strings are checked at compile-time. An invalid
+// value for the width can only be tested run-time.
+static void test_format_exception() {
+  std::stringstream sstr;
+  assert(sstr.good());
+
+  TEST_THROWS_TYPE(std::format_error, std::vprint_nonunicode(sstr, "no output {0:{0}}", std::make_format_args(-10)));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+
+  sstr.exceptions(std::stringstream::goodbit);
+  TEST_THROWS_TYPE(std::format_error, std::vprint_nonunicode(sstr, "no output {0:{0}}", std::make_format_args(-10)));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+
+  sstr.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+  TEST_THROWS_TYPE(std::format_error, std::vprint_nonunicode(sstr, "no output {0:{0}}", std::make_format_args(-10)));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+}
+
+static void test_write_failure() {
+  // Stream that fails to write a single character.
+  struct overflow_failure : public std::basic_streambuf<char> {
+  protected:
+    int virtual overflow(int) { return std::char_traits<char>::eof(); }
+  };
+  overflow_failure buf;
+  std::ostream os(&buf);
+  os.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  TEST_THROWS_TYPE(std::ios_base::failure, std::vprint_nonunicode(os, "valid", std::make_format_args()));
+  os.clear();
+  // When the parser would directly write to the output instead of
+  // formatting first it would fail writing the first character 't' of
+  // the string and result in a std::ios_base::failure exception.
+  TEST_THROWS_TYPE(std::format_error,
+                   std::vprint_nonunicode(os, "throws exception at run-time {0:{0}}", std::make_format_args(-10)));
+
+  os.exceptions(std::stringstream::goodbit);
+  os.clear();
+  std::vprint_nonunicode(os, "valid", std::make_format_args());
+  assert(os.fail());
+}
+
+static void test_stream_formatting() {
+  std::stringstream sstr;
+  auto test = [&]<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+    sstr.str("");
+    std::vprint_nonunicode(sstr, fmt.get(), std::make_format_args(args...));
+
+    std::string out = sstr.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  };
+
+  test("hello", "{}", "hello");
+
+  sstr.width(10);
+  test("     hello", "{}", "hello");
+
+  sstr.fill('+');
+
+  sstr.width(10);
+  test("+++++hello", "{}", "hello");
+
+  // *** Test embedded NUL character ***
+  using namespace std::literals;
+  sstr.width(15);
+  test("++++hello\0world"sv, "hello{}{}", '\0', "world");
+
+  // *** Test Unicode ***
+  // Streams count code units not code points
+  // 2-byte code points
+  sstr.width(5);
+  test("+++\u00a1", "{}", "\u00a1"); // INVERTED EXCLAMATION MARK
+  sstr.width(5);
+  test("+++\u07ff", "{}", "\u07ff"); // NKO TAMAN SIGN
+
+  // 3-byte code points
+  sstr.width(5);
+  test("++\u0800", "{}", "\u0800"); // SAMARITAN LETTER ALAF
+  sstr.width(5);
+  test("++\ufffd", "{}", "\ufffd"); // REPLACEMENT CHARACTER
+
+  // 4-byte code points
+  sstr.width(5);
+  test("+\U00010000", "{}", "\U00010000"); // LINEAR B SYLLABLE B008 A
+  sstr.width(5);
+  test("+\U0010FFFF", "{}", "\U0010FFFF"); // Undefined Character
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+  test_sentry_failure();
+  test_format_exception();
+  test_write_failure();
+  test_stream_formatting();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <ostream>
+
+// void vprint_unicode(ostream& os, string_view fmt, format_args args);
+// [ostream.formatted.print]/3
+//   If the function is vprint_unicode and os is a stream that refers to
+//   a terminal capable of displaying Unicode which is determined in an
+//   implementation-defined manner, writes out to the terminal using the
+//   native Unicode API;
+// This is tested in
+// test/libcxx/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.print/vprint_unicode.pass.cpp
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "print_tests.h"
+#include "test_format_string.h"
+#include "test_macros.h"
+
+auto test_file = []<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::stringstream sstr;
+  std::vprint_unicode(sstr, fmt.get(), std::make_format_args(args...));
+
+  std::string out = sstr.str();
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>(std::string_view, std::string_view, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+// [ostream.formatted.print]/3.2
+//   ...
+//   After constructing a sentry object, the function initializes an automatic variable via
+//     string out = vformat(os.getloc(), fmt, args);
+// This means if both
+// - creating a sentry fails
+// - the formatting fails
+// the first one "wins" and the format_error is not thrown.
+static void test_sentry_failure() {
+  // In order for the creation of a sentry to fail a tied stream's
+  // sync operation should fail.
+  struct sync_failure : public std::basic_streambuf<char> {
+  protected:
+    int virtual sync() { return -1; }
+  };
+  sync_failure buf_tied;
+  std::ostream os_tied(&buf_tied);
+  os_tied.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  std::stringstream os;
+  os.tie(&os_tied);
+  os.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  TEST_THROWS_TYPE(std::ios_base::failure, std::vprint_unicode(os, "valid", std::make_format_args()));
+  os_tied.clear();
+  TEST_THROWS_TYPE(std::ios_base::failure,
+                   std::vprint_unicode(os, "throws exception at run-time {0:{0}}", std::make_format_args(-10)));
+
+  os.exceptions(std::stringstream::goodbit);
+  os.setstate(std::stringstream::failbit);
+  std::vprint_unicode(
+      os, "not called when the os.good() is false, so no exception is thrown {0:{0}}", std::make_format_args(-10));
+}
+
+// [ostream.formatted.print]/3.2
+//   any exception thrown by the call to vformat is propagated without
+//   regard to the value of os.exceptions() and without turning on
+//   ios_base!::!badbit in the error state of os.
+// Most invalid format strings are checked at compile-time. An invalid
+// value for the width can only be tested run-time.
+static void test_format_exception() {
+  std::stringstream sstr;
+  assert(sstr.good());
+
+  TEST_THROWS_TYPE(std::format_error, std::vprint_unicode(sstr, "no output {0:{0}}", std::make_format_args(-10)));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+
+  sstr.exceptions(std::stringstream::goodbit);
+  TEST_THROWS_TYPE(std::format_error, std::vprint_unicode(sstr, "no output {0:{0}}", std::make_format_args(-10)));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+
+  sstr.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+  TEST_THROWS_TYPE(std::format_error, std::vprint_unicode(sstr, "no output {0:{0}}", std::make_format_args(-10)));
+  assert(sstr.good());
+  assert(sstr.str().empty());
+}
+
+static void test_write_failure() {
+  // Stream that fails to write a single character.
+  struct overflow_failure : public std::basic_streambuf<char> {
+  protected:
+    int virtual overflow(int) { return std::char_traits<char>::eof(); }
+  };
+  overflow_failure buf;
+  std::ostream os(&buf);
+  os.exceptions(std::stringstream::failbit | std::stringstream::badbit | std::stringstream::eofbit);
+
+  TEST_THROWS_TYPE(std::ios_base::failure, std::vprint_unicode(os, "valid", std::make_format_args()));
+  os.clear();
+  // When the parser would directly write to the output instead of
+  // formatting first it would fail writing the first character 't' of
+  // the string and result in a std::ios_base::failure exception.
+  TEST_THROWS_TYPE(
+      std::format_error, std::vprint_unicode(os, "throws exception at run-time {0:{0}}", std::make_format_args(-10)));
+
+  os.exceptions(std::stringstream::goodbit);
+  os.clear();
+  std::vprint_unicode(os, "valid", std::make_format_args());
+  assert(os.fail());
+}
+
+static void test_stream_formatting() {
+  std::stringstream sstr;
+  auto test = [&]<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+    sstr.str("");
+    std::vprint_unicode(sstr, fmt.get(), std::make_format_args(args...));
+
+    std::string out = sstr.str();
+    TEST_REQUIRE(out == expected,
+                 TEST_WRITE_CONCATENATED(
+                     "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  };
+
+  test("hello", "{}", "hello");
+
+  sstr.width(10);
+  test("     hello", "{}", "hello");
+
+  sstr.fill('+');
+
+  sstr.width(10);
+  test("+++++hello", "{}", "hello");
+
+  // *** Test embedded NUL character ***
+  using namespace std::literals;
+  sstr.width(15);
+  test("++++hello\0world"sv, "hello{}{}", '\0', "world");
+
+  // *** Test Unicode ***
+  // Streams count code units not code points
+  // 2-byte code points
+  sstr.width(5);
+  test("+++\u00a1", "{}", "\u00a1"); // INVERTED EXCLAMATION MARK
+  sstr.width(5);
+  test("+++\u07ff", "{}", "\u07ff"); // NKO TAMAN SIGN
+
+  // 3-byte code points
+  sstr.width(5);
+  test("++\u0800", "{}", "\u0800"); // SAMARITAN LETTER ALAF
+  sstr.width(5);
+  test("++\ufffd", "{}", "\ufffd"); // REPLACEMENT CHARACTER
+
+  // 4-byte code points
+  sstr.width(5);
+  test("+\U00010000", "{}", "\U00010000"); // LINEAR B SYLLABLE B008 A
+  sstr.width(5);
+  test("+\U0010FFFF", "{}", "\U0010FFFF"); // Undefined Character
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+  test_sentry_failure();
+  test_format_exception();
+  test_write_failure();
+  test_stream_formatting();
+
+  return 0;
+}

libcxx/test/std/language.support/support.limits/support.limits.general/ostream.version.compile.pass.cpp

 #     error "__cpp_lib_char8_t should have the value 201907L in c++23"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when the requirement 'defined(__cpp_char8_t)' is not met!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_print
-#     error "__cpp_lib_print should be defined in c++23"
-#   endif
-#   if __cpp_lib_print != 202207L
-#     error "__cpp_lib_print should have the value 202207L in c++23"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_print
-#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_print
+#   error "__cpp_lib_print should be defined in c++23"
+# endif
+# if __cpp_lib_print != 202207L
+#   error "__cpp_lib_print should have the value 202207L in c++23"
+# endif
 
 #elif TEST_STD_VER > 23
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++26"
 #   endif
 #   if __cpp_lib_char8_t != 201907L
 #     error "__cpp_lib_char8_t should have the value 201907L in c++26"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when the requirement 'defined(__cpp_char8_t)' is not met!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_print
-#     error "__cpp_lib_print should be defined in c++26"
-#   endif
-#   if __cpp_lib_print != 202207L
-#     error "__cpp_lib_print should have the value 202207L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_print
-#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_print
+#   error "__cpp_lib_print should be defined in c++26"
+# endif
+# if __cpp_lib_print != 202207L
+#   error "__cpp_lib_print should have the value 202207L in c++26"
+# endif
 
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/print.version.compile.pass.cpp

 #elif TEST_STD_VER == 20
 
 # ifdef __cpp_lib_print
 #   error "__cpp_lib_print should not be defined before c++23"
 # endif
 
 #elif TEST_STD_VER == 23
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_print
-#     error "__cpp_lib_print should be defined in c++23"
-#   endif
-#   if __cpp_lib_print != 202207L
-#     error "__cpp_lib_print should have the value 202207L in c++23"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_print
-#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_print
+#   error "__cpp_lib_print should be defined in c++23"
+# endif
+# if __cpp_lib_print != 202207L
+#   error "__cpp_lib_print should have the value 202207L in c++23"
+# endif
 
 #elif TEST_STD_VER > 23
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_print
-#     error "__cpp_lib_print should be defined in c++26"
-#   endif
-#   if __cpp_lib_print != 202207L
-#     error "__cpp_lib_print should have the value 202207L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_print
-#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_print
+#   error "__cpp_lib_print should be defined in c++26"
+# endif
+# if __cpp_lib_print != 202207L
+#   error "__cpp_lib_print should have the value 202207L in c++26"
+# endif
 
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 #     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++23"
 #   endif
 # else
 #   ifdef __cpp_lib_polymorphic_allocator
 #     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_print
-#     error "__cpp_lib_print should be defined in c++23"
-#   endif
-#   if __cpp_lib_print != 202207L
-#     error "__cpp_lib_print should have the value 202207L in c++23"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_print
-#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_print
+#   error "__cpp_lib_print should be defined in c++23"
+# endif
+# if __cpp_lib_print != 202207L
+#   error "__cpp_lib_print should have the value 202207L in c++23"
+# endif
 
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++23"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++23"
 # endif
 

 #     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++26"
 #   endif
 # else
 #   ifdef __cpp_lib_polymorphic_allocator
 #     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_print
-#     error "__cpp_lib_print should be defined in c++26"
-#   endif
-#   if __cpp_lib_print != 202207L
-#     error "__cpp_lib_print should have the value 202207L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_print
-#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_print
+#   error "__cpp_lib_print should be defined in c++26"
+# endif
+# if __cpp_lib_print != 202207L
+#   error "__cpp_lib_print should have the value 202207L in c++26"
+# endif
 
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++26"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++26"
 # endif
 

libcxx/utils/ci/buildkite-pipeline.yml

agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
-  #
-  # General testing with the default configuration, under all the supported
-  # Standard modes, with Clang and GCC. This catches most issues upfront.
-  # The goal of this step is to catch most issues while being very fast.
-  #
-  - wait
-
   - label: "GCC ${GCC_STABLE_VERSION} / C++latest"
     command: "libcxx/utils/ci/run-buildbot generic-gcc"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     env:
         CC: "gcc-${GCC_STABLE_VERSION}"
         CXX: "g++-${GCC_STABLE_VERSION}"
         ENABLE_CLANG_TIDY: "On"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
-  - label: "C++26"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx26"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
   - label: "Modular build"
     command: "libcxx/utils/ci/run-buildbot generic-modules"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     env:
         CC: "clang-${LLVM_HEAD_VERSION}"
         CXX: "clang++-${LLVM_HEAD_VERSION}"
agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
-  - label: "C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++03"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx03"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  #
-  # All other supported configurations of libc++.
-  #
-  - wait
-
-  - label: "C++23"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx23"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++20"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx20"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++17"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx17"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++14"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx14"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with the supported compilers.
-  - label: "GCC ${GCC_STABLE_VERSION} / C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-gcc-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "gcc-${GCC_STABLE_VERSION}"
-        CXX: "g++-${GCC_STABLE_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Clang 15"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx23"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-15"
-        CXX: "clang++-15"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Clang 16"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx23"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-16"
-        CXX: "clang++-16"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with the sanitizers.
-  - group: "Sanitizers"
-    steps:
-    - label: "ASAN"
-      command: "libcxx/utils/ci/run-buildbot generic-asan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "TSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-tsan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "UBSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-ubsan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-msan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  # Tests with the various supported ways to build libc++.
-  - label: "Bootstrapping build"
-    command: "libcxx/utils/ci/run-buildbot bootstrapping-build"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-      - "**/crash_diagnostics/*"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        LLVM_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer-${LLVM_HEAD_VERSION}"
-        CLANG_CRASH_DIAGNOSTICS_DIR: "crash_diagnostics"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with various build configurations.
-  - label: "Static libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-static"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Shared library with merged ABI and unwinder libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-merged"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Hardened mode"
-    command: "libcxx/utils/ci/run-buildbot generic-hardened-mode"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Debug mode"
-    command: "libcxx/utils/ci/run-buildbot generic-debug-mode"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "With LLVM's libunwind"
-    command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Modular build with Local Submodule Visibility"
-    command: "libcxx/utils/ci/run-buildbot generic-modules-lsv"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
   - group: "Parts disabled"
     steps:
-    - label: "No threads"
-      command: "libcxx/utils/ci/run-buildbot generic-no-threads"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
     - label: "No filesystem"
       command: "libcxx/utils/ci/run-buildbot generic-no-filesystem"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
           CC: "clang-${LLVM_HEAD_VERSION}"
           CXX: "clang++-${LLVM_HEAD_VERSION}"
           ENABLE_CLANG_TIDY: "On"
       agents:
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "No random device"
-      command: "libcxx/utils/ci/run-buildbot generic-no-random_device"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
     - label: "No locale"
       command: "libcxx/utils/ci/run-buildbot generic-no-localization"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
           CC: "clang-${LLVM_HEAD_VERSION}"
           CXX: "clang++-${LLVM_HEAD_VERSION}"
- label: "No Unicode"
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "No wide characters"
-      command: "libcxx/utils/ci/run-buildbot generic-no-wide-characters"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No experimental features"
-      command: "libcxx/utils/ci/run-buildbot generic-no-experimental"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
     - label: "No exceptions"
       command: "libcxx/utils/ci/run-buildbot generic-no-exceptions"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
           CC: "clang-${LLVM_HEAD_VERSION}"
           CXX: "clang++-${LLVM_HEAD_VERSION}"
           ENABLE_CLANG_TIDY: "On"
       agents:
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-  - label: "Unstable ABI"
-    command: "libcxx/utils/ci/run-buildbot generic-abi-unstable"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Other non-testing CI jobs
-  - label: "Benchmarks"
-    command: "libcxx/utils/ci/run-buildbot benchmarks"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
   # Tests on non-Unix platforms
   - group: ":windows: Windows"
     steps:
     - label: "Clang-cl (DLL)"
       command: "bash libcxx/utils/ci/run-buildbot clang-cl-dll"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
- label: "Clang-cl (Static)"
       agents:
         queue: "windows"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "Clang-cl (no vcruntime exceptions)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-no-vcruntime"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-
-    - label: "Clang-cl (Debug mode)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-debug"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Clang-cl (Static CRT)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-static-crt"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (DLL, x86_64)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-dll"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (Static, x86_64)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-static"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (DLL, i686)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-dll-i686"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
   - group: ":mac: Apple"
     steps:
     - label: "MacOS x86_64"
       command: "libcxx/utils/ci/run-buildbot generic-cxx20"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       agents:
- label: "MacOS arm64"
         os: "macos"
         arch: "arm64"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "MacOS with Modules"
-      command: "libcxx/utils/ci/run-buildbot generic-modules"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # Build with the configuration we use to generate libc++.dylib on Apple platforms
-    - label: "Apple system"
-      command: "libcxx/utils/ci/run-buildbot apple-system"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64" # This can technically run on any architecture, but we have more resources on arm64 so we pin this job to arm64
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # Test back-deployment to older Apple platforms
-    - label: "Apple back-deployment macosx10.13"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.13"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # We need to use x86_64 for back-deployment CI on this target since macOS didn't support arm64 back then.
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Apple back-deployment macosx10.15"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.15"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # We need to use x86_64 for back-deployment CI on this target since macOS didn't support arm64 back then.
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # TODO: Re-enable this once we've figured out how to run back-deployment testing on arm64 on recent OSes
-    # - label: "Apple back-deployment macosx11.0 arm64"
-    #   command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-11.0"
-    #   artifact_paths:
-    #     - "**/test-results.xml"
-    #     - "**/*.abilist"
-    #   agents:
-    #     queue: "libcxx-builders"
-    #     os: "macos"
-    #     arch: "arm64"
-    #   retry:
-    #     automatic:
-    #       - exit_status: -1  # Agent was lost
-    #         limit: 2
-    #   timeout_in_minutes: 120
-
-    - label: "Apple back-deployment with hardening enabled"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-hardened-11.0"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # TODO: Remove this once we are able to run back-deployment on arm64 again, since this isn't x86_64 specific
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
   - group: "ARM"
     steps:
     - label: "AArch64"
       command: "libcxx/utils/ci/run-buildbot aarch64"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       agents:
- label: "Armv8 -fno-exceptions"
         queue: "libcxx-builders-linaro-arm"
         arch: "armv8l"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "Armv7"
-      command: "libcxx/utils/ci/run-buildbot armv7"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l" # Compiling for v7, running on v8 hardware
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv7 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot armv7-no-exceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l" # Compiling for v7, running on v8 hardware
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
   - group: "AIX"
     steps:
     - label: "AIX (32-bit)"
       command: "libcxx/utils/ci/run-buildbot aix"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "headers": ["memory_resource"],
             "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
             "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
         },
         {
             "name": "__cpp_lib_print",
             "values": {"c++23": 202207},
             "headers": ["ostream", "print"],
-            "unimplemented": True,
         },
         {
             "name": "__cpp_lib_quoted_string_io",
             "values": {"c++14": 201304},
             "headers": ["iomanip"],
         },
         {
             "name": "__cpp_lib_ranges",