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

[Mordante]

Thanks! This look quite good, a few small issues.

libcxx/include/sstream

813

I prefer the wording of the standard, I know the existing code doesn't do that but let's do it for the new code.

863

This function is not constrained in the Standard. Why is it needed?

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

28

I would avoid std::ios_base::in in these tests if possible. This should be automatically be set.

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.move.pass.cpp

33

Is the moved from state specified?

[pfusik]

libcxx/include/sstream

863

If we omit this constraint, we get:

call to member function 'str' is ambiguous
        ss.str(" 789");

I think the standard should include it.

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

28

Why? What to use instead of std::ios_base::in ?

[pfusik]

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.move.pass.cpp

33

It is:

29.8.3.4 Member functions [istringstream.members]
basic_string<charT,traits,Allocator> str() &&;
Effects: Equivalent to: return std::move(*rdbuf()).str();

29.8.2.4 Member functions [stringbuf.members]
basic_string<charT, traits, Allocator> str() &&;
Postconditions: The underlying character sequence buf is empty

[Mordante]

libcxx/include/sstream

813

This item is not done.

863

Thanks. I want to look at this locally. If this indeed is needed it looks like a defect in the Standard.

When this is a bug in the Standard we should file an LWG issue and mention that in the code.
(No need to take an action now, I first want to test.)

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

28

When we don't set it we can test whether the in flag is set. I would set the binary flag.

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.move.pass.cpp

33

Thanks!

[pfusik]

s/&/std::addressof/
s/std:ios_base::in/std::ios_base::binary/

libcxx/include/sstream

813

Sorry, I'm still learning Phabricator. It's a little confusing that both "arc diff" and "Submit" on the web submit the "Done" flags.

[Mordante]

libcxx/include/sstream

863

This is correct. I got reminded the Equivalent to wording "inherits" the constrains.
(And indeed tests fails without the constrain.)

[Mordante]

LGTM!

libcxx/include/sstream

813

I didn't know arc diff did that. It doesn't for me.

[pfusik]

Please land it so I can continue with ostringstream and stringstream.

[Mordante]

In D154454#4495142, @pfusik wrote:

Please land it so I can continue with ostringstream and stringstream.

Can you rebase the patch to make sure the CI is green. Note in Phabricator you can created stacked patches, which allows you to continue working on the other patches while they are reviewed.

[pfusik]

Rebased.

[Mordante]

btw feel free to request commit access.

[pfusik]

Rebased without conflicts.

I also need to apply the https://reviews.llvm.org/D155185 workaround to istringstream.
If https://reviews.llvm.org/D154454 lands first, I can edit https://reviews.llvm.org/D155185
If https://reviews.llvm.org/D155185 lands first, I can edit https://reviews.llvm.org/D154454

[Mordante]

Nice to see you have commit access now!

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: All `stringbuf` members and `view()` in all classes implemented.
+   .. [#note-P0408] P0408: All `stringbuf` and `istringstream` members plus `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 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(const basic_string<char_type, traits_type,allocator_type>& str,
+    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>& 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;
-    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<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
 };
 
 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;
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>(std::addressof(__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>(std::addressof(__sb_)), __sb_(std::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>(std::addressof(__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>(std::addressof(__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_);
     }
 
void swap(basic_istringstream& __rhs) {
         __sb_.swap(__rhs.__sb_);
     }
 
     // [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 {
-        return __sb_.str();
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void str(const string_type& __s) {
-        __sb_.str(__s);
+
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI string_type str() const & { return __sb_.str(); }
+
+    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);
     }
+
+    _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
+
+    _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#else // _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+#endif // _LIBCPP_STD_VER >= 20
+
+    _LIBCPP_HIDE_FROM_ABI 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>
+    _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+        __sb_.str(__s);
     }
-#endif
+
+    _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(std::move(__s)); }
+#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)
 {

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::binary, 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/istringstream/istringstream.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_istringstream
+
+// template <class SAlloc>
+// explicit basic_istringstream(const basic_string<char_type, traits_type, 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() {
+  {
+    const std::basic_string<CharT> s(STR("testing"));
+    const std::basic_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s);
+    assert(ss.view() == SV("testing"));
+  }
+  {
+    const std::basic_string<CharT> s(STR("testing"));
+    const std::basic_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s, std::ios_base::binary);
+    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/istringstream/istringstream.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_istringstream
+
+// template <class SAlloc>
+// basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s, const Allocator& a)
+//     : basic_istringstream(s, ios_base::in, 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_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s, a);
+  assert(ss.rdbuf()->get_allocator() == a);
+  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/istringstream/istringstream.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_istringstream
+
+// template <class SAlloc>
+// basic_istringstream(const basic_string<char_type, traits_type, 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_istringstream<CharT, std::char_traits<CharT>, test_allocator<CharT>> ss(s, std::ios_base::binary, a);
+  assert(ss.rdbuf()->get_allocator() == a);
+  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/istringstream/istringstream.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_istringstream
+
+// explicit basic_istringstream(basic_string<char_type, traits_type, allocator_type>&& s, ios_base::openmode which = ios_base::in);
+
+#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_string<CharT> s(STR("testing"));
+    const std::basic_istringstream<CharT> ss(std::move(s));
+    assert(ss.str() == STR("testing"));
+  }
+  {
+    std::basic_string<CharT> s(STR("testing"));
+    const std::basic_istringstream<CharT> ss(std::move(s), std::ios_base::binary);
+    assert(ss.str() == STR("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/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;
+
+#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_istringstream<CharT> ss(STR("testing"));
+  const test_allocator<CharT> a(1);
+  const std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>> s = ss.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/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() &&;
+
+#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_istringstream<CharT> ss(STR("testing"));
+    std::basic_string<CharT> s = std::move(ss).str();
+    assert(s == STR("testing"));
+    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/istringstream/istringstream.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_istringstream
+
+// 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)
+
+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_istringstream<CharT> ss;
+    ss.str(s);
+    assert(ss.str() == STR("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/istringstream/istringstream.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_istringstream
+
+// 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_istringstream<CharT> ss;
+    std::basic_string<CharT> s(STR("testing"));
+    ss.str(std::move(s));
+    assert(ss.str() == STR("testing"));
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  return 0;
+}