| //===----------------------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // UNSUPPORTED: c++03, c++11, c++14, c++17 |
| // UNSUPPORTED: no-localization |
| // UNSUPPORTED: libcpp-has-no-experimental-syncstream |
| |
| // <syncstream> |
| |
| // template <class charT, class traits, class Allocator> |
| // class basic_syncbuf; |
| |
| // basic_syncbuf& operator=(basic_syncbuf&& rhs); |
| |
| #include <syncstream> |
| #include <sstream> |
| #include <cassert> |
| #include <concepts> |
| |
| #include "test_macros.h" |
| |
| template <class T, class propagate> |
| struct test_allocator : std::allocator<T> { |
| using propagate_on_container_move_assignment = propagate; |
| |
| int id{-1}; |
| |
| test_allocator(int _id = -1) : id(_id) {} |
| test_allocator(test_allocator const& other) = default; |
| test_allocator(test_allocator&& other) = default; |
| test_allocator& operator=(const test_allocator& other) = default; |
| |
| test_allocator& operator=(test_allocator&& other) { |
| if constexpr (propagate_on_container_move_assignment::value) |
| id = other.id; |
| else |
| id = -1; |
| return *this; |
| } |
| }; |
| |
| template <class T> |
| class test_buf : public std::basic_streambuf<T> { |
| public: |
| int id; |
| |
| test_buf(int _id = 0) : id(_id) {} |
| |
| T* _pptr() { return this->pptr(); } |
| }; |
| |
| template <class T, class Alloc = std::allocator<T>> |
| class test_syncbuf : public std::basic_syncbuf<T, std::char_traits<T>, Alloc> { |
| using Base = std::basic_syncbuf<T, std::char_traits<T>, Alloc>; |
| |
| public: |
| test_syncbuf() = default; |
| |
| test_syncbuf(test_buf<T>* buf, Alloc alloc) : Base(buf, alloc) {} |
| |
| test_syncbuf(typename Base::streambuf_type* buf, Alloc alloc) : Base(buf, alloc) {} |
| |
| void _setp(T* begin, T* end) { return this->setp(begin, end); } |
| }; |
| |
| // Helper wrapper to inspect the internal state of the basic_syncbuf |
| // |
| // This is used to validate some standard requirements and libc++ |
| // implementation details. |
| template <class CharT, class Traits, class Allocator> |
| class syncbuf_inspector : public std::basic_syncbuf<CharT, Traits, Allocator> { |
| public: |
| syncbuf_inspector() = default; |
| explicit syncbuf_inspector(std::basic_syncbuf<CharT, Traits, Allocator>&& base) |
| : std::basic_syncbuf<CharT, Traits, Allocator>(std::move(base)) {} |
| |
| void operator=(std::basic_syncbuf<CharT, Traits, Allocator>&& base) { *this = std::move(base); } |
| |
| using std::basic_syncbuf<CharT, Traits, Allocator>::pbase; |
| using std::basic_syncbuf<CharT, Traits, Allocator>::pptr; |
| using std::basic_syncbuf<CharT, Traits, Allocator>::epptr; |
| }; |
| |
| template <class CharT> |
| static void test_assign() { |
| test_buf<CharT> base; |
| |
| { // Test using the real class, propagating allocator. |
| using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, test_allocator<CharT, std::true_type>>; |
| |
| BuffT buff1(&base, test_allocator<CharT, std::true_type>{42}); |
| buff1.sputc(CharT('A')); |
| |
| assert(buff1.get_wrapped() != nullptr); |
| |
| BuffT buff2; |
| assert(buff2.get_allocator().id == -1); |
| buff2 = std::move(buff1); |
| assert(buff1.get_wrapped() == nullptr); |
| assert(buff2.get_wrapped() == &base); |
| |
| assert(buff2.get_wrapped() == &base); |
| assert(buff2.get_allocator().id == 42); |
| } |
| |
| { // Test using the real class, non-propagating allocator. |
| using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, test_allocator<CharT, std::false_type>>; |
| |
| BuffT buff1(&base, test_allocator<CharT, std::false_type>{42}); |
| buff1.sputc(CharT('A')); |
| |
| assert(buff1.get_wrapped() != nullptr); |
| |
| BuffT buff2; |
| assert(buff2.get_allocator().id == -1); |
| buff2 = std::move(buff1); |
| assert(buff1.get_wrapped() == nullptr); |
| assert(buff2.get_wrapped() == &base); |
| |
| assert(buff2.get_wrapped() == &base); |
| assert(buff2.get_allocator().id == -1); |
| } |
| |
| { // Move assignment propagating allocator |
| // Test using the inspection wrapper. |
| // Not all these requirements are explicitly in the Standard, |
| // however the asserts are based on secondary requirements. The |
| // LIBCPP_ASSERTs are implementation specific. |
| |
| using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>; |
| |
| using Inspector = syncbuf_inspector<CharT, std::char_traits<CharT>, std::allocator<CharT>>; |
| Inspector inspector1{BuffT(&base)}; |
| inspector1.sputc(CharT('A')); |
| |
| assert(inspector1.get_wrapped() != nullptr); |
| assert(inspector1.pbase() != nullptr); |
| assert(inspector1.pptr() != nullptr); |
| assert(inspector1.epptr() != nullptr); |
| assert(inspector1.pbase() != inspector1.pptr()); |
| assert(inspector1.pptr() - inspector1.pbase() == 1); |
| [[maybe_unused]] std::streamsize size = inspector1.epptr() - inspector1.pbase(); |
| |
| Inspector inspector2; |
| inspector2 = std::move(inspector1); |
| |
| assert(inspector1.get_wrapped() == nullptr); |
| LIBCPP_ASSERT(inspector1.pbase() == nullptr); |
| LIBCPP_ASSERT(inspector1.pptr() == nullptr); |
| LIBCPP_ASSERT(inspector1.epptr() == nullptr); |
| assert(inspector1.pbase() == inspector1.pptr()); |
| |
| assert(inspector2.get_wrapped() == &base); |
| LIBCPP_ASSERT(inspector2.pbase() != nullptr); |
| LIBCPP_ASSERT(inspector2.pptr() != nullptr); |
| LIBCPP_ASSERT(inspector2.epptr() != nullptr); |
| assert(inspector2.pptr() - inspector2.pbase() == 1); |
| LIBCPP_ASSERT(inspector2.epptr() - inspector2.pbase() == size); |
| } |
| } |
| |
| template <class CharT> |
| static void test_basic() { |
| { // Test properties |
| std::basic_syncbuf<CharT> sync_buf1(nullptr); |
| std::basic_syncbuf<CharT> sync_buf2(nullptr); |
| [[maybe_unused]] std::same_as<std::basic_syncbuf<CharT>&> decltype(auto) ret = |
| sync_buf1.operator=(std::move(sync_buf2)); |
| } |
| |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| #if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS) |
| assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&sstr1) == 1); |
| assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&sstr2) == 1); |
| #endif |
| |
| sync_buf2 = std::move(sync_buf1); |
| assert(sync_buf2.get_wrapped() == &sstr1); |
| |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| |
| #if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS) |
| assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&sstr1) == 1); |
| assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&sstr2) == 0); |
| #endif |
| } |
| |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| |
| template <class CharT> |
| static void test_short_write_after_assign() { |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| sync_buf2 = std::move(sync_buf1); |
| sync_buf2.sputc(CharT('Z')); |
| |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| } |
| |
| assert(sstr1.str().size() == 2); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr1.str()[1] == CharT('Z')); |
| assert(sstr2.str() == expected); |
| } |
| |
| template <class CharT> |
| static void test_long_write_after_assign() { |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| sync_buf2 = std::move(sync_buf1); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| } |
| |
| assert(sstr1.str().size() == 1 + expected.size()); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr1.str().substr(1) == expected); |
| assert(sstr2.str() == expected); |
| } |
| |
| template <class CharT> |
| static void test_emit_on_assign() { |
| { // don't emit / don't emit |
| |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.set_emit_on_sync(false); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.set_emit_on_sync(false); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| sync_buf2 = std::move(sync_buf1); |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| |
| sync_buf2.pubsync(); |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| } |
| |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| |
| { // don't emit / do emit |
| |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.set_emit_on_sync(true); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.set_emit_on_sync(false); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| sync_buf2 = std::move(sync_buf1); |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| |
| sync_buf2.pubsync(); |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| |
| { // do emit / don't emit |
| |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.set_emit_on_sync(false); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.set_emit_on_sync(true); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| sync_buf2 = std::move(sync_buf1); |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| |
| sync_buf2.pubsync(); |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| } |
| |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| |
| { // do emit / do emit |
| |
| std::basic_stringbuf<CharT> sstr1; |
| std::basic_stringbuf<CharT> sstr2; |
| std::basic_string<CharT> expected(42, CharT('*')); // a long string |
| |
| { |
| std::basic_syncbuf<CharT> sync_buf1(&sstr1); |
| sync_buf1.set_emit_on_sync(true); |
| sync_buf1.sputc(CharT('A')); // a short string |
| |
| std::basic_syncbuf<CharT> sync_buf2(&sstr2); |
| sync_buf2.set_emit_on_sync(true); |
| sync_buf2.sputn(expected.data(), expected.size()); |
| |
| sync_buf2 = std::move(sync_buf1); |
| assert(sstr1.str().empty()); |
| assert(sstr2.str() == expected); |
| |
| sync_buf2.pubsync(); |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| |
| assert(sstr1.str().size() == 1); |
| assert(sstr1.str()[0] == CharT('A')); |
| assert(sstr2.str() == expected); |
| } |
| } |
| |
| template <class CharT> |
| static void test() { |
| test_assign<CharT>(); |
| test_basic<CharT>(); |
| test_short_write_after_assign<CharT>(); |
| test_long_write_after_assign<CharT>(); |
| test_emit_on_assign<CharT>(); |
| } |
| |
| int main(int, char**) { |
| test<char>(); |
| |
| #ifndef TEST_HAS_NO_WIDE_CHARACTERS |
| test<wchar_t>(); |
| #endif |
| |
| return 0; |
| } |