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

static_buffer coverage

Browse Source
This commit is contained in:
Vinnie Falco
2017-07-20 08:12:19 -07:00
parent 4a3b42b398
commit 99f2425de4
7 changed files with 210 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/core/async_result.cpp
+29
View File
@@ -7,3 +7,32 @@
// Test that header file is self-contained.
#include <beast/core/async_result.hpp>
#include <beast/core/error.hpp>
#include <beast/core/type_traits.hpp>
#include <cstdlib>
namespace beast {
namespace {
struct handler
{
void operator()(beast::error_code, std::size_t) const;
};
static_assert(detail::is_invocable<
typename async_result<handler, void(error_code, std::size_t)>::completion_handler_type,
void(error_code, std::size_t)>::value, "");
static_assert(std::is_same<void,
typename async_result<handler, void(error_code, std::size_t)>::return_type>::value, "");
static_assert(std::is_constructible<
async_result<handler,
void(error_code, std::size_t)>,
typename async_result<handler,
void(error_code, std::size_t)
>::completion_handler_type&>::value, "");
} // (anon-ns)
} // beast
test/core/buffer_test.hpp
+30
View File
@@ -8,16 +8,43 @@
#ifndef BEAST_TEST_BUFFER_TEST_HPP
#define BEAST_TEST_BUFFER_TEST_HPP
#include <beast/core/string_view.hpp>
#include <beast/core/type_traits.hpp>
#include <beast/core/detail/read_size_helper.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/asio/buffer.hpp>
#include <algorithm>
#include <string>
#include <type_traits>
namespace beast {
namespace test {
template<class ConstBufferSequence>
typename std::enable_if<
is_const_buffer_sequence<ConstBufferSequence>::value,
std::string>::type
to_string(ConstBufferSequence const& bs)
{
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
std::string s;
s.reserve(buffer_size(bs));
for(auto const& b : bs)
s.append(buffer_cast<char const*>(b),
buffer_size(b));
return s;
}
template<class DynamicBuffer>
void
write_buffer(DynamicBuffer& b, string_view s)
{
b.commit(boost::asio::buffer_copy(
b.prepare(s.size()), boost::asio::buffer(
s.data(), s.size())));
}
template<class ConstBufferSequence>
typename std::enable_if<
is_const_buffer_sequence<ConstBufferSequence>::value,
@@ -101,6 +128,8 @@ namespace has_read_size_helper
};
}
//------------------------------------------------------------------------------
// Make sure read_size_helper works
template<class DynamicBuffer>
inline
@@ -109,6 +138,7 @@ check_read_size_helper()
{
static_assert(is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met ");
static_assert(has_read_size_helper::trait<DynamicBuffer>::value,
"Missing read_size_helper for dynamic buffer");
}
test/core/static_buffer.cpp
+95 -18
View File
@@ -9,33 +9,25 @@
#include <beast/core/static_buffer.hpp>
#include "buffer_test.hpp"
#include <beast/core/ostream.hpp>
#include <beast/core/string_view.hpp>
#include <beast/unit_test/suite.hpp>
#include <boost/asio/buffer.hpp>
#include <string>
namespace beast {
static_assert(
is_dynamic_buffer<static_buffer>::value,
"DynamicBuffer requirements not met");
class static_buffer_test : public beast::unit_test::suite
{
public:
template<class ConstBufferSequence>
static
std::string
to_string(ConstBufferSequence const& bs)
{
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
std::string s;
s.reserve(buffer_size(bs));
for(auto const& b : bs)
s.append(buffer_cast<char const*>(b),
buffer_size(b));
return s;
}
void
testStaticBuffer()
{
using namespace test;
using boost::asio::buffer;
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
@@ -142,15 +134,100 @@ public:
}
void
testReadSizeHelper()
testBuffer()
{
using namespace test;
string_view const s = "Hello, world!";
// static_buffer
{
char buf[64];
static_buffer b{buf, sizeof(buf)};
ostream(b) << s;
BEAST_EXPECT(to_string(b.data()) == s);
b.consume(b.size());
BEAST_EXPECT(to_string(b.data()) == "");
}
// static_buffer_n
{
static_buffer_n<64> b1;
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.max_size() == 64);
BEAST_EXPECT(b1.capacity() == 64);
ostream(b1) << s;
BEAST_EXPECT(to_string(b1.data()) == s);
{
static_buffer_n<64> b2{b1};
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
{
static_buffer_n<64> b2;
b2 = b1;
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
}
// cause memmove
{
static_buffer_n<10> b;
write_buffer(b, "12345");
b.consume(3);
write_buffer(b, "67890123");
BEAST_EXPECT(to_string(b.data()) == "4567890123");
try
{
b.prepare(1);
fail("", __FILE__, __LINE__);
}
catch(std::length_error const&)
{
pass();
}
}
// read_size_helper
{
using detail::read_size_helper;
static_buffer_n<10> b;
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);
}
// base
{
static_buffer_n<10> b;
[&](static_buffer& b)
{
BEAST_EXPECT(b.max_size() == b.capacity());
}
(b.base());
[&](static_buffer const&)
{
BEAST_EXPECT(b.max_size() == b.capacity());
}
(b.base());
}
}
void run() override
{
test::check_read_size_helper<static_buffer_n<32>>();
testStaticBuffer();
testBuffer();
//testStaticBuffer();
}
};