[libc++] Implement stringbuf members of P0408R7 (Efficient Access to basic_stringbuf's Buffer)

[Mordante]

Thanks a lot for splitting, that really helped me to finally do a full review of this patch.
It looks mostely good, some minor things.

libcxx/include/sstream

364

http://eel.is/c++draft/stringbuf#members-15 Constraints: is_same_v<SAlloc,Allocator> is false.

423

We still need to look at this issue.

470

Same here.

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

14

Here and in the other tests.

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

35

How about testing the allocator of buf.str()?
Maybe we should do even more testing the expected allocator is used. The test_allocator has ways to log that information.

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

32

This nesting is not needed.

[pfusik]

Address review comments.

[pfusik]

libcxx/include/sstream

423

I think it is okay to use nullptr instead of __p obtained from the moved string.
But since it is an unrelated fix, I'd prefer to do this in a separate change.

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

35

How?
stringbuf fixes its allocator at construction time. Here we are testing a constructor overload that doesn't accept an allocator.

[Mordante]

Thanks LGTM! I'll land the patch on your behalf.

libcxx/include/sstream

365

Nit: we only use std:: for function calls to avoid ADL.

Note since the rest of the patch is fine, I'll fix this before landing.

423

+1 for doing it in a separate patch.

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

35

Good point.

[hans]

libcxx/include/sstream

337

This is causing link errors for us on Windows. (https://crbug.com/1463881)

The problem is that sstream has an explicit instantiation declaration of basic_stringbuf<char> in the sstream header, but when compiling the instantiation in ios.instantiations.cpp, _LIBCPP_BUILDING_LIBRARY is defined and so this string_type str() const & member function doesn't get defined.

(Apologies for the late report; we were blocked on https://reviews.llvm.org/D151953#4472195 until yesterday.)

[pfusik]

libcxx/include/sstream

337

str() const & is _LIBCPP_HIDE_FROM_ABI so I think it should NOT be linked.
Why is it __declspec(dllimport) ?

[hans]

libcxx/include/sstream

337

The explicit instantiation decl uses _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS which is dllimport: https://github.com/llvm/llvm-project/blob/main/libcxx/include/__config#L564

I think the idea is that _LIBCPP_HIDE_FROM_ABI should exclude the method from the explicit instantiation but that attribute doesn't seem to be really working with dllimport: https://godbolt.org/z/qc3zfvdaa

[pfusik]

libcxx/include/sstream

337

Is this issue specific to the str() const & overload?
How do the other _LIBCPP_HIDE_FROM_ABI members work? Are they dllimport too?

[hans]

libcxx/include/sstream

337

Yes, we're only seeing this issue for str() const & (I suppose the const && overload has the same problem, but we're not calling it.)

I believe the other members are also dllimport, so in effect the _LIBCPP_HIDE_FROM_ABI isn't working, but it still builds because the members (at least the ones that get called in our builds) do get defined in the dll.

What makes these specific methods problematic is that they're excluded when _LIBCPP_BUILDING_LIBRARY is set. I suppose that's technically an ODR violation, but I can see why it's needed for compatibility.

I suppose we can try to make exclude_from_explicit_instantiation work better with dllimport explicit instantiations, but that means the code would only work with versions of Clang which has that fix.

We could also stop using exclude_from_explicit_instantiation on Windows and go back to _LIBCPP_ALWAYS_INLINE. I guess that was more brittle which is why the attribute was added in the first place though.

Maybe @ldionne has ideas here?

[ldionne]

libcxx/include/sstream

337

This seems like https://github.com/llvm/llvm-project/issues/40363. I never had time to look into it, and until now it seemed like it wasn't hard-blocking anyone.

The medium term fix is to fix https://github.com/llvm/llvm-project/issues/40363 and be done with it.
The short term fix could be this:

// TODO(LLVM 19): Remove this once we drop support for Clang 16, which had this bug: https://github.com/llvm/llvm-project/issues/40363
#ifdef _WIN32
_LIBCPP_ALWAYS_INLINE string_type str() const & { return str(__str_.get_allocator()); }
#else
_LIBCPP_HIDE_FROM_ABI string_type str() const & { return str(__str_.get_allocator()); }
#endif

WDYT?

Would someone with Windows access be willing to take on the fix for Clang? I can review it, I'm just really under water until the release. I don't think it's too hard to fix, the attribute was really simple to implement. It would be nice to fix this for LLVM 17, then we can remove the workaround fairly soon.

[pfusik]

libcxx/include/sstream

337

I'm fine with both the short and medium term fixes and can do both.

[hans]

libcxx/include/sstream

337

Both of these sound good to me too. I just confirmed the short-term one fixes our build, and I'm happy to help with the medium-term one too. (Thanks for finding the bug Louis, I had completely forgotten that we already had it on file.)

[ldionne]

libcxx/include/sstream

337

Linking this thread to D155713.

[thakis]

libcxx/include/sstream

337

Mentioning this here since this is where the discussion is: We're also seeing "missing symbol" errors for basic_ostringstream::str() (D155276) and basic_stringstream::str() (D155359) when building libc++ as a dll, and using it from client code built as c++17. (_Not_ for the const & overload as above, just for str(void) const.)

(basic_istringstream was D154454 and it probably has similar issues, but we apparently don't have callers to it.)

We only see this for the str() method, but we probably just don't call the str(string) method.

I'm guessing this has a similar cause to what's discussed above. Using the ALWAYS_INLINE hack that was added in D155185 here as well, they go away: https://bugs.chromium.org/p/chromium/issues/detail?id=1463881#c11 For a more complete workaround, I'm guessing we'd have to slap on that attribute to the other functions touched in the revisions linked to above.)

@pfusik Could you extend the workaround to cover those three classes too?

[pfusik]

libcxx/include/sstream

337

https://reviews.llvm.org/D157602

My solution retains str() const in the DLL for compatibility with libc++ 16. Could you please verify if that works for you?

[thakis]

libcxx/include/sstream

337

Yes, it helps. Thanks!

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.
+   .. [#note-P0408] P0408: All `stringbuf` members and `view()` in all classes implemented.
    .. [#note-P0660] P0660: Section 32.3 Stop Tokens is complete. ``jthread`` hasn't been implemented yet.
 
 .. _issues-status-cxx20:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx20Issues.csv
    :header-rows: 1
    :widths: auto

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(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) noexcept(see below);                               // conditionally noexcept since C++20
 
     // [stringbuf.members] Member functions:
-    basic_string<char_type, traits_type, allocator_type> str() const;
-    void str(const basic_string<char_type, traits_type, allocator_type>& s);
-    basic_string_view<char_type, traits_type> view() const noexcept; // C++20
+    allocator_type get_allocator() const noexcept;                                     // C++20
+    basic_string<char_type, traits_type, allocator_type> str() const;                  // before C++20
+    basic_string<char_type, traits_type, allocator_type> str() const &;                // C++20
+    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
+    basic_string_view<char_type, traits_type> view() const noexcept;                   // C++20
+    void str(const basic_string<char_type, traits_type, allocator_type>& s);
+    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
 
 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);
     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
public:
 
     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);
+#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_(std::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>
+      requires (!is_same_v<_SAlloc, allocator_type>)
+    _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();
+    }
+#endif // _LIBCPP_STD_VER >= 20
+
+    basic_stringbuf(basic_stringbuf&& __rhs) : __mode_(__rhs.__mode_) { __move_init(std::move(__rhs)); }
+
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a)
+        : basic_stringbuf(__rhs.__mode_, __a) {
+        __move_init(std::move(__rhs));
+    }
+#endif
 
     // [stringbuf.assign] Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& __rhs);
     void swap(basic_stringbuf& __rhs)
 #if _LIBCPP_STD_VER >= 20
         noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
                  allocator_traits<allocator_type>::is_always_equal::value)
 #endif
         ;
 
     // [stringbuf.members] Member functions:
+
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+#endif
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
     string_type str() const;
-    void str(const string_type& __s);
+#else
+    _LIBCPP_HIDE_FROM_ABI string_type str() const & { return str(__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() && {
+        const basic_string_view<_CharT, _Traits> __view = view();
+        string_type __result(std::move(__str_), __view.data() - __str_.data(), __view.size());
+        __str_.clear();
+        __init_buf_ptrs();
+        return __result;
+    }
+#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept;
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept;
 #endif
 
+    void str(const string_type& __s) {
+        __str_ = __s;
+        __init_buf_ptrs();
+    }
+
+#if _LIBCPP_STD_VER >= 20
+    template <class _SAlloc>
+      requires (!is_same_v<_SAlloc, allocator_type>)
+    _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_ = std::move(__s);
+        __init_buf_ptrs();
+    }
+#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;
_LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__move_init(basic_stringbuf&& __rhs) {
     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>&
if (__bout != -1)
         this->setp(__p + __bout, __p + __eout);
         this->__pbump(__nout);
     }
     else
         this->setp(nullptr, nullptr);
 
     __hm_ = __hm == -1 ? nullptr : __p + __hm;
     __mode_ = __rhs.__mode_;
     __p = const_cast<char_type*>(__rhs.__str_.data());
     __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>
swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
      basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
 #if _LIBCPP_STD_VER >= 20
     noexcept(noexcept(__x.swap(__y)))
 #endif
 {
     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-basic_stringbuf<_CharT, _Traits, _Allocator>::str() const
-{
-#if _LIBCPP_STD_VER >= 20
-    return string_type(view(), __str_.get_allocator());
-#else // _LIBCPP_STD_VER >= 20
-    if (__mode_ & ios_base::out)
-    {
+basic_stringbuf<_CharT, _Traits, _Allocator>::str() const {
+    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)
+    } 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
 }
+#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
 
 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)
-    {
+    char_type* __data = const_cast<char_type*>(__str_.data());
         typename string_type::size_type __sz = __str_.size();
-        __hm_ = const_cast<char_type*>(__str_.data()) + __sz;
+    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);
         }
     }
 }

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