boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-08-01 22:04:34 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename to BEAST_EXPECT

Browse Source
This commit is contained in:
Vinnie Falco
2017-07-25 12:35:54 -07:00
parent 175763e773
commit c831afd93b
54 changed files with 2014 additions and 1657 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -1,6 +1,7 @@
Version 87:
* Update appveyor for Boost branch
* Rename to BEAST_EXPECT
--------------------------------------------------------------------------------

8
extras/boost/beast/unit_test/suite.hpp
View File

@@ -601,20 +601,20 @@ run(runner& r)
}
}
#ifndef BOOST_BEAST_EXPECT
#ifndef BEAST_EXPECT
/** Check a precondition.
If the condition is false, the file and line number are reported.
*/
#define BOOST_BEAST_EXPECT(cond) expect(cond, __FILE__, __LINE__)
#define BEAST_EXPECT(cond) expect(cond, __FILE__, __LINE__)
#endif
#ifndef BOOST_BEAST_EXPECTS
#ifndef BEAST_EXPECTS
/** Check a precondition.
If the condition is false, the file and line number are reported.
*/
#define BOOST_BEAST_EXPECTS(cond, reason) ((cond) ? (pass(), true) : \
#define BEAST_EXPECTS(cond, reason) ((cond) ? (pass(), true) : \
(fail((reason), __FILE__, __LINE__), false))
#endif

8
test/benchmarks/parser.cpp
View File

@@ -61,7 +61,7 @@ public:
{
mg.request(v[i]);
size_ += v[i].size();
BOOST_BEAST_EXPECT(v[i].size() > 0);
BEAST_EXPECT(v[i].size() > 0);
}
return v;
}
@@ -76,7 +76,7 @@ public:
{
mg.response(v[i]);
size_ += v[i].size();
BOOST_BEAST_EXPECT(v[i].size() > 0);
BEAST_EXPECT(v[i].size() > 0);
}
return v;
}
@@ -121,7 +121,7 @@ public:
Parser p;
error_code ec;
p.write(b.data(), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
log << to_string(b.data()) << std::endl;
}
}
@@ -137,7 +137,7 @@ public:
p.header_limit((std::numeric_limits<std::uint32_t>::max)());
error_code ec;
feed(b.data(), p, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
log << to_string(b.data()) << std::endl;
}
}

4
test/core/base64.cpp
View File

@@ -23,8 +23,8 @@ public:
check (std::string const& in, std::string const& out)
{
auto const encoded = base64_encode (in);
BOOST_BEAST_EXPECT(encoded == out);
BOOST_BEAST_EXPECT(base64_decode (encoded) == in);
BEAST_EXPECT(encoded == out);
BEAST_EXPECT(base64_decode (encoded) == in);
}
void

2
test/core/bind_handler.cpp
View File

@@ -41,7 +41,7 @@ public:
void
callback(int v)
{
BOOST_BEAST_EXPECT(v == 42);
BEAST_EXPECT(v == 42);
}
void

28
test/core/buffer_cat.cpp
View File

@@ -102,34 +102,34 @@ public:
std::list<const_buffer> b6;
auto bs = buffer_cat(
b1, b2, b3, b4, b5, b6);
BOOST_BEAST_EXPECT(buffer_size(bs) == 10);
BOOST_BEAST_EXPECT(bsize1(bs) == 10);
BOOST_BEAST_EXPECT(bsize2(bs) == 10);
BOOST_BEAST_EXPECT(bsize3(bs) == 10);
BOOST_BEAST_EXPECT(bsize4(bs) == 10);
BEAST_EXPECT(buffer_size(bs) == 10);
BEAST_EXPECT(bsize1(bs) == 10);
BEAST_EXPECT(bsize2(bs) == 10);
BEAST_EXPECT(bsize3(bs) == 10);
BEAST_EXPECT(bsize4(bs) == 10);
std::vector<const_buffer> v;
for(auto iter = make_reverse_iterator(bs.end());
iter != make_reverse_iterator(bs.begin()); ++iter)
v.emplace_back(*iter);
BOOST_BEAST_EXPECT(buffer_size(bs) == 10);
BEAST_EXPECT(buffer_size(bs) == 10);
decltype(bs) bs2(bs);
auto bs3(std::move(bs));
{
boost::asio::streambuf sb1, sb2;
BOOST_BEAST_EXPECT(buffer_size(buffer_cat(
BEAST_EXPECT(buffer_size(buffer_cat(
sb1.prepare(5), sb2.prepare(7))) == 12);
sb1.commit(5);
sb2.commit(7);
BOOST_BEAST_EXPECT(buffer_size(buffer_cat(
BEAST_EXPECT(buffer_size(buffer_cat(
sb1.data(), sb2.data())) == 12);
}
for(auto it = bs.begin(); it != bs.end(); ++it)
{
decltype(bs)::const_iterator copy;
copy = it;
BOOST_BEAST_EXPECT(copy == it);
BEAST_EXPECT(copy == it);
copy = copy;
BOOST_BEAST_EXPECT(copy == it);
BEAST_EXPECT(copy == it);
}
}
@@ -182,7 +182,7 @@ public:
std::size_t n = 0;
for(auto it = rbegin; it != rend; ++it)
n += buffer_size(*it);
BOOST_BEAST_EXPECT(n == 9);
BEAST_EXPECT(n == 9);
}
#endif
@@ -208,11 +208,11 @@ public:
pass();
}
auto bs2 = bs;
BOOST_BEAST_EXPECT(bs.begin() != bs2.begin());
BOOST_BEAST_EXPECT(bs.end() != bs2.end());
BEAST_EXPECT(bs.begin() != bs2.begin());
BEAST_EXPECT(bs.end() != bs2.end());
decltype(bs)::const_iterator it;
decltype(bs2)::const_iterator it2;
BOOST_BEAST_EXPECT(it == it2);
BEAST_EXPECT(it == it2);
}
void run() override

36
test/core/buffer_prefix.cpp
View File

@@ -112,7 +112,7 @@ public:
{
using boost::asio::buffer_size;
std::string s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == 12);
BEAST_EXPECT(s.size() == 12);
for(std::size_t x = 1; x < 4; ++x) {
for(std::size_t y = 1; y < 4; ++y) {
std::size_t z = s.size() - (x + y);
@@ -124,14 +124,14 @@ public:
for(std::size_t i = 0; i <= s.size() + 1; ++i)
{
auto pb = buffer_prefix(i, bs);
BOOST_BEAST_EXPECT(to_string(pb) == s.substr(0, i));
BEAST_EXPECT(to_string(pb) == s.substr(0, i));
auto pb2 = pb;
BOOST_BEAST_EXPECT(to_string(pb2) == to_string(pb));
BEAST_EXPECT(to_string(pb2) == to_string(pb));
pb = buffer_prefix(0, bs);
pb2 = pb;
BOOST_BEAST_EXPECT(buffer_size(pb2) == 0);
BEAST_EXPECT(buffer_size(pb2) == 0);
pb2 = buffer_prefix(i, bs);
BOOST_BEAST_EXPECT(to_string(pb2) == s.substr(0, i));
BEAST_EXPECT(to_string(pb2) == s.substr(0, i));
}
}
}}
@@ -143,22 +143,22 @@ public:
using boost::asio::buffer_size;
using boost::asio::null_buffers;
auto pb0 = buffer_prefix(0, null_buffers{});
BOOST_BEAST_EXPECT(buffer_size(pb0) == 0);
BEAST_EXPECT(buffer_size(pb0) == 0);
auto pb1 = buffer_prefix(1, null_buffers{});
BOOST_BEAST_EXPECT(buffer_size(pb1) == 0);
BOOST_BEAST_EXPECT(buffer_copy(pb0, pb1) == 0);
BEAST_EXPECT(buffer_size(pb1) == 0);
BEAST_EXPECT(buffer_copy(pb0, pb1) == 0);
using pb_type = decltype(pb0);
consuming_buffers<pb_type> cb(pb0);
BOOST_BEAST_EXPECT(buffer_size(cb) == 0);
BOOST_BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
BEAST_EXPECT(buffer_size(cb) == 0);
BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
cb.consume(1);
BOOST_BEAST_EXPECT(buffer_size(cb) == 0);
BOOST_BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
BEAST_EXPECT(buffer_size(cb) == 0);
BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
auto pbc = buffer_prefix(2, cb);
BOOST_BEAST_EXPECT(buffer_size(pbc) == 0);
BOOST_BEAST_EXPECT(buffer_copy(pbc, cb) == 0);
BEAST_EXPECT(buffer_size(pbc) == 0);
BEAST_EXPECT(buffer_copy(pbc, cb) == 0);
}
void testIterator()
@@ -171,10 +171,10 @@ public:
const_buffer{&b[1], 1},
const_buffer{&b[2], 1}}};
auto pb = buffer_prefix(2, bs);
BOOST_BEAST_EXPECT(bsize1(pb) == 2);
BOOST_BEAST_EXPECT(bsize2(pb) == 2);
BOOST_BEAST_EXPECT(bsize3(pb) == 2);
BOOST_BEAST_EXPECT(bsize4(pb) == 2);
BEAST_EXPECT(bsize1(pb) == 2);
BEAST_EXPECT(bsize2(pb) == 2);
BEAST_EXPECT(bsize3(pb) == 2);
BEAST_EXPECT(bsize4(pb) == 2);
}
void run() override

20
test/core/buffered_read_stream.cpp
View File

@@ -35,8 +35,8 @@ public:
buffered_read_stream<socket_type, multi_buffer> srs(ios);
buffered_read_stream<socket_type, multi_buffer> srs2(std::move(srs));
srs = std::move(srs2);
BOOST_BEAST_EXPECT(&srs.get_io_service() == &ios);
BOOST_BEAST_EXPECT(&srs.get_io_service() == &srs2.get_io_service());
BEAST_EXPECT(&srs.get_io_service() == &ios);
BEAST_EXPECT(&srs.get_io_service() == &srs2.get_io_service());
}
{
socket_type sock(ios);
@@ -66,11 +66,11 @@ public:
boost::asio::read(srs, buffer(&s[0], s.size()), ec);
if(! ec)
{
BOOST_BEAST_EXPECT(s == "Hello, world!");
BEAST_EXPECT(s == "Hello, world!");
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -85,11 +85,11 @@ public:
boost::asio::read(srs, buffer(&s[0], s.size()), ec);
if(! ec)
{
BOOST_BEAST_EXPECT(s == "Hello, world!");
BEAST_EXPECT(s == "Hello, world!");
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -104,11 +104,11 @@ public:
srs, buffer(&s[0], s.size()), do_yield[ec]);
if(! ec)
{
BOOST_BEAST_EXPECT(s == "Hello, world!");
BEAST_EXPECT(s == "Hello, world!");
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -124,11 +124,11 @@ public:
srs, buffer(&s[0], s.size()), do_yield[ec]);
if(! ec)
{
BOOST_BEAST_EXPECT(s == "Hello, world!");
BEAST_EXPECT(s == "Hello, world!");
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void run() override

68
test/core/buffers_adapter.cpp
View File

@@ -48,7 +48,7 @@ public:
using boost::asio::mutable_buffer;
char buf[12];
std::string const s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == sizeof(buf));
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) {
@@ -65,83 +65,83 @@ public:
mutable_buffer{&buf[i], j},
mutable_buffer{&buf[i+j], k}}};
buffers_adapter<decltype(bs)> ba(std::move(bs));
BOOST_BEAST_EXPECT(ba.max_size() == sizeof(buf));
BEAST_EXPECT(ba.max_size() == sizeof(buf));
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
ba.commit(buffer_copy(d, buffer(s.data(), x)));
}
BOOST_BEAST_EXPECT(ba.size() == x);
BOOST_BEAST_EXPECT(ba.max_size() == sizeof(buf) - x);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(ba.size() == x);
BEAST_EXPECT(ba.max_size() == sizeof(buf) - x);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
}
ba.commit(1);
BOOST_BEAST_EXPECT(ba.size() == x + y);
BOOST_BEAST_EXPECT(ba.max_size() == sizeof(buf) - (x + y));
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(ba.size() == x + y);
BEAST_EXPECT(ba.max_size() == sizeof(buf) - (x + y));
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z); BOOST_BEAST_EXPECT(buffer_size(d) == z);
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);
BOOST_BEAST_EXPECT(ba.size() == x + y + z);
BOOST_BEAST_EXPECT(ba.max_size() == 0);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BOOST_BEAST_EXPECT(to_string(ba.data()) == s);
BEAST_EXPECT(ba.size() == x + y + z);
BEAST_EXPECT(ba.max_size() == 0);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(to_string(ba.data()) == s);
ba.consume(t);
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
BOOST_BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
ba.consume(u);
BOOST_BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
ba.consume(v);
BOOST_BEAST_EXPECT(to_string(ba.data()) == "");
BEAST_EXPECT(to_string(ba.data()) == "");
ba.consume(1);
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
try
{
@@ -163,9 +163,9 @@ public:
sb_type b;
buffers_adapter<
sb_type::mutable_buffers_type> ba(b.prepare(3));
BOOST_BEAST_EXPECT(buffer_size(ba.prepare(3)) == 3);
BEAST_EXPECT(buffer_size(ba.prepare(3)) == 3);
ba.commit(2);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == 2);
BEAST_EXPECT(buffer_size(ba.data()) == 2);
}
{
using sb_type = beast::multi_buffer;
@@ -173,13 +173,13 @@ public:
b.prepare(3);
buffers_adapter<
sb_type::mutable_buffers_type> ba(b.prepare(8));
BOOST_BEAST_EXPECT(buffer_size(ba.prepare(8)) == 8);
BEAST_EXPECT(buffer_size(ba.prepare(8)) == 8);
ba.commit(2);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == 2);
BEAST_EXPECT(buffer_size(ba.data()) == 2);
ba.consume(1);
ba.commit(6);
ba.consume(2);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == 5);
BEAST_EXPECT(buffer_size(ba.data()) == 5);
ba.consume(5);
}
}

2
test/core/clamp.cpp
View File

@@ -22,7 +22,7 @@ class clamp_test : public beast::unit_test::suite
public:
void testClamp()
{
BOOST_BEAST_EXPECT(clamp(
BEAST_EXPECT(clamp(
(std::numeric_limits<std::uint64_t>::max)()) ==
(std::numeric_limits<std::size_t>::max)());
}

44
test/core/consuming_buffers.cpp
View File

@@ -47,10 +47,10 @@ public:
void
expect_size(std::size_t n, ConstBufferSequence const& buffers)
{
BOOST_BEAST_EXPECT(test::size_pre(buffers) == n);
BOOST_BEAST_EXPECT(test::size_post(buffers) == n);
BOOST_BEAST_EXPECT(test::size_rev_pre(buffers) == n);
BOOST_BEAST_EXPECT(test::size_rev_post(buffers) == n);
BEAST_EXPECT(test::size_pre(buffers) == n);
BEAST_EXPECT(test::size_post(buffers) == n);
BEAST_EXPECT(test::size_rev_pre(buffers) == n);
BEAST_EXPECT(test::size_rev_post(buffers) == n);
}
void
@@ -75,9 +75,9 @@ public:
using boost::asio::const_buffer;
char buf[12];
std::string const s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == sizeof(buf));
BEAST_EXPECT(s.size() == sizeof(buf));
buffer_copy(buffer(buf), buffer(s));
BOOST_BEAST_EXPECT(to_string(buffer(buf)) == s);
BEAST_EXPECT(to_string(buffer(buf)) == s);
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) {
@@ -90,24 +90,24 @@ public:
const_buffer{&buf[i], j},
const_buffer{&buf[i+j], k}}};
consuming_buffers<decltype(bs)> cb(bs);
BOOST_BEAST_EXPECT(to_string(cb) == s);
BEAST_EXPECT(to_string(cb) == s);
expect_size(s.size(), cb);
cb.consume(0);
BOOST_BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0)));
BOOST_BEAST_EXPECT(to_string(cb) == s);
BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0)));
BEAST_EXPECT(to_string(cb) == s);
expect_size(s.size(), cb);
cb.consume(x);
BOOST_BEAST_EXPECT(to_string(cb) == s.substr(x));
BOOST_BEAST_EXPECT(eq(cb, consumed_buffers(bs, x)));
BEAST_EXPECT(to_string(cb) == s.substr(x));
BEAST_EXPECT(eq(cb, consumed_buffers(bs, x)));
cb.consume(y);
BOOST_BEAST_EXPECT(to_string(cb) == s.substr(x+y));
BOOST_BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y)));
BEAST_EXPECT(to_string(cb) == s.substr(x+y));
BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y)));
cb.consume(z);
BOOST_BEAST_EXPECT(to_string(cb) == "");
BOOST_BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
BEAST_EXPECT(to_string(cb) == "");
BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
cb.consume(1);
BOOST_BEAST_EXPECT(to_string(cb) == "");
BOOST_BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
BEAST_EXPECT(to_string(cb) == "");
BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
}
}}}}
}
@@ -126,7 +126,7 @@ public:
};
consuming_buffers<test_buffer> cb;
BOOST_BEAST_EXPECT(to_string(cb) == "\r\n");
BEAST_EXPECT(to_string(cb) == "\r\n");
}
void
@@ -139,7 +139,7 @@ public:
boost::in_place_init,
boost::asio::const_buffers_1("\r", 1),
boost::asio::const_buffers_1("\n", 1));
BOOST_BEAST_EXPECT(to_string(cb) == "\r\n");
BEAST_EXPECT(to_string(cb) == "\r\n");
}
void
@@ -150,10 +150,10 @@ public:
using boost::asio::null_buffers;
consuming_buffers<null_buffers> cb(
null_buffers{});
BOOST_BEAST_EXPECT(buffer_size(cb) == 0);
BEAST_EXPECT(buffer_size(cb) == 0);
consuming_buffers<null_buffers> cb2(
null_buffers{});
BOOST_BEAST_EXPECT(buffer_copy(cb2, cb) == 0);
BEAST_EXPECT(buffer_copy(cb2, cb) == 0);
}
void
@@ -165,7 +165,7 @@ public:
std::size_t n = 0;
for(auto it = cb.end(); it != cb.begin(); --it)
++n;
BOOST_BEAST_EXPECT(n == 3);
BEAST_EXPECT(n == 3);
}
void run() override

356
test/core/detail/variant.cpp Normal file
View File

@@ -0,0 +1,356 @@
//
// 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)
//
// Test that header file is self-contained.
#include <boost/beast/core/detail/variant.hpp>
#include <boost/beast/unit_test/suite.hpp>
#include <string>
namespace boost {
namespace beast {
namespace detail {
class variant_test : public beast::unit_test::suite
{
public:
template<unsigned char I>
struct Q
{
static
unsigned char&
count()
{
static unsigned char n = 0;
return n;
}
bool move = false;
bool copy = false;
bool move_assign = false;
bool copy_assign = false;
Q() { ++count(); }
~Q() { --count(); }
Q(Q&&) { ++count(); move = true; }
Q(Q const&) { ++count(); copy = true; }
Q& operator=(Q&&) { move_assign = true; return *this; }
Q& operator=(Q const&) { copy_assign = true; return *this; }
};
void
testVariant()
{
// Default Constructor
// Destructor
{
variant<int> v;
BEAST_EXPECT(v.index() == 0);
}
// emplace
{
variant<int> v;
BEAST_EXPECT(v.index() == 0);
v.emplace<1>(10);
BEAST_EXPECT(v.index() == 1);
BEAST_EXPECT(v.get<1>() == 10);
}
{
variant<std::string> v;
v.emplace<1>("Hello, world!");
BEAST_EXPECT(v.index() == 1);
BEAST_EXPECT(v.get<1>() == "Hello, world!");
}
{
variant<Q<1>> v;
BEAST_EXPECT(Q<1>::count() == 0);
v.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 1);
v.reset();
BEAST_EXPECT(Q<1>::count() == 0);
}
BEAST_EXPECT(Q<1>::count() == 0);
{
variant<Q<1>, Q<2>, Q<3>> v;
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
v.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 1);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
v.emplace<2>();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
v.emplace<3>();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 1);
v.reset();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
}
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
// move
{
variant<std::string> v1;
BEAST_EXPECT(v1.index() == 0);
variant<std::string> v2{std::move(v1)};
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(v2.index() == 0);
v2.emplace<1>("Hello");
BEAST_EXPECT(v2.get<1>() == "Hello");
variant<std::string> v3{std::move(v2)};
BEAST_EXPECT(v2.index() == 0);
BEAST_EXPECT(v3.get<1>() == "Hello");
}
{
variant<Q<1>> v1;
BEAST_EXPECT(Q<1>::count() == 0);
v1.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 1);
BEAST_EXPECT(! v1.get<1>().move);
variant<Q<1>> v2{std::move(v1)};
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(Q<1>::count() == 1);
BEAST_EXPECT(v2.get<1>().move);
}
BEAST_EXPECT(Q<1>::count() == 0);
{
variant<Q<1>, Q<2>, Q<3>> v1;
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
v1.emplace<2>();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
variant<Q<1>, Q<2>, Q<3>> v2{std::move(v1)};
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
BEAST_EXPECT(v2.get<2>().move);
}
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
// copy
{
variant<std::string> v1;
BEAST_EXPECT(v1.index() == 0);
variant<std::string> v2{v1};
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(v2.index() == 0);
v2.emplace<1>("Hello");
BEAST_EXPECT(v2.get<1>() == "Hello");
variant<std::string> v3{v2};
BEAST_EXPECT(v2.get<1>() == "Hello");
BEAST_EXPECT(v3.get<1>() == "Hello");
}
{
variant<Q<1>> v1;
BEAST_EXPECT(Q<1>::count() == 0);
v1.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 1);
BEAST_EXPECT(! v1.get<1>().copy);
variant<Q<1>> v2{v1};
BEAST_EXPECT(v1.index() == 1);
BEAST_EXPECT(Q<1>::count() == 2);
BEAST_EXPECT(v2.get<1>().copy);
}
BEAST_EXPECT(Q<1>::count() == 0);
{
variant<Q<1>, Q<2>, Q<3>> v1;
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
v1.emplace<2>();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
variant<Q<1>, Q<2>, Q<3>> v2{v1};
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 2);
BEAST_EXPECT(Q<3>::count() == 0);
BEAST_EXPECT(v2.get<2>().copy);
}
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
// move assign
{
variant<std::string> v1;
BEAST_EXPECT(v1.index() == 0);
variant<std::string> v2;
v2 = std::move(v1);
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(v2.index() == 0);
v2.emplace<1>("Hello");
BEAST_EXPECT(v2.get<1>() == "Hello");
variant<std::string> v3;
v3 = std::move(v2);
BEAST_EXPECT(v2.index() == 0);
BEAST_EXPECT(v3.get<1>() == "Hello");
}
{
variant<Q<1>> v1;
v1.emplace<1>();
BEAST_EXPECT(! v1.get<1>().move_assign);
BEAST_EXPECT(Q<1>::count() == 1);
variant<Q<1>> v2;
v2.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 2);
BEAST_EXPECT(! v2.get<1>().move_assign);
v2 = std::move(v1);
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(v2.index() == 1);
BEAST_EXPECT(v2.get<1>().move);
BEAST_EXPECT(!v2.get<1>().move_assign);
BEAST_EXPECT(Q<1>::count() == 1);
}
BEAST_EXPECT(Q<1>::count() == 0);
{
variant<Q<1>, Q<2>, Q<3>> v1;
v1.emplace<2>();
BEAST_EXPECT(! v1.get<2>().move_assign);
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
variant<Q<1>, Q<2>, Q<3>> v2;
v2.emplace<2>();
BEAST_EXPECT(! v2.get<2>().move_assign);
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 2);
BEAST_EXPECT(Q<3>::count() == 0);
v2 = std::move(v1);
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(v2.index() == 2);
BEAST_EXPECT(! v2.get<2>().move_assign);
BEAST_EXPECT(v2.get<2>().move);
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
}
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
// copy assign
{
variant<std::string> v1;
BEAST_EXPECT(v1.index() == 0);
variant<std::string> v2;
v2 = v1;
BEAST_EXPECT(v1.index() == 0);
BEAST_EXPECT(v2.index() == 0);
v2.emplace<1>("Hello");
BEAST_EXPECT(v2.get<1>() == "Hello");
variant<std::string> v3;
v3 = v2;
BEAST_EXPECT(v2.get<1>() == "Hello");
BEAST_EXPECT(v3.get<1>() == "Hello");
}
{
variant<Q<1>> v1;
v1.emplace<1>();
BEAST_EXPECT(! v1.get<1>().copy_assign);
BEAST_EXPECT(Q<1>::count() == 1);
variant<Q<1>> v2;
v2.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 2);
BEAST_EXPECT(! v2.get<1>().copy_assign);
v2 = v1;
BEAST_EXPECT(v1.index() == 1);
BEAST_EXPECT(v2.index() == 1);
BEAST_EXPECT(! v2.get<1>().copy_assign);
BEAST_EXPECT(v2.get<1>().copy);
BEAST_EXPECT(Q<1>::count() == 2);
}
BEAST_EXPECT(Q<1>::count() == 0);
{
variant<Q<1>, Q<2>, Q<3>> v1;
v1.emplace<2>();
BEAST_EXPECT(! v1.get<2>().copy_assign);
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
variant<Q<1>, Q<2>, Q<3>> v2;
v2.emplace<2>();
BEAST_EXPECT(! v2.get<2>().copy_assign);
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 2);
BEAST_EXPECT(Q<3>::count() == 0);
v2 = v1;
BEAST_EXPECT(v1.index() == 2);
BEAST_EXPECT(v2.index() == 2);
BEAST_EXPECT(! v2.get<2>().copy_assign);
BEAST_EXPECT(v2.get<2>().copy);
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 2);
BEAST_EXPECT(Q<3>::count() == 0);
}
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
// get
{
variant<std::string> v;
v.emplace<1>("Hello");
v.get<1>() = "World!";
BEAST_EXPECT(v.get<1>() == "World!");
}
// reset
{
variant<std::string> v;
v.emplace<1>("Hello");
v.reset();
BEAST_EXPECT(v.index() == 0);
}
{
variant<Q<1>> v;
BEAST_EXPECT(Q<1>::count() == 0);
v.emplace<1>();
BEAST_EXPECT(Q<1>::count() == 1);
v.reset();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(v.index() == 0);
}
{
variant<Q<1>, Q<2>, Q<3>> v;
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
v.emplace<2>();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 1);
BEAST_EXPECT(Q<3>::count() == 0);
v.reset();
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
BEAST_EXPECT(v.index() == 0);
}
BEAST_EXPECT(Q<1>::count() == 0);
BEAST_EXPECT(Q<2>::count() == 0);
BEAST_EXPECT(Q<3>::count() == 0);
}
void
run()
{
testVariant();
}
};
BOOST_BEAST_DEFINE_TESTSUITE(variant,core,beast);
} // detail
} // beast
} // boost

2
test/core/detail/varint.cpp
View File

@@ -30,7 +30,7 @@ public:
varint_write(it, n0);
it = &buf[0];
auto n = varint_read(it);
BOOST_BEAST_EXPECT(n == n0);
BEAST_EXPECT(n == n0);
n = n0 + n1;
if(n < n1)
break;

20
test/core/doc_examples.cpp
View File

@@ -32,18 +32,18 @@ public:
buf[1] = 0;
buf[2] = 0;
buf[3] = 0;
BOOST_BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
boost::asio::buffer(buf, 0))));
BOOST_BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
boost::asio::buffer(buf, 1))));
BOOST_BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
boost::asio::buffer(buf, 2))));
BOOST_BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
BEAST_EXPECT(boost::indeterminate(is_ssl_handshake(
boost::asio::buffer(buf, 3))));
BOOST_BEAST_EXPECT(is_ssl_handshake(
BEAST_EXPECT(is_ssl_handshake(
boost::asio::buffer(buf, 4)));
buf[0] = 0;
BOOST_BEAST_EXPECT(! is_ssl_handshake(
BEAST_EXPECT(! is_ssl_handshake(
boost::asio::buffer(buf, 1)));
}
@@ -57,8 +57,8 @@ public:
error_code ec;
flat_buffer b;
auto const result = detect_ssl(p.server, b, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(result);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(result);
}
yield_to(
[&](yield_context yield)
@@ -69,8 +69,8 @@ public:
error_code ec;
flat_buffer b;
auto const result = async_detect_ssl(p.server, b, yield[ec]);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(result);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(result);
});
}

12
test/core/drain_buffer.cpp
View File

@@ -27,8 +27,8 @@ public:
{
using boost::asio::buffer_size;
drain_buffer b;
BOOST_BEAST_EXPECT(buffer_size(b.prepare(0)) == 0);
BOOST_BEAST_EXPECT(buffer_size(b.prepare(100)) == 100);
BEAST_EXPECT(buffer_size(b.prepare(0)) == 0);
BEAST_EXPECT(buffer_size(b.prepare(100)) == 100);
try
{
b.prepare(b.max_size() + 1);
@@ -39,13 +39,13 @@ public:
pass();
}
b.prepare(10);
BOOST_BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.size() == 0);
b.commit(10);
BOOST_BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.size() == 0);
b.consume(10);
BOOST_BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.size() == 0);
b.consume(1000);
BOOST_BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.size() == 0);
}
};

4
test/core/empty_base_optimization.cpp
View File

@@ -85,8 +85,8 @@ public:
void
run()
{
BOOST_BEAST_EXPECT(test_one());
BOOST_BEAST_EXPECT(test_two());
BEAST_EXPECT(test_one());
BEAST_EXPECT(test_two());
pass();
}
};

64
test/core/file_test.hpp
View File

@@ -31,93 +31,93 @@ doTestFile(beast::unit_test::suite& test)
{
{
File f1;
test.BOOST_BEAST_EXPECT(! f1.is_open());
test.BEAST_EXPECT(! f1.is_open());
f1.open(temp.string<std::string>().c_str(), file_mode::write, ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
File f2{std::move(f1)};
test.BOOST_BEAST_EXPECT(! f1.is_open());
test.BOOST_BEAST_EXPECT(f2.is_open());
test.BEAST_EXPECT(! f1.is_open());
test.BEAST_EXPECT(f2.is_open());
File f3;
f3 = std::move(f2);
test.BOOST_BEAST_EXPECT(! f2.is_open());
test.BOOST_BEAST_EXPECT(f3.is_open());
test.BEAST_EXPECT(! f2.is_open());
test.BEAST_EXPECT(f3.is_open());
f1.close(ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
auto const temp2 = boost::filesystem::unique_path();
f3.open(temp2.string<std::string>().c_str(), file_mode::read, ec);
test.BOOST_BEAST_EXPECT(ec);
test.BEAST_EXPECT(ec);
ec.assign(0, ec.category());
}
boost::filesystem::remove(temp, ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
}
File f;
test.BOOST_BEAST_EXPECT(! f.is_open());
test.BEAST_EXPECT(! f.is_open());
f.size(ec);
test.BOOST_BEAST_EXPECT(ec == errc::invalid_argument);
test.BEAST_EXPECT(ec == errc::invalid_argument);
ec.assign(0, ec.category());
f.pos(ec);
test.BOOST_BEAST_EXPECT(ec == errc::invalid_argument);
test.BEAST_EXPECT(ec == errc::invalid_argument);
ec.assign(0, ec.category());
f.seek(0, ec);
test.BOOST_BEAST_EXPECT(ec == errc::invalid_argument);
test.BEAST_EXPECT(ec == errc::invalid_argument);
ec.assign(0, ec.category());
f.read(nullptr, 0, ec);
test.BOOST_BEAST_EXPECT(ec == errc::invalid_argument);
test.BEAST_EXPECT(ec == errc::invalid_argument);
ec.assign(0, ec.category());
f.write(nullptr, 0, ec);
test.BOOST_BEAST_EXPECT(ec == errc::invalid_argument);
test.BEAST_EXPECT(ec == errc::invalid_argument);
ec.assign(0, ec.category());
f.open(temp.string<std::string>().c_str(), file_mode::write, ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
std::string const s = "Hello, world!";
f.write(s.data(), s.size(), ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
auto size = f.size(ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BOOST_BEAST_EXPECT(size == s.size());
test.BEAST_EXPECT(! ec);
test.BEAST_EXPECT(size == s.size());
auto pos = f.pos(ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BOOST_BEAST_EXPECT(pos == size);
test.BEAST_EXPECT(! ec);
test.BEAST_EXPECT(pos == size);
f.close(ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
f.open(temp.string<std::string>().c_str(), file_mode::read, ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
std::string buf;
buf.resize(s.size());
f.read(&buf[0], buf.size(), ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BOOST_BEAST_EXPECT(buf == s);
test.BEAST_EXPECT(! ec);
test.BEAST_EXPECT(buf == s);
f.seek(1, ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
buf.resize(3);
f.read(&buf[0], buf.size(), ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BOOST_BEAST_EXPECT(buf == "ell");
test.BEAST_EXPECT(! ec);
test.BEAST_EXPECT(buf == "ell");
pos = f.pos(ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BOOST_BEAST_EXPECT(pos == 4);
test.BEAST_EXPECT(! ec);
test.BEAST_EXPECT(pos == 4);
f.close(ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
boost::filesystem::remove(temp, ec);
test.BOOST_BEAST_EXPECT(! ec);
test.BEAST_EXPECT(! ec);
}
} // beast

164
test/core/flat_buffer.cpp
View File

@@ -44,25 +44,25 @@ public:
{
{
flat_buffer b;
BOOST_BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.capacity() == 0);
}
{
flat_buffer b{500};
BOOST_BEAST_EXPECT(b.capacity() == 0);
BOOST_BEAST_EXPECT(b.max_size() == 500);
BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.max_size() == 500);
}
{
a_neq_t a1;
basic_flat_buffer<a_neq_t> b{a1};
BOOST_BEAST_EXPECT(b.get_allocator() == a1);
BEAST_EXPECT(b.get_allocator() == a1);
a_neq_t a2;
BOOST_BEAST_EXPECT(b.get_allocator() != a2);
BEAST_EXPECT(b.get_allocator() != a2);
}
{
a_neq_t a;
basic_flat_buffer<a_neq_t> b{500, a};
BOOST_BEAST_EXPECT(b.capacity() == 0);
BOOST_BEAST_EXPECT(b.max_size() == 500);
BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.max_size() == 500);
}
}
@@ -70,34 +70,34 @@ public:
{
{
basic_flat_buffer<a_t> b1{30};
BOOST_BEAST_EXPECT(b1.get_allocator()->nmove == 0);
BEAST_EXPECT(b1.get_allocator()->nmove == 0);
ostream(b1) << "Hello";
basic_flat_buffer<a_t> b2{std::move(b1)};
BOOST_BEAST_EXPECT(b2.get_allocator()->nmove == 1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size());
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};
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size());
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};
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size());
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());
}
}
@@ -106,34 +106,34 @@ public:
basic_flat_buffer<a_t> b1;
ostream(b1) << "Hello";
basic_flat_buffer<a_t> b2(b1);
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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);
BOOST_BEAST_EXPECT(b2.get_allocator() == a);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b2.get_allocator() == a);
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
// move assignment
@@ -143,9 +143,9 @@ public:
ostream(b1) << "Hello";
flat_buffer b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.capacity() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
using na_t = test::test_allocator<char,
@@ -154,10 +154,10 @@ public:
ostream(b1) << "Hello";
basic_flat_buffer<na_t> b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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,
@@ -166,10 +166,10 @@ public:
ostream(b1) << "Hello";
basic_flat_buffer<na_t> b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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
@@ -179,8 +179,8 @@ public:
ostream(b1) << "Hello";
basic_flat_buffer<pocma_t> b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
// propagate_on_container_move_assignment : false
@@ -190,8 +190,8 @@ public:
ostream(b1) << "Hello";
basic_flat_buffer<pocma_t> b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
}
@@ -202,11 +202,11 @@ public:
ostream(b1) << "Hello";
flat_buffer b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
basic_flat_buffer<a_t> b3;
b3 = b2;
BOOST_BEAST_EXPECT(to_string(b3.data()) == "Hello");
BEAST_EXPECT(to_string(b3.data()) == "Hello");
}
{
// propagate_on_container_copy_assignment : true
@@ -216,7 +216,7 @@ public:
ostream(b1) << "Hello";
basic_flat_buffer<pocca_t> b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
// propagate_on_container_copy_assignment : false
@@ -226,7 +226,7 @@ public:
ostream(b1) << "Hello";
basic_flat_buffer<pocca_t> b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
}
@@ -234,23 +234,23 @@ public:
{
string_view const s = "Hello, world!";
flat_buffer b1{64};
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.max_size() == 64);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.max_size() == 64);
BEAST_EXPECT(b1.capacity() == 0);
ostream(b1) << s;
BOOST_BEAST_EXPECT(to_string(b1.data()) == s);
BEAST_EXPECT(to_string(b1.data()) == s);
{
flat_buffer b2{b1};
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
{
flat_buffer b2{64};
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
}
@@ -260,21 +260,21 @@ public:
ostream(b) << "12345";
b.consume(3);
ostream(b) << "67890123";
BOOST_BEAST_EXPECT(to_string(b.data()) == "4567890123");
BEAST_EXPECT(to_string(b.data()) == "4567890123");
}
// read_size
{
flat_buffer b{10};
BOOST_BEAST_EXPECT(read_size(b, 512) == 10);
BEAST_EXPECT(read_size(b, 512) == 10);
b.prepare(4);
b.commit(4);
BOOST_BEAST_EXPECT(read_size(b, 512) == 6);
BEAST_EXPECT(read_size(b, 512) == 6);
b.consume(2);
BOOST_BEAST_EXPECT(read_size(b, 512) == 8);
BEAST_EXPECT(read_size(b, 512) == 8);
b.prepare(8);
b.commit(8);
BOOST_BEAST_EXPECT(read_size(b, 512) == 0);
BEAST_EXPECT(read_size(b, 512) == 0);
}
// swap
@@ -283,12 +283,12 @@ public:
basic_flat_buffer<a_neq_t> b1;
ostream(b1) << "Hello";
basic_flat_buffer<a_neq_t> b2;
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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,
@@ -298,13 +298,13 @@ public:
na_t a2;
ostream(b1) << "Hello";
basic_flat_buffer<na_t> b2{a2};
BOOST_BEAST_EXPECT(b1.get_allocator() == a1);
BOOST_BEAST_EXPECT(b2.get_allocator() == a2);
BEAST_EXPECT(b1.get_allocator() == a1);
BEAST_EXPECT(b2.get_allocator() == a2);
swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
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");
}
}
@@ -314,7 +314,7 @@ public:
b.prepare(10);
b.commit(10);
b.prepare(5);
BOOST_BEAST_EXPECT(b.capacity() >= 5);
BEAST_EXPECT(b.capacity() >= 5);
try
{
b.prepare(1000);
@@ -329,15 +329,15 @@ public:
// shrink to fit
{
flat_buffer b;
BOOST_BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.capacity() == 0);
b.prepare(50);
BOOST_BEAST_EXPECT(b.capacity() == 50);
BEAST_EXPECT(b.capacity() == 50);
b.commit(50);
BOOST_BEAST_EXPECT(b.capacity() == 50);
BEAST_EXPECT(b.capacity() == 50);
b.prepare(75);
BOOST_BEAST_EXPECT(b.capacity() >= 125);
BEAST_EXPECT(b.capacity() >= 125);
b.shrink_to_fit();
BOOST_BEAST_EXPECT(b.capacity() == b.size());
BEAST_EXPECT(b.capacity() == b.size());
}
}

86
test/core/flat_static_buffer.cpp
View File

@@ -36,7 +36,7 @@ public:
using boost::asio::buffer_size;
char buf[12];
std::string const s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == sizeof(buf));
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) {
@@ -50,79 +50,79 @@ public:
flat_static_buffer<sizeof(buf)> ba;
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
ba.commit(buffer_copy(d, buffer(s.data(), x)));
}
BOOST_BEAST_EXPECT(ba.size() == x);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(ba.size() == x);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
}
ba.commit(1);
BOOST_BEAST_EXPECT(ba.size() == x + y);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(ba.size() == x + y);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
ba.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
}
ba.commit(2);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == buffer_size(ba.mutable_data()));
BOOST_BEAST_EXPECT(ba.size() == x + y + z);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BOOST_BEAST_EXPECT(to_string(ba.data()) == s);
BEAST_EXPECT(buffer_size(ba.data()) == buffer_size(ba.mutable_data()));
BEAST_EXPECT(ba.size() == x + y + z);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(to_string(ba.data()) == s);
ba.consume(t);
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
BOOST_BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
ba.consume(u);
BOOST_BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
ba.consume(v);
BOOST_BEAST_EXPECT(to_string(ba.data()) == "");
BEAST_EXPECT(to_string(ba.data()) == "");
ba.consume(1);
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
try
{
@@ -148,31 +148,31 @@ public:
char buf[64];
flat_static_buffer_base b{buf, sizeof(buf)};
ostream(b) << s;
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
b.consume(b.size());
BOOST_BEAST_EXPECT(to_string(b.data()) == "");
BEAST_EXPECT(to_string(b.data()) == "");
}
// flat_static_buffer
{
flat_static_buffer<64> b1;
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.max_size() == 64);
BOOST_BEAST_EXPECT(b1.capacity() == 64);
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.max_size() == 64);
BEAST_EXPECT(b1.capacity() == 64);
ostream(b1) << s;
BOOST_BEAST_EXPECT(to_string(b1.data()) == s);
BEAST_EXPECT(to_string(b1.data()) == s);
{
flat_static_buffer<64> b2{b1};
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
{
flat_static_buffer<64> b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
}
@@ -182,7 +182,7 @@ public:
write_buffer(b, "12345");
b.consume(3);
write_buffer(b, "67890123");
BOOST_BEAST_EXPECT(to_string(b.data()) == "4567890123");
BEAST_EXPECT(to_string(b.data()) == "4567890123");
try
{
b.prepare(1);
@@ -197,15 +197,15 @@ public:
// read_size
{
flat_static_buffer<10> b;
BOOST_BEAST_EXPECT(read_size(b, 512) == 10);
BEAST_EXPECT(read_size(b, 512) == 10);
b.prepare(4);
b.commit(4);
BOOST_BEAST_EXPECT(read_size(b, 512) == 6);
BEAST_EXPECT(read_size(b, 512) == 6);
b.consume(2);
BOOST_BEAST_EXPECT(read_size(b, 512) == 8);
BEAST_EXPECT(read_size(b, 512) == 8);
b.prepare(8);
b.commit(8);
BOOST_BEAST_EXPECT(read_size(b, 512) == 0);
BEAST_EXPECT(read_size(b, 512) == 0);
}
// base
@@ -213,13 +213,13 @@ public:
flat_static_buffer<10> b;
[&](flat_static_buffer_base& base)
{
BOOST_BEAST_EXPECT(base.max_size() == b.capacity());
BEAST_EXPECT(base.max_size() == b.capacity());
}
(b.base());
[&](flat_static_buffer_base const& base)
{
BOOST_BEAST_EXPECT(base.max_size() == b.capacity());
BEAST_EXPECT(base.max_size() == b.capacity());
}
(b.base());
}

4
test/core/handler_alloc.cpp
View File

@@ -49,9 +49,9 @@ public:
handler h2;
handler_alloc<char, handler> a1{h};
handler_alloc<char, handler> a2{h2};
BOOST_BEAST_EXPECT(a2 == a1);
BEAST_EXPECT(a2 == a1);
auto a3 = a1;
BOOST_BEAST_EXPECT(a3 == a1);
BEAST_EXPECT(a3 == a1);
{
std::vector<char,
handler_alloc<char, handler>> v(a1);

2
test/core/handler_ptr.cpp
View File

@@ -73,7 +73,7 @@ public:
handler_ptr<T, handler> p4{std::move(h)};
bool b = false;
p4.invoke(std::ref(b));
BOOST_BEAST_EXPECT(b);
BEAST_EXPECT(b);
}
};

300
test/core/multi_buffer.cpp
View File

@@ -45,10 +45,10 @@ public:
void
expect_size(std::size_t n, ConstBufferSequence const& buffers)
{
BOOST_BEAST_EXPECT(test::size_pre(buffers) == n);
BOOST_BEAST_EXPECT(test::size_post(buffers) == n);
BOOST_BEAST_EXPECT(test::size_rev_pre(buffers) == n);
BOOST_BEAST_EXPECT(test::size_rev_post(buffers) == n);
BEAST_EXPECT(test::size_pre(buffers) == n);
BEAST_EXPECT(test::size_post(buffers) == n);
BEAST_EXPECT(test::size_rev_pre(buffers) == n);
BEAST_EXPECT(test::size_rev_post(buffers) == n);
}
template<class U, class V>
@@ -65,7 +65,7 @@ public:
using namespace test;
using boost::asio::buffer;
std::string const s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == 12);
BEAST_EXPECT(s.size() == 12);
for(std::size_t i = 1; i < 12; ++i) {
for(std::size_t x = 1; x < 4; ++x) {
for(std::size_t y = 1; y < 4; ++y) {
@@ -75,28 +75,28 @@ public:
b.commit(buffer_copy(b.prepare(x), buffer(s.data(), x)));
b.commit(buffer_copy(b.prepare(y), buffer(s.data()+x, y)));
b.commit(buffer_copy(b.prepare(z), buffer(s.data()+x+y, z)));
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
{
multi_buffer mb2{b};
BOOST_BEAST_EXPECT(eq(b, mb2));
BEAST_EXPECT(eq(b, mb2));
}
{
multi_buffer mb2;
mb2 = b;
BOOST_BEAST_EXPECT(eq(b, mb2));
BEAST_EXPECT(eq(b, mb2));
}
{
multi_buffer mb2{std::move(b)};
BOOST_BEAST_EXPECT(to_string(mb2.data()) == s);
BEAST_EXPECT(to_string(mb2.data()) == s);
expect_size(0, b.data());
b = std::move(mb2);
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
expect_size(0, mb2.data());
}
self_assign(b, b);
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
self_assign(b, std::move(b));
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
}
}}}
}
@@ -108,7 +108,7 @@ public:
using boost::asio::buffer;
using boost::asio::buffer_size;
std::string const s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == 12);
BEAST_EXPECT(s.size() == 12);
for(std::size_t i = 1; i < 12; ++i) {
for(std::size_t x = 1; x < 4; ++x) {
for(std::size_t y = 1; y < 4; ++y) {
@@ -120,78 +120,78 @@ public:
multi_buffer b;
{
auto d = b.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = b.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = b.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = b.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
b.commit(buffer_copy(d, buffer(s.data(), x)));
}
BOOST_BEAST_EXPECT(b.size() == x);
BOOST_BEAST_EXPECT(buffer_size(b.data()) == b.size());
BEAST_EXPECT(b.size() == x);
BEAST_EXPECT(buffer_size(b.data()) == b.size());
{
auto d = b.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = b.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = b.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = b.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
b.commit(buffer_copy(d, buffer(s.data()+x, y)));
}
b.commit(1);
BOOST_BEAST_EXPECT(b.size() == x + y);
BOOST_BEAST_EXPECT(buffer_size(b.data()) == b.size());
BEAST_EXPECT(b.size() == x + y);
BEAST_EXPECT(buffer_size(b.data()) == b.size());
{
auto d = b.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = b.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = b.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = b.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
b.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
}
b.commit(2);
BOOST_BEAST_EXPECT(b.size() == x + y + z);
BOOST_BEAST_EXPECT(buffer_size(b.data()) == b.size());
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(b.size() == x + y + z);
BEAST_EXPECT(buffer_size(b.data()) == b.size());
BEAST_EXPECT(to_string(b.data()) == s);
b.consume(t);
{
auto d = b.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
BOOST_BEAST_EXPECT(to_string(b.data()) == s.substr(t, std::string::npos));
BEAST_EXPECT(to_string(b.data()) == s.substr(t, std::string::npos));
b.consume(u);
BOOST_BEAST_EXPECT(to_string(b.data()) == s.substr(t + u, std::string::npos));
BEAST_EXPECT(to_string(b.data()) == s.substr(t + u, std::string::npos));
b.consume(v);
BOOST_BEAST_EXPECT(to_string(b.data()) == "");
BEAST_EXPECT(to_string(b.data()) == "");
b.consume(1);
{
auto d = b.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
}
}}}}}
@@ -229,18 +229,18 @@ public:
{
{
multi_buffer b;
BOOST_BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.capacity() == 0);
}
{
multi_buffer b{500};
BOOST_BEAST_EXPECT(b.capacity() == 0);
BOOST_BEAST_EXPECT(b.max_size() == 500);
BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.max_size() == 500);
}
{
unequal_t a1;
basic_multi_buffer<unequal_t> b{a1};
BOOST_BEAST_EXPECT(b.get_allocator() == a1);
BOOST_BEAST_EXPECT(b.get_allocator() != unequal_t{});
BEAST_EXPECT(b.get_allocator() == a1);
BEAST_EXPECT(b.get_allocator() != unequal_t{});
}
}
@@ -248,14 +248,14 @@ public:
{
{
basic_multi_buffer<equal_t> b1{30};
BOOST_BEAST_EXPECT(b1.get_allocator()->nmove == 0);
BEAST_EXPECT(b1.get_allocator()->nmove == 0);
ostream(b1) << "Hello";
basic_multi_buffer<equal_t> b2{std::move(b1)};
BOOST_BEAST_EXPECT(b2.get_allocator()->nmove == 1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size());
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());
}
// allocators equal
{
@@ -263,10 +263,10 @@ public:
ostream(b1) << "Hello";
equal_t a;
basic_multi_buffer<equal_t> b2{std::move(b1), a};
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size());
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());
}
{
// allocators unequal
@@ -274,10 +274,10 @@ public:
ostream(b1) << "Hello";
unequal_t a;
basic_multi_buffer<unequal_t> b2{std::move(b1), a};
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size());
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());
}
}
@@ -287,34 +287,34 @@ public:
basic_multi_buffer<equal_t> b1;
ostream(b1) << "Hello";
basic_multi_buffer<equal_t> b2{b1};
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
basic_multi_buffer<unequal_t> b1;
ostream(b1) << "Hello";
unequal_t a;
basic_multi_buffer<unequal_t> b2(b1, a);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
basic_multi_buffer<equal_t> b1;
ostream(b1) << "Hello";
basic_multi_buffer<unequal_t> b2(b1);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
basic_multi_buffer<unequal_t> b1;
ostream(b1) << "Hello";
equal_t a;
basic_multi_buffer<equal_t> b2(b1, a);
BOOST_BEAST_EXPECT(b2.get_allocator() == a);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b2.get_allocator() == a);
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
}
@@ -325,9 +325,9 @@ public:
ostream(b1) << "Hello";
multi_buffer b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.capacity() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
// propagate_on_container_move_assignment : true
@@ -337,8 +337,8 @@ public:
ostream(b1) << "Hello";
basic_multi_buffer<pocma_t> b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
// propagate_on_container_move_assignment : false
@@ -348,8 +348,8 @@ public:
ostream(b1) << "Hello";
basic_multi_buffer<pocma_t> b2;
b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
}
@@ -360,11 +360,11 @@ public:
ostream(b1) << "Hello";
multi_buffer b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
basic_multi_buffer<equal_t> b3;
b3 = b2;
BOOST_BEAST_EXPECT(to_string(b3.data()) == "Hello");
BEAST_EXPECT(to_string(b3.data()) == "Hello");
}
{
// propagate_on_container_copy_assignment : true
@@ -374,7 +374,7 @@ public:
ostream(b1) << "Hello";
basic_multi_buffer<pocca_t> b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
{
// propagate_on_container_copy_assignment : false
@@ -384,7 +384,7 @@ public:
ostream(b1) << "Hello";
basic_multi_buffer<pocca_t> b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(to_string(b2.data()) == "Hello");
}
}
@@ -405,60 +405,60 @@ public:
{
string_view const s = "Hello, world!";
multi_buffer b1{64};
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.max_size() == 64);
BOOST_BEAST_EXPECT(b1.capacity() == 0);
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.max_size() == 64);
BEAST_EXPECT(b1.capacity() == 0);
ostream(b1) << s;
BOOST_BEAST_EXPECT(to_string(b1.data()) == s);
BEAST_EXPECT(to_string(b1.data()) == s);
{
multi_buffer b2{b1};
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
{
multi_buffer b2{64};
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
}
{
multi_buffer b;
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.commit(1);
BOOST_BEAST_EXPECT(b.size() == 1);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.size() == 1);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(1000);
BOOST_BEAST_EXPECT(b.size() == 1);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.size() == 1);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(1500);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
}
{
multi_buffer b;
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.commit(1);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(2000);
BOOST_BEAST_EXPECT(b.capacity() >= 2000);
BEAST_EXPECT(b.capacity() >= 2000);
b.commit(2);
}
{
multi_buffer b;
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(2000);
BOOST_BEAST_EXPECT(b.capacity() >= 2000);
BEAST_EXPECT(b.capacity() >= 2000);
b.prepare(4000);
BOOST_BEAST_EXPECT(b.capacity() >= 4000);
BEAST_EXPECT(b.capacity() >= 4000);
b.prepare(50);
BOOST_BEAST_EXPECT(b.capacity() >= 50);
BEAST_EXPECT(b.capacity() >= 50);
}
}
@@ -466,24 +466,24 @@ public:
{
multi_buffer b;
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.commit(1000);
BOOST_BEAST_EXPECT(b.size() == 1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.size() == 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.consume(1000);
BOOST_BEAST_EXPECT(b.size() == 0);
BOOST_BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.capacity() == 0);
b.prepare(1000);
b.commit(650);
BOOST_BEAST_EXPECT(b.size() == 650);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.size() == 650);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1650);
BEAST_EXPECT(b.capacity() >= 1650);
b.commit(100);
BOOST_BEAST_EXPECT(b.size() == 750);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.size() == 750);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 2000);
BEAST_EXPECT(b.capacity() >= 2000);
b.commit(500);
}
@@ -491,29 +491,29 @@ public:
{
multi_buffer b;
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.commit(1000);
BOOST_BEAST_EXPECT(b.size() == 1000);
BOOST_BEAST_EXPECT(b.capacity() >= 1000);
BEAST_EXPECT(b.size() == 1000);
BEAST_EXPECT(b.capacity() >= 1000);
b.prepare(1000);
BOOST_BEAST_EXPECT(b.capacity() >= 2000);
BEAST_EXPECT(b.capacity() >= 2000);
b.commit(750);
BOOST_BEAST_EXPECT(b.size() == 1750);
BEAST_EXPECT(b.size() == 1750);
b.consume(500);
BOOST_BEAST_EXPECT(b.size() == 1250);
BEAST_EXPECT(b.size() == 1250);
b.consume(500);
BOOST_BEAST_EXPECT(b.size() == 750);
BEAST_EXPECT(b.size() == 750);
b.prepare(250);
b.consume(750);
BOOST_BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.size() == 0);
b.prepare(1000);
b.commit(800);
BOOST_BEAST_EXPECT(b.size() == 800);
BEAST_EXPECT(b.size() == 800);
b.prepare(1000);
b.commit(600);
BOOST_BEAST_EXPECT(b.size() == 1400);
BEAST_EXPECT(b.size() == 1400);
b.consume(1400);
BOOST_BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(b.size() == 0);
}
// swap
@@ -523,60 +523,60 @@ public:
using pocs_t = test::test_allocator<char,
false, true, true, true, true>;
pocs_t a1, a2;
BOOST_BEAST_EXPECT(a1 != a2);
BEAST_EXPECT(a1 != a2);
basic_multi_buffer<pocs_t> b1{a1};
ostream(b1) << "Hello";
basic_multi_buffer<pocs_t> b2{a2};
BOOST_BEAST_EXPECT(b1.get_allocator() == a1);
BOOST_BEAST_EXPECT(b2.get_allocator() == a2);
BEAST_EXPECT(b1.get_allocator() == a1);
BEAST_EXPECT(b2.get_allocator() == a2);
swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator() == a2);
BOOST_BEAST_EXPECT(b2.get_allocator() == a1);
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.get_allocator() == a2);
BEAST_EXPECT(b2.get_allocator() == a1);
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator() == a1);
BOOST_BEAST_EXPECT(b2.get_allocator() == a2);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(b2.size() == 0);
BEAST_EXPECT(b1.get_allocator() == a1);
BEAST_EXPECT(b2.get_allocator() == a2);
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(b2.size() == 0);
}
{
// propagate_on_container_swap : false
using pocs_t = test::test_allocator<char,
true, true, true, false, true>;
pocs_t a1, a2;
BOOST_BEAST_EXPECT(a1 == a2);
BOOST_BEAST_EXPECT(a1.id() != a2.id());
BEAST_EXPECT(a1 == a2);
BEAST_EXPECT(a1.id() != a2.id());
basic_multi_buffer<pocs_t> b1{a1};
ostream(b1) << "Hello";
basic_multi_buffer<pocs_t> b2{a2};
BOOST_BEAST_EXPECT(b1.get_allocator() == a1);
BOOST_BEAST_EXPECT(b2.get_allocator() == a2);
BEAST_EXPECT(b1.get_allocator() == a1);
BEAST_EXPECT(b2.get_allocator() == a2);
swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator().id() == a1.id());
BOOST_BEAST_EXPECT(b2.get_allocator().id() == a2.id());
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello");
BEAST_EXPECT(b1.get_allocator().id() == a1.id());
BEAST_EXPECT(b2.get_allocator().id() == a2.id());
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(to_string(b2.data()) == "Hello");
swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator().id() == a1.id());
BOOST_BEAST_EXPECT(b2.get_allocator().id() == a2.id());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(b2.size() == 0);
BEAST_EXPECT(b1.get_allocator().id() == a1.id());
BEAST_EXPECT(b2.get_allocator().id() == a2.id());
BEAST_EXPECT(to_string(b1.data()) == "Hello");
BEAST_EXPECT(b2.size() == 0);
}
}
// read_size
{
multi_buffer b{10};
BOOST_BEAST_EXPECT(read_size(b, 512) == 10);
BEAST_EXPECT(read_size(b, 512) == 10);
b.prepare(4);
b.commit(4);
BOOST_BEAST_EXPECT(read_size(b, 512) == 6);
BEAST_EXPECT(read_size(b, 512) == 6);
b.consume(2);
BOOST_BEAST_EXPECT(read_size(b, 512) == 8);
BEAST_EXPECT(read_size(b, 512) == 8);
b.prepare(8);
b.commit(8);
BOOST_BEAST_EXPECT(read_size(b, 512) == 0);
BEAST_EXPECT(read_size(b, 512) == 0);
}
}

4
test/core/ostream.cpp
View File

@@ -43,7 +43,7 @@ public:
auto os = ostream(b);
os << "Hello, world!\n";
os.flush();
BOOST_BEAST_EXPECT(to_string(b.data()) == "Hello, world!\n");
BEAST_EXPECT(to_string(b.data()) == "Hello, world!\n");
auto os2 = std::move(os);
}
{
@@ -58,7 +58,7 @@ public:
"0123456789abcdef" "0123456789abcdef" "0123456789abcdef" "0123456789abcdef";
multi_buffer b;
ostream(b) << s;
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
}
}
};

2
test/core/sha1.cpp
View File

@@ -57,7 +57,7 @@ public:
init(ctx);
update(ctx, message.data(), message.size());
finish(ctx, &result[0]);
BOOST_BEAST_EXPECT(result == digest);
BEAST_EXPECT(result == digest);
}
void

2
test/core/span.cpp
View File

@@ -42,7 +42,7 @@ public:
testSpan()
{
span<char const> sp{"hello", 5};
BOOST_BEAST_EXPECT(sp.size() == 5);
BEAST_EXPECT(sp.size() == 5);
std::string s("world");
sp = s;
}

86
test/core/static_buffer.cpp
View File

@@ -36,7 +36,7 @@ public:
using boost::asio::buffer_size;
char buf[12];
std::string const s = "Hello, world";
BOOST_BEAST_EXPECT(s.size() == sizeof(buf));
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) {
@@ -50,79 +50,79 @@ public:
static_buffer<sizeof(buf)> ba;
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
ba.commit(buffer_copy(d, buffer(s.data(), x)));
}
BOOST_BEAST_EXPECT(ba.size() == x);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(ba.size() == x);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
}
ba.commit(1);
BOOST_BEAST_EXPECT(ba.size() == x + y);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(ba.size() == x + y);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{
auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_size(d) == x);
}
{
auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_size(d) == y);
}
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
{
auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_size(d) == z);
ba.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
}
ba.commit(2);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == buffer_size(ba.mutable_data()));
BOOST_BEAST_EXPECT(ba.size() == x + y + z);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BOOST_BEAST_EXPECT(to_string(ba.data()) == s);
BEAST_EXPECT(buffer_size(ba.data()) == buffer_size(ba.mutable_data()));
BEAST_EXPECT(ba.size() == x + y + z);
BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BEAST_EXPECT(to_string(ba.data()) == s);
ba.consume(t);
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
BOOST_BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
ba.consume(u);
BOOST_BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
ba.consume(v);
BOOST_BEAST_EXPECT(to_string(ba.data()) == "");
BEAST_EXPECT(to_string(ba.data()) == "");
ba.consume(1);
{
auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_size(d) == 0);
}
try
{
@@ -148,31 +148,31 @@ public:
char buf[64];
static_buffer_base b{buf, sizeof(buf)};
ostream(b) << s;
BOOST_BEAST_EXPECT(to_string(b.data()) == s);
BEAST_EXPECT(to_string(b.data()) == s);
b.consume(b.size());
BOOST_BEAST_EXPECT(to_string(b.data()) == "");
BEAST_EXPECT(to_string(b.data()) == "");
}
// static_buffer
{
static_buffer<64> b1;
BOOST_BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.max_size() == 64);
BOOST_BEAST_EXPECT(b1.capacity() == 64);
BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.max_size() == 64);
BEAST_EXPECT(b1.capacity() == 64);
ostream(b1) << s;
BOOST_BEAST_EXPECT(to_string(b1.data()) == s);
BEAST_EXPECT(to_string(b1.data()) == s);
{
static_buffer<64> b2{b1};
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
{
static_buffer<64> b2;
b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == s);
BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7);
BOOST_BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
BEAST_EXPECT(to_string(b2.data()) == s.substr(7));
}
}
@@ -182,7 +182,7 @@ public:
write_buffer(b, "12345");
b.consume(3);
write_buffer(b, "67890123");
BOOST_BEAST_EXPECT(to_string(b.data()) == "4567890123");
BEAST_EXPECT(to_string(b.data()) == "4567890123");
try
{
b.prepare(1);
@@ -197,15 +197,15 @@ public:
// read_size
{
static_buffer<10> b;
BOOST_BEAST_EXPECT(read_size(b, 512) == 10);
BEAST_EXPECT(read_size(b, 512) == 10);
b.prepare(4);
b.commit(4);
BOOST_BEAST_EXPECT(read_size(b, 512) == 6);
BEAST_EXPECT(read_size(b, 512) == 6);
b.consume(2);
BOOST_BEAST_EXPECT(read_size(b, 512) == 8);
BEAST_EXPECT(read_size(b, 512) == 8);
b.prepare(8);
b.commit(8);
BOOST_BEAST_EXPECT(read_size(b, 512) == 0);
BEAST_EXPECT(read_size(b, 512) == 0);
}
// base
@@ -213,13 +213,13 @@ public:
static_buffer<10> b;
[&](static_buffer_base& base)
{
BOOST_BEAST_EXPECT(base.max_size() == b.capacity());
BEAST_EXPECT(base.max_size() == b.capacity());
}
(b.base());
[&](static_buffer_base const& base)
{
BOOST_BEAST_EXPECT(base.max_size() == b.capacity());
BEAST_EXPECT(base.max_size() == b.capacity());
}
(b.base());
}

692
test/core/static_string.cpp
View File

File diff suppressed because it is too large Load Diff

2
test/core/string_param.cpp
View File

@@ -24,7 +24,7 @@ public:
void
check(string_param const& v, string_view s)
{
BOOST_BEAST_EXPECT(static_cast<string_view>(v) == s);
BEAST_EXPECT(static_cast<string_view>(v) == s);
}
class repeater

178
test/http/basic_parser.cpp
View File

@@ -55,7 +55,7 @@ public:
void
operator()(Parser const& p) const
{
s_.BOOST_BEAST_EXPECT(p.version == version_);
s_.BEAST_EXPECT(p.version == version_);
}
};
@@ -75,7 +75,7 @@ public:
void
operator()(Parser const& p) const
{
s_.BOOST_BEAST_EXPECT(p.status == status_);
s_.BEAST_EXPECT(p.status == status_);
}
};
@@ -96,13 +96,13 @@ public:
operator()(Parser const& p) const
{
if(flags_ & parse_flag::chunked)
s_.BOOST_BEAST_EXPECT(p.is_chunked());
s_.BEAST_EXPECT(p.is_chunked());
if(flags_ & parse_flag::connection_keep_alive)
s_.BOOST_BEAST_EXPECT(p.is_keep_alive());
s_.BEAST_EXPECT(p.is_keep_alive());
if(flags_ & parse_flag::connection_close)
s_.BOOST_BEAST_EXPECT(! p.is_keep_alive());
s_.BEAST_EXPECT(! p.is_keep_alive());
if(flags_ & parse_flag::upgrade)
s_.BOOST_BEAST_EXPECT(! p.is_upgrade());
s_.BEAST_EXPECT(! p.is_upgrade());
}
};
@@ -122,7 +122,7 @@ public:
void
operator()(Parser const& p) const
{
s_.BOOST_BEAST_EXPECT(p.is_keep_alive() == v_);
s_.BEAST_EXPECT(p.is_keep_alive() == v_);
}
};
@@ -144,7 +144,7 @@ public:
void
operator()(Parser const& p) const
{
s_.BOOST_BEAST_EXPECT(p.body == body_);
s_.BEAST_EXPECT(p.body == body_);
}
};
@@ -165,24 +165,24 @@ public:
error_code ec;
consuming_buffers<ConstBufferSequence> cb{buffers};
auto n = p.put(buffer_prefix(i, cb), ec);
if(! BOOST_BEAST_EXPECTS(! ec ||
if(! BEAST_EXPECTS(! ec ||
ec == error::need_more, ec.message()))
continue;
if(! BOOST_BEAST_EXPECT(! p.is_done()))
if(! BEAST_EXPECT(! p.is_done()))
continue;
cb.consume(n);
n = p.put(cb, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
if(! BOOST_BEAST_EXPECT(n == boost::asio::buffer_size(cb)))
if(! BEAST_EXPECT(n == boost::asio::buffer_size(cb)))
continue;
if(p.need_eof())
{
p.put_eof(ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
}
if(! BOOST_BEAST_EXPECT(p.is_done()))
if(! BEAST_EXPECT(p.is_done()))
continue;
test(p);
}
@@ -195,14 +195,14 @@ public:
cb.consume(i);
auto n = p.put(buffer_cat(
buffer_prefix(i, buffers), cb), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
if(! BOOST_BEAST_EXPECT(n == size))
if(! BEAST_EXPECT(n == size))
continue;
if(p.need_eof())
{
p.put_eof(ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
}
test(p);
@@ -249,16 +249,16 @@ public:
pass();
continue;
}
if(! BOOST_BEAST_EXPECTS(
if(! BEAST_EXPECTS(
ec == error::need_more, ec.message()))
continue;
if(! BOOST_BEAST_EXPECT(! p.is_done()))
if(! BEAST_EXPECT(! p.is_done()))
continue;
cb.consume(n);
n = p.put(cb, ec);
if(! ec)
p.put_eof(ec);
BOOST_BEAST_EXPECTS(ec == result, ec.message());
BEAST_EXPECTS(ec == result, ec.message());
}
for(std::size_t i = 1; i < msg.size() - 1; ++i)
{
@@ -271,7 +271,7 @@ public:
msg.data() + i, msg.size() - i}), ec);
if(! ec)
p.put_eof(ec);
BOOST_BEAST_EXPECTS(ec == result, ec.message());
BEAST_EXPECTS(ec == result, ec.message());
}
}
@@ -328,7 +328,7 @@ public:
parsegrind<parser<true, string_body>>(m,
[&](parser<true, string_body> const& p)
{
BOOST_BEAST_EXPECT(p.get()["f"] == value);
BEAST_EXPECT(p.get()["f"] == value);
});
};
check("x", "x");
@@ -369,12 +369,12 @@ public:
"*",
[&](test_parser<true> const& p)
{
BOOST_BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 0);
BOOST_BEAST_EXPECT(p.got_on_complete == 1);
BEAST_EXPECT(p.got_on_begin == 1);
BEAST_EXPECT(p.got_on_field == 2);
BEAST_EXPECT(p.got_on_header == 1);
BEAST_EXPECT(p.got_on_body == 1);
BEAST_EXPECT(p.got_on_chunk == 0);
BEAST_EXPECT(p.got_on_complete == 1);
});
parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n"
@@ -384,12 +384,12 @@ public:
"*",
[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 0);
BOOST_BEAST_EXPECT(p.got_on_complete == 1);
BEAST_EXPECT(p.got_on_begin == 1);
BEAST_EXPECT(p.got_on_field == 2);
BEAST_EXPECT(p.got_on_header == 1);
BEAST_EXPECT(p.got_on_body == 1);
BEAST_EXPECT(p.got_on_chunk == 0);
BEAST_EXPECT(p.got_on_complete == 1);
});
parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n"
@@ -400,12 +400,12 @@ public:
"0\r\n\r\n",
[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 2);
BOOST_BEAST_EXPECT(p.got_on_complete == 1);
BEAST_EXPECT(p.got_on_begin == 1);
BEAST_EXPECT(p.got_on_field == 2);
BEAST_EXPECT(p.got_on_header == 1);
BEAST_EXPECT(p.got_on_body == 1);
BEAST_EXPECT(p.got_on_chunk == 2);
BEAST_EXPECT(p.got_on_complete == 1);
});
parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n"
@@ -416,12 +416,12 @@ public:
"0\r\n\r\n",
[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 2);
BOOST_BEAST_EXPECT(p.got_on_complete == 1);
BEAST_EXPECT(p.got_on_begin == 1);
BEAST_EXPECT(p.got_on_field == 2);
BEAST_EXPECT(p.got_on_header == 1);
BEAST_EXPECT(p.got_on_body == 1);
BEAST_EXPECT(p.got_on_chunk == 2);
BEAST_EXPECT(p.got_on_complete == 1);
});
}
@@ -673,8 +673,8 @@ public:
parsegrind<P>(c(s),
[&](P const& p)
{
BOOST_BEAST_EXPECT(p.content_length());
BOOST_BEAST_EXPECT(p.content_length() && *p.content_length() == v);
BEAST_EXPECT(p.content_length());
BEAST_EXPECT(p.content_length() && *p.content_length() == v);
}, true);
};
@@ -784,7 +784,7 @@ public:
"\r\n",
[&](P const& p)
{
BOOST_BEAST_EXPECT(p.is_upgrade());
BEAST_EXPECT(p.is_upgrade());
});
}
@@ -808,17 +808,17 @@ public:
"\r\n",
[&](test_parser<true> const& p)
{
BOOST_BEAST_EXPECT(p.fields.size() == 10);
BOOST_BEAST_EXPECT(p.fields.at("a") == "0");
BOOST_BEAST_EXPECT(p.fields.at("b") == "1");
BOOST_BEAST_EXPECT(p.fields.at("c") == "2");
BOOST_BEAST_EXPECT(p.fields.at("d") == "3");
BOOST_BEAST_EXPECT(p.fields.at("e") == "4");
BOOST_BEAST_EXPECT(p.fields.at("f") == "5");
BOOST_BEAST_EXPECT(p.fields.at("g") == "6");
BOOST_BEAST_EXPECT(p.fields.at("h") == "7");
BOOST_BEAST_EXPECT(p.fields.at("i") == "8");
BOOST_BEAST_EXPECT(p.fields.at("j") == "9");
BEAST_EXPECT(p.fields.size() == 10);
BEAST_EXPECT(p.fields.at("a") == "0");
BEAST_EXPECT(p.fields.at("b") == "1");
BEAST_EXPECT(p.fields.at("c") == "2");
BEAST_EXPECT(p.fields.at("d") == "3");
BEAST_EXPECT(p.fields.at("e") == "4");
BEAST_EXPECT(p.fields.at("f") == "5");
BEAST_EXPECT(p.fields.at("g") == "6");
BEAST_EXPECT(p.fields.at("h") == "7");
BEAST_EXPECT(p.fields.at("i") == "8");
BEAST_EXPECT(p.fields.at("j") == "9");
});
}
@@ -837,7 +837,7 @@ public:
p.header_limit(10);
p.eager(true);
p.put(b.data(), ec);
BOOST_BEAST_EXPECTS(ec == error::header_limit, ec.message());
BEAST_EXPECTS(ec == error::header_limit, ec.message());
}
{
multi_buffer b;
@@ -851,7 +851,7 @@ public:
p.body_limit(1);
p.eager(true);
p.put(b.data(), ec);
BOOST_BEAST_EXPECTS(ec == error::body_limit, ec.message());
BEAST_EXPECTS(ec == error::body_limit, ec.message());
}
{
multi_buffer b;
@@ -864,7 +864,7 @@ public:
p.body_limit(1);
p.eager(true);
p.put(b.data(), ec);
BOOST_BEAST_EXPECTS(ec == error::body_limit, ec.message());
BEAST_EXPECTS(ec == error::body_limit, ec.message());
}
{
multi_buffer b;
@@ -880,7 +880,7 @@ public:
p.body_limit(1);
p.eager(true);
p.put(b.data(), ec);
BOOST_BEAST_EXPECTS(ec == error::body_limit, ec.message());
BEAST_EXPECTS(ec == error::body_limit, ec.message());
}
}
@@ -914,7 +914,7 @@ public:
"0\r\n\r\n"
,[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.body == "abcd");
BEAST_EXPECT(p.body == "abcd");
});
parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n"
@@ -932,7 +932,7 @@ public:
"\r\n"
,[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.body == "*****--");
BEAST_EXPECT(p.body == "*****--");
});
parsegrind<test_parser<true>>(
@@ -965,8 +965,8 @@ public:
"GET / HTTP/1.0\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
{
error_code ec;
@@ -975,8 +975,8 @@ public:
"GET / HTTP/1.1\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
// response without Content-Length or
@@ -988,9 +988,9 @@ public:
"HTTP/1.0 200 OK\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(! p.is_done());
BOOST_BEAST_EXPECT(p.need_eof());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(! p.is_done());
BEAST_EXPECT(p.need_eof());
}
// 304 "Not Modified" response does not require eof
@@ -1001,8 +1001,8 @@ public:
"HTTP/1.0 304 Not Modified\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
// Chunked response does not require eof
@@ -1014,13 +1014,13 @@ public:
"Transfer-Encoding: chunked\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(! p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(! p.is_done());
feed(buf(
"0\r\n\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
// restart: 1.0 assumes Connection: close
@@ -1031,8 +1031,8 @@ public:
"GET / HTTP/1.0\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
// restart: 1.1 assumes Connection: keep-alive
@@ -1043,8 +1043,8 @@ public:
"GET / HTTP/1.1\r\n"
"\r\n"
), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
failgrind<test_parser<true>>(
@@ -1082,9 +1082,9 @@ public:
"die!";
p.put(boost::asio::buffer(
s.data(), s.size()), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECT(p.is_done());
}
// https://github.com/vinniefalco/Beast/issues/496
@@ -1102,7 +1102,7 @@ public:
"0\r\n\r\n"
,[&](P const& p)
{
BOOST_BEAST_EXPECT(p.body == "abcd");
BEAST_EXPECT(p.body == "abcd");
});
}
@@ -1140,7 +1140,7 @@ public:
p.eager(true);
p.put(boost::asio::const_buffers_1{
msg.data(), msg.size()}, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
grind(msg);
};
auto const bad =
@@ -1157,7 +1157,7 @@ public:
p.eager(true);
p.put(boost::asio::const_buffers_1{
msg.data(), msg.size()}, ec);
BOOST_BEAST_EXPECT(ec);
BEAST_EXPECT(ec);
grind(msg);
};
chunkExtensionsTest(good, bad);
@@ -1192,7 +1192,7 @@ public:
error_code ec;
test_parser<true> p;
feed(boost::asio::buffer(buf, sizeof(buf)), p, ec);
BOOST_BEAST_EXPECT(ec);
BEAST_EXPECT(ec);
}
//--------------------------------------------------------------------------

40
test/http/chunk_encode.cpp
View File

@@ -54,11 +54,11 @@ public:
check(string_view match, Args&&... args)
{
T t{std::forward<Args>(args)...};
BOOST_BEAST_EXPECT(to_string(t) == match);
BEAST_EXPECT(to_string(t) == match);
T t2{t};
BOOST_BEAST_EXPECT(to_string(t2) == match);
BEAST_EXPECT(to_string(t2) == match);
T t3{std::move(t2)};
BOOST_BEAST_EXPECT(to_string(t3) == match);
BEAST_EXPECT(to_string(t3) == match);
}
template<class T, class... Args>
@@ -66,11 +66,11 @@ public:
check_fwd(string_view match, Args&&... args)
{
T t{std::forward<Args>(args)...};
BOOST_BEAST_EXPECT(to_string(t) == match);
BEAST_EXPECT(to_string(t) == match);
T t2{t};
BOOST_BEAST_EXPECT(to_string(t2) == match);
BEAST_EXPECT(to_string(t2) == match);
T t3{std::move(t2)};
BOOST_BEAST_EXPECT(to_string(t3) == match);
BEAST_EXPECT(to_string(t3) == match);
}
using cb_t = boost::asio::const_buffers_1;
@@ -220,20 +220,20 @@ public:
};
chunk_extensions ce;
ce.insert("x");
BOOST_BEAST_EXPECT(ce.str() == ";x");
BOOST_BEAST_EXPECT(str(ce) == "x,");
BEAST_EXPECT(ce.str() == ";x");
BEAST_EXPECT(str(ce) == "x,");
ce.insert("y", "z");
BOOST_BEAST_EXPECT(ce.str() == ";x;y=z");
BOOST_BEAST_EXPECT(str(ce) == "x,y,z,");
BEAST_EXPECT(ce.str() == ";x;y=z");
BEAST_EXPECT(str(ce) == "x,y,z,");
ce.insert("z", R"(")");
BOOST_BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"")");
BOOST_BEAST_EXPECT(str(ce) == R"(x,y,z,z,",)");
BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"")");
BEAST_EXPECT(str(ce) == R"(x,y,z,z,",)");
ce.insert("p", R"(\)");
BOOST_BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\")");
BOOST_BEAST_EXPECT(str(ce) == R"(x,y,z,z,",p,\,)");
BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\")");
BEAST_EXPECT(str(ce) == R"(x,y,z,z,",p,\,)");
ce.insert("q", R"(1"2\)");
BOOST_BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\";q="1\"2\\")");
BOOST_BEAST_EXPECT(str(ce) == R"(x,y,z,z,",p,\,q,1"2\,)");
BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\";q="1\"2\\")");
BEAST_EXPECT(str(ce) == R"(x,y,z,z,",p,\,q,1"2\,)");
}
void
@@ -259,7 +259,7 @@ public:
}
chunk_extensions c2;
c2.parse(c1.str(), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
chunk_extensions c3;
for(auto const& v : c2)
@@ -267,7 +267,7 @@ public:
c3.insert(v.first);
else
c3.insert(v.first, v.second);
BOOST_BEAST_EXPECTS(c2.str() == c3.str(), c3.str());
BEAST_EXPECTS(c2.str() == c3.str(), c3.str());
});
}
};
@@ -277,7 +277,7 @@ public:
error_code ec;
chunk_extensions ce;
ce.parse(s, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
grind(s);
};
auto const bad =
@@ -286,7 +286,7 @@ public:
error_code ec;
chunk_extensions ce;
ce.parse(s, ec);
BOOST_BEAST_EXPECT(ec);
BEAST_EXPECT(ec);
grind(s);
};
chunkExtensionsTest(good, bad);

42
test/http/doc_examples.cpp
View File

@@ -100,7 +100,7 @@ public:
flat_buffer buffer;
receive_expect_100_continue(
p.server, buffer, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
},
[&](yield_context)
{
@@ -116,7 +116,7 @@ public:
error_code ec;
send_expect_100_continue(
p.client, buffer, req, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
});
}
@@ -131,8 +131,8 @@ public:
test::pipe p{ios_};
error_code ec;
send_cgi_response(child.server, p.client, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(equal_body<false>(p.server.str(), s));
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(equal_body<false>(p.server.str(), s));
}
void
@@ -153,7 +153,7 @@ public:
error_code ec;
write(downstream.client, req);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
downstream.client.close();
flat_buffer buffer;
@@ -164,8 +164,8 @@ public:
h.erase("Content-Length");
h.set("Transfer-Encoding", "chunked");
});
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(equal_body<true>(
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(equal_body<true>(
upstream.server.str(), req.body));
}
@@ -182,8 +182,8 @@ public:
flat_buffer buffer;
response<string_body> res;
read_istream(is, buffer, res, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(to_string(res) == s);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(to_string(res) == s);
}
void
@@ -197,8 +197,8 @@ public:
req.insert(field::user_agent, "test");
error_code ec;
write_ostream(os, req, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(to_string(req) == os.str());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(to_string(req) == os.str());
}
void
@@ -216,7 +216,7 @@ public:
custom_parser<true> p;
p.put(boost::asio::buffer(
s.data(), s.size()), ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
}
{
string_view s{
@@ -233,7 +233,7 @@ public:
custom_parser<false> p;
p.put(boost::asio::buffer(
s.data(), s.size()), ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
}
}
@@ -247,14 +247,14 @@ public:
error_code ec;
flat_buffer buffer;
do_server_head(p.server, buffer, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
},
[&](yield_context)
{
error_code ec;
flat_buffer buffer;
auto res = do_head_request(p.client, buffer, "/", ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
});
}
@@ -290,7 +290,7 @@ public:
handler h;
flat_buffer buffer;
do_form_request(p.server, buffer, h);
BOOST_BEAST_EXPECT(h.body == "Hello, world!");
BEAST_EXPECT(h.body == "Hello, world!");
}
//--------------------------------------------------------------------------
@@ -310,8 +310,8 @@ public:
flat_buffer b;
std::stringstream ss;
read_and_print_body<false>(ss, c.server, b, ec);
if(BOOST_BEAST_EXPECTS(! ec, ec.message()))
BOOST_BEAST_EXPECT(ss.str() == s);
if(BEAST_EXPECTS(! ec, ec.message()))
BEAST_EXPECT(ss.str() == s);
}
//--------------------------------------------------------------------------
@@ -366,7 +366,7 @@ public:
trailers,
std::allocator<double>{}
), ec);
BOOST_BEAST_EXPECT(
BEAST_EXPECT(
to_string(p.server.buffer.data()) ==
"HTTP/1.1 200 OK\r\n"
"Server: test\r\n"
@@ -417,8 +417,8 @@ public:
flat_buffer b;
std::stringstream ss;
print_chunked_body<false>(ss, c.client, b, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(ss.str() ==
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(ss.str() ==
"Chunk Body: First\n"
"Extension: quality = 1.0\n"
"Chunk Body: Hello, world!\n"

4
test/http/dynamic_body.cpp
View File

@@ -66,8 +66,8 @@ public:
multi_buffer b;
read(ss, b, p);
auto const& m = p.get();
BOOST_BEAST_EXPECT(to_string(m.body.data()) == "xyz");
BOOST_BEAST_EXPECT(to_string(m) == s);
BEAST_EXPECT(to_string(m.body.data()) == "xyz");
BEAST_EXPECT(to_string(m) == s);
}
};

10
test/http/error.cpp
View File

@@ -24,15 +24,15 @@ public:
check(char const* name, error ev)
{
auto const ec = make_error_code(ev);
BOOST_BEAST_EXPECT(std::string(ec.category().name()) == name);
BOOST_BEAST_EXPECT(! ec.message().empty());
BOOST_BEAST_EXPECT(std::addressof(ec.category()) ==
BEAST_EXPECT(std::string(ec.category().name()) == name);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(std::addressof(ec.category()) ==
std::addressof(detail::get_http_error_category()));
BOOST_BEAST_EXPECT(detail::get_http_error_category().equivalent(
BEAST_EXPECT(detail::get_http_error_category().equivalent(
static_cast<std::underlying_type<error>::type>(ev),
ec.category().default_error_condition(
static_cast<std::underlying_type<error>::type>(ev))));
BOOST_BEAST_EXPECT(detail::get_http_error_category().equivalent(
BEAST_EXPECT(detail::get_http_error_category().equivalent(
ec, static_cast<std::underlying_type<error>::type>(ev)));
}

6
test/http/field.cpp
View File

@@ -25,8 +25,8 @@ public:
auto const match =
[&](field f, string_view s)
{
BOOST_BEAST_EXPECT(iequals(to_string(f), s));
BOOST_BEAST_EXPECT(string_to_field(s) == f);
BEAST_EXPECT(iequals(to_string(f), s));
BEAST_EXPECT(string_to_field(s) == f);
};
match(field::accept, "accept");
@@ -389,7 +389,7 @@ public:
auto const unknown =
[&](string_view s)
{
BOOST_BEAST_EXPECT(string_to_field(s) == field::unknown);
BEAST_EXPECT(string_to_field(s) == field::unknown);
};
unknown("");
unknown("x");

454
test/http/fields.cpp
View File

@@ -81,13 +81,13 @@ public:
{
{
fields f;
BOOST_BEAST_EXPECT(f.begin() == f.end());
BEAST_EXPECT(f.begin() == f.end());
}
{
unequal_t a1;
basic_fields<unequal_t> f{a1};
BOOST_BEAST_EXPECT(f.get_allocator() == a1);
BOOST_BEAST_EXPECT(f.get_allocator() != unequal_t{});
BEAST_EXPECT(f.get_allocator() == a1);
BEAST_EXPECT(f.get_allocator() != unequal_t{});
}
}
@@ -95,13 +95,13 @@ public:
{
{
basic_fields<equal_t> f1;
BOOST_BEAST_EXPECT(f1.get_allocator()->nmove == 0);
BEAST_EXPECT(f1.get_allocator()->nmove == 0);
f1.insert("1", "1");
BOOST_BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f1["1"] == "1");
basic_fields<equal_t> f2{std::move(f1)};
BOOST_BEAST_EXPECT(f2.get_allocator()->nmove == 1);
BOOST_BEAST_EXPECT(f2["1"] == "1");
BOOST_BEAST_EXPECT(f1["1"] == "");
BEAST_EXPECT(f2.get_allocator()->nmove == 1);
BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1["1"] == "");
}
// allocators equal
{
@@ -109,8 +109,8 @@ public:
f1.insert("1", "1");
equal_t a;
basic_fields<equal_t> f2{std::move(f1), a};
BOOST_BEAST_EXPECT(f2["1"] == "1");
BOOST_BEAST_EXPECT(f1["1"] == "");
BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1["1"] == "");
}
{
// allocators unequal
@@ -118,7 +118,7 @@ public:
f1.insert("1", "1");
unequal_t a;
basic_fields<unequal_t> f2{std::move(f1), a};
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
}
@@ -128,34 +128,34 @@ public:
basic_fields<equal_t> f1;
f1.insert("1", "1");
basic_fields<equal_t> f2{f1};
BOOST_BEAST_EXPECT(f1.get_allocator() == f2.get_allocator());
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.get_allocator() == f2.get_allocator());
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
{
basic_fields<unequal_t> f1;
f1.insert("1", "1");
unequal_t a;
basic_fields<unequal_t> f2(f1, a);
BOOST_BEAST_EXPECT(f1.get_allocator() != f2.get_allocator());
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.get_allocator() != f2.get_allocator());
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
{
basic_fields<equal_t> f1;
f1.insert("1", "1");
basic_fields<unequal_t> f2(f1);
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
{
basic_fields<unequal_t> f1;
f1.insert("1", "1");
equal_t a;
basic_fields<equal_t> f2(f1, a);
BOOST_BEAST_EXPECT(f2.get_allocator() == a);
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f2.get_allocator() == a);
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
}
@@ -166,8 +166,8 @@ public:
f1.insert("1", "1");
fields f2;
f2 = std::move(f1);
BOOST_BEAST_EXPECT(f1.begin() == f1.end());
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.begin() == f1.end());
BEAST_EXPECT(f2["1"] == "1");
}
{
// propagate_on_container_move_assignment : true
@@ -177,8 +177,8 @@ public:
f1.insert("1", "1");
basic_fields<pocma_t> f2;
f2 = std::move(f1);
BOOST_BEAST_EXPECT(f1.begin() == f1.end());
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.begin() == f1.end());
BEAST_EXPECT(f2["1"] == "1");
}
{
// propagate_on_container_move_assignment : false
@@ -188,8 +188,8 @@ public:
f1.insert("1", "1");
basic_fields<pocma_t> f2;
f2 = std::move(f1);
BOOST_BEAST_EXPECT(f1.begin() == f1.end());
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.begin() == f1.end());
BEAST_EXPECT(f2["1"] == "1");
}
}
@@ -200,11 +200,11 @@ public:
f1.insert("1", "1");
fields f2;
f2 = f1;
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
basic_fields<equal_t> f3;
f3 = f2;
BOOST_BEAST_EXPECT(f3["1"] == "1");
BEAST_EXPECT(f3["1"] == "1");
}
{
// propagate_on_container_copy_assignment : true
@@ -214,7 +214,7 @@ public:
f1.insert("1", "1");
basic_fields<pocca_t> f2;
f2 = f1;
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
{
// propagate_on_container_copy_assignment : false
@@ -224,7 +224,7 @@ public:
f1.insert("1", "1");
basic_fields<pocca_t> f2;
f2 = f1;
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f2["1"] == "1");
}
}
@@ -235,45 +235,45 @@ public:
using pocs_t = test::test_allocator<char,
false, true, true, true, true>;
pocs_t a1, a2;
BOOST_BEAST_EXPECT(a1 != a2);
BEAST_EXPECT(a1 != a2);
basic_fields<pocs_t> f1{a1};
f1.insert("1", "1");
basic_fields<pocs_t> f2{a2};
BOOST_BEAST_EXPECT(f1.get_allocator() == a1);
BOOST_BEAST_EXPECT(f2.get_allocator() == a2);
BEAST_EXPECT(f1.get_allocator() == a1);
BEAST_EXPECT(f2.get_allocator() == a2);
swap(f1, f2);
BOOST_BEAST_EXPECT(f1.get_allocator() == a2);
BOOST_BEAST_EXPECT(f2.get_allocator() == a1);
BOOST_BEAST_EXPECT(f1.begin() == f1.end());
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.get_allocator() == a2);
BEAST_EXPECT(f2.get_allocator() == a1);
BEAST_EXPECT(f1.begin() == f1.end());
BEAST_EXPECT(f2["1"] == "1");
swap(f1, f2);
BOOST_BEAST_EXPECT(f1.get_allocator() == a1);
BOOST_BEAST_EXPECT(f2.get_allocator() == a2);
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2.begin() == f2.end());
BEAST_EXPECT(f1.get_allocator() == a1);
BEAST_EXPECT(f2.get_allocator() == a2);
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2.begin() == f2.end());
}
{
// propagate_on_container_swap : false
using pocs_t = test::test_allocator<char,
true, true, true, false, true>;
pocs_t a1, a2;
BOOST_BEAST_EXPECT(a1 == a2);
BOOST_BEAST_EXPECT(a1.id() != a2.id());
BEAST_EXPECT(a1 == a2);
BEAST_EXPECT(a1.id() != a2.id());
basic_fields<pocs_t> f1{a1};
f1.insert("1", "1");
basic_fields<pocs_t> f2{a2};
BOOST_BEAST_EXPECT(f1.get_allocator() == a1);
BOOST_BEAST_EXPECT(f2.get_allocator() == a2);
BEAST_EXPECT(f1.get_allocator() == a1);
BEAST_EXPECT(f2.get_allocator() == a2);
swap(f1, f2);
BOOST_BEAST_EXPECT(f1.get_allocator().id() == a1.id());
BOOST_BEAST_EXPECT(f2.get_allocator().id() == a2.id());
BOOST_BEAST_EXPECT(f1.begin() == f1.end());
BOOST_BEAST_EXPECT(f2["1"] == "1");
BEAST_EXPECT(f1.get_allocator().id() == a1.id());
BEAST_EXPECT(f2.get_allocator().id() == a2.id());
BEAST_EXPECT(f1.begin() == f1.end());
BEAST_EXPECT(f2["1"] == "1");
swap(f1, f2);
BOOST_BEAST_EXPECT(f1.get_allocator().id() == a1.id());
BOOST_BEAST_EXPECT(f2.get_allocator().id() == a2.id());
BOOST_BEAST_EXPECT(f1["1"] == "1");
BOOST_BEAST_EXPECT(f2.begin() == f2.end());
BEAST_EXPECT(f1.get_allocator().id() == a1.id());
BEAST_EXPECT(f2.get_allocator().id() == a2.id());
BEAST_EXPECT(f1["1"] == "1");
BEAST_EXPECT(f2.begin() == f2.end());
}
}
@@ -281,35 +281,35 @@ public:
{
fields f;
f.insert(field::user_agent, "x");
BOOST_BEAST_EXPECT(f.count(field::user_agent));
BOOST_BEAST_EXPECT(f.count(to_string(field::user_agent)));
BOOST_BEAST_EXPECT(f.count(field::user_agent) == 1);
BOOST_BEAST_EXPECT(f.count(to_string(field::user_agent)) == 1);
BEAST_EXPECT(f.count(field::user_agent));
BEAST_EXPECT(f.count(to_string(field::user_agent)));
BEAST_EXPECT(f.count(field::user_agent) == 1);
BEAST_EXPECT(f.count(to_string(field::user_agent)) == 1);
f.insert(field::user_agent, "y");
BOOST_BEAST_EXPECT(f.count(field::user_agent) == 2);
BEAST_EXPECT(f.count(field::user_agent) == 2);
}
}
void testHeaders()
{
f_t f1;
BOOST_BEAST_EXPECT(empty(f1));
BEAST_EXPECT(empty(f1));
fill(1, f1);
BOOST_BEAST_EXPECT(size(f1) == 1);
BEAST_EXPECT(size(f1) == 1);
f_t f2;
f2 = f1;
BOOST_BEAST_EXPECT(size(f2) == 1);
BEAST_EXPECT(size(f2) == 1);
f2.insert("2", "2");
BOOST_BEAST_EXPECT(std::distance(f2.begin(), f2.end()) == 2);
BEAST_EXPECT(std::distance(f2.begin(), f2.end()) == 2);
f1 = std::move(f2);
BOOST_BEAST_EXPECT(size(f1) == 2);
BOOST_BEAST_EXPECT(size(f2) == 0);
BEAST_EXPECT(size(f1) == 2);
BEAST_EXPECT(size(f2) == 0);
f_t f3(std::move(f1));
BOOST_BEAST_EXPECT(size(f3) == 2);
BOOST_BEAST_EXPECT(size(f1) == 0);
BEAST_EXPECT(size(f3) == 2);
BEAST_EXPECT(size(f1) == 0);
self_assign(f3, std::move(f3));
BOOST_BEAST_EXPECT(size(f3) == 2);
BOOST_BEAST_EXPECT(f2.erase("Not-Present") == 0);
BEAST_EXPECT(size(f3) == 2);
BEAST_EXPECT(f2.erase("Not-Present") == 0);
}
void testRFC2616()
@@ -319,7 +319,7 @@ public:
f.insert("a", "x");
f.insert("aa", "y");
f.insert("f", "z");
BOOST_BEAST_EXPECT(f.count("a") == 2);
BEAST_EXPECT(f.count("a") == 2);
}
void testErase()
@@ -329,9 +329,9 @@ public:
f.insert("a", "x");
f.insert("aa", "y");
f.insert("f", "z");
BOOST_BEAST_EXPECT(size(f) == 4);
BEAST_EXPECT(size(f) == 4);
f.erase("a");
BOOST_BEAST_EXPECT(size(f) == 2);
BEAST_EXPECT(size(f) == 2);
}
void
@@ -344,21 +344,21 @@ public:
f.insert(field::body, 2);
f.insert(field::close, 3);
f.insert(field::body, 4);
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->name() == field::age);
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name() == field::body);
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->name() == field::body);
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->name() == field::close);
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "Age");
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "Body");
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "Body");
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->name_string() == "Close");
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->value() == "1");
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->value() == "2");
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->value() == "4");
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->value() == "3");
BOOST_BEAST_EXPECT(f.erase(field::body) == 2);
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "Age");
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "Close");
BEAST_EXPECT(std::next(f.begin(), 0)->name() == field::age);
BEAST_EXPECT(std::next(f.begin(), 1)->name() == field::body);
BEAST_EXPECT(std::next(f.begin(), 2)->name() == field::body);
BEAST_EXPECT(std::next(f.begin(), 3)->name() == field::close);
BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "Age");
BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "Body");
BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "Body");
BEAST_EXPECT(std::next(f.begin(), 3)->name_string() == "Close");
BEAST_EXPECT(std::next(f.begin(), 0)->value() == "1");
BEAST_EXPECT(std::next(f.begin(), 1)->value() == "2");
BEAST_EXPECT(std::next(f.begin(), 2)->value() == "4");
BEAST_EXPECT(std::next(f.begin(), 3)->value() == "3");
BEAST_EXPECT(f.erase(field::body) == 2);
BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "Age");
BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "Close");
}
{
// group fields, case insensitive
@@ -367,21 +367,21 @@ public:
f.insert("ab", 2);
f.insert("b", 3);
f.insert("AB", 4);
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->name() == field::unknown);
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name() == field::unknown);
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->name() == field::unknown);
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->name() == field::unknown);
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "a");
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "ab");
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "AB");
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->name_string() == "b");
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->value() == "1");
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->value() == "2");
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->value() == "4");
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->value() == "3");
BOOST_BEAST_EXPECT(f.erase("Ab") == 2);
BOOST_BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "a");
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "b");
BEAST_EXPECT(std::next(f.begin(), 0)->name() == field::unknown);
BEAST_EXPECT(std::next(f.begin(), 1)->name() == field::unknown);
BEAST_EXPECT(std::next(f.begin(), 2)->name() == field::unknown);
BEAST_EXPECT(std::next(f.begin(), 3)->name() == field::unknown);
BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "a");
BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "ab");
BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "AB");
BEAST_EXPECT(std::next(f.begin(), 3)->name_string() == "b");
BEAST_EXPECT(std::next(f.begin(), 0)->value() == "1");
BEAST_EXPECT(std::next(f.begin(), 1)->value() == "2");
BEAST_EXPECT(std::next(f.begin(), 2)->value() == "4");
BEAST_EXPECT(std::next(f.begin(), 3)->value() == "3");
BEAST_EXPECT(f.erase("Ab") == 2);
BEAST_EXPECT(std::next(f.begin(), 0)->name_string() == "a");
BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "b");
}
{
// verify insertion orde
@@ -394,14 +394,14 @@ public:
f.insert("Dd", 6);
f.insert("DD", 7);
f.insert( "e", 8);
BOOST_BEAST_EXPECT(f.count("dd") == 4);
BOOST_BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "dd");
BOOST_BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "dD");
BOOST_BEAST_EXPECT(std::next(f.begin(), 3)->name_string() == "Dd");
BOOST_BEAST_EXPECT(std::next(f.begin(), 4)->name_string() == "DD");
BEAST_EXPECT(f.count("dd") == 4);
BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "dd");
BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "dD");
BEAST_EXPECT(std::next(f.begin(), 3)->name_string() == "Dd");
BEAST_EXPECT(std::next(f.begin(), 4)->name_string() == "DD");
f.set("dd", "-");
BOOST_BEAST_EXPECT(f.count("dd") == 1);
BOOST_BEAST_EXPECT(f["dd"] == "-");
BEAST_EXPECT(f.count("dd") == 1);
BEAST_EXPECT(f["dd"] == "-");
}
}
@@ -432,25 +432,25 @@ public:
req.method(verb::get);
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
req.set(field::content_length, "0");
req.set(field::transfer_encoding, "chunked");
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
req.set(field::transfer_encoding, "deflate");
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
req.set(field::transfer_encoding, "deflate, chunked");
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
}
// GET, sized
@@ -461,19 +461,19 @@ public:
req.body = 50;
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "50");
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "");
BEAST_EXPECT(req[field::content_length] == "50");
BEAST_EXPECT(req[field::transfer_encoding] == "");
req.set(field::content_length, "0");
req.set(field::transfer_encoding, "chunked");
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "50");
BOOST_BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
BEAST_EXPECT(req[field::content_length] == "50");
BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
req.set(field::transfer_encoding, "deflate, chunked");
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "50");
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
BEAST_EXPECT(req[field::content_length] == "50");
BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
}
// PUT, empty
@@ -483,14 +483,14 @@ public:
req.method(verb::put);
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "0");
BOOST_BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
BEAST_EXPECT(req[field::content_length] == "0");
BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
req.set(field::content_length, "50");
req.set(field::transfer_encoding, "deflate, chunked");
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "0");
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
BEAST_EXPECT(req[field::content_length] == "0");
BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
}
// PUT, sized
@@ -501,14 +501,14 @@ public:
req.body = 50;
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "50");
BOOST_BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
BEAST_EXPECT(req[field::content_length] == "50");
BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
req.set(field::content_length, "25");
req.set(field::transfer_encoding, "deflate, chunked");
req.prepare_payload();
BOOST_BEAST_EXPECT(req[field::content_length] == "50");
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
BEAST_EXPECT(req[field::content_length] == "50");
BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
}
// POST, unsized
@@ -518,13 +518,13 @@ public:
req.method(verb::post);
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "chunked");
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req[field::transfer_encoding] == "chunked");
req.set(field::transfer_encoding, "deflate");
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate, chunked");
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req[field::transfer_encoding] == "deflate, chunked");
}
// POST, unsized HTTP/1.0
@@ -534,13 +534,13 @@ public:
req.method(verb::post);
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req.count(field::transfer_encoding) == 0);
req.set(field::transfer_encoding, "deflate");
req.prepare_payload();
BOOST_BEAST_EXPECT(req.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
BEAST_EXPECT(req.count(field::content_length) == 0);
BEAST_EXPECT(req[field::transfer_encoding] == "deflate");
}
// OK, empty
@@ -549,14 +549,14 @@ public:
res.version = 11;
res.prepare_payload();
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.erase(field::content_length);
res.set(field::transfer_encoding, "chunked");
res.prepare_payload();
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
}
// OK, sized
@@ -566,14 +566,14 @@ public:
res.body = 50;
res.prepare_payload();
BOOST_BEAST_EXPECT(res[field::content_length] == "50");
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res[field::content_length] == "50");
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.erase(field::content_length);
res.set(field::transfer_encoding, "chunked");
res.prepare_payload();
BOOST_BEAST_EXPECT(res[field::content_length] == "50");
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res[field::content_length] == "50");
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
}
// OK, unsized
@@ -582,8 +582,8 @@ public:
res.version = 11;
res.prepare_payload();
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
}
}
@@ -595,7 +595,7 @@ public:
[&](bool v)
{
res.keep_alive(v);
BOOST_BEAST_EXPECT(
BEAST_EXPECT(
(res.keep_alive() && v) ||
(! res.keep_alive() && ! v));
};
@@ -608,70 +608,70 @@ public:
res.erase(field::connection);
keep_alive(false);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.set(field::connection, "close");
keep_alive(false);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.set(field::connection, "keep-alive");
keep_alive(false);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.set(field::connection, "keep-alive, close");
keep_alive(false);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.erase(field::connection);
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == "keep-alive");
BEAST_EXPECT(res[field::connection] == "keep-alive");
res.set(field::connection, "close");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == "keep-alive");
BEAST_EXPECT(res[field::connection] == "keep-alive");
res.set(field::connection, "keep-alive");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == "keep-alive");
BEAST_EXPECT(res[field::connection] == "keep-alive");
res.set(field::connection, "keep-alive, close");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == "keep-alive");
BEAST_EXPECT(res[field::connection] == "keep-alive");
auto const test10 =
[&](std::string s)
{
res.set(field::connection, s);
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, s + ", close");
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, "keep-alive, " + s);
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, "keep-alive, " + s + ", close");
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, s);
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == s + ", keep-alive");
BEAST_EXPECT(res[field::connection] == s + ", keep-alive");
res.set(field::connection, s + ", close");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == s + ", keep-alive");
BEAST_EXPECT(res[field::connection] == s + ", keep-alive");
res.set(field::connection, "keep-alive, " + s);
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == "keep-alive, " + s);
BEAST_EXPECT(res[field::connection] == "keep-alive, " + s);
res.set(field::connection, "keep-alive, " + s+ ", close");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == "keep-alive, " + s);
BEAST_EXPECT(res[field::connection] == "keep-alive, " + s);
};
test10("foo");
@@ -682,70 +682,70 @@ public:
res.erase(field::connection);
keep_alive(true);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.set(field::connection, "close");
keep_alive(true);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.set(field::connection, "keep-alive");
keep_alive(true);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.set(field::connection, "keep-alive, close");
keep_alive(true);
BOOST_BEAST_EXPECT(res.count(field::connection) == 0);
BEAST_EXPECT(res.count(field::connection) == 0);
res.erase(field::connection);
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == "close");
BEAST_EXPECT(res[field::connection] == "close");
res.set(field::connection, "close");
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == "close");
BEAST_EXPECT(res[field::connection] == "close");
res.set(field::connection, "keep-alive");
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == "close");
BEAST_EXPECT(res[field::connection] == "close");
res.set(field::connection, "keep-alive, close");
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == "close");
BEAST_EXPECT(res[field::connection] == "close");
auto const test11 =
[&](std::string s)
{
res.set(field::connection, s);
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, s + ", close");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, "keep-alive, " + s);
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, "keep-alive, " + s + ", close");
keep_alive(true);
BOOST_BEAST_EXPECT(res[field::connection] == s);
BEAST_EXPECT(res[field::connection] == s);
res.set(field::connection, s);
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == s + ", close");
BEAST_EXPECT(res[field::connection] == s + ", close");
res.set(field::connection, "close, " + s);
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == "close, " + s);
BEAST_EXPECT(res[field::connection] == "close, " + s);
res.set(field::connection, "keep-alive, " + s);
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == s + ", close");
BEAST_EXPECT(res[field::connection] == s + ", close");
res.set(field::connection, "close, " + s + ", keep-alive");
keep_alive(false);
BOOST_BEAST_EXPECT(res[field::connection] == "close, " + s);
BEAST_EXPECT(res[field::connection] == "close, " + s);
};
test11("foo");
@@ -756,79 +756,79 @@ public:
testContentLength()
{
response<empty_body> res{status::ok, 11};
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.content_length(0);
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res[field::content_length] == "0");
res.content_length(100);
BOOST_BEAST_EXPECT(res[field::content_length] == "100");
BEAST_EXPECT(res[field::content_length] == "100");
res.content_length(boost::none);
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res.count(field::content_length) == 0);
res.set(field::transfer_encoding, "chunked");
res.content_length(0);
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.set(field::transfer_encoding, "chunked");
res.content_length(100);
BOOST_BEAST_EXPECT(res[field::content_length] == "100");
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res[field::content_length] == "100");
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.set(field::transfer_encoding, "chunked");
res.content_length(boost::none);
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
auto const check = [&](std::string s)
{
res.set(field::transfer_encoding, s);
res.content_length(0);
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == s);
BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res[field::transfer_encoding] == s);
res.set(field::transfer_encoding, s);
res.content_length(100);
BOOST_BEAST_EXPECT(res[field::content_length] == "100");
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == s);
BEAST_EXPECT(res[field::content_length] == "100");
BEAST_EXPECT(res[field::transfer_encoding] == s);
res.set(field::transfer_encoding, s);
res.content_length(boost::none);
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == s);
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res[field::transfer_encoding] == s);
res.set(field::transfer_encoding, s + ", chunked");
res.content_length(0);
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == s);
BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res[field::transfer_encoding] == s);
res.set(field::transfer_encoding, s + ", chunked");
res.content_length(100);
BOOST_BEAST_EXPECT(res[field::content_length] == "100");
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == s);
BEAST_EXPECT(res[field::content_length] == "100");
BEAST_EXPECT(res[field::transfer_encoding] == s);
res.set(field::transfer_encoding, s + ", chunked");
res.content_length(boost::none);
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == s);
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res[field::transfer_encoding] == s);
res.set(field::transfer_encoding, "chunked, " + s);
res.content_length(0);
BOOST_BEAST_EXPECT(res[field::content_length] == "0");
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, " + s);
BEAST_EXPECT(res[field::content_length] == "0");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, " + s);
res.set(field::transfer_encoding, "chunked, " + s);
res.content_length(100);
BOOST_BEAST_EXPECT(res[field::content_length] == "100");
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, " + s);
BEAST_EXPECT(res[field::content_length] == "100");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, " + s);
res.set(field::transfer_encoding, "chunked, " + s);
res.content_length(boost::none);
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, " + s);
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, " + s);
};
check("foo");
@@ -843,63 +843,63 @@ public:
testChunked()
{
response<empty_body> res{status::ok, 11};
BOOST_BEAST_EXPECT(res.count(field::content_length) == 0);
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res.count(field::content_length) == 0);
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
auto const chunked =
[&](bool v)
{
res.chunked(v);
BOOST_BEAST_EXPECT(
BEAST_EXPECT(
(res.chunked() && v) ||
(! res.chunked() && ! v));
BOOST_BEAST_EXPECT(res.count(
BEAST_EXPECT(res.count(
field::content_length) == 0);
};
res.erase(field::transfer_encoding);
res.set(field::content_length, 32);
chunked(true);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
res.set(field::transfer_encoding, "chunked");
chunked(true);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
res.erase(field::transfer_encoding);
res.set(field::content_length, 32);
chunked(false);
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.set(field::transfer_encoding, "chunked");
chunked(false);
BOOST_BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
res.set(field::transfer_encoding, "foo");
chunked(true);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "foo, chunked");
BEAST_EXPECT(res[field::transfer_encoding] == "foo, chunked");
res.set(field::transfer_encoding, "chunked, foo");
chunked(true);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo, chunked");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo, chunked");
res.set(field::transfer_encoding, "chunked, foo, chunked");
chunked(true);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo, chunked");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo, chunked");
res.set(field::transfer_encoding, "foo, chunked");
chunked(false);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "foo");
BEAST_EXPECT(res[field::transfer_encoding] == "foo");
res.set(field::transfer_encoding, "chunked, foo");
chunked(false);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo");
res.set(field::transfer_encoding, "chunked, foo, chunked");
chunked(false);
BOOST_BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo");
BEAST_EXPECT(res[field::transfer_encoding] == "chunked, foo");
}
void

20
test/http/file_body.cpp
View File

@@ -56,22 +56,22 @@ public:
p.get().body.open(
temp.string<std::string>().c_str(), file_mode::write, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
p.put(boost::asio::buffer(s.data(), s.size()), ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
}
{
File f;
f.open(temp.string<std::string>().c_str(), file_mode::read, ec);
auto size = f.size(ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(size == 3);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(size == 3);
std::string s1;
s1.resize(3);
f.read(&s1[0], s1.size(), ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECTS(s1 == "xyz", s);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(s1 == "xyz", s);
}
{
lambda visit;
@@ -80,21 +80,21 @@ public:
res.set(field::server, "test");
res.body.open(temp.string<std::string>().c_str(),
file_mode::scan, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
res.prepare_payload();
serializer<false, basic_file_body<File>, fields> sr{res};
sr.next(ec, visit);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const cb = *visit.buffer.data().begin();
string_view const s1{
boost::asio::buffer_cast<char const*>(cb),
boost::asio::buffer_size(cb)};
BOOST_BEAST_EXPECTS(s1 == s, s1);
BEAST_EXPECTS(s1 == s, s1);
}
}
boost::filesystem::remove(temp, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
}
void
run() override

142
test/http/message.cpp
View File

@@ -126,26 +126,26 @@ public:
{
Arg1 arg1;
request<one_arg_body>{verb::get, "/", 11, std::move(arg1)};
BOOST_BEAST_EXPECT(arg1.moved);
BEAST_EXPECT(arg1.moved);
}
{
header<true> h;
h.set(field::user_agent, "test");
BOOST_BEAST_EXPECT(h[field::user_agent] == "test");
BEAST_EXPECT(h[field::user_agent] == "test");
request<default_body> m{std::move(h)};
BOOST_BEAST_EXPECT(m[field::user_agent] == "test");
BOOST_BEAST_EXPECT(h.count(field::user_agent) == 0);
BEAST_EXPECT(m[field::user_agent] == "test");
BEAST_EXPECT(h.count(field::user_agent) == 0);
}
{
request<empty_body> h{verb::get, "/", 10};
h.set(field::user_agent, "test");
request<one_arg_body> m{std::move(h.base()), Arg1{}};
BOOST_BEAST_EXPECT(m["User-Agent"] == "test");
BOOST_BEAST_EXPECT(h.count(http::field::user_agent) == 0);
BOOST_BEAST_EXPECT(m.method() == verb::get);
BOOST_BEAST_EXPECT(m.target() == "/");
BOOST_BEAST_EXPECT(m.version == 10);
BEAST_EXPECT(m["User-Agent"] == "test");
BEAST_EXPECT(h.count(http::field::user_agent) == 0);
BEAST_EXPECT(m.method() == verb::get);
BEAST_EXPECT(m.target() == "/");
BEAST_EXPECT(m.version == 10);
}
// swap
@@ -157,14 +157,14 @@ public:
m2.method_string("G");
m2.body = "2";
swap(m1, m2);
BOOST_BEAST_EXPECT(m1.method_string() == "G");
BOOST_BEAST_EXPECT(m2.method_string().empty());
BOOST_BEAST_EXPECT(m1.target().empty());
BOOST_BEAST_EXPECT(m2.target() == "u");
BOOST_BEAST_EXPECT(m1.body == "2");
BOOST_BEAST_EXPECT(m2.body == "1");
BOOST_BEAST_EXPECT(! m1.count("h"));
BOOST_BEAST_EXPECT(m2.count("h"));
BEAST_EXPECT(m1.method_string() == "G");
BEAST_EXPECT(m2.method_string().empty());
BEAST_EXPECT(m1.target().empty());
BEAST_EXPECT(m2.target() == "u");
BEAST_EXPECT(m1.body == "2");
BEAST_EXPECT(m2.body == "1");
BEAST_EXPECT(! m1.count("h"));
BEAST_EXPECT(m2.count("h"));
}
struct MoveFields : fields
@@ -212,57 +212,57 @@ public:
{
{
request<empty_body> req;
BOOST_BEAST_EXPECT(req.version == 11);
BOOST_BEAST_EXPECT(req.method() == verb::unknown);
BOOST_BEAST_EXPECT(req.target() == "");
BEAST_EXPECT(req.version == 11);
BEAST_EXPECT(req.method() == verb::unknown);
BEAST_EXPECT(req.target() == "");
}
{
request<empty_body> req{verb::get, "/", 11};
BOOST_BEAST_EXPECT(req.version == 11);
BOOST_BEAST_EXPECT(req.method() == verb::get);
BOOST_BEAST_EXPECT(req.target() == "/");
BEAST_EXPECT(req.version == 11);
BEAST_EXPECT(req.method() == verb::get);
BEAST_EXPECT(req.target() == "/");
}
{
request<string_body> req{verb::get, "/", 11, "Hello"};
BOOST_BEAST_EXPECT(req.version == 11);
BOOST_BEAST_EXPECT(req.method() == verb::get);
BOOST_BEAST_EXPECT(req.target() == "/");
BOOST_BEAST_EXPECT(req.body == "Hello");
BEAST_EXPECT(req.version == 11);
BEAST_EXPECT(req.method() == verb::get);
BEAST_EXPECT(req.target() == "/");
BEAST_EXPECT(req.body == "Hello");
}
{
request<string_body, test_fields> req{
verb::get, "/", 11, "Hello", token{}};
BOOST_BEAST_EXPECT(req.version == 11);
BOOST_BEAST_EXPECT(req.method() == verb::get);
BOOST_BEAST_EXPECT(req.target() == "/");
BOOST_BEAST_EXPECT(req.body == "Hello");
BEAST_EXPECT(req.version == 11);
BEAST_EXPECT(req.method() == verb::get);
BEAST_EXPECT(req.target() == "/");
BEAST_EXPECT(req.body == "Hello");
}
{
response<string_body> res;
BOOST_BEAST_EXPECT(res.version == 11);
BOOST_BEAST_EXPECT(res.result() == status::ok);
BOOST_BEAST_EXPECT(res.reason() == "OK");
BEAST_EXPECT(res.version == 11);
BEAST_EXPECT(res.result() == status::ok);
BEAST_EXPECT(res.reason() == "OK");
}
{
response<string_body> res{status::bad_request, 10};
BOOST_BEAST_EXPECT(res.version == 10);
BOOST_BEAST_EXPECT(res.result() == status::bad_request);
BOOST_BEAST_EXPECT(res.reason() == "Bad Request");
BEAST_EXPECT(res.version == 10);
BEAST_EXPECT(res.result() == status::bad_request);
BEAST_EXPECT(res.reason() == "Bad Request");
}
{
response<string_body> res{status::bad_request, 10, "Hello"};
BOOST_BEAST_EXPECT(res.version == 10);
BOOST_BEAST_EXPECT(res.result() == status::bad_request);
BOOST_BEAST_EXPECT(res.reason() == "Bad Request");
BOOST_BEAST_EXPECT(res.body == "Hello");
BEAST_EXPECT(res.version == 10);
BEAST_EXPECT(res.result() == status::bad_request);
BEAST_EXPECT(res.reason() == "Bad Request");
BEAST_EXPECT(res.body == "Hello");
}
{
response<string_body, test_fields> res{
status::bad_request, 10, "Hello", token{}};
BOOST_BEAST_EXPECT(res.version == 10);
BOOST_BEAST_EXPECT(res.result() == status::bad_request);
BOOST_BEAST_EXPECT(res.reason() == "Bad Request");
BOOST_BEAST_EXPECT(res.body == "Hello");
BEAST_EXPECT(res.version == 10);
BEAST_EXPECT(res.result() == status::bad_request);
BEAST_EXPECT(res.reason() == "Bad Request");
BEAST_EXPECT(res.body == "Hello");
}
}
@@ -279,18 +279,18 @@ public:
m2.body = "2";
m2.version = 11;
swap(m1, m2);
BOOST_BEAST_EXPECT(m1.result() == status::not_found);
BOOST_BEAST_EXPECT(m1.result_int() == 404);
BOOST_BEAST_EXPECT(m2.result() == status::ok);
BOOST_BEAST_EXPECT(m2.result_int() == 200);
BOOST_BEAST_EXPECT(m1.reason() == "Not Found");
BOOST_BEAST_EXPECT(m2.reason() == "OK");
BOOST_BEAST_EXPECT(m1.version == 11);
BOOST_BEAST_EXPECT(m2.version == 10);
BOOST_BEAST_EXPECT(m1.body == "2");
BOOST_BEAST_EXPECT(m2.body == "1");
BOOST_BEAST_EXPECT(! m1.count("h"));
BOOST_BEAST_EXPECT(m2.count("h"));
BEAST_EXPECT(m1.result() == status::not_found);
BEAST_EXPECT(m1.result_int() == 404);
BEAST_EXPECT(m2.result() == status::ok);
BEAST_EXPECT(m2.result_int() == 200);
BEAST_EXPECT(m1.reason() == "Not Found");
BEAST_EXPECT(m2.reason() == "OK");
BEAST_EXPECT(m1.version == 11);
BEAST_EXPECT(m2.version == 10);
BEAST_EXPECT(m1.body == "2");
BEAST_EXPECT(m2.body == "1");
BEAST_EXPECT(! m1.count("h"));
BEAST_EXPECT(m2.count("h"));
}
void
@@ -314,15 +314,15 @@ public:
[&](verb v)
{
h.method(v);
BOOST_BEAST_EXPECT(h.method() == v);
BOOST_BEAST_EXPECT(h.method_string() == to_string(v));
BEAST_EXPECT(h.method() == v);
BEAST_EXPECT(h.method_string() == to_string(v));
};
auto const scheck =
[&](string_view s)
{
h.method_string(s);
BOOST_BEAST_EXPECT(h.method() == string_to_verb(s));
BOOST_BEAST_EXPECT(h.method_string() == s);
BEAST_EXPECT(h.method() == string_to_verb(s));
BEAST_EXPECT(h.method_string() == s);
};
vcheck(verb::get);
vcheck(verb::head);
@@ -336,14 +336,14 @@ public:
{
header<false> h;
h.result(200);
BOOST_BEAST_EXPECT(h.result_int() == 200);
BOOST_BEAST_EXPECT(h.result() == status::ok);
BEAST_EXPECT(h.result_int() == 200);
BEAST_EXPECT(h.result() == status::ok);
h.result(status::switching_protocols);
BOOST_BEAST_EXPECT(h.result_int() == 101);
BOOST_BEAST_EXPECT(h.result() == status::switching_protocols);
BEAST_EXPECT(h.result_int() == 101);
BEAST_EXPECT(h.result() == status::switching_protocols);
h.result(1);
BOOST_BEAST_EXPECT(h.result_int() == 1);
BOOST_BEAST_EXPECT(h.result() == status::unknown);
BEAST_EXPECT(h.result_int() == 1);
BEAST_EXPECT(h.result() == status::unknown);
}
void
@@ -351,13 +351,13 @@ public:
{
header<false> h;
h.result(status::ok);
BOOST_BEAST_EXPECT(h.reason() == "OK");
BEAST_EXPECT(h.reason() == "OK");
h.reason("Pepe");
BOOST_BEAST_EXPECT(h.reason() == "Pepe");
BEAST_EXPECT(h.reason() == "Pepe");
h.result(status::not_found);
BOOST_BEAST_EXPECT(h.reason() == "Pepe");
BEAST_EXPECT(h.reason() == "Pepe");
h.reason({});
BOOST_BEAST_EXPECT(h.reason() == "Not Found");
BEAST_EXPECT(h.reason() == "Not Found");
}
void

128
test/http/parser.cpp
View File

@@ -83,7 +83,7 @@ public:
error_code ec;
parser_type<isRequest> p;
put(buffer(s.data(), s.size()), p, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
f(p);
}
@@ -99,22 +99,22 @@ public:
s.remove_prefix(used);
if(ec == error::need_more)
ec.assign(0, ec.category());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
BOOST_BEAST_EXPECT(! p.is_done());
BEAST_EXPECT(! p.is_done());
used = p.put(
buffer(s.data(), s.size()), ec);
s.remove_prefix(used);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
BOOST_BEAST_EXPECT(s.empty());
BEAST_EXPECT(s.empty());
if(p.need_eof())
{
p.put_eof(ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
}
if(BOOST_BEAST_EXPECT(p.is_done()))
if(BEAST_EXPECT(p.is_done()))
f(p);
}
}
@@ -130,14 +130,14 @@ public:
[&](parser_type<false> const& p)
{
auto const& m = p.get();
BOOST_BEAST_EXPECT(! p.is_chunked());
BOOST_BEAST_EXPECT(p.need_eof());
BOOST_BEAST_EXPECT(p.content_length() == boost::none);
BOOST_BEAST_EXPECT(m.version == 10);
BOOST_BEAST_EXPECT(m.result() == status::ok);
BOOST_BEAST_EXPECT(m.reason() == "OK");
BOOST_BEAST_EXPECT(m["Server"] == "test");
BOOST_BEAST_EXPECT(m.body == "Hello, world!");
BEAST_EXPECT(! p.is_chunked());
BEAST_EXPECT(p.need_eof());
BEAST_EXPECT(p.content_length() == boost::none);
BEAST_EXPECT(m.version == 10);
BEAST_EXPECT(m.result() == status::ok);
BEAST_EXPECT(m.reason() == "OK");
BEAST_EXPECT(m["Server"] == "test");
BEAST_EXPECT(m.body == "Hello, world!");
}
);
doMatrix<false>(
@@ -157,17 +157,17 @@ public:
[&](parser_type<false> const& p)
{
auto const& m = p.get();
BOOST_BEAST_EXPECT(! p.need_eof());
BOOST_BEAST_EXPECT(p.is_chunked());
BOOST_BEAST_EXPECT(p.content_length() == boost::none);
BOOST_BEAST_EXPECT(m.version == 11);
BOOST_BEAST_EXPECT(m.result() == status::ok);
BOOST_BEAST_EXPECT(m.reason() == "OK");
BOOST_BEAST_EXPECT(m["Server"] == "test");
BOOST_BEAST_EXPECT(m["Transfer-Encoding"] == "chunked");
BOOST_BEAST_EXPECT(m["Expires"] == "never");
BOOST_BEAST_EXPECT(m["MD5-Fingerprint"] == "-");
BOOST_BEAST_EXPECT(m.body == "*****--");
BEAST_EXPECT(! p.need_eof());
BEAST_EXPECT(p.is_chunked());
BEAST_EXPECT(p.content_length() == boost::none);
BEAST_EXPECT(m.version == 11);
BEAST_EXPECT(m.result() == status::ok);
BEAST_EXPECT(m.reason() == "OK");
BEAST_EXPECT(m["Server"] == "test");
BEAST_EXPECT(m["Transfer-Encoding"] == "chunked");
BEAST_EXPECT(m["Expires"] == "never");
BEAST_EXPECT(m["MD5-Fingerprint"] == "-");
BEAST_EXPECT(m.body == "*****--");
}
);
doMatrix<false>(
@@ -179,7 +179,7 @@ public:
[&](parser_type<false> const& p)
{
auto const& m = p.get();
BOOST_BEAST_EXPECT(m.body == "*****");
BEAST_EXPECT(m.body == "*****");
}
);
doMatrix<true>(
@@ -189,12 +189,12 @@ public:
[&](parser_type<true> const& p)
{
auto const& m = p.get();
BOOST_BEAST_EXPECT(m.method() == verb::get);
BOOST_BEAST_EXPECT(m.target() == "/");
BOOST_BEAST_EXPECT(m.version == 11);
BOOST_BEAST_EXPECT(! p.need_eof());
BOOST_BEAST_EXPECT(! p.is_chunked());
BOOST_BEAST_EXPECT(p.content_length() == boost::none);
BEAST_EXPECT(m.method() == verb::get);
BEAST_EXPECT(m.target() == "/");
BEAST_EXPECT(m.version == 11);
BEAST_EXPECT(! p.need_eof());
BEAST_EXPECT(! p.is_chunked());
BEAST_EXPECT(p.content_length() == boost::none);
}
);
doMatrix<true>(
@@ -205,7 +205,7 @@ public:
[&](parser_type<true> const& p)
{
auto const& m = p.get();
BOOST_BEAST_EXPECT(m["X"] == "x");
BEAST_EXPECT(m["X"] == "x");
}
);
@@ -222,15 +222,15 @@ public:
"*")
, ec);
auto const& m = p.get();
BOOST_BEAST_EXPECT(! ec);
BOOST_BEAST_EXPECT(p.is_done());
BOOST_BEAST_EXPECT(p.is_header_done());
BOOST_BEAST_EXPECT(! p.need_eof());
BOOST_BEAST_EXPECT(m.method() == verb::get);
BOOST_BEAST_EXPECT(m.target() == "/");
BOOST_BEAST_EXPECT(m.version == 11);
BOOST_BEAST_EXPECT(m["User-Agent"] == "test");
BOOST_BEAST_EXPECT(m.body == "*");
BEAST_EXPECT(! ec);
BEAST_EXPECT(p.is_done());
BEAST_EXPECT(p.is_header_done());
BEAST_EXPECT(! p.need_eof());
BEAST_EXPECT(m.method() == verb::get);
BEAST_EXPECT(m.target() == "/");
BEAST_EXPECT(m.version == 11);
BEAST_EXPECT(m["User-Agent"] == "test");
BEAST_EXPECT(m.body == "*");
}
{
// test partial parsing of final chunk
@@ -247,9 +247,9 @@ public:
"*";
auto used = p.put(b.data(), ec);
b.consume(used);
BOOST_BEAST_EXPECT(! ec);
BOOST_BEAST_EXPECT(! p.is_done());
BOOST_BEAST_EXPECT(p.get().body == "*");
BEAST_EXPECT(! ec);
BEAST_EXPECT(! p.is_done());
BEAST_EXPECT(p.get().body == "*");
ostream(b) <<
"\r\n"
"0;d;e=3;f=\"4\"\r\n"
@@ -258,15 +258,15 @@ public:
// incomplete parse, missing the final crlf
used = p.put(b.data(), ec);
b.consume(used);
BOOST_BEAST_EXPECT(ec == error::need_more);
BEAST_EXPECT(ec == error::need_more);
ec.assign(0, ec.category());
BOOST_BEAST_EXPECT(! p.is_done());
BEAST_EXPECT(! p.is_done());
ostream(b) <<
"\r\n"; // final crlf to end message
used = p.put(b.data(), ec);
b.consume(used);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
}
// skip body
{
@@ -279,10 +279,10 @@ public:
"\r\n"
"*****")
, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done());
BOOST_BEAST_EXPECT(p.is_header_done());
BOOST_BEAST_EXPECT(p.content_length() &&
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
BEAST_EXPECT(p.is_header_done());
BEAST_EXPECT(p.content_length() &&
*p.content_length() == 5);
}
}
@@ -301,17 +301,17 @@ public:
ostream(b) <<
"GET / HTTP/1.1\r\n";
used = p.put(b.data(), ec);
BOOST_BEAST_EXPECTS(ec == error::need_more, ec.message());
BEAST_EXPECTS(ec == error::need_more, ec.message());
b.consume(used);
ec.assign(0, ec.category());
ostream(b) <<
"User-Agent: test\r\n"
"\r\n";
used = p.put(b.data(), ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
b.consume(used);
BOOST_BEAST_EXPECT(p.is_done());
BOOST_BEAST_EXPECT(p.is_header_done());
BEAST_EXPECT(p.is_done());
BEAST_EXPECT(p.is_header_done());
}
}
@@ -321,14 +321,14 @@ public:
error_code ec;
parser_type<true> p;
auto used = p.put(buf(""), ec);
BOOST_BEAST_EXPECT(ec == error::need_more);
BOOST_BEAST_EXPECT(! p.got_some());
BOOST_BEAST_EXPECT(used == 0);
BEAST_EXPECT(ec == error::need_more);
BEAST_EXPECT(! p.got_some());
BEAST_EXPECT(used == 0);
ec.assign(0, ec.category());
used = p.put(buf("G"), ec);
BOOST_BEAST_EXPECT(ec == error::need_more);
BOOST_BEAST_EXPECT(p.got_some());
BOOST_BEAST_EXPECT(used == 0);
BEAST_EXPECT(ec == error::need_more);
BEAST_EXPECT(p.got_some());
BEAST_EXPECT(used == 0);
}
void

44
test/http/read.cpp
View File

@@ -58,7 +58,7 @@ public:
if(! ec)
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
static std::size_t constexpr pre = 10;
@@ -74,7 +74,7 @@ public:
if(! ec)
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
multi_buffer b;
@@ -89,7 +89,7 @@ public:
if(! ec)
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
static std::size_t constexpr pre = 10;
@@ -105,7 +105,7 @@ public:
if(! ec)
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void testThrow()
@@ -165,7 +165,7 @@ public:
flat_static_buffer<10> b;
request<string_body> req;
read(p.server, b, req, ec);
BOOST_BEAST_EXPECTS(ec == error::buffer_overflow,
BEAST_EXPECTS(ec == error::buffer_overflow,
ec.message());
}
}
@@ -257,7 +257,7 @@ public:
{
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -275,7 +275,7 @@ public:
if(! ec)
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -293,7 +293,7 @@ public:
if(! ec)
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void
@@ -305,7 +305,7 @@ public:
request_parser<dynamic_body> p;
error_code ec;
read(ss, b, p, ec);
BOOST_BEAST_EXPECT(ec == http::error::end_of_stream);
BEAST_EXPECT(ec == http::error::end_of_stream);
}
{
multi_buffer b;
@@ -313,7 +313,7 @@ public:
request_parser<dynamic_body> p;
error_code ec;
async_read(ss, b, p, do_yield[ec]);
BOOST_BEAST_EXPECT(ec == http::error::end_of_stream);
BEAST_EXPECT(ec == http::error::end_of_stream);
}
}
@@ -337,17 +337,17 @@ public:
boost::asio::io_service ios;
test::string_istream is{ios,
"GET / HTTP/1.1\r\n\r\n"};
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
multi_buffer b;
request<dynamic_body> m;
async_read(is, b, m, handler{});
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
ios.stop();
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
ios.reset();
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
ios.run_one();
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
}
{
// Make sure uninvoked handlers are
@@ -356,13 +356,13 @@ public:
boost::asio::io_service ios;
test::string_istream is{ios,
"GET / HTTP/1.1\r\n\r\n"};
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
multi_buffer b;
request<dynamic_body> m;
async_read(is, b, m, handler{});
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
}
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
}
}
@@ -383,7 +383,7 @@ public:
flat_buffer fb;
parser<false, dynamic_body> p;
read(c.server, fb, p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
}
//--------------------------------------------------------------------------
@@ -402,7 +402,7 @@ public:
ostream(c.server.buffer) << s;
c.server.read_size(n);
read(c.server, b, p, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
continue;
pred(p);
}
@@ -420,7 +420,7 @@ public:
"0\r\n\r\n"
,[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.body == "abcd");
BEAST_EXPECT(p.body == "abcd");
});
readgrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n"
@@ -438,7 +438,7 @@ public:
"\r\n"
,[&](test_parser<false> const& p)
{
BOOST_BEAST_EXPECT(p.body == "*****--");
BEAST_EXPECT(p.body == "*****--");
});
}

36
test/http/rfc7230.cpp
View File

@@ -63,7 +63,7 @@ public:
[&](std::string const& s)
{
auto const got = str(param_list{s});
BOOST_BEAST_EXPECTS(got == s, fmt(got));
BEAST_EXPECTS(got == s, fmt(got));
};
auto const cs =
[&](std::string const& s, std::string const& answer)
@@ -71,13 +71,13 @@ public:
ce(answer);
auto const got = str(param_list{s});
ce(got);
BOOST_BEAST_EXPECTS(got == answer, fmt(got));
BEAST_EXPECTS(got == answer, fmt(got));
};
auto const cq =
[&](std::string const& s, std::string const& answer)
{
auto const got = str(param_list{s});
BOOST_BEAST_EXPECTS(got == answer, fmt(got));
BEAST_EXPECTS(got == answer, fmt(got));
};
ce("");
@@ -122,7 +122,7 @@ public:
[&](std::string const& s)
{
auto const got = str(ext_list{s});
BOOST_BEAST_EXPECTS(got == s, fmt(got));
BEAST_EXPECTS(got == s, fmt(got));
};
auto const cs =
[&](std::string const& s, std::string const& good)
@@ -130,13 +130,13 @@ public:
ce(good);
auto const got = str(ext_list{s});
ce(got);
BOOST_BEAST_EXPECTS(got == good, fmt(got));
BEAST_EXPECTS(got == good, fmt(got));
};
auto const cq =
[&](std::string const& s, std::string const& good)
{
auto const got = str(ext_list{s});
BOOST_BEAST_EXPECTS(got == good, fmt(got));
BEAST_EXPECTS(got == good, fmt(got));
};
/*
ext-basic_parsed_list = *( "," OWS ) ext *( OWS "," [ OWS ext ] )
@@ -172,9 +172,9 @@ public:
cq("ab;x=\" \"", "ab;x= ");
cq("ab;x=\"\\\"\"", "ab;x=\"");
BOOST_BEAST_EXPECT(ext_list{"a,b;i=1,c;j=2;k=3"}.exists("A"));
BOOST_BEAST_EXPECT(ext_list{"a,b;i=1,c;j=2;k=3"}.exists("b"));
BOOST_BEAST_EXPECT(! ext_list{"a,b;i=1,c;j=2;k=3"}.exists("d"));
BEAST_EXPECT(ext_list{"a,b;i=1,c;j=2;k=3"}.exists("A"));
BEAST_EXPECT(ext_list{"a,b;i=1,c;j=2;k=3"}.exists("b"));
BEAST_EXPECT(! ext_list{"a,b;i=1,c;j=2;k=3"}.exists("d"));
// invalid strings
cs("i j", "i");
@@ -204,7 +204,7 @@ public:
[&](std::string const& s)
{
auto const got = str(token_list{s});
BOOST_BEAST_EXPECTS(got == s, fmt(got));
BEAST_EXPECTS(got == s, fmt(got));
};
auto const cs =
[&](std::string const& s, std::string const& good)
@@ -212,7 +212,7 @@ public:
ce(good);
auto const got = str(token_list{s});
ce(got);
BOOST_BEAST_EXPECTS(got == good, fmt(got));
BEAST_EXPECTS(got == good, fmt(got));
};
cs("", "");
@@ -233,9 +233,9 @@ public:
cs("x ,\ty ", "x,y");
cs("x, y, z", "x,y,z");
BOOST_BEAST_EXPECT(token_list{"a,b,c"}.exists("A"));
BOOST_BEAST_EXPECT(token_list{"a,b,c"}.exists("b"));
BOOST_BEAST_EXPECT(! token_list{"a,b,c"}.exists("d"));
BEAST_EXPECT(token_list{"a,b,c"}.exists("A"));
BEAST_EXPECT(token_list{"a,b,c"}.exists("b"));
BEAST_EXPECT(! token_list{"a,b,c"}.exists("d"));
// invalid
cs("x y", "x");
@@ -259,14 +259,14 @@ public:
validate(string_view in,
std::vector<std::string> const& v)
{
BOOST_BEAST_EXPECT(to_vector<Policy>(in) == v);
BEAST_EXPECT(to_vector<Policy>(in) == v);
}
template<class Policy>
void
good(string_view in)
{
BOOST_BEAST_EXPECT(validate_list(
BEAST_EXPECT(validate_list(
detail::basic_parsed_list<Policy>{in}));
}
@@ -275,7 +275,7 @@ public:
good(string_view in,
std::vector<std::string> const& v)
{
BOOST_BEAST_EXPECT(validate_list(
BEAST_EXPECT(validate_list(
detail::basic_parsed_list<Policy>{in}));
validate<Policy>(in, v);
}
@@ -284,7 +284,7 @@ public:
void
bad(string_view in)
{
BOOST_BEAST_EXPECT(! validate_list(
BEAST_EXPECT(! validate_list(
detail::basic_parsed_list<Policy>{in}));
}

2
test/http/serializer.cpp
View File

@@ -108,7 +108,7 @@ public:
for(;;)
{
sr.next(ec, visit);
BOOST_BEAST_EXPECT(visit.size <= limit);
BEAST_EXPECT(visit.size <= limit);
sr.consume(visit.size);
if(sr.is_done())
break;

30
test/http/span_body.cpp
View File

@@ -27,23 +27,23 @@ struct span_body_test
using B = span_body<char const>;
request<B> req;
BOOST_BEAST_EXPECT(req.body.size() == 0);
BOOST_BEAST_EXPECT(B::size(req.body) == 0);
BEAST_EXPECT(req.body.size() == 0);
BEAST_EXPECT(B::size(req.body) == 0);
req.body = B::value_type("xyz", 3);
BOOST_BEAST_EXPECT(req.body.size() == 3);
BOOST_BEAST_EXPECT(B::size(req.body) == 3);
BEAST_EXPECT(req.body.size() == 3);
BEAST_EXPECT(B::size(req.body) == 3);
B::reader r{req};
error_code ec;
r.init(ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const buf = r.get(ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
if(! BOOST_BEAST_EXPECT(buf != boost::none))
BEAST_EXPECTS(! ec, ec.message());
if(! BEAST_EXPECT(buf != boost::none))
return;
BOOST_BEAST_EXPECT(boost::asio::buffer_size(buf->first) == 3);
BOOST_BEAST_EXPECT(! buf->second);
BEAST_EXPECT(boost::asio::buffer_size(buf->first) == 3);
BEAST_EXPECT(! buf->second);
}
{
char buf[5];
@@ -53,16 +53,16 @@ struct span_body_test
B::writer w{req};
error_code ec;
w.init(boost::none, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
w.put(boost::asio::const_buffers_1{
"123", 3}, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(buf[0] == '1');
BOOST_BEAST_EXPECT(buf[1] == '2');
BOOST_BEAST_EXPECT(buf[2] == '3');
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(buf[0] == '1');
BEAST_EXPECT(buf[1] == '2');
BEAST_EXPECT(buf[2] == '3');
w.put(boost::asio::const_buffers_1{
"456", 3}, ec);
BOOST_BEAST_EXPECTS(ec == error::buffer_overflow, ec.message());
BEAST_EXPECTS(ec == error::buffer_overflow, ec.message());
}
}

12
test/http/status.cpp
View File

@@ -25,9 +25,9 @@ public:
{
auto const check = [&](status s, int i, status_class sc)
{
BOOST_BEAST_EXPECT(int_to_status(i) == s);
BOOST_BEAST_EXPECT(to_status_class(i) == sc);
BOOST_BEAST_EXPECT(to_status_class(int_to_status(i)) == sc);
BEAST_EXPECT(int_to_status(i) == s);
BEAST_EXPECT(to_status_class(i) == sc);
BEAST_EXPECT(to_status_class(int_to_status(i)) == sc);
};
check(status::continue_ ,100, status_class::informational);
check(status::switching_protocols ,101, status_class::informational);
@@ -96,13 +96,13 @@ public:
check(status::network_authentication_required ,511, status_class::server_error);
check(status::network_connect_timeout_error ,599, status_class::server_error);
BOOST_BEAST_EXPECT(to_status_class(1) == status_class::unknown);
BOOST_BEAST_EXPECT(to_status_class(status::unknown) == status_class::unknown);
BEAST_EXPECT(to_status_class(1) == status_class::unknown);
BEAST_EXPECT(to_status_class(status::unknown) == status_class::unknown);
auto const good =
[&](status v)
{
BOOST_BEAST_EXPECT(obsolete_reason(v) != "Unknown Status");
BEAST_EXPECT(obsolete_reason(v) != "Unknown Status");
};
good(status::continue_);
good(status::switching_protocols);

4
test/http/verb.cpp
View File

@@ -26,7 +26,7 @@ public:
auto const good =
[&](verb v)
{
BOOST_BEAST_EXPECT(string_to_verb(to_string(v)) == v);
BEAST_EXPECT(string_to_verb(to_string(v)) == v);
};
good(verb::unknown);
@@ -69,7 +69,7 @@ public:
[&](string_view s)
{
auto const v = string_to_verb(s);
BOOST_BEAST_EXPECTS(v == verb::unknown, to_string(v));
BEAST_EXPECTS(v == verb::unknown, to_string(v));
};
bad("AC_");

80
test/http/write.cpp
View File

@@ -328,8 +328,8 @@ public:
error_code ec;
test::string_ostream ss{ios_};
async_write(ss, m, do_yield[ec]);
if(BOOST_BEAST_EXPECTS(ec == error::end_of_stream, ec.message()))
BOOST_BEAST_EXPECT(ss.str ==
if(BEAST_EXPECTS(ec == error::end_of_stream, ec.message()))
BEAST_EXPECT(ss.str ==
"HTTP/1.0 200 OK\r\n"
"Server: test\r\n"
"Content-Length: 5\r\n"
@@ -346,8 +346,8 @@ public:
error_code ec;
test::string_ostream ss(ios_);
async_write(ss, m, do_yield[ec]);
if(BOOST_BEAST_EXPECTS(! ec, ec.message()))
BOOST_BEAST_EXPECT(ss.str ==
if(BEAST_EXPECTS(! ec, ec.message()))
BEAST_EXPECT(ss.str ==
"HTTP/1.1 200 OK\r\n"
"Server: test\r\n"
"Transfer-Encoding: chunked\r\n"
@@ -377,7 +377,7 @@ public:
try
{
write(fs, m);
BOOST_BEAST_EXPECT(fs.next_layer().str ==
BEAST_EXPECT(fs.next_layer().str ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"Connection: keep-alive\r\n"
@@ -392,7 +392,7 @@ public:
{
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -407,7 +407,7 @@ public:
write(fs, m, ec);
if(ec == error::end_of_stream)
{
BOOST_BEAST_EXPECT(fs.next_layer().str ==
BEAST_EXPECT(fs.next_layer().str ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"Transfer-Encoding: chunked\r\n"
@@ -422,7 +422,7 @@ public:
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -437,7 +437,7 @@ public:
async_write(fs, m, do_yield[ec]);
if(ec == error::end_of_stream)
{
BOOST_BEAST_EXPECT(fs.next_layer().str ==
BEAST_EXPECT(fs.next_layer().str ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"Transfer-Encoding: chunked\r\n"
@@ -452,7 +452,7 @@ public:
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -468,7 +468,7 @@ public:
write(fs, m, ec);
if(! ec)
{
BOOST_BEAST_EXPECT(fs.next_layer().str ==
BEAST_EXPECT(fs.next_layer().str ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"Connection: keep-alive\r\n"
@@ -479,7 +479,7 @@ public:
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n)
{
@@ -495,7 +495,7 @@ public:
async_write(fs, m, do_yield[ec]);
if(! ec)
{
BOOST_BEAST_EXPECT(fs.next_layer().str ==
BEAST_EXPECT(fs.next_layer().str ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"Connection: keep-alive\r\n"
@@ -506,7 +506,7 @@ public:
break;
}
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void
@@ -521,7 +521,7 @@ public:
m.set(field::user_agent, "test");
m.body = "*";
m.prepare_payload();
BOOST_BEAST_EXPECT(str(m) ==
BEAST_EXPECT(str(m) ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"Content-Length: 1\r\n"
@@ -541,8 +541,8 @@ public:
test::string_ostream ss(ios_);
error_code ec;
write(ss, m, ec);
BOOST_BEAST_EXPECT(ec == error::end_of_stream);
BOOST_BEAST_EXPECT(ss.str ==
BEAST_EXPECT(ec == error::end_of_stream);
BEAST_EXPECT(ss.str ==
"GET / HTTP/1.0\r\n"
"User-Agent: test\r\n"
"\r\n"
@@ -558,7 +558,7 @@ public:
m.set(field::user_agent, "test");
m.body = "*";
m.prepare_payload();
BOOST_BEAST_EXPECT(str(m) ==
BEAST_EXPECT(str(m) ==
"GET / HTTP/1.1\r\n"
"User-Agent: test\r\n"
"Content-Length: 1\r\n"
@@ -578,7 +578,7 @@ public:
test::string_ostream ss(ios_);
error_code ec;
write(ss, m, ec);
BOOST_BEAST_EXPECT(ss.str ==
BEAST_EXPECT(ss.str ==
"GET / HTTP/1.1\r\n"
"User-Agent: test\r\n"
"Transfer-Encoding: chunked\r\n"
@@ -599,7 +599,7 @@ public:
m.version = 11;
m.set(field::user_agent, "test");
m.body = "*";
BOOST_BEAST_EXPECT(to_string(m) ==
BEAST_EXPECT(to_string(m) ==
"GET / HTTP/1.1\r\nUser-Agent: test\r\n\r\n*");
}
@@ -622,7 +622,7 @@ public:
// after calling io_service::stop
boost::asio::io_service ios;
test::string_ostream os{ios};
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
request<string_body> m;
m.method(verb::get);
m.version = 11;
@@ -630,13 +630,13 @@ public:
m.set("Content-Length", 5);
m.body = "*****";
async_write(os, m, handler{});
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
ios.stop();
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
ios.reset();
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
ios.run_one();
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
}
{
// Make sure uninvoked handlers are
@@ -644,7 +644,7 @@ public:
{
boost::asio::io_service ios;
test::string_ostream is{ios};
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
request<string_body> m;
m.method(verb::get);
m.version = 11;
@@ -652,9 +652,9 @@ public:
m.set("Content-Length", 5);
m.body = "*****";
async_write(is, m, handler{});
BOOST_BEAST_EXPECT(handler::count() > 0);
BEAST_EXPECT(handler::count() > 0);
}
BOOST_BEAST_EXPECT(handler::count() == 0);
BEAST_EXPECT(handler::count() == 0);
}
}
@@ -674,7 +674,7 @@ public:
write_some(stream, sr, ec);
if(ec)
return;
BOOST_BEAST_EXPECT(stream.nwrite <= 1);
BEAST_EXPECT(stream.nwrite <= 1);
if(sr.is_done())
break;
}
@@ -697,7 +697,7 @@ public:
async_write_some(stream, sr, yield[ec]);
if(ec)
return;
BOOST_BEAST_EXPECT(stream.nwrite <= 1);
BEAST_EXPECT(stream.nwrite <= 1);
if(sr.is_done())
break;
}
@@ -727,8 +727,8 @@ public:
auto m = m0;
error_code ec;
do_write(p.client, m, ec);
BOOST_BEAST_EXPECT(p.server.str() == result);
BOOST_BEAST_EXPECT(equal_body<false>(
BEAST_EXPECT(p.server.str() == result);
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
@@ -736,8 +736,8 @@ public:
auto m = m0;
error_code ec;
do_async_write(p.client, m, ec, yield);
BOOST_BEAST_EXPECT(p.server.str() == result);
BOOST_BEAST_EXPECT(equal_body<false>(
BEAST_EXPECT(p.server.str() == result);
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
@@ -752,7 +752,7 @@ public:
if(sr.is_header_done())
break;
}
BOOST_BEAST_EXPECT(! m.body.read);
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
{
@@ -766,7 +766,7 @@ public:
if(sr.is_header_done())
break;
}
BOOST_BEAST_EXPECT(! m.body.read);
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
}
@@ -776,7 +776,7 @@ public:
auto m = m0;
error_code ec;
do_write(p.client, m, ec);
BOOST_BEAST_EXPECT(equal_body<false>(
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
@@ -784,7 +784,7 @@ public:
auto m = m0;
error_code ec;
do_async_write(p.client, m, ec, yield);
BOOST_BEAST_EXPECT(equal_body<false>(
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
@@ -800,7 +800,7 @@ public:
if(sr.is_header_done())
break;
}
BOOST_BEAST_EXPECT(! m.body.read);
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
{
@@ -814,7 +814,7 @@ public:
if(sr.is_header_done())
break;
}
BOOST_BEAST_EXPECT(! m.body.read);
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
}

52
test/server/tests.cpp
View File

@@ -78,7 +78,7 @@ public:
req.set(beast::http::field::connection, "close");
beast::http::write(stream, req, ec);
if(! BOOST_BEAST_EXPECTS(
if(! BEAST_EXPECTS(
ec == beast::http::error::end_of_stream,
ec.message()))
return;
@@ -86,7 +86,7 @@ public:
beast::flat_buffer b;
beast::http::response<beast::http::string_body> res;
beast::http::read(stream, b, res, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
}
@@ -95,17 +95,17 @@ public:
doHello(stream<NextLayer>& ws, error_code& ec)
{
ws.handshake("localhost", "/", ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
ws.write(boost::asio::buffer(std::string("Hello, world!")), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
beast::multi_buffer b;
ws.read(b, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
ws.close(beast::websocket::close_code::normal, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
// VFALCO Verify the buffer's contents
drain_buffer drain;
@@ -114,7 +114,7 @@ public:
ws.read(drain, ec);
if(ec == beast::websocket::error::closed)
break;
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
}
}
@@ -125,7 +125,7 @@ public:
error_code ec;
boost::asio::ip::tcp::socket con{ios_};
con.connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
doOptions(con, ec);
}
@@ -136,7 +136,7 @@ public:
error_code ec;
stream<boost::asio::ip::tcp::socket> ws{ios_};
ws.next_layer().connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
doHello(ws, ec);
}
@@ -154,7 +154,7 @@ public:
address_type::from_string("127.0.0.1"), port_num};
auto const wsp = instance.make_port<ws_sync_port>(
ec, ep1, instance, log, get_ws_options());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
auto const ep2 = endpoint_type{
address_type::from_string("127.0.0.1"),
@@ -162,10 +162,10 @@ public:
auto const sp = instance.make_port<
http_sync_port<ws_upgrade_service<ws_sync_port>>>(
ec, ep2, instance, log);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
sp->template init<0>(ec, *wsp);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
wsClient(ep1);
@@ -182,7 +182,7 @@ public:
address_type::from_string("127.0.0.1"), port_num};
auto const wsp = instance.make_port<ws_async_port>(
ec, ep1, instance, log, get_ws_options());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
auto const ep2 = endpoint_type{
address_type::from_string("127.0.0.1"),
@@ -190,10 +190,10 @@ public:
auto const sp = instance.make_port<
http_async_port<ws_upgrade_service<ws_async_port>>>(
ec, ep2, instance, log);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
sp->template init<0>(ec, *wsp);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
wsClient(ep1);
@@ -215,11 +215,11 @@ public:
error_code ec;
boost::asio::ssl::stream<boost::asio::ip::tcp::socket> con{ios_, ctx};
con.next_layer().connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
con.handshake(
boost::asio::ssl::stream_base::client, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
doOptions(con, ec);
if(ec)
@@ -228,7 +228,7 @@ public:
// VFALCO No idea why we get eof in the normal case
if(ec == boost::asio::error::eof)
ec.assign(0, ec.category());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
}
@@ -239,11 +239,11 @@ public:
error_code ec;
stream<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> wss{ios_, ctx};
wss.next_layer().next_layer().connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
wss.next_layer().handshake(
boost::asio::ssl::stream_base::client, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
doHello(wss, ec);
}
@@ -263,7 +263,7 @@ public:
address_type::from_string("127.0.0.1"), port_num};
auto const wsp = instance.make_port<wss_sync_port>(
ec, ep1, instance, log, cert.get(), get_ws_options());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
auto const ep2 = endpoint_type{
address_type::from_string("127.0.0.1"),
@@ -271,10 +271,10 @@ public:
auto const sp = instance.make_port<
https_sync_port<ws_upgrade_service<wss_sync_port>>>(
ec, ep2, instance, log, cert.get());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
sp->template init<0>(ec, *wsp);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
wssClient(ep1, cert.get());
@@ -291,7 +291,7 @@ public:
address_type::from_string("127.0.0.1"), port_num};
auto const wsp = instance.make_port<wss_async_port>(
ec, ep1, instance, log, cert.get(), get_ws_options());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
auto const ep2 = endpoint_type{
address_type::from_string("127.0.0.1"),
@@ -299,10 +299,10 @@ public:
auto const sp = instance.make_port<
https_async_port<ws_upgrade_service<wss_async_port>>>(
ec, ep2, instance, log, cert.get());
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
sp->template init<0>(ec, *wsp);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
wssClient(ep1, cert.get());

10
test/websocket/error.cpp
View File

@@ -23,15 +23,15 @@ public:
void check(char const* name, error ev)
{
auto const ec = make_error_code(ev);
BOOST_BEAST_EXPECT(std::string{ec.category().name()} == name);
BOOST_BEAST_EXPECT(! ec.message().empty());
BOOST_BEAST_EXPECT(std::addressof(ec.category()) ==
BEAST_EXPECT(std::string{ec.category().name()} == name);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(std::addressof(ec.category()) ==
std::addressof(detail::get_error_category()));
BOOST_BEAST_EXPECT(detail::get_error_category().equivalent(
BEAST_EXPECT(detail::get_error_category().equivalent(
static_cast<std::underlying_type<error>::type>(ev),
ec.category().default_error_condition(
static_cast<std::underlying_type<error>::type>(ev))));
BOOST_BEAST_EXPECT(detail::get_error_category().equivalent(
BEAST_EXPECT(detail::get_error_category().equivalent(
ec, static_cast<std::underlying_type<error>::type>(ev)));
}

50
test/websocket/frame.cpp
View File

@@ -42,20 +42,20 @@ class frame_test
public:
void testCloseCodes()
{
BOOST_BEAST_EXPECT(! is_valid_close_code(0));
BOOST_BEAST_EXPECT(! is_valid_close_code(1));
BOOST_BEAST_EXPECT(! is_valid_close_code(999));
BOOST_BEAST_EXPECT(! is_valid_close_code(1004));
BOOST_BEAST_EXPECT(! is_valid_close_code(1005));
BOOST_BEAST_EXPECT(! is_valid_close_code(1006));
BOOST_BEAST_EXPECT(! is_valid_close_code(1016));
BOOST_BEAST_EXPECT(! is_valid_close_code(2000));
BOOST_BEAST_EXPECT(! is_valid_close_code(2999));
BOOST_BEAST_EXPECT(is_valid_close_code(1000));
BOOST_BEAST_EXPECT(is_valid_close_code(1002));
BOOST_BEAST_EXPECT(is_valid_close_code(3000));
BOOST_BEAST_EXPECT(is_valid_close_code(4000));
BOOST_BEAST_EXPECT(is_valid_close_code(5000));
BEAST_EXPECT(! is_valid_close_code(0));
BEAST_EXPECT(! is_valid_close_code(1));
BEAST_EXPECT(! is_valid_close_code(999));
BEAST_EXPECT(! is_valid_close_code(1004));
BEAST_EXPECT(! is_valid_close_code(1005));
BEAST_EXPECT(! is_valid_close_code(1006));
BEAST_EXPECT(! is_valid_close_code(1016));
BEAST_EXPECT(! is_valid_close_code(2000));
BEAST_EXPECT(! is_valid_close_code(2999));
BEAST_EXPECT(is_valid_close_code(1000));
BEAST_EXPECT(is_valid_close_code(1002));
BEAST_EXPECT(is_valid_close_code(3000));
BEAST_EXPECT(is_valid_close_code(4000));
BEAST_EXPECT(is_valid_close_code(5000));
}
struct test_fh : frame_header
@@ -95,16 +95,16 @@ public:
detail::frame_header fh1;
auto const n =
stream.read_fh1(fh1, b, code);
if(! BOOST_BEAST_EXPECT(! code))
if(! BEAST_EXPECT(! code))
return;
if(! BOOST_BEAST_EXPECT(b.size() == n))
if(! BEAST_EXPECT(b.size() == n))
return;
stream.read_fh2(fh1, b, code);
if(! BOOST_BEAST_EXPECT(! code))
if(! BEAST_EXPECT(! code))
return;
if(! BOOST_BEAST_EXPECT(b.size() == 0))
if(! BEAST_EXPECT(b.size() == 0))
return;
BOOST_BEAST_EXPECT(fh1 == fh);
BEAST_EXPECT(fh1 == fh);
};
test_fh fh;
@@ -152,12 +152,12 @@ public:
pass();
return;
}
if(! BOOST_BEAST_EXPECT(b.size() == n))
if(! BEAST_EXPECT(b.size() == n))
return;
stream.read_fh2(fh1, b, code);
if(! BOOST_BEAST_EXPECT(code))
if(! BEAST_EXPECT(code))
return;
if(! BOOST_BEAST_EXPECT(b.size() == 0))
if(! BEAST_EXPECT(b.size() == 0))
return;
};
@@ -221,12 +221,12 @@ public:
pass();
return;
}
if(! BOOST_BEAST_EXPECT(b.size() == n))
if(! BEAST_EXPECT(b.size() == n))
return;
stream.read_fh2(fh, b, code);
if(! BOOST_BEAST_EXPECT(code))
if(! BEAST_EXPECT(code))
return;
if(! BOOST_BEAST_EXPECT(b.size() == 0))
if(! BEAST_EXPECT(b.size() == 0))
return;
}

2
test/websocket/mask.cpp
View File

@@ -46,7 +46,7 @@ public:
void run() override
{
maskgen_t<test_generator> mg;
BOOST_BEAST_EXPECT(mg() != 0);
BEAST_EXPECT(mg() != 0);
}
};

10
test/websocket/rfc6455.cpp
View File

@@ -25,18 +25,18 @@ public:
{
http::header<true> req;
req.version = 10;
BOOST_BEAST_EXPECT(! is_upgrade(req));
BEAST_EXPECT(! is_upgrade(req));
req.version = 11;
req.method(http::verb::post);
req.target("/");
BOOST_BEAST_EXPECT(! is_upgrade(req));
BEAST_EXPECT(! is_upgrade(req));
req.method(http::verb::get);
req.insert("Connection", "upgrade");
BOOST_BEAST_EXPECT(! is_upgrade(req));
BEAST_EXPECT(! is_upgrade(req));
req.insert("Upgrade", "websocket");
BOOST_BEAST_EXPECT(! is_upgrade(req));
BEAST_EXPECT(! is_upgrade(req));
req.insert("Sec-WebSocket-Version", "13");
BOOST_BEAST_EXPECT(is_upgrade(req));
BEAST_EXPECT(is_upgrade(req));
}
void

148
test/websocket/stream.cpp
View File

@@ -636,7 +636,7 @@ public:
, 20};
bool called = false;
c.accept_ex(ws, res_decorator{called});
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
}
// request in buffers
{
@@ -665,7 +665,7 @@ public:
"Sec-WebSocket-Version: 13\r\n"
"\r\n"),
res_decorator{called});
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
}
// request in buffers and stream
{
@@ -696,7 +696,7 @@ public:
"Host: localhost\r\n"
"Upgrade: websocket\r\n"),
res_decorator{called});
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
}
// request in message
{
@@ -728,7 +728,7 @@ public:
bool called = false;
c.accept_ex(ws, req,
res_decorator{called});
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
}
// request in message, close frame in buffers
{
@@ -773,7 +773,7 @@ public:
c.accept_ex(ws, req,
cbuf(0x88, 0x82, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x17),
res_decorator{called});
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
try
{
multi_buffer b;
@@ -873,7 +873,7 @@ public:
}
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void
@@ -944,7 +944,7 @@ public:
bool called = false;
c.handshake_ex(ws, "localhost", "/",
req_decorator{called});
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
}
// handshake_ex, response
{
@@ -956,7 +956,7 @@ public:
c.handshake_ex(ws, res, "localhost", "/",
req_decorator{called});
// VFALCO validate res?
BOOST_BEAST_EXPECT(called);
BEAST_EXPECT(called);
}
}
catch(system_error const&)
@@ -965,7 +965,7 @@ public:
}
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void
@@ -976,7 +976,7 @@ public:
auto const any = endpoint_type{
address_type::from_string("127.0.0.1"), 0};
server.open(any, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const ep = server.local_endpoint();
testHandshake(ep, SyncClient{});
yield_to(
@@ -1001,11 +1001,11 @@ public:
{
ws.accept(
boost::asio::buffer(s.data(), i));
BOOST_BEAST_EXPECTS(! ev, ev.message());
BEAST_EXPECTS(! ev, ev.message());
}
catch(system_error const& se)
{
BOOST_BEAST_EXPECTS(se.code() == ev, se.what());
BEAST_EXPECTS(se.code() == ev, se.what());
}
}
};
@@ -1111,7 +1111,7 @@ public:
}
catch(system_error const& se)
{
BOOST_BEAST_EXPECT(se.code() == error::handshake_failed);
BEAST_EXPECT(se.code() == error::handshake_failed);
}
};
// wrong HTTP version
@@ -1186,20 +1186,20 @@ public:
error_code ec = test::error::fail_error;
socket_type sock(ios_);
sock.connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
stream<socket_type&> ws(sock);
ws.handshake("localhost", "/", ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
ws.write(boost::asio::buffer(v), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
multi_buffer db;
ws.read(db, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
BOOST_BEAST_EXPECT(to_string(db.data()) ==
BEAST_EXPECT(to_string(db.data()) ==
std::string(v.data(), v.size()));
v.push_back(n+1);
}
@@ -1211,20 +1211,20 @@ public:
error_code ec = test::error::fail_error;
socket_type sock(ios_);
sock.connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
stream<socket_type&> ws(sock);
ws.handshake("localhost", "/", ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
ws.async_write(boost::asio::buffer(v), do_yield[ec]);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
multi_buffer db;
ws.async_read(db, do_yield[ec]);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
BOOST_BEAST_EXPECT(to_string(db.data()) ==
BEAST_EXPECT(to_string(db.data()) ==
std::string(v.data(), v.size()));
v.push_back(n+1);
}
@@ -1301,7 +1301,7 @@ public:
{
++count;
// Send is canceled because close received.
BOOST_BEAST_EXPECT(ec == boost::asio::
BEAST_EXPECT(ec == boost::asio::
error::operation_aborted,
ec.message());
// Writes after close are aborted.
@@ -1309,7 +1309,7 @@ public:
[&](error_code ec)
{
++count;
BOOST_BEAST_EXPECT(ec == boost::asio::
BEAST_EXPECT(ec == boost::asio::
error::operation_aborted,
ec.message());
});
@@ -1323,7 +1323,7 @@ public:
break;
ios.run_one();
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
ios.run();
}
#endif
@@ -1348,14 +1348,14 @@ public:
{
// Read should fail with protocol error
++count;
BOOST_BEAST_EXPECTS(
BEAST_EXPECTS(
ec == error::failed, ec.message());
// Reads after failure are aborted
ws.async_read(db,
[&](error_code ec, std::size_t)
{
++count;
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
});
@@ -1370,7 +1370,7 @@ public:
{
++count;
// Send is canceled because close received.
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
// Writes after close are aborted.
@@ -1378,7 +1378,7 @@ public:
[&](error_code ec)
{
++count;
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
});
@@ -1392,7 +1392,7 @@ public:
break;
ios.run_one();
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
ios.run();
}
@@ -1415,19 +1415,19 @@ public:
{
// Read should complete with error::closed
++count;
BOOST_BEAST_EXPECTS(ec == error::closed,
BEAST_EXPECTS(ec == error::closed,
ec.message());
// Pings after a close are aborted
ws.async_ping("",
[&](error_code ec)
{
++count;
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
});
});
if(! BOOST_BEAST_EXPECT(run_until(ios, 100,
if(! BEAST_EXPECT(run_until(ios, 100,
[&]{ return ws.wr_close_; })))
return;
// Try to ping
@@ -1436,7 +1436,7 @@ public:
{
// Pings after a close are aborted
++count;
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
// Subsequent calls to close are aborted
@@ -1444,7 +1444,7 @@ public:
[&](error_code ec)
{
++count;
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
});
@@ -1457,7 +1457,7 @@ public:
break;
ios.run_one();
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
ios.run();
}
@@ -1477,7 +1477,7 @@ public:
[&](error_code ec, std::size_t)
{
++count;
BOOST_BEAST_EXPECTS(ec == error::closed,
BEAST_EXPECTS(ec == error::closed,
ec.message());
});
while(! ws.wr_block_)
@@ -1487,7 +1487,7 @@ public:
[&](error_code ec)
{
++count;
BOOST_BEAST_EXPECTS(ec == boost::asio::
BEAST_EXPECTS(ec == boost::asio::
error::operation_aborted,
ec.message());
});
@@ -1499,7 +1499,7 @@ public:
break;
ios.run_one();
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
ios.run();
}
@@ -1514,20 +1514,20 @@ public:
ws.async_write(sbuf("CLOSE"),
[&](error_code ec)
{
BOOST_BEAST_EXPECT(! ec);
BEAST_EXPECT(! ec);
ws.async_write(sbuf("PING"),
[&](error_code ec)
{
BOOST_BEAST_EXPECT(! ec);
BEAST_EXPECT(! ec);
});
});
multi_buffer db;
ws.async_read(db,
[&](error_code ec, std::size_t)
{
BOOST_BEAST_EXPECTS(ec == error::closed, ec.message());
BEAST_EXPECTS(ec == error::closed, ec.message());
});
if(! BOOST_BEAST_EXPECT(run_until(ios, 100,
if(! BEAST_EXPECT(run_until(ios, 100,
[&]{ return ios.stopped(); })))
return;
}
@@ -1544,17 +1544,17 @@ public:
error_code ec;
socket_type sock{ios_};
sock.connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
stream<socket_type&> ws{sock};
ws.handshake("localhost", "/", ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
ws.write_some(false, sbuf("u"));
ws.write_some(true, sbuf("v"));
multi_buffer b;
ws.read(b, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
}
@@ -1567,11 +1567,11 @@ public:
error_code ec;
socket_type sock(ios);
sock.connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
stream<socket_type&> ws(sock);
ws.handshake("localhost", "/", ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
ws.async_write_some(false,
boost::asio::null_buffers{},
@@ -1580,7 +1580,7 @@ public:
fail();
});
ws.next_layer().cancel(ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
break;
//
// Destruction of the io_service will cause destruction
@@ -1623,7 +1623,7 @@ public:
}
error_code ec;
ws.lowest_layer().connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
throw abort_test{};
c.handshake(ws, "localhost", "/");
};
@@ -1633,7 +1633,7 @@ public:
// connect
error_code ec;
ws.lowest_layer().connect(ep, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
}
c.handshake(ws, "localhost", "/");
@@ -1646,8 +1646,8 @@ public:
// receive echoed message
multi_buffer db;
c.read(ws, db);
BOOST_BEAST_EXPECT(ws.got_text());
BOOST_BEAST_EXPECT(to_string(db.data()) == "Hello");
BEAST_EXPECT(ws.got_text());
BEAST_EXPECT(to_string(db.data()) == "Hello");
}
// close, no payload
@@ -1669,10 +1669,10 @@ public:
ws.control_callback(
[&](frame_type kind, string_view s)
{
BOOST_BEAST_EXPECT(kind == frame_type::pong);
BOOST_BEAST_EXPECT(! once);
BEAST_EXPECT(kind == frame_type::pong);
BEAST_EXPECT(! once);
once = true;
BOOST_BEAST_EXPECT(s == "");
BEAST_EXPECT(s == "");
});
c.ping(ws, "");
ws.binary(true);
@@ -1681,9 +1681,9 @@ public:
// receive echoed message
multi_buffer db;
c.read(ws, db);
BOOST_BEAST_EXPECT(once);
BOOST_BEAST_EXPECT(ws.got_binary());
BOOST_BEAST_EXPECT(to_string(db.data()) == "Hello");
BEAST_EXPECT(once);
BEAST_EXPECT(ws.got_binary());
BEAST_EXPECT(to_string(db.data()) == "Hello");
}
ws.control_callback({});
@@ -1692,10 +1692,10 @@ public:
ws.control_callback(
[&](frame_type kind, string_view s)
{
BOOST_BEAST_EXPECT(kind == frame_type::pong);
BOOST_BEAST_EXPECT(! once);
BEAST_EXPECT(kind == frame_type::pong);
BEAST_EXPECT(! once);
once = true;
BOOST_BEAST_EXPECT(s == "payload");
BEAST_EXPECT(s == "payload");
});
ws.ping("payload");
c.write_some(ws, false, sbuf("Hello, "));
@@ -1705,8 +1705,8 @@ public:
// receive echoed message
multi_buffer db;
c.read(ws, db);
BOOST_BEAST_EXPECT(once);
BOOST_BEAST_EXPECT(to_string(db.data()) == "Hello, World!");
BEAST_EXPECT(once);
BEAST_EXPECT(to_string(db.data()) == "Hello, World!");
}
ws.control_callback({});
@@ -1721,7 +1721,7 @@ public:
// receive echoed message
multi_buffer b;
c.read(ws, b);
BOOST_BEAST_EXPECT(to_string(b.data()) == "Now is the time for all good men");
BEAST_EXPECT(to_string(b.data()) == "Now is the time for all good men");
}
ws.auto_fragment(false);
ws.write_buffer_size(4096);
@@ -1735,7 +1735,7 @@ public:
// receive echoed message
multi_buffer db;
c.read(ws, db);
BOOST_BEAST_EXPECT(to_string(db.data()) == s);
BEAST_EXPECT(to_string(db.data()) == s);
}
}
@@ -1748,8 +1748,8 @@ public:
// receive echoed message
multi_buffer db;
c.read(ws, db);
BOOST_BEAST_EXPECT(ws.got_text());
BOOST_BEAST_EXPECT(to_string(db.data()) == "Hello");
BEAST_EXPECT(ws.got_text());
BEAST_EXPECT(to_string(db.data()) == "Hello");
}
// cause close
@@ -1819,7 +1819,7 @@ public:
}
break;
}
BOOST_BEAST_EXPECT(n < limit);
BEAST_EXPECT(n < limit);
}
void
@@ -1864,7 +1864,7 @@ public:
::websocket::sync_echo_server server{nullptr};
server.set_option(pmd);
server.open(any, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const ep = server.local_endpoint();
//testPausation1(ep);
testPausation2(ep);
@@ -1879,7 +1879,7 @@ public:
error_code ec;
::websocket::async_echo_server server{nullptr, 4};
server.open(any, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const ep = server.local_endpoint();
testAsyncWriteFrame(ep);
}
@@ -1892,7 +1892,7 @@ public:
::websocket::sync_echo_server server{nullptr};
server.set_option(pmd);
server.open(any, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const ep = server.local_endpoint();
testEndpoint(SyncClient{}, ep, pmd);
yield_to(
@@ -1907,7 +1907,7 @@ public:
::websocket::async_echo_server server{nullptr, 4};
server.set_option(pmd);
server.open(any, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECTS(! ec, ec.message());
auto const ep = server.local_endpoint();
testEndpoint(SyncClient{}, ep, pmd);
yield_to(

112
test/websocket/utf8_checker.cpp
View File

@@ -38,22 +38,22 @@ public:
})();
// Valid range 0-127
BOOST_BEAST_EXPECT(utf8.write(buf.data(), 128));
BOOST_BEAST_EXPECT(utf8.finish());
BEAST_EXPECT(utf8.write(buf.data(), 128));
BEAST_EXPECT(utf8.finish());
// Invalid range 128-193
for(auto it = std::next(buf.begin(), 128);
it != std::next(buf.begin(), 194); ++it)
BOOST_BEAST_EXPECT(! utf8.write(&(*it), 1));
BEAST_EXPECT(! utf8.write(&(*it), 1));
// Invalid range 245-255
for(auto it = std::next(buf.begin(), 245);
it != buf.end(); ++it)
BOOST_BEAST_EXPECT(! utf8.write(&(*it), 1));
BEAST_EXPECT(! utf8.write(&(*it), 1));
// Invalid sequence
std::fill(buf.begin(), buf.end(), '\xff');
BOOST_BEAST_EXPECT(! utf8.write(&buf.front(), buf.size()));
BEAST_EXPECT(! utf8.write(&buf.front(), buf.size()));
}
void
@@ -70,27 +70,27 @@ public:
{
// Second byte valid range 128-191
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(utf8.write(buf, 2));
BOOST_BEAST_EXPECT(utf8.finish());
BEAST_EXPECT(utf8.write(buf, 2));
BEAST_EXPECT(utf8.finish());
}
for(auto j = 0; j <= 127; ++j)
{
// Second byte invalid range 0-127
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(! utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(buf, 2));
}
for(auto j = 192; j <= 255; ++j)
{
// Second byte invalid range 192-255
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(! utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(buf, 2));
}
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(utf8.write(buf, 1));
BOOST_BEAST_EXPECT(! utf8.write(&buf[1], 1));
BEAST_EXPECT(utf8.write(buf, 1));
BEAST_EXPECT(! utf8.write(&buf[1], 1));
utf8.reset();
}
}
@@ -116,15 +116,15 @@ public:
{
// Third byte valid range 128-191
buf[2] = static_cast<std::uint8_t>(k);
BOOST_BEAST_EXPECT(utf8.write(buf, 3));
BOOST_BEAST_EXPECT(utf8.finish());
BEAST_EXPECT(utf8.write(buf, 3));
BEAST_EXPECT(utf8.finish());
// Segmented sequence
BOOST_BEAST_EXPECT(utf8.write(buf, 1));
BOOST_BEAST_EXPECT(utf8.write(&buf[1], 2));
BEAST_EXPECT(utf8.write(buf, 1));
BEAST_EXPECT(utf8.write(&buf[1], 2));
utf8.reset();
// Segmented sequence
BOOST_BEAST_EXPECT(utf8.write(buf, 2));
BOOST_BEAST_EXPECT(utf8.write(&buf[2], 1));
BEAST_EXPECT(utf8.write(buf, 2));
BEAST_EXPECT(utf8.write(&buf[2], 1));
utf8.reset();
if (i == 224)
@@ -133,11 +133,11 @@ public:
{
// Second byte invalid range 0-127 or 0-159
buf[1] = static_cast<std::uint8_t>(l);
BOOST_BEAST_EXPECT(! utf8.write(buf, 3));
BEAST_EXPECT(! utf8.write(buf, 3));
if (l > 127)
{
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(! utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(buf, 2));
utf8.reset();
}
}
@@ -149,11 +149,11 @@ public:
{
// Second byte invalid range 160-255 or 192-255
buf[1] = static_cast<std::uint8_t>(l);
BOOST_BEAST_EXPECT(!utf8.write(buf, 3));
BEAST_EXPECT(!utf8.write(buf, 3));
if (l > 159)
{
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(! utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(buf, 2));
utf8.reset();
}
}
@@ -165,19 +165,19 @@ public:
{
// Third byte invalid range 0-127
buf[2] = static_cast<std::uint8_t>(k);
BOOST_BEAST_EXPECT(! utf8.write(buf, 3));
BEAST_EXPECT(! utf8.write(buf, 3));
}
for(auto k = 192; k <= 255; ++k)
{
// Third byte invalid range 192-255
buf[2] = static_cast<std::uint8_t>(k);
BOOST_BEAST_EXPECT(! utf8.write(buf, 3));
BEAST_EXPECT(! utf8.write(buf, 3));
}
// Segmented sequence third byte invalid
BOOST_BEAST_EXPECT(utf8.write(buf, 2));
BOOST_BEAST_EXPECT(! utf8.write(&buf[2], 1));
BEAST_EXPECT(utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(&buf[2], 1));
utf8.reset();
}
@@ -185,19 +185,19 @@ public:
{
// Second byte invalid range 0-127 or 0-159
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(! utf8.write(buf, 3));
BEAST_EXPECT(! utf8.write(buf, 3));
}
for(auto j = e + 1; j <= 255; ++j)
{
// Second byte invalid range 160-255 or 192-255
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(! utf8.write(buf, 3));
BEAST_EXPECT(! utf8.write(buf, 3));
}
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(utf8.write(buf, 1));
BOOST_BEAST_EXPECT(! utf8.write(&buf[1], 1));
BEAST_EXPECT(utf8.write(buf, 1));
BEAST_EXPECT(! utf8.write(&buf[1], 1));
utf8.reset();
}
}
@@ -229,19 +229,19 @@ public:
{
// Fourth byte valid range 128-191
buf[3] = static_cast<std::uint8_t>(n);
BOOST_BEAST_EXPECT(utf8.write(const_buffers_1{buf, 4}));
BOOST_BEAST_EXPECT(utf8.finish());
BEAST_EXPECT(utf8.write(const_buffers_1{buf, 4}));
BEAST_EXPECT(utf8.finish());
// Segmented sequence
BOOST_BEAST_EXPECT(utf8.write(buf, 1));
BOOST_BEAST_EXPECT(utf8.write(&buf[1], 3));
BEAST_EXPECT(utf8.write(buf, 1));
BEAST_EXPECT(utf8.write(&buf[1], 3));
utf8.reset();
// Segmented sequence
BOOST_BEAST_EXPECT(utf8.write(buf, 2));
BOOST_BEAST_EXPECT(utf8.write(&buf[2], 2));
BEAST_EXPECT(utf8.write(buf, 2));
BEAST_EXPECT(utf8.write(&buf[2], 2));
utf8.reset();
// Segmented sequence
BOOST_BEAST_EXPECT(utf8.write(buf, 3));
BOOST_BEAST_EXPECT(utf8.write(&buf[3], 1));
BEAST_EXPECT(utf8.write(buf, 3));
BEAST_EXPECT(utf8.write(&buf[3], 1));
utf8.reset();
if (i == 240)
@@ -250,11 +250,11 @@ public:
{
// Second byte invalid range 0-127 or 0-143
buf[1] = static_cast<std::uint8_t>(l);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
if (l > 127)
{
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(! utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(buf, 2));
utf8.reset();
}
}
@@ -266,11 +266,11 @@ public:
{
// Second byte invalid range 144-255 or 192-255
buf[1] = static_cast<std::uint8_t>(l);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
if (l > 143)
{
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(! utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(buf, 2));
utf8.reset();
}
}
@@ -282,19 +282,19 @@ public:
{
// Fourth byte invalid range 0-127
buf[3] = static_cast<std::uint8_t>(n);
BOOST_BEAST_EXPECT(! utf8.write(const_buffers_1{buf, 4}));
BEAST_EXPECT(! utf8.write(const_buffers_1{buf, 4}));
}
for(auto n = 192; n <= 255; ++n)
{
// Fourth byte invalid range 192-255
buf[3] = static_cast<std::uint8_t>(n);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
}
// Segmented sequence fourth byte invalid
BOOST_BEAST_EXPECT(utf8.write(buf, 3));
BOOST_BEAST_EXPECT(! utf8.write(&buf[3], 1));
BEAST_EXPECT(utf8.write(buf, 3));
BEAST_EXPECT(! utf8.write(&buf[3], 1));
utf8.reset();
}
@@ -302,19 +302,19 @@ public:
{
// Third byte invalid range 0-127
buf[2] = static_cast<std::uint8_t>(k);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
}
for(auto k = 192; k <= 255; ++k)
{
// Third byte invalid range 192-255
buf[2] = static_cast<std::uint8_t>(k);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
}
// Segmented sequence third byte invalid
BOOST_BEAST_EXPECT(utf8.write(buf, 2));
BOOST_BEAST_EXPECT(! utf8.write(&buf[2], 1));
BEAST_EXPECT(utf8.write(buf, 2));
BEAST_EXPECT(! utf8.write(&buf[2], 1));
utf8.reset();
}
@@ -322,19 +322,19 @@ public:
{
// Second byte invalid range 0-127 or 0-143
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
}
for(auto j = e + 1; j <= 255; ++j)
{
// Second byte invalid range 144-255 or 192-255
buf[1] = static_cast<std::uint8_t>(j);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
}
// Segmented sequence second byte invalid
BOOST_BEAST_EXPECT(utf8.write(buf, 1));
BOOST_BEAST_EXPECT(! utf8.write(&buf[1], 1));
BEAST_EXPECT(utf8.write(buf, 1));
BEAST_EXPECT(! utf8.write(&buf[1], 1));
utf8.reset();
}
@@ -342,7 +342,7 @@ public:
{
// First byte invalid range 245-255
buf[0] = static_cast<std::uint8_t>(i);
BOOST_BEAST_EXPECT(! utf8.write(buf, 4));
BEAST_EXPECT(! utf8.write(buf, 4));
}
}
@@ -390,8 +390,8 @@ public:
cb.consume(amount);
n -= amount;
}
BOOST_BEAST_EXPECT(utf8.write(b.data()));
BOOST_BEAST_EXPECT(utf8.finish());
BEAST_EXPECT(utf8.write(b.data()));
BEAST_EXPECT(utf8.finish());
}
}
}

22
test/zlib/deflate_stream.cpp
View File

@@ -56,7 +56,7 @@ public:
-windowBits,
8,
strategy);
if(! BOOST_BEAST_EXPECT(result == Z_OK))
if(! BEAST_EXPECT(result == Z_OK))
goto err;
out.resize(deflateBound(&zs,
static_cast<uLong>(check.size())));
@@ -72,7 +72,7 @@ public:
if( result == Z_BUF_ERROR ||
result == Z_STREAM_END) // per zlib FAQ
goto fin;
if(! BOOST_BEAST_EXPECT(progress))
if(! BEAST_EXPECT(progress))
goto err;
progress = false;
}
@@ -83,7 +83,7 @@ public:
{
z_inflator zi;
auto const s = zi(out);
BOOST_BEAST_EXPECT(s == check);
BEAST_EXPECT(s == check);
}
err:
@@ -118,9 +118,9 @@ public:
if( ec == error::need_buffers ||
ec == error::end_of_stream) // per zlib FAQ
goto fin;
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
goto err;
if(! BOOST_BEAST_EXPECT(progress))
if(! BEAST_EXPECT(progress))
goto err;
progress = false;
}
@@ -131,7 +131,7 @@ public:
{
z_inflator zi;
auto const s = zi(out);
BOOST_BEAST_EXPECT(s == check);
BEAST_EXPECT(s == check);
}
err:
@@ -158,7 +158,7 @@ public:
-windowBits,
8,
strategy);
if(! BOOST_BEAST_EXPECT(result == Z_OK))
if(! BEAST_EXPECT(result == Z_OK))
continue;
std::string out;
out.resize(deflateBound(&zs,
@@ -181,7 +181,7 @@ public:
if( result == Z_BUF_ERROR ||
result == Z_STREAM_END) // per zlib FAQ
goto fin;
if(! BOOST_BEAST_EXPECT(result == Z_OK))
if(! BEAST_EXPECT(result == Z_OK))
goto err;
if(zs.avail_in == 0 && ! bi)
{
@@ -202,7 +202,7 @@ public:
{
z_inflator zi;
auto const s = zi(out);
BOOST_BEAST_EXPECT(s == check);
BEAST_EXPECT(s == check);
}
err:
@@ -246,7 +246,7 @@ public:
if( ec == error::need_buffers ||
ec == error::end_of_stream) // per zlib FAQ
goto fin;
if(! BOOST_BEAST_EXPECTS(! ec, ec.message()))
if(! BEAST_EXPECTS(! ec, ec.message()))
goto err;
if(zs.avail_in == 0 && ! bi)
{
@@ -267,7 +267,7 @@ public:
{
z_inflator zi;
auto const s = zi(out);
BOOST_BEAST_EXPECT(s == check);
BEAST_EXPECT(s == check);
}
err:

10
test/zlib/error.cpp
View File

@@ -23,15 +23,15 @@ public:
void check(char const* name, error ev)
{
auto const ec = make_error_code(ev);
BOOST_BEAST_EXPECT(std::string{ec.category().name()} == name);
BOOST_BEAST_EXPECT(! ec.message().empty());
BOOST_BEAST_EXPECT(std::addressof(ec.category()) ==
BEAST_EXPECT(std::string{ec.category().name()} == name);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(std::addressof(ec.category()) ==
std::addressof(detail::get_error_category()));
BOOST_BEAST_EXPECT(detail::get_error_category().equivalent(
BEAST_EXPECT(detail::get_error_category().equivalent(
static_cast<std::underlying_type<error>::type>(ev),
ec.category().default_error_condition(
static_cast<std::underlying_type<error>::type>(ev))));
BOOST_BEAST_EXPECT(detail::get_error_category().equivalent(
BEAST_EXPECT(detail::get_error_category().equivalent(
ec, static_cast<std::underlying_type<error>::type>(ev)));
}