forked from boostorg/beast
78f4858e98
read_size_helper can return zero if the buffer reaches its maximum size, causing infinite loops in HTTP. The function maybe_read_size_helper is provided to throw an exception instead of returning a value for this case.
299 lines
8.6 KiB
C++
299 lines
8.6 KiB
C++
//
|
|
// Copyright (c) 2013-2016 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)
|
|
//
|
|
|
|
// Test that header file is self-contained.
|
|
#include <beast/core/flat_buffer.hpp>
|
|
|
|
#include "buffer_test.hpp"
|
|
#include <beast/core/ostream.hpp>
|
|
#include <beast/test/test_allocator.hpp>
|
|
#include <beast/unit_test/suite.hpp>
|
|
#include <boost/lexical_cast.hpp>
|
|
#include <algorithm>
|
|
|
|
namespace beast {
|
|
|
|
static_assert(is_dynamic_buffer<flat_buffer>::value,
|
|
"DynamicBuffer requirements not met");
|
|
|
|
class flat_buffer_test : public beast::unit_test::suite
|
|
{
|
|
public:
|
|
template<class ConstBufferSequence>
|
|
static
|
|
std::string
|
|
to_string(ConstBufferSequence const& bs)
|
|
{
|
|
return boost::lexical_cast<
|
|
std::string>(buffers(bs));
|
|
}
|
|
|
|
template<class Alloc1, class Alloc2>
|
|
static
|
|
bool
|
|
eq(basic_flat_buffer<Alloc1> const& sb1,
|
|
basic_flat_buffer<Alloc2> const& sb2)
|
|
{
|
|
return to_string(sb1.data()) == to_string(sb2.data());
|
|
}
|
|
|
|
template<
|
|
bool Equal, bool Assign, bool Move, bool Swap, bool Select>
|
|
void
|
|
testCtor()
|
|
{
|
|
using allocator = test::test_allocator<char,
|
|
Equal, Assign, Move, Swap, Select>;
|
|
{
|
|
using boost::asio::buffer_size;
|
|
basic_flat_buffer<allocator> b1{10};
|
|
BEAST_EXPECT(b1.size() == 0);
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(b1.max_size() == 10);
|
|
b1.prepare(1);
|
|
b1.commit(1);
|
|
basic_flat_buffer<allocator> b2{std::move(b1)};
|
|
BEAST_EXPECT(b1.capacity() == 0);
|
|
BEAST_EXPECT(b1.max_size() == 10);
|
|
BEAST_EXPECT(b2.size() == 1);
|
|
BEAST_EXPECT(b2.max_size() == 10);
|
|
BEAST_EXPECT(buffer_size(b1.data()) == 0);
|
|
BEAST_EXPECT(buffer_size(b1.prepare(1)) == 1);
|
|
}
|
|
{
|
|
basic_flat_buffer<allocator> b1{10};
|
|
basic_flat_buffer<allocator> b2{std::move(b1), allocator{}};
|
|
}
|
|
{
|
|
basic_flat_buffer<allocator> b1{10};
|
|
basic_flat_buffer<allocator> b2{b1};
|
|
}
|
|
{
|
|
basic_flat_buffer<allocator> b1{10};
|
|
basic_flat_buffer<allocator> b2{b1, allocator{}};
|
|
}
|
|
{
|
|
flat_buffer b1{10};
|
|
b1.prepare(1);
|
|
b1.commit(1);
|
|
basic_flat_buffer<allocator> b2{b1};
|
|
BEAST_EXPECT(b2.size() == 1);
|
|
}
|
|
{
|
|
basic_flat_buffer<allocator> b1{10};
|
|
}
|
|
{
|
|
basic_flat_buffer<allocator> b1{10, allocator{}};
|
|
}
|
|
}
|
|
|
|
void
|
|
testCtors()
|
|
{
|
|
testCtor<false, false, false, false, false>();
|
|
testCtor<false, false, false, false, true>();
|
|
testCtor<false, false, false, true, false>();
|
|
testCtor<false, false, false, true, true>();
|
|
testCtor<false, false, true, false, false>();
|
|
testCtor<false, false, true, false, true>();
|
|
testCtor<false, false, true, true, false>();
|
|
testCtor<false, false, true, true, true>();
|
|
testCtor<false, true, false, false, false>();
|
|
testCtor<false, true, false, false, true>();
|
|
testCtor<false, true, false, true, false>();
|
|
testCtor<false, true, false, true, true>();
|
|
testCtor<false, true, true, false, false>();
|
|
testCtor<false, true, true, false, true>();
|
|
testCtor<false, true, true, true, false>();
|
|
testCtor<false, true, true, true, true>();
|
|
testCtor< true, false, false, false, false>();
|
|
testCtor< true, false, false, false, true>();
|
|
testCtor< true, false, false, true, false>();
|
|
testCtor< true, false, false, true, true>();
|
|
testCtor< true, false, true, false, false>();
|
|
testCtor< true, false, true, false, true>();
|
|
testCtor< true, false, true, true, false>();
|
|
testCtor< true, false, true, true, true>();
|
|
testCtor< true, true, false, false, false>();
|
|
testCtor< true, true, false, false, true>();
|
|
testCtor< true, true, false, true, false>();
|
|
testCtor< true, true, false, true, true>();
|
|
testCtor< true, true, true, false, false>();
|
|
testCtor< true, true, true, false, true>();
|
|
testCtor< true, true, true, true, false>();
|
|
testCtor< true, true, true, true, true>();
|
|
}
|
|
|
|
void
|
|
testOperations()
|
|
{
|
|
//
|
|
// reserve
|
|
//
|
|
|
|
{
|
|
flat_buffer b{10};
|
|
b.prepare(1);
|
|
b.commit(1);
|
|
b.reserve(2);
|
|
BEAST_EXPECT(b.size() == 1);
|
|
}
|
|
{
|
|
flat_buffer b{20};
|
|
ostream(b) << "12345";
|
|
b.consume(3);
|
|
ostream(b) << "67890123";
|
|
BEAST_EXPECT(to_string(b.data()) == "4567890123");
|
|
}
|
|
}
|
|
|
|
void
|
|
testSpecialMembers()
|
|
{
|
|
using boost::asio::buffer;
|
|
using boost::asio::buffer_copy;
|
|
{
|
|
flat_buffer b{10};
|
|
BEAST_EXPECT(b.max_size() == 10);
|
|
}
|
|
{
|
|
flat_buffer b{1024};
|
|
BEAST_EXPECT(b.max_size() == 1024);
|
|
}
|
|
std::string const s = "Hello, world!";
|
|
for(std::size_t i = 1; i < s.size() - 1; ++i)
|
|
{
|
|
flat_buffer b{1024};
|
|
b.commit(buffer_copy(
|
|
b.prepare(i), buffer(s)));
|
|
b.commit(buffer_copy(
|
|
b.prepare(s.size() - i),
|
|
buffer(s.data() + i, s.size() - i)));
|
|
BEAST_EXPECT(to_string(b.data()) == s);
|
|
{
|
|
flat_buffer b2{b};
|
|
BEAST_EXPECT(eq(b2, b));
|
|
flat_buffer b3{std::move(b2)};
|
|
BEAST_EXPECT(eq(b3, b));
|
|
BEAST_EXPECT(! eq(b2, b3));
|
|
BEAST_EXPECT(b2.size() == 0);
|
|
}
|
|
|
|
using alloc_type = std::allocator<double>;
|
|
using type =
|
|
basic_flat_buffer<alloc_type>;
|
|
alloc_type alloc;
|
|
{
|
|
type fba{1, alloc};
|
|
BEAST_EXPECT(fba.max_size() == 1);
|
|
}
|
|
{
|
|
type fba{1024, alloc};
|
|
BEAST_EXPECT(fba.max_size() == 1024);
|
|
}
|
|
{
|
|
type fb2{b};
|
|
BEAST_EXPECT(eq(fb2, b));
|
|
type fb3{std::move(fb2)};
|
|
BEAST_EXPECT(eq(fb3, b));
|
|
BEAST_EXPECT(! eq(fb2, fb3));
|
|
BEAST_EXPECT(fb2.size() == 0);
|
|
}
|
|
{
|
|
type fb2{b, alloc};
|
|
BEAST_EXPECT(eq(fb2, b));
|
|
type fb3{std::move(fb2), alloc};
|
|
BEAST_EXPECT(eq(fb3, b));
|
|
BEAST_EXPECT(! eq(fb2, fb3));
|
|
BEAST_EXPECT(fb2.size() == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
testStream()
|
|
{
|
|
using boost::asio::buffer_size;
|
|
|
|
flat_buffer b{100};
|
|
BEAST_EXPECT(b.size() == 0);
|
|
BEAST_EXPECT(b.capacity() == 0);
|
|
|
|
BEAST_EXPECT(buffer_size(b.prepare(100)) == 100);
|
|
BEAST_EXPECT(b.size() == 0);
|
|
BEAST_EXPECT(b.capacity() > 0);
|
|
|
|
b.commit(20);
|
|
BEAST_EXPECT(b.size() == 20);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
|
|
b.consume(5);
|
|
BEAST_EXPECT(b.size() == 15);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
|
|
b.prepare(80);
|
|
b.commit(80);
|
|
BEAST_EXPECT(b.size() == 95);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
|
|
b.shrink_to_fit();
|
|
BEAST_EXPECT(b.size() == 95);
|
|
BEAST_EXPECT(b.capacity() == 95);
|
|
}
|
|
|
|
void
|
|
testPrepare()
|
|
{
|
|
flat_buffer b{100};
|
|
b.prepare(20);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
b.commit(10);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
b.consume(4);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
b.prepare(14);
|
|
BEAST_EXPECT(b.size() == 6);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
b.consume(10);
|
|
BEAST_EXPECT(b.size() == 0);
|
|
BEAST_EXPECT(b.capacity() == 100);
|
|
}
|
|
|
|
void
|
|
testMax()
|
|
{
|
|
flat_buffer b{1};
|
|
try
|
|
{
|
|
b.prepare(2);
|
|
fail("", __FILE__, __LINE__);
|
|
}
|
|
catch(std::length_error const&)
|
|
{
|
|
pass();
|
|
}
|
|
}
|
|
|
|
void
|
|
run() override
|
|
{
|
|
test::check_read_size_helper<flat_buffer>();
|
|
|
|
testCtors();
|
|
testOperations();
|
|
|
|
testSpecialMembers();
|
|
testStream();
|
|
testPrepare();
|
|
testMax();
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(flat_buffer,core,beast);
|
|
|
|
} // beast
|