[libc++] Add get_allocator and some constructor overloads of P0408R7 (Efficient Access to basic_stringbuf's Buffer)

[pfusik]

Summary

First small part of https://reviews.llvm.org/D151896

[Mordante]

Sorry, but would it be possible to to a patch per class instead, starting with stringbuf? That way I can keep track that all classes are done. The subtile differences in all overloads make it really annoying the review for correctness.

[pfusik]

In D153405#4446388, @Mordante wrote:

Sorry, but would it be possible to to a patch per class instead, starting with stringbuf? That way I can keep track that all classes are done. The subtile differences in all overloads make it really annoying the review for correctness.

Would you like all the changes in stringbuf in one patch? That's quite a lot.
The remaining three classes are just simple wrappers over stringbuf.
I thought it would be easier to split into features.

Also, I expect that users don't typically use stringbuf directly, so having features exposed in *stringstream is what they care. That's how we proceeded with the already merged view().

[Mordante]

In D153405#4446413, @pfusik wrote:

In D153405#4446388, @Mordante wrote:

Sorry, but would it be possible to to a patch per class instead, starting with stringbuf? That way I can keep track that all classes are done. The subtile differences in all overloads make it really annoying the review for correctness.

Would you like all the changes in stringbuf in one patch? That's quite a lot.
The remaining three classes are just simple wrappers over stringbuf.
I thought it would be easier to split into features.

Yes I would like that, I've already reviewed all code changes in stringbuf so that would be faster for me to review again.

Also, I expect that users don't typically use stringbuf directly, so having features exposed in *stringstream is what they care. That's how we proceeded with the already merged view().

I agree, that most users don't care about these "internals". Still we need them to implement the "externals". I think the externals are smaller and can be reviewed a lot faster. It's mainly that I have limited time to work on libc++ and large complex patches are quite hard to find time for.

[pfusik]

Ok, I'll submit a patch implementing the whole paper in stringbuf. Since you asked for a separate test per overload, be prepared for two dozen tests. :)

[pfusik]

https://reviews.llvm.org/D153709 - only 11 overloads/tests.

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: Only `view()`, `get_allocator()` members and some constructor overloads 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
     basic_stringbuf(basic_stringbuf&& rhs);
 
     // [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);
-    basic_string_view<char_type, traits_type> view() const noexcept; // 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);
 
 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 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;
 
     // [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(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
     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;
-    void str(const basic_string<char_type, traits_type, allocator_type>& s);
-    basic_string_view<char_type, traits_type> view() const noexcept; // 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 charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 
 typedef basic_istringstream<char>    istringstream;
 typedef basic_istringstream<wchar_t> wistringstream;
 
 // Class template basic_ostringstream [ostringstream]
 template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 class basic_ostringstream
     : public basic_ostream<charT, traits>
 {
 public:
     // types:
     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;
 
     // [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(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
     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;
-    void str(const basic_string<char_type, traits_type, allocator_type>& s);
-    basic_string_view<char_type, traits_type> view() const noexcept; // 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 charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 
 typedef basic_ostringstream<char>    ostringstream;
 typedef basic_ostringstream<wchar_t> wostringstream;
public:
     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);                                // 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::out | ios_base::in);
+    basic_stringstream(ios_base::openmode which, const allocator_type& a);                // 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_view<char_type, traits_type> view() const noexcept; // 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>& str);
 };
 
 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;
 typedef basic_stringstream<wchar_t> wstringstream;
public:
     _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);
     }
 
+#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) {}
+#endif
+
     basic_stringbuf(basic_stringbuf&& __rhs);
 
     // [stringbuf.assign] Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& __rhs);
     void swap(basic_stringbuf& __rhs);
 
     // [stringbuf.members] Member functions:
     string_type str() const;
-    void str(const string_type& __s);
+
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept;
+    _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept;
 #endif
 
+    void str(const string_type& __s);
+
 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
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) {}
+#endif
+
     _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_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 {
         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 {
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept {
         return __sb_.view();
     }
 #endif
+    _LIBCPP_INLINE_VISIBILITY
+    void str(const string_type& __s) {
+        __sb_.str(__s);
+    }
 };
 
 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) {}
+#endif
+
     _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_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 {
         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 {
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept {
         return __sb_.view();
     }
 #endif
+    _LIBCPP_INLINE_VISIBILITY
+    void str(const string_type& __s) {
+        __sb_.str(__s);
+    }
 };
 
 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) {}
+#endif
+
     _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_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 {
         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 {
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept {
         return __sb_.view();
     }
 #endif
+    _LIBCPP_INLINE_VISIBILITY
+    void str(const string_type& __s) {
+        __sb_.str(__s);
+    }
 };
 
 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/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_istringstream
+
+// basic_istringstream(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_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(std::ios_base::in, a);
+  assert(ss.rdbuf()->get_allocator() == a);
+  assert(ss.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/ostringstream/ostringstream.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_ostringstream
+
+// basic_ostringstream(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_ostringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(std::ios_base::out, a);
+  assert(ss.rdbuf()->get_allocator() == a);
+  assert(ss.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/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/stringstream/stringstream.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_stringstream
+
+// basic_stringstream(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_stringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(std::ios_base::in, a);
+  assert(ss.rdbuf()->get_allocator() == a);
+  assert(ss.view().empty());
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}