[libc++] Implement C++20 P0408R7 (Efficient Access to basic_stringbuf's Buffer)

[pfusik]

Rebased.

[pfusik]

CI complains about missing stringbuf::str() const.
It's stringbuf::str() const & now, so it can be overloaded with stringbuf::str() &&.
How to handle this?

[philnik]

libcxx/include/sstream

374–375

Why do you add a conditional noexcept without any guards here?

378–383

Otherwise this is super confusing IMO. The extra bits should fix your problem.

[pfusik]

Added noexcept guard.
Hide the new str() overload from ABI.

[pfusik]

libcxx/include/sstream

374–375

Fixed.

378–383

This doesn't look right: the & should be in C++20. What's _LIBCPP_BUILDING_LIBRARY ?

It looks similar to std::string::substr which doesn't use _LIBCPP_BUILDING_LIBRARY.

[philnik]

libcxx/include/sstream

378–383

_LIBCPP_BUILDING_LIBRARY is defined when building the static or shared library. It's not required for string::substr, because that's not part of the library. stringbuf::str() OTOH is part of the library through an extern template.

[pfusik]

Keep stringbuf::str() when building the library.
Avoid the _NOEXCEPT_ macro.

[pfusik]

Fix LIBCXX_ENABLE_DEBUG_MODE=ON failure by using string_view::data instead of string_view::begin.

[Mordante]

Thanks for working on this. I mainly glossed over the patch.

libcxx/docs/Status/Cxx20Papers.csv

102

Please mention this in ReleaseNotes.rst too

libcxx/include/sstream

36

Pleas align // C++20 in the same column

285

I really dislike this macro. It's quite unclear what it does. Signatures like string str() && are valid. Looking at the number of use cases I rather ifdef at these places.

342

We use std in new code. We don't change existing code to avoid merge conflicts with open patches.

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.alloc.pass.cpp

18

I miss tests for const member functions.

[pfusik]

Address code review comments.
Include pre-C++20 str() in synopsis.

[pfusik]

One const too far.

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.alloc.pass.cpp

18

Added const in alloc.pass.cpp tests, members and constructors.

[pfusik]

Add const to one more test.

[pfusik]

Ensure postconditions of str() &&

[pfusik]

Ensure buffer is empty after str() &&.

[Mordante]

Could you split the patch in 4 parts. I'm not too familiar with this code and it's not the easiest to grok so reviewing takes quite a bit of time. I mainly looked at streambuf, I still need to verify that there are tests for all post conditions.

Having smaller patches makes it a lot easier to find time to look at it.

libcxx/include/sstream

38

54

void swap(basic_stringbuf& rhs) noexcept(see below ); 
                                ~~~~~~~~~~~~~~~~~~~~

This misses an addition

60

please move the basic_string_view<char_type, traits_type> view() const noexcept; // C++20 here so it matches the synopsis.

Same for the str() && function.

359

This constraint http://eel.is/c++draft/stringbuf#cons-8 Constraints: is_same_v<SAlloc, Allocator> is false. is missing.

365

I would prefer this in its own ifdef block so the code follows the order of the wording in the Standard.
Normally I don't care too much, but this class has way to many constructors with small differences; so it's easy to look at "the wrong one".

448

move from __rhs.__str_.

458

Use after move of __rhs.__str_.

Note this was existing, but is a bug.

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/alloc.pass.cpp

17–29

Typically we do one test per function overload. Can you split this in multiple tests?

The same for other tests.

[pfusik]

Addressing the review comments.
Will split to smaller changes.

libcxx/include/sstream

458

What fix would you suggest?

[pfusik]

Splitting to smaller chunks. First one: https://reviews.llvm.org/D153405

libcxx/docs/Status/Cxx20.rst

.. note::
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set and the libary is only available when built with ``-fexperimental-library``).
       Not yet implemented LWG-issues will cause API and ABI breakage.
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
    .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.
-   .. [#note-P0408] P0408: Only `view()` members implemented.
 
 .. _issues-status-cxx20:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx20Issues.csv
    :header-rows: 1
    :widths: auto

libcxx/docs/Status/Cxx20Papers.csv

 "`P1357R1 <https://wg21.link/P1357R1>`__","LWG","Traits for [Un]bounded Arrays","Kona","|Complete|","9.0"
 "`P1458R1 <https://wg21.link/P1458R1>`__","LWG","Mandating the Standard Library: Clause 16 - Language support library","Kona","|Complete|","9.0"
 "`P1459R1 <https://wg21.link/P1459R1>`__","LWG","Mandating the Standard Library: Clause 18 - Diagnostics library","Kona","|Complete|","9.0"
 "`P1462R1 <https://wg21.link/P1462R1>`__","LWG","Mandating the Standard Library: Clause 20 - Strings library","Kona","|Complete|","9.0"
 "`P1463R1 <https://wg21.link/P1463R1>`__","LWG","Mandating the Standard Library: Clause 21 - Containers library","Kona","",""
 "`P1464R1 <https://wg21.link/P1464R1>`__","LWG","Mandating the Standard Library: Clause 22 - Iterators library","Kona","|Complete|","9.0"
 "","","","","","",""
 "`P0325R4 <https://wg21.link/P0325R4>`__","LWG","to_array from LFTS with updates","Cologne","|Complete|","10.0"
-"`P0408R7 <https://wg21.link/P0408R7>`__","LWG","Efficient Access to basic_stringbuf's Buffer","Cologne","|In Progress| [#note-P0408]_",""
+"`P0408R7 <https://wg21.link/P0408R7>`__","LWG","Efficient Access to basic_stringbuf's Buffer","Cologne","|Complete|","17.0"
 "`P0466R5 <https://wg21.link/P0466R5>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
 "`P0553R4 <https://wg21.link/P0553R4>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631R8 <https://wg21.link/P0631R8>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|Complete| [#note-P0645]_","14.0"
 "`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"

libcxx/include/sstream

public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // [stringbuf.cons] constructors:
     explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out); // before C++20
     basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}               // C++20
     explicit basic_stringbuf(ios_base::openmode which);                                // C++20
-    explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& str,
+    explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& s,
                              ios_base::openmode which = ios_base::in | ios_base::out);
+    explicit basic_stringbuf(const allocator_type& a)
+        : basic_stringbuf(ios_base::in | ios_base::out, a) {} // C++20
+    basic_stringbuf(ios_base::openmode which, const allocator_type& a); // C++20
+    explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>&& s,
+                             ios_base::openmode which = ios_base::in | ios_base::out); // C++20
+    template <class SAlloc>
+    basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_stringbuf(s, ios_base::in | ios_base::out, a) {} // C++20
+    template <class SAlloc>
+    basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s,
+                    ios_base::openmode which, const allocator_type& a); // C++20
+    template <class SAlloc>
+    explicit basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s,
+                             ios_base::openmode which = ios_base::in | ios_base::out); // C++20
     basic_stringbuf(basic_stringbuf&& rhs);
+    basic_stringbuf(basic_stringbuf&& rhs, const allocator_type& a); // C++20
 
     // [stringbuf.assign] Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
     void swap(basic_stringbuf& rhs);
 
     // [stringbuf.members] Member functions:
+    allocator_type get_allocator() const noexcept; // C++20
     basic_string<char_type, traits_type, allocator_type> str() const;
     void str(const basic_string<char_type, traits_type, allocator_type>& s);
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20
+    basic_string<char_type, traits_type, allocator_type> str() &&; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20
     basic_string_view<char_type, traits_type> view() const noexcept; // C++20
 
 protected:
     // [stringbuf.virtuals] Overridden virtual functions:
     virtual int_type underflow();
     virtual int_type pbackfail(int_type c = traits_type::eof());
     virtual int_type overflow (int_type c = traits_type::eof());
     virtual basic_streambuf<char_type, traits_type>* setbuf(char_type*, streamsize);
public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // [istringstream.cons] Constructors:
     explicit basic_istringstream(ios_base::openmode which = ios_base::in); // before C++20
     basic_istringstream() : basic_istringstream(ios_base::in) {}           // C++20
     explicit basic_istringstream(ios_base::openmode which);                // C++20
-
-    explicit basic_istringstream(const basic_string<char_type, traits_type,allocator_type>& str,
+    explicit basic_istringstream(const basic_string<char_type, traits_type, allocator_type>& s,
                                  ios_base::openmode which = ios_base::in);
+    basic_istringstream(ios_base::openmode which, const allocator_type& a); // C++20
+    explicit basic_istringstream(basic_string<char_type, traits_type, allocator_type>&& s,
+                                 ios_base::openmode which = ios_base::in); // C++20
+    template <class SAlloc>
+    basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_istringstream(s, ios_base::in, a) {} // C++20
+    template <class SAlloc>
+    basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                        ios_base::openmode which, const allocator_type& a); // C++20
+    template <class SAlloc>
+    explicit basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                                 ios_base::openmode which = ios_base::in); // C++20
     basic_istringstream(basic_istringstream&& rhs);
 
     // [istringstream.assign] Assign and swap:
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
 
     // [istringstream.members] Member functions:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
     basic_string<char_type, traits_type, allocator_type> str() const;
+    basic_string<char_type, traits_type, allocator_type> str() &&; // C++20
     void str(const basic_string<char_type, traits_type, allocator_type>& s);
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20
     basic_string_view<char_type, traits_type> view() const noexcept; // C++20
 };
 
 template <class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 
 typedef basic_istringstream<char>    istringstream;
public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // [ostringstream.cons] Constructors:
     explicit basic_ostringstream(ios_base::openmode which = ios_base::out); // before C++20
     basic_ostringstream() : basic_ostringstream(ios_base::out) {}           // C++20
     explicit basic_ostringstream(ios_base::openmode which);                 // C++20
-
-    explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& str,
+    explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& s,
                                  ios_base::openmode which = ios_base::out);
+    basic_ostringstream(ios_base::openmode which, const allocator_type& a); // C++20
+    explicit basic_ostringstream(basic_string<char_type, traits_type, allocator_type>&& s,
+                                 ios_base::openmode which = ios_base::out); // C++20
+    template <class SAlloc>
+    basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_ostringstream(s, ios_base::out, a) {} // C++20
+    template <class SAlloc>
+    basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                        ios_base::openmode which, const allocator_type& a); // C++20
+    template <class SAlloc>
+    explicit basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                                 ios_base::openmode which = ios_base::out); // C++20
     basic_ostringstream(basic_ostringstream&& rhs);
 
     // [ostringstream.assign] Assign and swap:
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
 
     // [ostringstream.members] Member functions:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
     basic_string<char_type, traits_type, allocator_type> str() const;
+    basic_string<char_type, traits_type, allocator_type> str() &&; // C++20
     void str(const basic_string<char_type, traits_type, allocator_type>& s);
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20
     basic_string_view<char_type, traits_type> view() const noexcept; // C++20
 };
 
 template <class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 
 typedef basic_ostringstream<char>    ostringstream;
public:
     typedef charT                          char_type;
     typedef traits                         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 Allocator                      allocator_type;
 
     // [stringstream.cons] constructors
-    explicit basic_stringstream(ios_base::openmode which = ios_base::out | ios_base::in); // before C++20
-    basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}            // C++20
+    explicit basic_stringstream(ios_base::openmode which = ios_base::in | ios_base::out); // before C++20
+    basic_stringstream() : basic_stringstream(ios_base::in | ios_base::out) {}            // C++20
     explicit basic_stringstream(ios_base::openmode which);                                // C++20
-
-    explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& str,
-                                ios_base::openmode which = ios_base::out|ios_base::in);
+    explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& s,
+                                ios_base::openmode which = ios_base::in | ios_base::out);
+    basic_stringstream(ios_base::openmode which, const allocator_type& a); // C++20
+    explicit basic_stringstream(basic_string<char_type, traits_type, allocator_type>&& s,
+                                ios_base::openmode which = ios_base::in | ios_base::out); // C++20
+    template <class SAlloc>
+    basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_stringstream(s, ios_base::in | ios_base::out, a) {} // C++20
+    template <class SAlloc>
+    basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                       ios_base::openmode which, const allocator_type& a); // C++20
+    template <class SAlloc>
+    explicit basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                                ios_base::openmode which = ios_base::in | ios_base::out); // C++20
     basic_stringstream(basic_stringstream&& rhs);
 
     // [stringstream.assign] Assign and swap:
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
 
     // [stringstream.members] Member functions:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
     basic_string<char_type, traits_type, allocator_type> str() const;
-    void str(const basic_string<char_type, traits_type, allocator_type>& str);
+    basic_string<char_type, traits_type, allocator_type> str() &&; // C++20
+    void str(const basic_string<char_type, traits_type, allocator_type>& s);
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20
     basic_string_view<char_type, traits_type> view() const noexcept; // C++20
 };
 
 template <class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 
 typedef basic_stringstream<char>    stringstream;

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
+#if _LIBCPP_STD_VER >= 20
+#  define _LIBCPP_REF_SINCE_CXX20 &
+#else
+#  define _LIBCPP_REF_SINCE_CXX20
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Class template basic_stringbuf [stringbuf]
 
 template <class _CharT, class _Traits, class _Allocator>
 class _LIBCPP_TEMPLATE_VIS basic_stringbuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
     typedef _CharT                         char_type;
     typedef _Traits                        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 _Allocator                     allocator_type;
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
 
     string_type __str_;
     mutable char_type* __hm_;
     ios_base::openmode __mode_;
+    _LIBCPP_HIDE_FROM_ABI void __init_buf_ptrs();
+    _LIBCPP_HIDE_FROM_ABI void __move_init(basic_stringbuf&& __rhs);
 
 public:
     // [stringbuf.cons] constructors:
     _LIBCPP_INLINE_VISIBILITY
     basic_stringbuf()
         : __hm_(nullptr), __mode_(ios_base::in | ios_base::out) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringbuf(ios_base::openmode __wch)
         : __hm_(nullptr), __mode_(__wch) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringbuf(const string_type& __s,
                              ios_base::openmode __wch = ios_base::in | ios_base::out)
         : __str_(__s.get_allocator()), __hm_(nullptr), __mode_(__wch)
     {
         str(__s);
     }
 
-    basic_stringbuf(basic_stringbuf&& __rhs);
+    basic_stringbuf(basic_stringbuf&& __rhs) : __mode_(__rhs.__mode_) { __move_init(_VSTD::move(__rhs)); }
+
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(const allocator_type& __a)
+        : basic_stringbuf(ios_base::in | ios_base::out, __a) {}
+
+    _LIBCPP_HIDE_FROM_ABI basic_stringbuf(ios_base::openmode __wch, const allocator_type& __a)
+        : __str_(__a), __hm_(nullptr), __mode_(__wch) {}
+
+    _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(string_type&& __s,
+                                                   ios_base::openmode __wch = ios_base::in | ios_base::out)
+        : __str_(_VSTD::move(__s)), __hm_(nullptr), __mode_(__wch) {
+        __init_buf_ptrs();
+    }
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI
+    basic_stringbuf(const basic_string<char_type, traits_type, _SAlloc>& __s, const allocator_type& __a)
+        : basic_stringbuf(__s, ios_base::in | ios_base::out, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI basic_stringbuf(
+        const basic_string<char_type, traits_type, _SAlloc>& __s, ios_base::openmode __wch, const allocator_type& __a)
+        : __str_(__s, __a), __hm_(nullptr), __mode_(__wch) {
+        __init_buf_ptrs();
+    }
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(const basic_string<char_type, traits_type, _SAlloc>& __s,
+                                                   ios_base::openmode __wch = ios_base::in | ios_base::out)
+        : __str_(__s), __hm_(nullptr), __mode_(__wch) {
+        __init_buf_ptrs();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a)
+        : basic_stringbuf(__rhs.__mode_, __a) {
+        __move_init(_VSTD::move(__rhs));
+    }
+#endif // _LIBCPP_STD_VER >= 20
 
     // [stringbuf.assign] Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& __rhs);
-    void swap(basic_stringbuf& __rhs);
+    void swap(basic_stringbuf& __rhs)
+        _NOEXCEPT_(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
+                   allocator_traits<allocator_type>::is_always_equal::value);
 
     // [stringbuf.members] Member functions:
-    string_type str() const;
-    void str(const string_type& __s);
+    string_type str() const _LIBCPP_REF_SINCE_CXX20;
+    void str(const string_type& __s) {
+        __str_ = __s;
+        __init_buf_ptrs();
+    }
+
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept;
-#endif
+    _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+
+    template <class _SAlloc>
+      requires __is_allocator<_SAlloc>::value
+    _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+        return basic_string<_CharT, _Traits, _SAlloc>(view(), __sa);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI string_type str() && {
+        basic_string_view<_CharT, _Traits> __view = view();
+        return string_type(_VSTD::move(__str_), __view.begin() - __str_.data(), __view.size());
+    }
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+        __str_ = __s;
+        __init_buf_ptrs();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) {
+        __str_ = _VSTD::move(__s);
+        __init_buf_ptrs();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept;
+#endif // _LIBCPP_STD_VER >= 20
 
 protected:
     // [stringbuf.virtuals] 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;
     pos_type seekoff(off_type __off, ios_base::seekdir __way,
                      ios_base::openmode __wch = ios_base::in | ios_base::out) override;
     _LIBCPP_HIDE_FROM_ABI_VIRTUAL
     pos_type seekpos(pos_type __sp,
                      ios_base::openmode __wch = ios_base::in | ios_base::out) override {
         return seekoff(__sp, ios_base::beg, __wch);
     }
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs)
-    : __mode_(__rhs.__mode_)
-{
+_LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__move_init(basic_stringbuf&& __rhs) {
     char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
     ptrdiff_t __binp = -1;
     ptrdiff_t __ninp = -1;
     ptrdiff_t __einp = -1;
     if (__rhs.eback() != nullptr)
     {
         __binp = __rhs.eback() - __p;
         __ninp = __rhs.gptr() - __p;
         __einp = __rhs.egptr() - __p;
     }
     ptrdiff_t __bout = -1;
     ptrdiff_t __nout = -1;
     ptrdiff_t __eout = -1;
     if (__rhs.pbase() != nullptr)
     {
         __bout = __rhs.pbase() - __p;
         __nout = __rhs.pptr() - __p;
         __eout = __rhs.epptr() - __p;
     }
     ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
     __str_ = _VSTD::move(__rhs.__str_);
     __p = const_cast<char_type*>(__str_.data());
     if (__binp != -1)
         this->setg(__p + __binp, __p + __ninp, __p + __einp);
     if (__bout != -1)
     {
         this->setp(__p + __bout, __p + __eout);
         this->__pbump(__nout);
     }
     __hm_ = __hm == -1 ? nullptr : __p + __hm;
     __p = const_cast<char_type*>(__rhs.__str_.data());
     __rhs.setg(__p, __p, __p);
     __rhs.setp(__p, __p);
     __rhs.__hm_ = __p;
     this->pubimbue(__rhs.getloc());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_stringbuf<_CharT, _Traits, _Allocator>&
basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
     __rhs.setg(__p, __p, __p);
     __rhs.setp(__p, __p);
     __rhs.__hm_ = __p;
     this->pubimbue(__rhs.getloc());
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void
-basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
-{
+void basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
+    _NOEXCEPT_(allocator_traits<_Allocator>::propagate_on_container_swap::value ||
+               allocator_traits<_Allocator>::is_always_equal::value) {
     char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
     ptrdiff_t __rbinp = -1;
     ptrdiff_t __rninp = -1;
     ptrdiff_t __reinp = -1;
     if (__rhs.eback() != nullptr)
     {
         __rbinp = __rhs.eback() - __p;
         __rninp = __rhs.gptr() - __p;
else
         __rhs.setp(nullptr, nullptr);
     __rhs.__hm_ = __lhm == -1 ? nullptr : __p + __lhm;
     locale __tl = __rhs.getloc();
     __rhs.pubimbue(this->getloc());
     this->pubimbue(__tl);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
-     basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
-{
+inline _LIBCPP_INLINE_VISIBILITY void
+swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
+    _NOEXCEPT_(noexcept(__x.swap(__y))) {
     __x.swap(__y);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-basic_stringbuf<_CharT, _Traits, _Allocator>::str() const
-{
+basic_stringbuf<_CharT, _Traits, _Allocator>::str() const _LIBCPP_REF_SINCE_CXX20 {
 #if _LIBCPP_STD_VER >= 20
-    return string_type(view(), __str_.get_allocator());
+    return str(__str_.get_allocator());
 #else // _LIBCPP_STD_VER >= 20
     if (__mode_ & ios_base::out)
     {
         if (__hm_ < this->pptr())
             __hm_ = this->pptr();
         return string_type(this->pbase(), __hm_, __str_.get_allocator());
     }
     else if (__mode_ & ios_base::in)
         return string_type(this->eback(), this->egptr(), __str_.get_allocator());
     return string_type(__str_.get_allocator());
 #endif // _LIBCPP_STD_VER >= 20
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void
-basic_stringbuf<_CharT, _Traits, _Allocator>::str(const string_type& __s)
-{
-    __str_ = __s;
+_LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__init_buf_ptrs() {
     __hm_ = nullptr;
-    if (__mode_ & ios_base::in)
-    {
-        __hm_ = const_cast<char_type*>(__str_.data()) + __str_.size();
-        this->setg(const_cast<char_type*>(__str_.data()),
-                   const_cast<char_type*>(__str_.data()),
-                   __hm_);
-    }
-    if (__mode_ & ios_base::out)
-    {
-        typename string_type::size_type __sz = __str_.size();
-        __hm_ = const_cast<char_type*>(__str_.data()) + __sz;
+    char_type* __data = const_cast<char_type*>(__str_.data());
+    if (__mode_ & ios_base::in) {
+        __hm_ = __data + __sz;
+        this->setg(__data, __data, __hm_);
+    }
+    if (__mode_ & ios_base::out) {
+        __hm_ = __data + __sz;
         __str_.resize(__str_.capacity());
-        this->setp(const_cast<char_type*>(__str_.data()),
-                   const_cast<char_type*>(__str_.data()) + __str_.size());
-        if (__mode_ & (ios_base::app | ios_base::ate))
-        {
-            while (__sz > INT_MAX)
-            {
+        this->setp(__data, __data + __str_.size());
+        if (__mode_ & (ios_base::app | ios_base::ate)) {
+            while (__sz > INT_MAX) {
                 this->pbump(INT_MAX);
                 __sz -= INT_MAX;
             }
             if (__sz > 0)
                 this->pbump(__sz);
         }
     }
 }
public:
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_istringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::in)
         : basic_istream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch | ios_base::in)
     { }
 
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI basic_istringstream(ios_base::openmode __wch, const _Allocator& __a)
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in, __a) {}
+
+    _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(string_type&& __s, ios_base::openmode __wch = ios_base::in)
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(_VSTD::move(__s), __wch | ios_base::in) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, const _Allocator& __a)
+        : basic_istringstream(__s, ios_base::in, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI basic_istringstream(
+        const basic_string<_CharT, _Traits, _SAlloc>& __s, ios_base::openmode __wch, const _Allocator& __a)
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch | ios_base::in, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s,
+                                 ios_base::openmode __wch = ios_base::in)
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch | ios_base::in) {}
+#endif // _LIBCPP_STD_VER >= 20
+
     _LIBCPP_INLINE_VISIBILITY
     basic_istringstream(basic_istringstream&& __rhs)
         : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
         , __sb_(_VSTD::move(__rhs.__sb_))
     {
         basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
     }
 
#endif // _LIBCPP_STD_VER >= 20
     }
 
     // [istringstream.members] Member functions:
     _LIBCPP_INLINE_VISIBILITY
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
         return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
     }
     _LIBCPP_INLINE_VISIBILITY
-    string_type str() const {
+    string_type str() const _LIBCPP_REF_SINCE_CXX20 {
         return __sb_.str();
     }
     _LIBCPP_INLINE_VISIBILITY
     void str(const string_type& __s) {
         __sb_.str(__s);
     }
+
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept {
-        return __sb_.view();
+    template <class _SAlloc>
+      requires __is_allocator<_SAlloc>::value
+    _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+        return __sb_.str(__sa);
     }
-#endif
+
+    _LIBCPP_HIDE_FROM_ABI string_type str() && { return _VSTD::move(__sb_).str(); }
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+        __sb_.str(__s);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(_VSTD::move(__s)); }
+
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
      basic_istringstream<_CharT, _Traits, _Allocator>& __y)
 {
public:
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ostringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::out)
         : basic_ostream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch | ios_base::out)
     { }
 
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI basic_ostringstream(ios_base::openmode __wch, const _Allocator& __a)
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::out, __a) {}
+
+    _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(string_type&& __s, ios_base::openmode __wch = ios_base::out)
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(_VSTD::move(__s), __wch | ios_base::out) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, const _Allocator& __a)
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__s, ios_base::out, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI basic_ostringstream(
+        const basic_string<_CharT, _Traits, _SAlloc>& __s, ios_base::openmode __wch, const _Allocator& __a)
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch | ios_base::out, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s,
+                                                       ios_base::openmode __wch = ios_base::out)
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch | ios_base::out) {}
+#endif // _LIBCPP_STD_VER >= 20
+
     _LIBCPP_INLINE_VISIBILITY
     basic_ostringstream(basic_ostringstream&& __rhs)
         : basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs))
         , __sb_(_VSTD::move(__rhs.__sb_))
     {
         basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
     }
 
#endif // _LIBCPP_STD_VER >= 20
     }
 
     // [ostringstream.members] Member functions:
     _LIBCPP_INLINE_VISIBILITY
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
         return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
     }
     _LIBCPP_INLINE_VISIBILITY
-    string_type str() const {
+    string_type str() const _LIBCPP_REF_SINCE_CXX20 {
         return __sb_.str();
     }
     _LIBCPP_INLINE_VISIBILITY
     void str(const string_type& __s) {
         __sb_.str(__s);
     }
+
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept {
-        return __sb_.view();
+    template <class _SAlloc>
+    requires __is_allocator<_SAlloc>::value
+    _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+        return __sb_.str(__sa);
     }
-#endif
+
+    _LIBCPP_HIDE_FROM_ABI string_type str() && { return _VSTD::move(__sb_).str(); }
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+        __sb_.str(__s);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(_VSTD::move(__s)); }
+
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
      basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
 {
public:
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringstream(const string_type& __s,
                                 ios_base::openmode __wch = ios_base::in | ios_base::out)
         : basic_iostream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch)
     { }
 
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI basic_stringstream(ios_base::openmode __wch, const _Allocator& __a)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch, __a) {}
+
+    _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(string_type&& __s,
+                                ios_base::openmode __wch = ios_base::in | ios_base::out)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(_VSTD::move(__s), __wch) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, const _Allocator& __a)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__s, ios_base::in | ios_base::out, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI
+    basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, ios_base::openmode __wch, const _Allocator& __a)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch, __a) {}
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s,
+                                ios_base::openmode __wch = ios_base::in | ios_base::out)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch) {}
+#endif // _LIBCPP_STD_VER >= 20
+
     _LIBCPP_INLINE_VISIBILITY
     basic_stringstream(basic_stringstream&& __rhs)
         : basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs))
         , __sb_(_VSTD::move(__rhs.__sb_))
     {
         basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
     }
 
#endif // _LIBCPP_STD_VER >= 20
     }
 
     // [stringstream.members] Member functions:
     _LIBCPP_INLINE_VISIBILITY
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
         return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
     }
     _LIBCPP_INLINE_VISIBILITY
-    string_type str() const {
+    string_type str() const _LIBCPP_REF_SINCE_CXX20 {
         return __sb_.str();
     }
     _LIBCPP_INLINE_VISIBILITY
     void str(const string_type& __s) {
         __sb_.str(__s);
     }
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept {
-        return __sb_.view();
+    template <class _SAlloc>
+      requires __is_allocator<_SAlloc>::value
+    _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+        return __sb_.str(__sa);
     }
-#endif
+
+    _LIBCPP_HIDE_FROM_ABI string_type str() && { return _VSTD::move(__sb_).str(); }
+
+    template <class _SAlloc>
+    _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+        __sb_.str(__s);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(_VSTD::move(__s)); }
+
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
      basic_stringstream<_CharT, _Traits, _Allocator>& __y)
 {

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_istringstream
+
+// basic_istringstream(ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// basic_istringstream(const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+//     : basic_istringstream(s, ios_base::in, a) {}
+// template <class SAlloc>
+// basic_istringstream(const basic_string<charT, traits, SAlloc>& s,
+//                     ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// explicit basic_istringstream(const basic_string<charT, traits, SAlloc>& s,
+//                              ios_base::openmode which = ios_base::in);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  using test_istringstream = std::basic_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+  {
+    test_allocator<CharT> a(2);
+    test_istringstream ss(std::ios_base::in, a);
+    assert(ss.view() == SV(""));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(4);
+    test_istringstream ss(s, a);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(5);
+    test_istringstream ss(s, std::ios_base::in, a);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_istringstream<CharT> ss(s);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == std::allocator<CharT>());
+  }
+  {
+    test_allocator<CharT> a(7);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_istringstream<CharT> ss(s, std::ios_base::in);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == std::allocator<CharT>());
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/string.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_istringstream
+
+// explicit basic_istringstream(basic_string<charT, traits, Allocator>&& s,
+//                              ios_base::openmode which = ios_base::in);
+
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    std::string s("testing");
+    std::istringstream ss(std::move(s));
+    assert(ss.view() == "testing");
+  }
+  {
+    std::string s("testing");
+    std::istringstream ss(std::move(s), std::ios_base::in);
+    assert(ss.view() == "testing");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::wstring s(L"testing");
+    std::wistringstream ss(std::move(s));
+    assert(ss.view() == L"testing");
+  }
+  {
+    std::wstring s(L"testing");
+    std::wistringstream ss(std::move(s), std::ios_base::in);
+    assert(ss.view() == L"testing");
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_istringstream
+
+// template <class SAlloc>
+// basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
+// template <class SAlloc>
+// void str(const basic_string<charT, traits, SAlloc>& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_istringstream<CharT> ss(STR("testing"));
+    test_allocator<CharT> a(1);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s = ss.str(a);
+    assert(s == SV("testing"));
+    assert(s.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_istringstream
+
+// basic_string<charT, traits, Allocator> str() &&;
+// void str(basic_string<charT, traits, Allocator>&& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_istringstream<CharT> ss(STR("testing"));
+    std::basic_string<CharT> s = std::move(ss).str();
+    assert(s == SV("testing"));
+  }
+  {
+    std::basic_istringstream<CharT> ss;
+    std::basic_string<CharT> s(STR("testing"));
+    ss.str(std::move(s));
+    assert(ss.view() == SV("testing"));
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_ostringstream
+
+// basic_ostringstream(ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// basic_ostringstream(const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+//     : basic_ostringstream(s, ios_base::out, a) {}
+// template <class SAlloc>
+// basic_ostringstream(const basic_string<charT, traits, SAlloc>& s,
+//                     ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// explicit basic_ostringstream(const basic_string<charT, traits, SAlloc>& s,
+//                              ios_base::openmode which = ios_base::out);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  using test_ostringstream = std::basic_ostringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+  {
+    test_allocator<CharT> a(2);
+    test_ostringstream ss(std::ios_base::out, a);
+    assert(ss.view() == SV(""));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(4);
+    test_ostringstream ss(s, a);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(5);
+    test_ostringstream ss(s, std::ios_base::out, a);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_ostringstream<CharT> ss(s);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == std::allocator<CharT>());
+  }
+  {
+    test_allocator<CharT> a(7);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_ostringstream<CharT> ss(s, std::ios_base::out);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == std::allocator<CharT>());
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_ostringstream
+
+// explicit basic_ostringstream(basic_string<charT, traits, Allocator>&& s,
+//                              ios_base::openmode which = ios_base::out);
+
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    std::string s("testing");
+    std::ostringstream ss(std::move(s));
+    assert(ss.view() == "testing");
+  }
+  {
+    std::string s("testing");
+    std::ostringstream ss(std::move(s), std::ios_base::out);
+    assert(ss.view() == "testing");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::wstring s(L"testing");
+    std::wostringstream ss(std::move(s));
+    assert(ss.view() == L"testing");
+  }
+  {
+    std::wstring s(L"testing");
+    std::wostringstream ss(std::move(s), std::ios_base::out);
+    assert(ss.view() == L"testing");
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_ostringstream
+
+// template <class SAlloc>
+// basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
+// template <class SAlloc>
+// void str(const basic_string<charT, traits, SAlloc>& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_ostringstream<CharT> ss(STR("testing"));
+    test_allocator<CharT> a(1);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s = ss.str(a);
+    assert(s == SV("testing"));
+    assert(s.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_ostringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_ostringstream
+
+// basic_string<charT, traits, Allocator> str() &&;
+// void str(basic_string<charT, traits, Allocator>&& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_ostringstream<CharT> ss(STR("testing"));
+    std::basic_string<CharT> s = std::move(ss).str();
+    assert(s == SV("testing"));
+  }
+  {
+    std::basic_ostringstream<CharT> ss;
+    std::basic_string<CharT> s(STR("testing"));
+    ss.str(std::move(s));
+    assert(ss.view() == SV("testing"));
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringbuf
+
+// explicit basic_stringbuf(const Allocator& a)
+//     : basic_stringbuf(ios_base::in | ios_base::out, a) {}
+// basic_stringbuf(ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// basic_stringbuf(const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+//     : basic_stringbuf(s, ios_base::in | ios_base::out, a) {}
+// template <class SAlloc>
+// basic_stringbuf(const basic_string<charT, traits, SAlloc>& s,
+//                 ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// explicit basic_stringbuf(const basic_string<charT, traits, SAlloc>& s,
+//                          ios_base::openmode which = ios_base::in | ios_base::out);
+// basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  using test_stringbuf = std::basic_stringbuf<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+  {
+    test_allocator<CharT> a(1);
+    test_stringbuf buf(a);
+    assert(buf.view() == SV(""));
+    assert(buf.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(2);
+    test_stringbuf buf(std::ios_base::in, a);
+    assert(buf.view() == SV(""));
+    assert(buf.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(3);
+    test_stringbuf buf(std::ios_base::out, a);
+    assert(buf.view() == SV(""));
+    assert(buf.get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(4);
+    test_stringbuf buf(s, a);
+    assert(buf.view() == SV("testing"));
+    assert(buf.get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(5);
+    test_stringbuf buf(s, std::ios_base::in, a);
+    assert(buf.view() == SV("testing"));
+    assert(buf.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_stringbuf<CharT> buf(s);
+    assert(buf.view() == SV("testing"));
+    assert(buf.get_allocator() == std::allocator<CharT>());
+  }
+  {
+    test_allocator<CharT> a(7);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_stringbuf<CharT> buf(s, std::ios_base::in);
+    assert(buf.view() == SV("testing"));
+    assert(buf.get_allocator() == std::allocator<CharT>());
+  }
+  {
+    test_allocator<CharT> a(8);
+    test_stringbuf buf1(STR("testing"), a);
+    test_stringbuf buf(std::move(buf1), a);
+    assert(buf.view() == SV("testing"));
+    assert(buf.get_allocator() == a);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringbuf
+
+// explicit basic_stringbuf(basic_string<charT, traits, Allocator>&& s,
+//                          ios_base::openmode which = ios_base::in | ios_base::out);
+
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    std::string s("testing");
+    std::stringbuf buf(std::move(s));
+    assert(buf.view() == "testing");
+  }
+  {
+    std::string s("testing");
+    std::stringbuf buf(std::move(s), std::ios_base::in);
+    assert(buf.view() == "testing");
+  }
+  {
+    std::string s("testing");
+    std::stringbuf buf(std::move(s), std::ios_base::out);
+    assert(buf.view() == "testing");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::wstring s(L"testing");
+    std::wstringbuf buf(std::move(s));
+    assert(buf.view() == L"testing");
+  }
+  {
+    std::wstring s(L"testing");
+    std::wstringbuf buf(std::move(s), std::ios_base::in);
+    assert(buf.view() == L"testing");
+  }
+  {
+    std::wstring s(L"testing");
+    std::wstringbuf buf(std::move(s), std::ios_base::out);
+    assert(buf.view() == L"testing");
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringbuf
+
+// template <class SAlloc>
+// basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
+// template <class SAlloc>
+// void str(const basic_string<charT, traits, SAlloc>& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_stringbuf<CharT> buf(STR("testing"));
+    test_allocator<CharT> a(1);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s = buf.str(a);
+    assert(s == SV("testing"));
+    assert(s.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_stringbuf<CharT, std::char_traits<CharT>, test_allocator<CharT>> buf(s);
+    assert(buf.view() == SV("testing"));
+    assert(buf.get_allocator() == a);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringbuf
+
+// basic_string<charT, traits, Allocator> str() &&;
+// void str(basic_string<charT, traits, Allocator>&& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_stringbuf<CharT> buf(STR("testing"));
+    std::basic_string<CharT> s = std::move(buf).str();
+    assert(s == SV("testing"));
+  }
+  {
+    std::basic_stringbuf<CharT> buf;
+    std::basic_string<CharT> s(STR("testing"));
+    buf.str(std::move(s));
+    assert(buf.view() == SV("testing"));
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringstream.cons/alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringstream
+
+// basic_stringstream(ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// basic_stringstream(const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+//     : basic_stringstream(s, ios_base::in | ios_base::out, a) {}
+// template <class SAlloc>
+// basic_stringstream(const basic_string<charT, traits, SAlloc>& s,
+//                     ios_base::openmode which, const Allocator& a);
+// template <class SAlloc>
+// explicit basic_stringstream(const basic_string<charT, traits, SAlloc>& s,
+//                              ios_base::openmode which = ios_base::in | ios_base::out);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  using test_stringstream = std::basic_stringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+  {
+    test_allocator<CharT> a(2);
+    test_stringstream ss(std::ios_base::in, a);
+    assert(ss.view() == SV(""));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(4);
+    test_stringstream ss(s, a);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    test_allocator<CharT> a(5);
+    test_stringstream ss(s, std::ios_base::out, a);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_stringstream<CharT> ss(s);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == std::allocator<CharT>());
+  }
+  {
+    test_allocator<CharT> a(7);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_stringstream<CharT> ss(s, std::ios_base::in);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == std::allocator<CharT>());
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringstream.cons/string.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringstream
+
+// explicit basic_stringstream(basic_string<charT, traits, Allocator>&& s,
+//                             ios_base::openmode which = ios_base::in | ios_base::out);
+
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    std::string s("testing");
+    std::stringstream ss(std::move(s));
+    assert(ss.view() == "testing");
+  }
+  {
+    std::string s("testing");
+    std::stringstream ss(std::move(s), std::ios_base::in);
+    assert(ss.view() == "testing");
+  }
+  {
+    std::string s("testing");
+    std::stringstream ss(std::move(s), std::ios_base::out);
+    assert(ss.view() == "testing");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::wstring s(L"testing");
+    std::wstringstream ss(std::move(s));
+    assert(ss.view() == L"testing");
+  }
+  {
+    std::wstring s(L"testing");
+    std::wstringstream ss(std::move(s), std::ios_base::in);
+    assert(ss.view() == L"testing");
+  }
+  {
+    std::wstring s(L"testing");
+    std::wstringstream ss(std::move(s), std::ios_base::out);
+    assert(ss.view() == L"testing");
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringstream.members/str.alloc.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringstream
+
+// template <class SAlloc>
+// basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
+// template <class SAlloc>
+// void str(const basic_string<charT, traits, SAlloc>& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_stringstream<CharT> ss(STR("testing"));
+    test_allocator<CharT> a(1);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s = ss.str(a);
+    assert(s == SV("testing"));
+    assert(s.get_allocator() == a);
+  }
+  {
+    test_allocator<CharT> a(6);
+    std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s(STR("testing"), a);
+    std::basic_stringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s);
+    assert(ss.view() == SV("testing"));
+    assert(ss.rdbuf()->get_allocator() == a);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/string.streams/stringstream.members/str.move.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
+
+// <sstream>
+
+// template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+// class basic_stringstream
+
+// basic_string<charT, traits, Allocator> str() &&;
+// void str(basic_string<charT, traits, Allocator>&& s);
+
+#include <sstream>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static void test() {
+  {
+    std::basic_stringstream<CharT> ss(STR("testing"));
+    std::basic_string<CharT> s = std::move(ss).str();
+    assert(s == SV("testing"));
+  }
+  {
+    std::basic_stringstream<CharT> ss;
+    std::basic_string<CharT> s(STR("testing"));
+    ss.str(std::move(s));
+    assert(ss.view() == SV("testing"));
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}