feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity

flat_buffer coverage

Browse Source
This commit is contained in:
Vinnie Falco
2017-07-20 08:12:19 -07:00
parent 99f2425de4
commit 5d6d486da4
5 changed files with 374 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/core/flat_buffer.cpp
+288 -231
View File
@@ -9,7 +9,10 @@
#include <beast/core/flat_buffer.hpp>
#include "buffer_test.hpp"
#include <beast/core/ostream.hpp>
#include <beast/core/string_view.hpp>
#include <beast/core/detail/read_size_helper.hpp>
#include <beast/test/test_allocator.hpp>
#include <beast/unit_test/suite.hpp>
#include <boost/lexical_cast.hpp>
@@ -23,125 +26,233 @@ static_assert(is_dynamic_buffer<flat_buffer>::value,
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()
testBuffer()
{
using allocator = test::test_allocator<char,
Equal, Assign, Move, Swap, Select>;
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
{
using boost::asio::buffer_size;
basic_flat_buffer<allocator> b1{10};
{
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(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(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(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(to_string(b1.data()) == "Hello");
BEAST_EXPECT(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(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
basic_flat_buffer<a_t> b1;
ostream(b1) << "Hello";
basic_flat_buffer<a_neq_t> b2(b1);
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(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(to_string(b1.data()) == "Hello");
BEAST_EXPECT(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(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(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(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(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(to_string(b2.data()) == "Hello");
}
}
// copy assignment
{
{
flat_buffer b1;
ostream(b1) << "Hello";
flat_buffer b2;
b2 = b1;
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
basic_flat_buffer<a_t> b3;
b3 = b2;
BEAST_EXPECT(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(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(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);
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);
ostream(b1) << s;
BEAST_EXPECT(to_string(b1.data()) == s);
{
flat_buffer b2{b1};
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
{
flat_buffer b2{64};
b2 = b1;
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
}
{
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);
}
// cause memmove
{
flat_buffer b{20};
ostream(b) << "12345";
@@ -149,132 +260,84 @@ public:
ostream(b) << "67890123";
BEAST_EXPECT(to_string(b.data()) == "4567890123");
}
}
void
testSpecialMembers()
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
// read_size_helper
{
using detail::read_size_helper;
flat_buffer b{10};
BEAST_EXPECT(b.max_size() == 10);
BEAST_EXPECT(read_size_helper(b, 512) == 10);
b.prepare(4);
b.commit(4);
BEAST_EXPECT(read_size_helper(b, 512) == 6);
b.consume(2);
BEAST_EXPECT(read_size_helper(b, 512) == 8);
b.prepare(8);
b.commit(8);
BEAST_EXPECT(read_size_helper(b, 512) == 0);
}
{
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;
// swap
{
{
type fba{1, alloc};
BEAST_EXPECT(fba.max_size() == 1);
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(to_string(b2.data()) == "Hello");
}
{
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);
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(to_string(b2.data()) == "Hello");
}
}
}
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
// prepare
{
b.prepare(2);
fail("", __FILE__, __LINE__);
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();
}
}
catch(std::length_error const&)
// shrink to fit
{
pass();
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());
}
}
@@ -283,13 +346,7 @@ public:
{
test::check_read_size_helper<flat_buffer>();
testCtors();
testOperations();
testSpecialMembers();
testStream();
testPrepare();
testMax();
testBuffer();
}
};