//===----------------------------------------------------------------------===//
//
// 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;
}
Codebase Browser
llvm