boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-07-29 20:37:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Tidy up flat_static_buffer tests

Browse Source
This commit is contained in:
Vinnie Falco
2018-12-15 17:43:03 -08:00
parent 81e3642fa7
commit 05d22802ec
4 changed files with 67 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -14,6 +14,7 @@ Version 200
* Refactor buffers_suffix
* Tidy up flat_buffer tests
* Fix ostream prepare calculation for low limits
* Tidy up flat_static_buffer tests
API Changes:

50
test/beast/core/buffer_test.hpp
View File

@ -479,6 +479,56 @@ test_dynamic_buffer(
SUITE_EXPECT(test, b0.size() == 0);
SUITE_EXPECT(test, buffer_size(b0.data()) == 0);
// special members
{
string_view src = "Hello, world!";
DynamicBuffer b1(b0);
auto const mb = b1.prepare(src.size());
b1.commit(net::buffer_copy(mb,
net::const_buffer(src.data(), src.size())));
// copy constructor
{
DynamicBuffer b2(b1);
SUITE_EXPECT(test, b2.size() == b1.size());
SUITE_EXPECT(test,
buffers_to_string(b1.data()) ==
buffers_to_string(b2.data()));
}
// move constructor
{
DynamicBuffer b2(b1);
DynamicBuffer b3(std::move(b2));
SUITE_EXPECT(test, b3.size() == b1.size());
SUITE_EXPECT(test,
buffers_to_string(b1.data()) ==
buffers_to_string(b3.data()));
}
// copy assignment
{
DynamicBuffer b2(b0);
b2 = b1;
SUITE_EXPECT(test, b2.size() == b1.size());
SUITE_EXPECT(test,
buffers_to_string(b1.data()) ==
buffers_to_string(b2.data()));
}
// move assignment
{
DynamicBuffer b2(b1);
DynamicBuffer b3(b0);
b3 = std::move(b2);
SUITE_EXPECT(test, b3.size() == b1.size());
SUITE_EXPECT(test,
buffers_to_string(b1.data()) ==
buffers_to_string(b3.data()));
}
}
// n == 0
{
DynamicBuffer b(b0);

3
test/beast/core/flat_buffer.cpp
View File

@ -26,6 +26,9 @@ namespace beast {
class flat_buffer_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
is_mutable_dynamic_buffer<flat_buffer>::value);
void
testDynamicBuffer()
{

169
test/beast/core/flat_static_buffer.cpp
View File

@ -27,164 +27,21 @@ class flat_static_buffer_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
net::is_dynamic_buffer<
flat_static_buffer_base>::value);
BOOST_STATIC_ASSERT(
net::is_const_buffer_sequence<
flat_static_buffer_base::const_buffers_type>::value);
BOOST_STATIC_ASSERT(
net::is_mutable_buffer_sequence<
flat_static_buffer_base::mutable_data_type>::value);
BOOST_STATIC_ASSERT(
net::is_mutable_buffer_sequence<
flat_static_buffer_base::mutable_buffers_type>::value);
BOOST_STATIC_ASSERT(std::is_convertible<
flat_static_buffer_base::mutable_data_type,
flat_static_buffer_base::const_buffers_type>::value);
is_mutable_dynamic_buffer<
flat_static_buffer<13>>::value);
template<class DynamicBuffer>
void
testMutableData()
testDynamicBuffer()
{
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");
flat_static_buffer<13> b;
test_dynamic_buffer(*this, b);
}
void
testStaticBuffer()
testMembers()
{
using namespace test;
using net::buffer;
using net::buffer_size;
char buf[12];
std::string const s = "Hello, world";
BEAST_EXPECT(s.size() == sizeof(buf));
for(std::size_t i = 1; i < 4; ++i) {
for(std::size_t j = 1; j < 4; ++j) {
for(std::size_t x = 1; x < 4; ++x) {
for(std::size_t y = 1; y < 4; ++y) {
for(std::size_t t = 1; t < 4; ++ t) {
for(std::size_t u = 1; u < 4; ++ u) {
std::size_t z = sizeof(buf) - (x + y);
std::size_t v = sizeof(buf) - (t + u);
{
std::memset(buf, 0, sizeof(buf));
flat_static_buffer<sizeof(buf)> ba;
{
auto d = ba.prepare(z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(x);
BEAST_EXPECT(buffer_size(d) == x);
ba.commit(buffer_copy(d, buffer(s.data(), x)));
}
BEAST_EXPECT(ba.size() == x);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(y);
BEAST_EXPECT(buffer_size(d) == y);
ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
}
ba.commit(1);
BEAST_EXPECT(ba.size() == x + y);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BEAST_EXPECT(buffer_size(d) == z);
ba.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
}
ba.commit(2);
BEAST_EXPECT(ba.size() == x + y + z);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(buffers_to_string(ba.data()) == s);
ba.consume(t);
{
auto d = ba.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
}
BEAST_EXPECT(buffers_to_string(ba.data()) == s.substr(t, std::string::npos));
ba.consume(u);
BEAST_EXPECT(buffers_to_string(ba.data()) == s.substr(t + u, std::string::npos));
ba.consume(v);
BEAST_EXPECT(buffers_to_string(ba.data()) == "");
ba.consume(1);
{
auto d = ba.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
}
try
{
ba.prepare(ba.capacity() - ba.size() + 1);
fail();
}
catch(...)
{
pass();
}
}
}}}}}}
}
void
testBuffer()
{
using namespace test;
string_view const s = "Hello, world!";
// flat_static_buffer_base
@ -193,8 +50,9 @@ public:
flat_static_buffer_base b{buf, sizeof(buf)};
ostream(b) << s;
BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.consume(b.size());
BEAST_EXPECT(buffers_to_string(b.data()) == "");
b.clear();
BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0);
}
// flat_static_buffer
@ -223,9 +81,9 @@ public:
// cause memmove
{
flat_static_buffer<10> b;
write_buffer(b, "12345");
ostream(b) << "12345";
b.consume(3);
write_buffer(b, "67890123");
ostream(b) << "67890123";
BEAST_EXPECT(buffers_to_string(b.data()) == "4567890123");
try
{
@ -271,9 +129,8 @@ public:
void run() override
{
testBuffer();
testStaticBuffer();
testMutableData<flat_static_buffer<32>>();
testDynamicBuffer();
testMembers();
}
};