forked from boostorg/beast
11c71d118f
fix #1345 * Revise documentation * Add reserve() member * Add max_size() member * Respect Allocator max_size * Specify exception safety
424 lines
14 KiB
C++
424 lines
14 KiB
C++
//
|
|
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
// Official repository: https://github.com/boostorg/beast
|
|
//
|
|
|
|
// Test that header file is self-contained.
|
|
#include <boost/beast/core/flat_buffer.hpp>
|
|
|
|
#include "buffer_test.hpp"
|
|
|
|
#include <boost/beast/core/ostream.hpp>
|
|
#include <boost/beast/core/read_size.hpp>
|
|
#include <boost/beast/core/string.hpp>
|
|
#include <boost/beast/test/test_allocator.hpp>
|
|
#include <boost/beast/_experimental/unit_test/suite.hpp>
|
|
#include <boost/asio/buffers_iterator.hpp>
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
|
|
namespace boost {
|
|
namespace beast {
|
|
|
|
class flat_buffer_test : public beast::unit_test::suite
|
|
{
|
|
public:
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_dynamic_buffer<
|
|
flat_buffer>::value);
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_const_buffer_sequence<
|
|
flat_buffer::const_buffers_type>::value);
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_mutable_buffer_sequence<
|
|
flat_buffer::mutable_data_type>::value);
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_mutable_buffer_sequence<
|
|
flat_buffer::mutable_buffers_type>::value);
|
|
BOOST_STATIC_ASSERT(std::is_convertible<
|
|
flat_buffer::mutable_data_type,
|
|
flat_buffer::const_buffers_type>::value);
|
|
|
|
template<class DynamicBuffer>
|
|
void
|
|
testMutableData()
|
|
{
|
|
DynamicBuffer b;
|
|
DynamicBuffer const& cb = b;
|
|
ostream(b) << "Hello";
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_const_buffer_sequence<
|
|
decltype(cb.data())>::value &&
|
|
! net::is_mutable_buffer_sequence<
|
|
decltype(cb.data())>::value);
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_const_buffer_sequence<
|
|
decltype(cb.cdata())>::value &&
|
|
! net::is_mutable_buffer_sequence<
|
|
decltype(cb.cdata())>::value);
|
|
BOOST_STATIC_ASSERT(
|
|
net::is_mutable_buffer_sequence<
|
|
decltype(b.data())>::value);
|
|
std::for_each(
|
|
net::buffers_iterator<decltype(b.data())>::begin(b.data()),
|
|
net::buffers_iterator<decltype(b.data())>::end(b.data()),
|
|
[](char& c)
|
|
{
|
|
c = static_cast<char>(std::toupper(c));
|
|
});
|
|
BEAST_EXPECT(buffers_to_string(b.data()) == "HELLO");
|
|
BEAST_EXPECT(buffers_to_string(b.cdata()) == "HELLO");
|
|
}
|
|
|
|
void
|
|
testBuffer()
|
|
{
|
|
using namespace test;
|
|
|
|
using a_t = test::test_allocator<char,
|
|
true, true, true, true, true>;
|
|
|
|
// Equal == false
|
|
using a_neq_t = test::test_allocator<char,
|
|
false, true, true, true, true>;
|
|
|
|
// construction
|
|
{
|
|
{
|
|
flat_buffer b;
|
|
BEAST_EXPECT(b.capacity() == 0);
|
|
}
|
|
{
|
|
flat_buffer b{500};
|
|
BEAST_EXPECT(b.capacity() == 0);
|
|
BEAST_EXPECT(b.max_size() == 500);
|
|
}
|
|
{
|
|
a_neq_t a1;
|
|
basic_flat_buffer<a_neq_t> b{a1};
|
|
BEAST_EXPECT(b.get_allocator() == a1);
|
|
a_neq_t a2;
|
|
BEAST_EXPECT(b.get_allocator() != a2);
|
|
}
|
|
{
|
|
a_neq_t a;
|
|
basic_flat_buffer<a_neq_t> b{500, a};
|
|
BEAST_EXPECT(b.capacity() == 0);
|
|
BEAST_EXPECT(b.max_size() == 500);
|
|
}
|
|
}
|
|
|
|
// move construction
|
|
{
|
|
{
|
|
basic_flat_buffer<a_t> b1{30};
|
|
BEAST_EXPECT(b1.get_allocator()->nmove == 0);
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<a_t> b2{std::move(b1)};
|
|
BEAST_EXPECT(b2.get_allocator()->nmove == 1);
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
BEAST_EXPECT(b1.max_size() == b2.max_size());
|
|
}
|
|
{
|
|
basic_flat_buffer<a_t> b1{30};
|
|
ostream(b1) << "Hello";
|
|
a_t a;
|
|
basic_flat_buffer<a_t> b2{std::move(b1), a};
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
BEAST_EXPECT(b1.max_size() == b2.max_size());
|
|
}
|
|
{
|
|
basic_flat_buffer<a_neq_t> b1{30};
|
|
ostream(b1) << "Hello";
|
|
a_neq_t a;
|
|
basic_flat_buffer<a_neq_t> b2{std::move(b1), a};
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
BEAST_EXPECT(b1.max_size() == b2.max_size());
|
|
}
|
|
}
|
|
|
|
// copy construction
|
|
{
|
|
basic_flat_buffer<a_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<a_t> b2(b1);
|
|
BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
|
|
BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
basic_flat_buffer<a_neq_t> b1;
|
|
ostream(b1) << "Hello";
|
|
a_neq_t a;
|
|
basic_flat_buffer<a_neq_t> b2(b1, a);
|
|
BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
|
|
BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
basic_flat_buffer<a_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<a_neq_t> b2(b1);
|
|
BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
basic_flat_buffer<a_neq_t> b1;
|
|
ostream(b1) << "Hello";
|
|
a_t a;
|
|
basic_flat_buffer<a_t> b2(b1, a);
|
|
BEAST_EXPECT(b2.get_allocator() == a);
|
|
BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
|
|
// move assignment
|
|
{
|
|
{
|
|
flat_buffer b1;
|
|
ostream(b1) << "Hello";
|
|
flat_buffer b2;
|
|
b2 = std::move(b1);
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
using na_t = test::test_allocator<char,
|
|
true, true, false, true, true>;
|
|
basic_flat_buffer<na_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<na_t> b2;
|
|
b2 = std::move(b1);
|
|
BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
using na_t = test::test_allocator<char,
|
|
false, true, false, true, true>;
|
|
basic_flat_buffer<na_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<na_t> b2;
|
|
b2 = std::move(b1);
|
|
BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
// propagate_on_container_move_assignment : true
|
|
using pocma_t = test::test_allocator<char,
|
|
true, true, true, true, true>;
|
|
basic_flat_buffer<pocma_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<pocma_t> b2;
|
|
b2 = std::move(b1);
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
// propagate_on_container_move_assignment : false
|
|
using pocma_t = test::test_allocator<char,
|
|
true, true, false, true, true>;
|
|
basic_flat_buffer<pocma_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<pocma_t> b2;
|
|
b2 = std::move(b1);
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
}
|
|
|
|
// copy assignment
|
|
{
|
|
{
|
|
flat_buffer b1;
|
|
ostream(b1) << "Hello";
|
|
flat_buffer b2;
|
|
b2 = b1;
|
|
BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
basic_flat_buffer<a_t> b3;
|
|
b3 = b2;
|
|
BEAST_EXPECT(buffers_to_string(b3.data()) == "Hello");
|
|
}
|
|
{
|
|
// propagate_on_container_copy_assignment : true
|
|
using pocca_t = test::test_allocator<char,
|
|
true, true, true, true, true>;
|
|
basic_flat_buffer<pocca_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<pocca_t> b2;
|
|
b2 = b1;
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
// propagate_on_container_copy_assignment : false
|
|
using pocca_t = test::test_allocator<char,
|
|
true, false, true, true, true>;
|
|
basic_flat_buffer<pocca_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<pocca_t> b2;
|
|
b2 = b1;
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
}
|
|
|
|
// operations
|
|
{
|
|
string_view const s = "Hello, world!";
|
|
flat_buffer b1{64};
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.max_size() == 64);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
ostream(b1) << s;
|
|
BEAST_EXPECT(buffers_to_string(b1.data()) == s);
|
|
{
|
|
flat_buffer b2{b1};
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == s);
|
|
b2.consume(7);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == s.substr(7));
|
|
}
|
|
{
|
|
flat_buffer b2{32};
|
|
BEAST_EXPECT(b2.max_size() == 32);
|
|
b2 = b1;
|
|
BEAST_EXPECT(b2.max_size() == b1.max_size());
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == s);
|
|
b2.consume(7);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == s.substr(7));
|
|
}
|
|
}
|
|
|
|
// cause memmove
|
|
{
|
|
flat_buffer b{20};
|
|
ostream(b) << "12345";
|
|
b.consume(3);
|
|
ostream(b) << "67890123";
|
|
BEAST_EXPECT(buffers_to_string(b.data()) == "4567890123");
|
|
}
|
|
|
|
// max_size
|
|
{
|
|
flat_buffer b{10};
|
|
BEAST_EXPECT(b.max_size() == 10);
|
|
b.max_size(32);
|
|
BEAST_EXPECT(b.max_size() == 32);
|
|
}
|
|
|
|
// read_size
|
|
{
|
|
flat_buffer b{10};
|
|
BEAST_EXPECT(read_size(b, 512) == 10);
|
|
b.prepare(4);
|
|
b.commit(4);
|
|
BEAST_EXPECT(read_size(b, 512) == 6);
|
|
b.consume(2);
|
|
BEAST_EXPECT(read_size(b, 512) == 8);
|
|
b.prepare(8);
|
|
b.commit(8);
|
|
BEAST_EXPECT(read_size(b, 512) == 0);
|
|
}
|
|
|
|
// swap
|
|
{
|
|
{
|
|
basic_flat_buffer<a_neq_t> b1;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<a_neq_t> b2;
|
|
BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
|
|
swap(b1, b2);
|
|
BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
{
|
|
using na_t = test::test_allocator<char,
|
|
true, true, true, false, true>;
|
|
na_t a1;
|
|
basic_flat_buffer<na_t> b1{a1};
|
|
na_t a2;
|
|
ostream(b1) << "Hello";
|
|
basic_flat_buffer<na_t> b2{a2};
|
|
BEAST_EXPECT(b1.get_allocator() == a1);
|
|
BEAST_EXPECT(b2.get_allocator() == a2);
|
|
swap(b1, b2);
|
|
BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
|
|
}
|
|
}
|
|
|
|
// prepare
|
|
{
|
|
flat_buffer b{100};
|
|
b.prepare(10);
|
|
b.commit(10);
|
|
b.prepare(5);
|
|
BEAST_EXPECT(b.capacity() >= 5);
|
|
try
|
|
{
|
|
b.prepare(1000);
|
|
fail("", __FILE__, __LINE__);
|
|
}
|
|
catch(std::length_error const&)
|
|
{
|
|
pass();
|
|
}
|
|
}
|
|
|
|
// reserve
|
|
{
|
|
flat_buffer b;
|
|
BEAST_EXPECT(b.capacity() == 0);
|
|
b.reserve(50);
|
|
BEAST_EXPECT(b.capacity() == 50);
|
|
b.prepare(20);
|
|
b.commit(20);
|
|
b.reserve(50);
|
|
BEAST_EXPECT(b.capacity() == 50);
|
|
}
|
|
|
|
// shrink to fit
|
|
{
|
|
flat_buffer b;
|
|
BEAST_EXPECT(b.capacity() == 0);
|
|
b.prepare(50);
|
|
BEAST_EXPECT(b.capacity() == 50);
|
|
b.commit(50);
|
|
BEAST_EXPECT(b.capacity() == 50);
|
|
b.prepare(75);
|
|
BEAST_EXPECT(b.capacity() >= 125);
|
|
b.shrink_to_fit();
|
|
BEAST_EXPECT(b.capacity() == b.size());
|
|
}
|
|
}
|
|
|
|
void
|
|
run() override
|
|
{
|
|
testBuffer();
|
|
testMutableData<flat_buffer>();
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(beast,core,flat_buffer);
|
|
|
|
} // beast
|
|
} // boost
|