boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-08-02 06:15:24 +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: Version 87:
* Update appveyor for Boost branch * 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. /** Check a precondition.
If the condition is false, the file and line number are reported. 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 #endif
#ifndef BOOST_BEAST_EXPECTS #ifndef BEAST_EXPECTS
/** Check a precondition. /** Check a precondition.
If the condition is false, the file and line number are reported. 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)) (fail((reason), __FILE__, __LINE__), false))
#endif #endif

8
test/benchmarks/parser.cpp
View File

@@ -61,7 +61,7 @@ public:
{ {
mg.request(v[i]); mg.request(v[i]);
size_ += v[i].size(); size_ += v[i].size();
BOOST_BEAST_EXPECT(v[i].size() > 0); BEAST_EXPECT(v[i].size() > 0);
} }
return v; return v;
} }
@@ -76,7 +76,7 @@ public:
{ {
mg.response(v[i]); mg.response(v[i]);
size_ += v[i].size(); size_ += v[i].size();
BOOST_BEAST_EXPECT(v[i].size() > 0); BEAST_EXPECT(v[i].size() > 0);
} }
return v; return v;
} }
@@ -121,7 +121,7 @@ public:
Parser p; Parser p;
error_code ec; error_code ec;
p.write(b.data(), 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; log << to_string(b.data()) << std::endl;
} }
} }
@@ -137,7 +137,7 @@ public:
p.header_limit((std::numeric_limits<std::uint32_t>::max)()); p.header_limit((std::numeric_limits<std::uint32_t>::max)());
error_code ec; error_code ec;
feed(b.data(), p, 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; 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) check (std::string const& in, std::string const& out)
{ {
auto const encoded = base64_encode (in); auto const encoded = base64_encode (in);
BOOST_BEAST_EXPECT(encoded == out); BEAST_EXPECT(encoded == out);
BOOST_BEAST_EXPECT(base64_decode (encoded) == in); BEAST_EXPECT(base64_decode (encoded) == in);
} }
void void

2
test/core/bind_handler.cpp
View File

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

28
test/core/buffer_cat.cpp
View File

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

36
test/core/buffer_prefix.cpp
View File

@@ -112,7 +112,7 @@ public:
{ {
using boost::asio::buffer_size; using boost::asio::buffer_size;
std::string s = "Hello, world"; 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 x = 1; x < 4; ++x) {
for(std::size_t y = 1; y < 4; ++y) { for(std::size_t y = 1; y < 4; ++y) {
std::size_t z = s.size() - (x + 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) for(std::size_t i = 0; i <= s.size() + 1; ++i)
{ {
auto pb = buffer_prefix(i, bs); 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; 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); pb = buffer_prefix(0, bs);
pb2 = pb; pb2 = pb;
BOOST_BEAST_EXPECT(buffer_size(pb2) == 0); BEAST_EXPECT(buffer_size(pb2) == 0);
pb2 = buffer_prefix(i, bs); 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::buffer_size;
using boost::asio::null_buffers; using boost::asio::null_buffers;
auto pb0 = buffer_prefix(0, 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{}); auto pb1 = buffer_prefix(1, null_buffers{});
BOOST_BEAST_EXPECT(buffer_size(pb1) == 0); BEAST_EXPECT(buffer_size(pb1) == 0);
BOOST_BEAST_EXPECT(buffer_copy(pb0, pb1) == 0); BEAST_EXPECT(buffer_copy(pb0, pb1) == 0);
using pb_type = decltype(pb0); using pb_type = decltype(pb0);
consuming_buffers<pb_type> cb(pb0); consuming_buffers<pb_type> cb(pb0);
BOOST_BEAST_EXPECT(buffer_size(cb) == 0); BEAST_EXPECT(buffer_size(cb) == 0);
BOOST_BEAST_EXPECT(buffer_copy(cb, pb1) == 0); BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
cb.consume(1); cb.consume(1);
BOOST_BEAST_EXPECT(buffer_size(cb) == 0); BEAST_EXPECT(buffer_size(cb) == 0);
BOOST_BEAST_EXPECT(buffer_copy(cb, pb1) == 0); BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
auto pbc = buffer_prefix(2, cb); auto pbc = buffer_prefix(2, cb);
BOOST_BEAST_EXPECT(buffer_size(pbc) == 0); BEAST_EXPECT(buffer_size(pbc) == 0);
BOOST_BEAST_EXPECT(buffer_copy(pbc, cb) == 0); BEAST_EXPECT(buffer_copy(pbc, cb) == 0);
} }
void testIterator() void testIterator()
@@ -171,10 +171,10 @@ public:
const_buffer{&b[1], 1}, const_buffer{&b[1], 1},
const_buffer{&b[2], 1}}}; const_buffer{&b[2], 1}}};
auto pb = buffer_prefix(2, bs); auto pb = buffer_prefix(2, bs);
BOOST_BEAST_EXPECT(bsize1(pb) == 2); BEAST_EXPECT(bsize1(pb) == 2);
BOOST_BEAST_EXPECT(bsize2(pb) == 2); BEAST_EXPECT(bsize2(pb) == 2);
BOOST_BEAST_EXPECT(bsize3(pb) == 2); BEAST_EXPECT(bsize3(pb) == 2);
BOOST_BEAST_EXPECT(bsize4(pb) == 2); BEAST_EXPECT(bsize4(pb) == 2);
} }
void run() override 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> srs(ios);
buffered_read_stream<socket_type, multi_buffer> srs2(std::move(srs)); buffered_read_stream<socket_type, multi_buffer> srs2(std::move(srs));
srs = std::move(srs2); srs = std::move(srs2);
BOOST_BEAST_EXPECT(&srs.get_io_service() == &ios); BEAST_EXPECT(&srs.get_io_service() == &ios);
BOOST_BEAST_EXPECT(&srs.get_io_service() == &srs2.get_io_service()); BEAST_EXPECT(&srs.get_io_service() == &srs2.get_io_service());
} }
{ {
socket_type sock(ios); socket_type sock(ios);
@@ -66,11 +66,11 @@ public:
boost::asio::read(srs, buffer(&s[0], s.size()), ec); boost::asio::read(srs, buffer(&s[0], s.size()), ec);
if(! ec) if(! ec)
{ {
BOOST_BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
break; break;
} }
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
@@ -85,11 +85,11 @@ public:
boost::asio::read(srs, buffer(&s[0], s.size()), ec); boost::asio::read(srs, buffer(&s[0], s.size()), ec);
if(! ec) if(! ec)
{ {
BOOST_BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
break; break;
} }
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
@@ -104,11 +104,11 @@ public:
srs, buffer(&s[0], s.size()), do_yield[ec]); srs, buffer(&s[0], s.size()), do_yield[ec]);
if(! ec) if(! ec)
{ {
BOOST_BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
break; break;
} }
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
@@ -124,11 +124,11 @@ public:
srs, buffer(&s[0], s.size()), do_yield[ec]); srs, buffer(&s[0], s.size()), do_yield[ec]);
if(! ec) if(! ec)
{ {
BOOST_BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
break; break;
} }
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
} }
void run() override void run() override

68
test/core/buffers_adapter.cpp
View File

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

2
test/core/clamp.cpp
View File

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

44
test/core/consuming_buffers.cpp
View File

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

20
test/core/doc_examples.cpp
View File

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

12
test/core/drain_buffer.cpp
View File

@@ -27,8 +27,8 @@ public:
{ {
using boost::asio::buffer_size; using boost::asio::buffer_size;
drain_buffer b; drain_buffer b;
BOOST_BEAST_EXPECT(buffer_size(b.prepare(0)) == 0); BEAST_EXPECT(buffer_size(b.prepare(0)) == 0);
BOOST_BEAST_EXPECT(buffer_size(b.prepare(100)) == 100); BEAST_EXPECT(buffer_size(b.prepare(100)) == 100);
try try
{ {
b.prepare(b.max_size() + 1); b.prepare(b.max_size() + 1);
@@ -39,13 +39,13 @@ public:
pass(); pass();
} }
b.prepare(10); b.prepare(10);
BOOST_BEAST_EXPECT(b.size() == 0); BEAST_EXPECT(b.size() == 0);
b.commit(10); b.commit(10);
BOOST_BEAST_EXPECT(b.size() == 0); BEAST_EXPECT(b.size() == 0);
b.consume(10); b.consume(10);
BOOST_BEAST_EXPECT(b.size() == 0); BEAST_EXPECT(b.size() == 0);
b.consume(1000); 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 void
run() run()
{ {
BOOST_BEAST_EXPECT(test_one()); BEAST_EXPECT(test_one());
BOOST_BEAST_EXPECT(test_two()); BEAST_EXPECT(test_two());
pass(); pass();
} }
}; };

64
test/core/file_test.hpp
View File

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

164
test/core/flat_buffer.cpp
View File

@@ -44,25 +44,25 @@ public:
{ {
{ {
flat_buffer b; flat_buffer b;
BOOST_BEAST_EXPECT(b.capacity() == 0); BEAST_EXPECT(b.capacity() == 0);
} }
{ {
flat_buffer b{500}; flat_buffer b{500};
BOOST_BEAST_EXPECT(b.capacity() == 0); BEAST_EXPECT(b.capacity() == 0);
BOOST_BEAST_EXPECT(b.max_size() == 500); BEAST_EXPECT(b.max_size() == 500);
} }
{ {
a_neq_t a1; a_neq_t a1;
basic_flat_buffer<a_neq_t> b{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; a_neq_t a2;
BOOST_BEAST_EXPECT(b.get_allocator() != a2); BEAST_EXPECT(b.get_allocator() != a2);
} }
{ {
a_neq_t a; a_neq_t a;
basic_flat_buffer<a_neq_t> b{500, a}; basic_flat_buffer<a_neq_t> b{500, a};
BOOST_BEAST_EXPECT(b.capacity() == 0); BEAST_EXPECT(b.capacity() == 0);
BOOST_BEAST_EXPECT(b.max_size() == 500); BEAST_EXPECT(b.max_size() == 500);
} }
} }
@@ -70,34 +70,34 @@ public:
{ {
{ {
basic_flat_buffer<a_t> b1{30}; 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"; ostream(b1) << "Hello";
basic_flat_buffer<a_t> b2{std::move(b1)}; basic_flat_buffer<a_t> b2{std::move(b1)};
BOOST_BEAST_EXPECT(b2.get_allocator()->nmove == 1); BEAST_EXPECT(b2.get_allocator()->nmove == 1);
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size()); BEAST_EXPECT(b1.max_size() == b2.max_size());
} }
{ {
basic_flat_buffer<a_t> b1{30}; basic_flat_buffer<a_t> b1{30};
ostream(b1) << "Hello"; ostream(b1) << "Hello";
a_t a; a_t a;
basic_flat_buffer<a_t> b2{std::move(b1), a}; basic_flat_buffer<a_t> b2{std::move(b1), a};
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size()); BEAST_EXPECT(b1.max_size() == b2.max_size());
} }
{ {
basic_flat_buffer<a_neq_t> b1{30}; basic_flat_buffer<a_neq_t> b1{30};
ostream(b1) << "Hello"; ostream(b1) << "Hello";
a_neq_t a; a_neq_t a;
basic_flat_buffer<a_neq_t> b2{std::move(b1), a}; basic_flat_buffer<a_neq_t> b2{std::move(b1), a};
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
BOOST_BEAST_EXPECT(b1.max_size() == b2.max_size()); BEAST_EXPECT(b1.max_size() == b2.max_size());
} }
} }
@@ -106,34 +106,34 @@ public:
basic_flat_buffer<a_t> b1; basic_flat_buffer<a_t> b1;
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<a_t> b2(b1); basic_flat_buffer<a_t> b2(b1);
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator()); BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello"); BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
basic_flat_buffer<a_neq_t> b1; basic_flat_buffer<a_neq_t> b1;
ostream(b1) << "Hello"; ostream(b1) << "Hello";
a_neq_t a; a_neq_t a;
basic_flat_buffer<a_neq_t> b2(b1, a); basic_flat_buffer<a_neq_t> b2(b1, a);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator()); BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello"); BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
basic_flat_buffer<a_t> b1; basic_flat_buffer<a_t> b1;
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<a_neq_t> b2(b1); basic_flat_buffer<a_neq_t> b2(b1);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello"); BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
basic_flat_buffer<a_neq_t> b1; basic_flat_buffer<a_neq_t> b1;
ostream(b1) << "Hello"; ostream(b1) << "Hello";
a_t a; a_t a;
basic_flat_buffer<a_t> b2(b1, a); basic_flat_buffer<a_t> b2(b1, a);
BOOST_BEAST_EXPECT(b2.get_allocator() == a); BEAST_EXPECT(b2.get_allocator() == a);
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello"); BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
// move assignment // move assignment
@@ -143,9 +143,9 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
flat_buffer b2; flat_buffer b2;
b2 = std::move(b1); b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
using na_t = test::test_allocator<char, using na_t = test::test_allocator<char,
@@ -154,10 +154,10 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<na_t> b2; basic_flat_buffer<na_t> b2;
b2 = std::move(b1); b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator()); BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
using na_t = test::test_allocator<char, using na_t = test::test_allocator<char,
@@ -166,10 +166,10 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<na_t> b2; basic_flat_buffer<na_t> b2;
b2 = std::move(b1); b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator()); BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
// propagate_on_container_move_assignment : true // propagate_on_container_move_assignment : true
@@ -179,8 +179,8 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<pocma_t> b2; basic_flat_buffer<pocma_t> b2;
b2 = std::move(b1); b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
// propagate_on_container_move_assignment : false // propagate_on_container_move_assignment : false
@@ -190,8 +190,8 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<pocma_t> b2; basic_flat_buffer<pocma_t> b2;
b2 = std::move(b1); b2 = std::move(b1);
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
} }
@@ -202,11 +202,11 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
flat_buffer b2; flat_buffer b2;
b2 = b1; b2 = b1;
BOOST_BEAST_EXPECT(to_string(b1.data()) == "Hello"); BEAST_EXPECT(to_string(b1.data()) == "Hello");
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
basic_flat_buffer<a_t> b3; basic_flat_buffer<a_t> b3;
b3 = b2; b3 = b2;
BOOST_BEAST_EXPECT(to_string(b3.data()) == "Hello"); BEAST_EXPECT(to_string(b3.data()) == "Hello");
} }
{ {
// propagate_on_container_copy_assignment : true // propagate_on_container_copy_assignment : true
@@ -216,7 +216,7 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<pocca_t> b2; basic_flat_buffer<pocca_t> b2;
b2 = b1; b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
// propagate_on_container_copy_assignment : false // propagate_on_container_copy_assignment : false
@@ -226,7 +226,7 @@ public:
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<pocca_t> b2; basic_flat_buffer<pocca_t> b2;
b2 = b1; 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!"; string_view const s = "Hello, world!";
flat_buffer b1{64}; flat_buffer b1{64};
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.max_size() == 64); BEAST_EXPECT(b1.max_size() == 64);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
ostream(b1) << s; ostream(b1) << s;
BOOST_BEAST_EXPECT(to_string(b1.data()) == s); BEAST_EXPECT(to_string(b1.data()) == s);
{ {
flat_buffer b2{b1}; flat_buffer b2{b1};
BOOST_BEAST_EXPECT(to_string(b2.data()) == s); BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7); 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}; flat_buffer b2{64};
b2 = b1; b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == s); BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7); 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"; ostream(b) << "12345";
b.consume(3); b.consume(3);
ostream(b) << "67890123"; ostream(b) << "67890123";
BOOST_BEAST_EXPECT(to_string(b.data()) == "4567890123"); BEAST_EXPECT(to_string(b.data()) == "4567890123");
} }
// read_size // read_size
{ {
flat_buffer b{10}; flat_buffer b{10};
BOOST_BEAST_EXPECT(read_size(b, 512) == 10); BEAST_EXPECT(read_size(b, 512) == 10);
b.prepare(4); b.prepare(4);
b.commit(4); b.commit(4);
BOOST_BEAST_EXPECT(read_size(b, 512) == 6); BEAST_EXPECT(read_size(b, 512) == 6);
b.consume(2); b.consume(2);
BOOST_BEAST_EXPECT(read_size(b, 512) == 8); BEAST_EXPECT(read_size(b, 512) == 8);
b.prepare(8); b.prepare(8);
b.commit(8); b.commit(8);
BOOST_BEAST_EXPECT(read_size(b, 512) == 0); BEAST_EXPECT(read_size(b, 512) == 0);
} }
// swap // swap
@@ -283,12 +283,12 @@ public:
basic_flat_buffer<a_neq_t> b1; basic_flat_buffer<a_neq_t> b1;
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<a_neq_t> b2; 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); swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator() != b2.get_allocator()); BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
{ {
using na_t = test::test_allocator<char, using na_t = test::test_allocator<char,
@@ -298,13 +298,13 @@ public:
na_t a2; na_t a2;
ostream(b1) << "Hello"; ostream(b1) << "Hello";
basic_flat_buffer<na_t> b2{a2}; basic_flat_buffer<na_t> b2{a2};
BOOST_BEAST_EXPECT(b1.get_allocator() == a1); BEAST_EXPECT(b1.get_allocator() == a1);
BOOST_BEAST_EXPECT(b2.get_allocator() == a2); BEAST_EXPECT(b2.get_allocator() == a2);
swap(b1, b2); swap(b1, b2);
BOOST_BEAST_EXPECT(b1.get_allocator() == b2.get_allocator()); BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BOOST_BEAST_EXPECT(to_string(b2.data()) == "Hello"); BEAST_EXPECT(to_string(b2.data()) == "Hello");
} }
} }
@@ -314,7 +314,7 @@ public:
b.prepare(10); b.prepare(10);
b.commit(10); b.commit(10);
b.prepare(5); b.prepare(5);
BOOST_BEAST_EXPECT(b.capacity() >= 5); BEAST_EXPECT(b.capacity() >= 5);
try try
{ {
b.prepare(1000); b.prepare(1000);
@@ -329,15 +329,15 @@ public:
// shrink to fit // shrink to fit
{ {
flat_buffer b; flat_buffer b;
BOOST_BEAST_EXPECT(b.capacity() == 0); BEAST_EXPECT(b.capacity() == 0);
b.prepare(50); b.prepare(50);
BOOST_BEAST_EXPECT(b.capacity() == 50); BEAST_EXPECT(b.capacity() == 50);
b.commit(50); b.commit(50);
BOOST_BEAST_EXPECT(b.capacity() == 50); BEAST_EXPECT(b.capacity() == 50);
b.prepare(75); b.prepare(75);
BOOST_BEAST_EXPECT(b.capacity() >= 125); BEAST_EXPECT(b.capacity() >= 125);
b.shrink_to_fit(); 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; using boost::asio::buffer_size;
char buf[12]; char buf[12];
std::string const s = "Hello, world"; 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 i = 1; i < 4; ++i) {
for(std::size_t j = 1; j < 4; ++j) { for(std::size_t j = 1; j < 4; ++j) {
for(std::size_t x = 1; x < 4; ++x) { for(std::size_t x = 1; x < 4; ++x) {
@@ -50,79 +50,79 @@ public:
flat_static_buffer<sizeof(buf)> ba; flat_static_buffer<sizeof(buf)> ba;
{ {
auto d = ba.prepare(z); auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z); BEAST_EXPECT(buffer_size(d) == z);
} }
{ {
auto d = ba.prepare(0); auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_size(d) == 0);
} }
{ {
auto d = ba.prepare(y); auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y); BEAST_EXPECT(buffer_size(d) == y);
} }
{ {
auto d = ba.prepare(x); 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))); ba.commit(buffer_copy(d, buffer(s.data(), x)));
} }
BOOST_BEAST_EXPECT(ba.size() == x); BEAST_EXPECT(ba.size() == x);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size()); BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{ {
auto d = ba.prepare(x); auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x); BEAST_EXPECT(buffer_size(d) == x);
} }
{ {
auto d = ba.prepare(0); auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_size(d) == 0);
} }
{ {
auto d = ba.prepare(z); auto d = ba.prepare(z);
BOOST_BEAST_EXPECT(buffer_size(d) == z); BEAST_EXPECT(buffer_size(d) == z);
} }
{ {
auto d = ba.prepare(y); 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(buffer_copy(d, buffer(s.data()+x, y)));
} }
ba.commit(1); ba.commit(1);
BOOST_BEAST_EXPECT(ba.size() == x + y); BEAST_EXPECT(ba.size() == x + y);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size()); BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
{ {
auto d = ba.prepare(x); auto d = ba.prepare(x);
BOOST_BEAST_EXPECT(buffer_size(d) == x); BEAST_EXPECT(buffer_size(d) == x);
} }
{ {
auto d = ba.prepare(y); auto d = ba.prepare(y);
BOOST_BEAST_EXPECT(buffer_size(d) == y); BEAST_EXPECT(buffer_size(d) == y);
} }
{ {
auto d = ba.prepare(0); auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_size(d) == 0);
} }
{ {
auto d = ba.prepare(z); 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(buffer_copy(d, buffer(s.data()+x+y, z)));
} }
ba.commit(2); ba.commit(2);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == buffer_size(ba.mutable_data())); BEAST_EXPECT(buffer_size(ba.data()) == buffer_size(ba.mutable_data()));
BOOST_BEAST_EXPECT(ba.size() == x + y + z); BEAST_EXPECT(ba.size() == x + y + z);
BOOST_BEAST_EXPECT(buffer_size(ba.data()) == ba.size()); BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
BOOST_BEAST_EXPECT(to_string(ba.data()) == s); BEAST_EXPECT(to_string(ba.data()) == s);
ba.consume(t); ba.consume(t);
{ {
auto d = ba.prepare(0); 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); 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); ba.consume(v);
BOOST_BEAST_EXPECT(to_string(ba.data()) == ""); BEAST_EXPECT(to_string(ba.data()) == "");
ba.consume(1); ba.consume(1);
{ {
auto d = ba.prepare(0); auto d = ba.prepare(0);
BOOST_BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_size(d) == 0);
} }
try try
{ {
@@ -148,31 +148,31 @@ public:
char buf[64]; char buf[64];
flat_static_buffer_base b{buf, sizeof(buf)}; flat_static_buffer_base b{buf, sizeof(buf)};
ostream(b) << s; ostream(b) << s;
BOOST_BEAST_EXPECT(to_string(b.data()) == s); BEAST_EXPECT(to_string(b.data()) == s);
b.consume(b.size()); b.consume(b.size());
BOOST_BEAST_EXPECT(to_string(b.data()) == ""); BEAST_EXPECT(to_string(b.data()) == "");
} }
// flat_static_buffer // flat_static_buffer
{ {
flat_static_buffer<64> b1; flat_static_buffer<64> b1;
BOOST_BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BOOST_BEAST_EXPECT(b1.max_size() == 64); BEAST_EXPECT(b1.max_size() == 64);
BOOST_BEAST_EXPECT(b1.capacity() == 64); BEAST_EXPECT(b1.capacity() == 64);
ostream(b1) << s; ostream(b1) << s;
BOOST_BEAST_EXPECT(to_string(b1.data()) == s); BEAST_EXPECT(to_string(b1.data()) == s);
{ {
flat_static_buffer<64> b2{b1}; flat_static_buffer<64> b2{b1};
BOOST_BEAST_EXPECT(to_string(b2.data()) == s); BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7); 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; flat_static_buffer<64> b2;
b2 = b1; b2 = b1;
BOOST_BEAST_EXPECT(to_string(b2.data()) == s); BEAST_EXPECT(to_string(b2.data()) == s);
b2.consume(7); 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"); write_buffer(b, "12345");
b.consume(3); b.consume(3);
write_buffer(b, "67890123"); write_buffer(b, "67890123");
BOOST_BEAST_EXPECT(to_string(b.data()) == "4567890123"); BEAST_EXPECT(to_string(b.data()) == "4567890123");
try try
{ {
b.prepare(1); b.prepare(1);
@@ -197,15 +197,15 @@ public:
// read_size // read_size
{ {
flat_static_buffer<10> b; flat_static_buffer<10> b;
BOOST_BEAST_EXPECT(read_size(b, 512) == 10); BEAST_EXPECT(read_size(b, 512) == 10);
b.prepare(4); b.prepare(4);
b.commit(4); b.commit(4);
BOOST_BEAST_EXPECT(read_size(b, 512) == 6); BEAST_EXPECT(read_size(b, 512) == 6);
b.consume(2); b.consume(2);
BOOST_BEAST_EXPECT(read_size(b, 512) == 8); BEAST_EXPECT(read_size(b, 512) == 8);
b.prepare(8); b.prepare(8);
b.commit(8); b.commit(8);
BOOST_BEAST_EXPECT(read_size(b, 512) == 0); BEAST_EXPECT(read_size(b, 512) == 0);
} }
// base // base
@@ -213,13 +213,13 @@ public:
flat_static_buffer<10> b; flat_static_buffer<10> b;
[&](flat_static_buffer_base& base) [&](flat_static_buffer_base& base)
{ {
BOOST_BEAST_EXPECT(base.max_size() == b.capacity()); BEAST_EXPECT(base.max_size() == b.capacity());
} }
(b.base()); (b.base());
[&](flat_static_buffer_base const& base) [&](flat_static_buffer_base const& base)
{ {
BOOST_BEAST_EXPECT(base.max_size() == b.capacity()); BEAST_EXPECT(base.max_size() == b.capacity());
} }
(b.base()); (b.base());
} }

4
test/core/handler_alloc.cpp
View File

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

2
test/core/span.cpp
View File

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

86
test/core/static_buffer.cpp
View File

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

178
test/http/basic_parser.cpp
View File

@@ -55,7 +55,7 @@ public:
void void
operator()(Parser const& p) const operator()(Parser const& p) const
{ {
s_.BOOST_BEAST_EXPECT(p.version == version_); s_.BEAST_EXPECT(p.version == version_);
} }
}; };
@@ -75,7 +75,7 @@ public:
void void
operator()(Parser const& p) const 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 operator()(Parser const& p) const
{ {
if(flags_ & parse_flag::chunked) 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) 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) 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) if(flags_ & parse_flag::upgrade)
s_.BOOST_BEAST_EXPECT(! p.is_upgrade()); s_.BEAST_EXPECT(! p.is_upgrade());
} }
}; };
@@ -122,7 +122,7 @@ public:
void void
operator()(Parser const& p) const 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 void
operator()(Parser const& p) const 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; error_code ec;
consuming_buffers<ConstBufferSequence> cb{buffers}; consuming_buffers<ConstBufferSequence> cb{buffers};
auto n = p.put(buffer_prefix(i, cb), ec); auto n = p.put(buffer_prefix(i, cb), ec);
if(! BOOST_BEAST_EXPECTS(! ec || if(! BEAST_EXPECTS(! ec ||
ec == error::need_more, ec.message())) ec == error::need_more, ec.message()))
continue; continue;
if(! BOOST_BEAST_EXPECT(! p.is_done())) if(! BEAST_EXPECT(! p.is_done()))
continue; continue;
cb.consume(n); cb.consume(n);
n = p.put(cb, ec); n = p.put(cb, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
continue; continue;
if(! BOOST_BEAST_EXPECT(n == boost::asio::buffer_size(cb))) if(! BEAST_EXPECT(n == boost::asio::buffer_size(cb)))
continue; continue;
if(p.need_eof()) if(p.need_eof())
{ {
p.put_eof(ec); p.put_eof(ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
continue; continue;
} }
if(! BOOST_BEAST_EXPECT(p.is_done())) if(! BEAST_EXPECT(p.is_done()))
continue; continue;
test(p); test(p);
} }
@@ -195,14 +195,14 @@ public:
cb.consume(i); cb.consume(i);
auto n = p.put(buffer_cat( auto n = p.put(buffer_cat(
buffer_prefix(i, buffers), cb), ec); buffer_prefix(i, buffers), cb), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
continue; continue;
if(! BOOST_BEAST_EXPECT(n == size)) if(! BEAST_EXPECT(n == size))
continue; continue;
if(p.need_eof()) if(p.need_eof())
{ {
p.put_eof(ec); p.put_eof(ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
continue; continue;
} }
test(p); test(p);
@@ -249,16 +249,16 @@ public:
pass(); pass();
continue; continue;
} }
if(! BOOST_BEAST_EXPECTS( if(! BEAST_EXPECTS(
ec == error::need_more, ec.message())) ec == error::need_more, ec.message()))
continue; continue;
if(! BOOST_BEAST_EXPECT(! p.is_done())) if(! BEAST_EXPECT(! p.is_done()))
continue; continue;
cb.consume(n); cb.consume(n);
n = p.put(cb, ec); n = p.put(cb, ec);
if(! ec) if(! ec)
p.put_eof(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) for(std::size_t i = 1; i < msg.size() - 1; ++i)
{ {
@@ -271,7 +271,7 @@ public:
msg.data() + i, msg.size() - i}), ec); msg.data() + i, msg.size() - i}), ec);
if(! ec) if(! ec)
p.put_eof(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, parsegrind<parser<true, string_body>>(m,
[&](parser<true, string_body> const& p) [&](parser<true, string_body> const& p)
{ {
BOOST_BEAST_EXPECT(p.get()["f"] == value); BEAST_EXPECT(p.get()["f"] == value);
}); });
}; };
check("x", "x"); check("x", "x");
@@ -369,12 +369,12 @@ public:
"*", "*",
[&](test_parser<true> const& p) [&](test_parser<true> const& p)
{ {
BOOST_BEAST_EXPECT(p.got_on_begin == 1); BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2); BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1); BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1); BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 0); BEAST_EXPECT(p.got_on_chunk == 0);
BOOST_BEAST_EXPECT(p.got_on_complete == 1); BEAST_EXPECT(p.got_on_complete == 1);
}); });
parsegrind<test_parser<false>>( parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
@@ -384,12 +384,12 @@ public:
"*", "*",
[&](test_parser<false> const& p) [&](test_parser<false> const& p)
{ {
BOOST_BEAST_EXPECT(p.got_on_begin == 1); BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2); BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1); BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1); BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 0); BEAST_EXPECT(p.got_on_chunk == 0);
BOOST_BEAST_EXPECT(p.got_on_complete == 1); BEAST_EXPECT(p.got_on_complete == 1);
}); });
parsegrind<test_parser<false>>( parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
@@ -400,12 +400,12 @@ public:
"0\r\n\r\n", "0\r\n\r\n",
[&](test_parser<false> const& p) [&](test_parser<false> const& p)
{ {
BOOST_BEAST_EXPECT(p.got_on_begin == 1); BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2); BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1); BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1); BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 2); BEAST_EXPECT(p.got_on_chunk == 2);
BOOST_BEAST_EXPECT(p.got_on_complete == 1); BEAST_EXPECT(p.got_on_complete == 1);
}); });
parsegrind<test_parser<false>>( parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
@@ -416,12 +416,12 @@ public:
"0\r\n\r\n", "0\r\n\r\n",
[&](test_parser<false> const& p) [&](test_parser<false> const& p)
{ {
BOOST_BEAST_EXPECT(p.got_on_begin == 1); BEAST_EXPECT(p.got_on_begin == 1);
BOOST_BEAST_EXPECT(p.got_on_field == 2); BEAST_EXPECT(p.got_on_field == 2);
BOOST_BEAST_EXPECT(p.got_on_header == 1); BEAST_EXPECT(p.got_on_header == 1);
BOOST_BEAST_EXPECT(p.got_on_body == 1); BEAST_EXPECT(p.got_on_body == 1);
BOOST_BEAST_EXPECT(p.got_on_chunk == 2); BEAST_EXPECT(p.got_on_chunk == 2);
BOOST_BEAST_EXPECT(p.got_on_complete == 1); BEAST_EXPECT(p.got_on_complete == 1);
}); });
} }
@@ -673,8 +673,8 @@ public:
parsegrind<P>(c(s), parsegrind<P>(c(s),
[&](P const& p) [&](P const& p)
{ {
BOOST_BEAST_EXPECT(p.content_length()); BEAST_EXPECT(p.content_length());
BOOST_BEAST_EXPECT(p.content_length() && *p.content_length() == v); BEAST_EXPECT(p.content_length() && *p.content_length() == v);
}, true); }, true);
}; };
@@ -784,7 +784,7 @@ public:
"\r\n", "\r\n",
[&](P const& p) [&](P const& p)
{ {
BOOST_BEAST_EXPECT(p.is_upgrade()); BEAST_EXPECT(p.is_upgrade());
}); });
} }
@@ -808,17 +808,17 @@ public:
"\r\n", "\r\n",
[&](test_parser<true> const& p) [&](test_parser<true> const& p)
{ {
BOOST_BEAST_EXPECT(p.fields.size() == 10); BEAST_EXPECT(p.fields.size() == 10);
BOOST_BEAST_EXPECT(p.fields.at("a") == "0"); BEAST_EXPECT(p.fields.at("a") == "0");
BOOST_BEAST_EXPECT(p.fields.at("b") == "1"); BEAST_EXPECT(p.fields.at("b") == "1");
BOOST_BEAST_EXPECT(p.fields.at("c") == "2"); BEAST_EXPECT(p.fields.at("c") == "2");
BOOST_BEAST_EXPECT(p.fields.at("d") == "3"); BEAST_EXPECT(p.fields.at("d") == "3");
BOOST_BEAST_EXPECT(p.fields.at("e") == "4"); BEAST_EXPECT(p.fields.at("e") == "4");
BOOST_BEAST_EXPECT(p.fields.at("f") == "5"); BEAST_EXPECT(p.fields.at("f") == "5");
BOOST_BEAST_EXPECT(p.fields.at("g") == "6"); BEAST_EXPECT(p.fields.at("g") == "6");
BOOST_BEAST_EXPECT(p.fields.at("h") == "7"); BEAST_EXPECT(p.fields.at("h") == "7");
BOOST_BEAST_EXPECT(p.fields.at("i") == "8"); BEAST_EXPECT(p.fields.at("i") == "8");
BOOST_BEAST_EXPECT(p.fields.at("j") == "9"); BEAST_EXPECT(p.fields.at("j") == "9");
}); });
} }
@@ -837,7 +837,7 @@ public:
p.header_limit(10); p.header_limit(10);
p.eager(true); p.eager(true);
p.put(b.data(), ec); 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; multi_buffer b;
@@ -851,7 +851,7 @@ public:
p.body_limit(1); p.body_limit(1);
p.eager(true); p.eager(true);
p.put(b.data(), ec); 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; multi_buffer b;
@@ -864,7 +864,7 @@ public:
p.body_limit(1); p.body_limit(1);
p.eager(true); p.eager(true);
p.put(b.data(), ec); 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; multi_buffer b;
@@ -880,7 +880,7 @@ public:
p.body_limit(1); p.body_limit(1);
p.eager(true); p.eager(true);
p.put(b.data(), ec); 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" "0\r\n\r\n"
,[&](test_parser<false> const& p) ,[&](test_parser<false> const& p)
{ {
BOOST_BEAST_EXPECT(p.body == "abcd"); BEAST_EXPECT(p.body == "abcd");
}); });
parsegrind<test_parser<false>>( parsegrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
@@ -932,7 +932,7 @@ public:
"\r\n" "\r\n"
,[&](test_parser<false> const& p) ,[&](test_parser<false> const& p)
{ {
BOOST_BEAST_EXPECT(p.body == "*****--"); BEAST_EXPECT(p.body == "*****--");
}); });
parsegrind<test_parser<true>>( parsegrind<test_parser<true>>(
@@ -965,8 +965,8 @@ public:
"GET / HTTP/1.0\r\n" "GET / HTTP/1.0\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
{ {
error_code ec; error_code ec;
@@ -975,8 +975,8 @@ public:
"GET / HTTP/1.1\r\n" "GET / HTTP/1.1\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
// response without Content-Length or // response without Content-Length or
@@ -988,9 +988,9 @@ public:
"HTTP/1.0 200 OK\r\n" "HTTP/1.0 200 OK\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(! p.is_done()); BEAST_EXPECT(! p.is_done());
BOOST_BEAST_EXPECT(p.need_eof()); BEAST_EXPECT(p.need_eof());
} }
// 304 "Not Modified" response does not require eof // 304 "Not Modified" response does not require eof
@@ -1001,8 +1001,8 @@ public:
"HTTP/1.0 304 Not Modified\r\n" "HTTP/1.0 304 Not Modified\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
// Chunked response does not require eof // Chunked response does not require eof
@@ -1014,13 +1014,13 @@ public:
"Transfer-Encoding: chunked\r\n" "Transfer-Encoding: chunked\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(! p.is_done()); BEAST_EXPECT(! p.is_done());
feed(buf( feed(buf(
"0\r\n\r\n" "0\r\n\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
// restart: 1.0 assumes Connection: close // restart: 1.0 assumes Connection: close
@@ -1031,8 +1031,8 @@ public:
"GET / HTTP/1.0\r\n" "GET / HTTP/1.0\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
// restart: 1.1 assumes Connection: keep-alive // restart: 1.1 assumes Connection: keep-alive
@@ -1043,8 +1043,8 @@ public:
"GET / HTTP/1.1\r\n" "GET / HTTP/1.1\r\n"
"\r\n" "\r\n"
), p, ec); ), p, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
failgrind<test_parser<true>>( failgrind<test_parser<true>>(
@@ -1082,9 +1082,9 @@ public:
"die!"; "die!";
p.put(boost::asio::buffer( p.put(boost::asio::buffer(
s.data(), s.size()), ec); s.data(), s.size()), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
return; return;
BOOST_BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_done());
} }
// https://github.com/vinniefalco/Beast/issues/496 // https://github.com/vinniefalco/Beast/issues/496
@@ -1102,7 +1102,7 @@ public:
"0\r\n\r\n" "0\r\n\r\n"
,[&](P const& p) ,[&](P const& p)
{ {
BOOST_BEAST_EXPECT(p.body == "abcd"); BEAST_EXPECT(p.body == "abcd");
}); });
} }
@@ -1140,7 +1140,7 @@ public:
p.eager(true); p.eager(true);
p.put(boost::asio::const_buffers_1{ p.put(boost::asio::const_buffers_1{
msg.data(), msg.size()}, ec); msg.data(), msg.size()}, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
grind(msg); grind(msg);
}; };
auto const bad = auto const bad =
@@ -1157,7 +1157,7 @@ public:
p.eager(true); p.eager(true);
p.put(boost::asio::const_buffers_1{ p.put(boost::asio::const_buffers_1{
msg.data(), msg.size()}, ec); msg.data(), msg.size()}, ec);
BOOST_BEAST_EXPECT(ec); BEAST_EXPECT(ec);
grind(msg); grind(msg);
}; };
chunkExtensionsTest(good, bad); chunkExtensionsTest(good, bad);
@@ -1192,7 +1192,7 @@ public:
error_code ec; error_code ec;
test_parser<true> p; test_parser<true> p;
feed(boost::asio::buffer(buf, sizeof(buf)), p, ec); 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) check(string_view match, Args&&... args)
{ {
T t{std::forward<Args>(args)...}; T t{std::forward<Args>(args)...};
BOOST_BEAST_EXPECT(to_string(t) == match); BEAST_EXPECT(to_string(t) == match);
T t2{t}; T t2{t};
BOOST_BEAST_EXPECT(to_string(t2) == match); BEAST_EXPECT(to_string(t2) == match);
T t3{std::move(t2)}; T t3{std::move(t2)};
BOOST_BEAST_EXPECT(to_string(t3) == match); BEAST_EXPECT(to_string(t3) == match);
} }
template<class T, class... Args> template<class T, class... Args>
@@ -66,11 +66,11 @@ public:
check_fwd(string_view match, Args&&... args) check_fwd(string_view match, Args&&... args)
{ {
T t{std::forward<Args>(args)...}; T t{std::forward<Args>(args)...};
BOOST_BEAST_EXPECT(to_string(t) == match); BEAST_EXPECT(to_string(t) == match);
T t2{t}; T t2{t};
BOOST_BEAST_EXPECT(to_string(t2) == match); BEAST_EXPECT(to_string(t2) == match);
T t3{std::move(t2)}; 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; using cb_t = boost::asio::const_buffers_1;
@@ -220,20 +220,20 @@ public:
}; };
chunk_extensions ce; chunk_extensions ce;
ce.insert("x"); ce.insert("x");
BOOST_BEAST_EXPECT(ce.str() == ";x"); BEAST_EXPECT(ce.str() == ";x");
BOOST_BEAST_EXPECT(str(ce) == "x,"); BEAST_EXPECT(str(ce) == "x,");
ce.insert("y", "z"); ce.insert("y", "z");
BOOST_BEAST_EXPECT(ce.str() == ";x;y=z"); BEAST_EXPECT(ce.str() == ";x;y=z");
BOOST_BEAST_EXPECT(str(ce) == "x,y,z,"); BEAST_EXPECT(str(ce) == "x,y,z,");
ce.insert("z", R"(")"); ce.insert("z", R"(")");
BOOST_BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"")"); BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"")");
BOOST_BEAST_EXPECT(str(ce) == R"(x,y,z,z,",)"); BEAST_EXPECT(str(ce) == R"(x,y,z,z,",)");
ce.insert("p", R"(\)"); ce.insert("p", R"(\)");
BOOST_BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\")"); BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\")");
BOOST_BEAST_EXPECT(str(ce) == R"(x,y,z,z,",p,\,)"); BEAST_EXPECT(str(ce) == R"(x,y,z,z,",p,\,)");
ce.insert("q", R"(1"2\)"); ce.insert("q", R"(1"2\)");
BOOST_BEAST_EXPECT(ce.str() == R"(;x;y=z;z="\"";p="\\";q="1\"2\\")"); 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(str(ce) == R"(x,y,z,z,",p,\,q,1"2\,)");
} }
void void
@@ -259,7 +259,7 @@ public:
} }
chunk_extensions c2; chunk_extensions c2;
c2.parse(c1.str(), ec); c2.parse(c1.str(), ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
return; return;
chunk_extensions c3; chunk_extensions c3;
for(auto const& v : c2) for(auto const& v : c2)
@@ -267,7 +267,7 @@ public:
c3.insert(v.first); c3.insert(v.first);
else else
c3.insert(v.first, v.second); 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; error_code ec;
chunk_extensions ce; chunk_extensions ce;
ce.parse(s, ec); ce.parse(s, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
grind(s); grind(s);
}; };
auto const bad = auto const bad =
@@ -286,7 +286,7 @@ public:
error_code ec; error_code ec;
chunk_extensions ce; chunk_extensions ce;
ce.parse(s, ec); ce.parse(s, ec);
BOOST_BEAST_EXPECT(ec); BEAST_EXPECT(ec);
grind(s); grind(s);
}; };
chunkExtensionsTest(good, bad); chunkExtensionsTest(good, bad);

42
test/http/doc_examples.cpp
View File

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

4
test/http/dynamic_body.cpp
View File

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

10
test/http/error.cpp
View File

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

6
test/http/field.cpp
View File

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

454
test/http/fields.cpp
View File

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

20
test/http/file_body.cpp
View File

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

142
test/http/message.cpp
View File

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

128
test/http/parser.cpp
View File

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

44
test/http/read.cpp
View File

@@ -58,7 +58,7 @@ public:
if(! ec) if(! ec)
break; break;
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
static std::size_t constexpr pre = 10; static std::size_t constexpr pre = 10;
@@ -74,7 +74,7 @@ public:
if(! ec) if(! ec)
break; break;
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
multi_buffer b; multi_buffer b;
@@ -89,7 +89,7 @@ public:
if(! ec) if(! ec)
break; break;
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
static std::size_t constexpr pre = 10; static std::size_t constexpr pre = 10;
@@ -105,7 +105,7 @@ public:
if(! ec) if(! ec)
break; break;
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
} }
void testThrow() void testThrow()
@@ -165,7 +165,7 @@ public:
flat_static_buffer<10> b; flat_static_buffer<10> b;
request<string_body> req; request<string_body> req;
read(p.server, b, req, ec); read(p.server, b, req, ec);
BOOST_BEAST_EXPECTS(ec == error::buffer_overflow, BEAST_EXPECTS(ec == error::buffer_overflow,
ec.message()); ec.message());
} }
} }
@@ -257,7 +257,7 @@ public:
{ {
} }
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
@@ -275,7 +275,7 @@ public:
if(! ec) if(! ec)
break; break;
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
@@ -293,7 +293,7 @@ public:
if(! ec) if(! ec)
break; break;
} }
BOOST_BEAST_EXPECT(n < limit); BEAST_EXPECT(n < limit);
} }
void void
@@ -305,7 +305,7 @@ public:
request_parser<dynamic_body> p; request_parser<dynamic_body> p;
error_code ec; error_code ec;
read(ss, b, p, 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; multi_buffer b;
@@ -313,7 +313,7 @@ public:
request_parser<dynamic_body> p; request_parser<dynamic_body> p;
error_code ec; error_code ec;
async_read(ss, b, p, do_yield[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; boost::asio::io_service ios;
test::string_istream is{ios, test::string_istream is{ios,
"GET / HTTP/1.1\r\n\r\n"}; "GET / HTTP/1.1\r\n\r\n"};
BOOST_BEAST_EXPECT(handler::count() == 0); BEAST_EXPECT(handler::count() == 0);
multi_buffer b; multi_buffer b;
request<dynamic_body> m; request<dynamic_body> m;
async_read(is, b, m, handler{}); async_read(is, b, m, handler{});
BOOST_BEAST_EXPECT(handler::count() > 0); BEAST_EXPECT(handler::count() > 0);
ios.stop(); ios.stop();
BOOST_BEAST_EXPECT(handler::count() > 0); BEAST_EXPECT(handler::count() > 0);
ios.reset(); ios.reset();
BOOST_BEAST_EXPECT(handler::count() > 0); BEAST_EXPECT(handler::count() > 0);
ios.run_one(); ios.run_one();
BOOST_BEAST_EXPECT(handler::count() == 0); BEAST_EXPECT(handler::count() == 0);
} }
{ {
// Make sure uninvoked handlers are // Make sure uninvoked handlers are
@@ -356,13 +356,13 @@ public:
boost::asio::io_service ios; boost::asio::io_service ios;
test::string_istream is{ios, test::string_istream is{ios,
"GET / HTTP/1.1\r\n\r\n"}; "GET / HTTP/1.1\r\n\r\n"};
BOOST_BEAST_EXPECT(handler::count() == 0); BEAST_EXPECT(handler::count() == 0);
multi_buffer b; multi_buffer b;
request<dynamic_body> m; request<dynamic_body> m;
async_read(is, b, m, handler{}); 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; flat_buffer fb;
parser<false, dynamic_body> p; parser<false, dynamic_body> p;
read(c.server, fb, p, ec); 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; ostream(c.server.buffer) << s;
c.server.read_size(n); c.server.read_size(n);
read(c.server, b, p, ec); read(c.server, b, p, ec);
if(! BOOST_BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
continue; continue;
pred(p); pred(p);
} }
@@ -420,7 +420,7 @@ public:
"0\r\n\r\n" "0\r\n\r\n"
,[&](test_parser<false> const& p) ,[&](test_parser<false> const& p)
{ {
BOOST_BEAST_EXPECT(p.body == "abcd"); BEAST_EXPECT(p.body == "abcd");
}); });
readgrind<test_parser<false>>( readgrind<test_parser<false>>(
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
@@ -438,7 +438,7 @@ public:
"\r\n" "\r\n"
,[&](test_parser<false> const& p) ,[&](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) [&](std::string const& s)
{ {
auto const got = str(param_list{s}); auto const got = str(param_list{s});
BOOST_BEAST_EXPECTS(got == s, fmt(got)); BEAST_EXPECTS(got == s, fmt(got));
}; };
auto const cs = auto const cs =
[&](std::string const& s, std::string const& answer) [&](std::string const& s, std::string const& answer)
@@ -71,13 +71,13 @@ public:
ce(answer); ce(answer);
auto const got = str(param_list{s}); auto const got = str(param_list{s});
ce(got); ce(got);
BOOST_BEAST_EXPECTS(got == answer, fmt(got)); BEAST_EXPECTS(got == answer, fmt(got));
}; };
auto const cq = auto const cq =
[&](std::string const& s, std::string const& answer) [&](std::string const& s, std::string const& answer)
{ {
auto const got = str(param_list{s}); auto const got = str(param_list{s});
BOOST_BEAST_EXPECTS(got == answer, fmt(got)); BEAST_EXPECTS(got == answer, fmt(got));
}; };
ce(""); ce("");
@@ -122,7 +122,7 @@ public:
[&](std::string const& s) [&](std::string const& s)
{ {
auto const got = str(ext_list{s}); auto const got = str(ext_list{s});
BOOST_BEAST_EXPECTS(got == s, fmt(got)); BEAST_EXPECTS(got == s, fmt(got));
}; };
auto const cs = auto const cs =
[&](std::string const& s, std::string const& good) [&](std::string const& s, std::string const& good)
@@ -130,13 +130,13 @@ public:
ce(good); ce(good);
auto const got = str(ext_list{s}); auto const got = str(ext_list{s});
ce(got); ce(got);
BOOST_BEAST_EXPECTS(got == good, fmt(got)); BEAST_EXPECTS(got == good, fmt(got));
}; };
auto const cq = auto const cq =
[&](std::string const& s, std::string const& good) [&](std::string const& s, std::string const& good)
{ {
auto const got = str(ext_list{s}); 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 ] ) ext-basic_parsed_list = *( "," OWS ) ext *( OWS "," [ OWS ext ] )
@@ -172,9 +172,9 @@ public:
cq("ab;x=\" \"", "ab;x= "); cq("ab;x=\" \"", "ab;x= ");
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")); 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")); 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("d"));
// invalid strings // invalid strings
cs("i j", "i"); cs("i j", "i");
@@ -204,7 +204,7 @@ public:
[&](std::string const& s) [&](std::string const& s)
{ {
auto const got = str(token_list{s}); auto const got = str(token_list{s});
BOOST_BEAST_EXPECTS(got == s, fmt(got)); BEAST_EXPECTS(got == s, fmt(got));
}; };
auto const cs = auto const cs =
[&](std::string const& s, std::string const& good) [&](std::string const& s, std::string const& good)
@@ -212,7 +212,7 @@ public:
ce(good); ce(good);
auto const got = str(token_list{s}); auto const got = str(token_list{s});
ce(got); ce(got);
BOOST_BEAST_EXPECTS(got == good, fmt(got)); BEAST_EXPECTS(got == good, fmt(got));
}; };
cs("", ""); cs("", "");
@@ -233,9 +233,9 @@ public:
cs("x ,\ty ", "x,y"); cs("x ,\ty ", "x,y");
cs("x, y, z", "x,y,z"); cs("x, y, z", "x,y,z");
BOOST_BEAST_EXPECT(token_list{"a,b,c"}.exists("A")); BEAST_EXPECT(token_list{"a,b,c"}.exists("A"));
BOOST_BEAST_EXPECT(token_list{"a,b,c"}.exists("b")); 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("d"));
// invalid // invalid
cs("x y", "x"); cs("x y", "x");
@@ -259,14 +259,14 @@ public:
validate(string_view in, validate(string_view in,
std::vector<std::string> const& v) std::vector<std::string> const& v)
{ {
BOOST_BEAST_EXPECT(to_vector<Policy>(in) == v); BEAST_EXPECT(to_vector<Policy>(in) == v);
} }
template<class Policy> template<class Policy>
void void
good(string_view in) good(string_view in)
{ {
BOOST_BEAST_EXPECT(validate_list( BEAST_EXPECT(validate_list(
detail::basic_parsed_list<Policy>{in})); detail::basic_parsed_list<Policy>{in}));
} }
@@ -275,7 +275,7 @@ public:
good(string_view in, good(string_view in,
std::vector<std::string> const& v) std::vector<std::string> const& v)
{ {
BOOST_BEAST_EXPECT(validate_list( BEAST_EXPECT(validate_list(
detail::basic_parsed_list<Policy>{in})); detail::basic_parsed_list<Policy>{in}));
validate<Policy>(in, v); validate<Policy>(in, v);
} }
@@ -284,7 +284,7 @@ public:
void void
bad(string_view in) bad(string_view in)
{ {
BOOST_BEAST_EXPECT(! validate_list( BEAST_EXPECT(! validate_list(
detail::basic_parsed_list<Policy>{in})); detail::basic_parsed_list<Policy>{in}));
} }

2
test/http/serializer.cpp
View File

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

30
test/http/span_body.cpp
View File

@@ -27,23 +27,23 @@ struct span_body_test
using B = span_body<char const>; using B = span_body<char const>;
request<B> req; request<B> req;
BOOST_BEAST_EXPECT(req.body.size() == 0); BEAST_EXPECT(req.body.size() == 0);
BOOST_BEAST_EXPECT(B::size(req.body) == 0); BEAST_EXPECT(B::size(req.body) == 0);
req.body = B::value_type("xyz", 3); req.body = B::value_type("xyz", 3);
BOOST_BEAST_EXPECT(req.body.size() == 3); BEAST_EXPECT(req.body.size() == 3);
BOOST_BEAST_EXPECT(B::size(req.body) == 3); BEAST_EXPECT(B::size(req.body) == 3);
B::reader r{req}; B::reader r{req};
error_code ec; error_code ec;
r.init(ec); r.init(ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
auto const buf = r.get(ec); auto const buf = r.get(ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
if(! BOOST_BEAST_EXPECT(buf != boost::none)) if(! BEAST_EXPECT(buf != boost::none))
return; return;
BOOST_BEAST_EXPECT(boost::asio::buffer_size(buf->first) == 3); BEAST_EXPECT(boost::asio::buffer_size(buf->first) == 3);
BOOST_BEAST_EXPECT(! buf->second); BEAST_EXPECT(! buf->second);
} }
{ {
char buf[5]; char buf[5];
@@ -53,16 +53,16 @@ struct span_body_test
B::writer w{req}; B::writer w{req};
error_code ec; error_code ec;
w.init(boost::none, ec); w.init(boost::none, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
w.put(boost::asio::const_buffers_1{ w.put(boost::asio::const_buffers_1{
"123", 3}, ec); "123", 3}, ec);
BOOST_BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
BOOST_BEAST_EXPECT(buf[0] == '1'); BEAST_EXPECT(buf[0] == '1');
BOOST_BEAST_EXPECT(buf[1] == '2'); BEAST_EXPECT(buf[1] == '2');
BOOST_BEAST_EXPECT(buf[2] == '3'); BEAST_EXPECT(buf[2] == '3');
w.put(boost::asio::const_buffers_1{ w.put(boost::asio::const_buffers_1{
"456", 3}, ec); "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) auto const check = [&](status s, int i, status_class sc)
{ {
BOOST_BEAST_EXPECT(int_to_status(i) == s); BEAST_EXPECT(int_to_status(i) == s);
BOOST_BEAST_EXPECT(to_status_class(i) == sc); BEAST_EXPECT(to_status_class(i) == sc);
BOOST_BEAST_EXPECT(to_status_class(int_to_status(i)) == sc); BEAST_EXPECT(to_status_class(int_to_status(i)) == sc);
}; };
check(status::continue_ ,100, status_class::informational); check(status::continue_ ,100, status_class::informational);
check(status::switching_protocols ,101, 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_authentication_required ,511, status_class::server_error);
check(status::network_connect_timeout_error ,599, 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); 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(status::unknown) == status_class::unknown);
auto const good = auto const good =
[&](status v) [&](status v)
{ {
BOOST_BEAST_EXPECT(obsolete_reason(v) != "Unknown Status"); BEAST_EXPECT(obsolete_reason(v) != "Unknown Status");
}; };
good(status::continue_); good(status::continue_);
good(status::switching_protocols); good(status::switching_protocols);

4
test/http/verb.cpp
View File

@@ -26,7 +26,7 @@ public:
auto const good = auto const good =
[&](verb v) [&](verb v)
{ {
BOOST_BEAST_EXPECT(string_to_verb(to_string(v)) == v); BEAST_EXPECT(string_to_verb(to_string(v)) == v);
}; };
good(verb::unknown); good(verb::unknown);
@@ -69,7 +69,7 @@ public:
[&](string_view s) [&](string_view s)
{ {
auto const v = string_to_verb(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_"); bad("AC_");

80
test/http/write.cpp
View File

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

52
test/server/tests.cpp
View File

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

10
test/websocket/error.cpp
View File

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

50
test/websocket/frame.cpp
View File

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

2
test/websocket/mask.cpp
View File

@@ -46,7 +46,7 @@ public:
void run() override void run() override
{ {
maskgen_t<test_generator> mg; 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; http::header<true> req;
req.version = 10; req.version = 10;
BOOST_BEAST_EXPECT(! is_upgrade(req)); BEAST_EXPECT(! is_upgrade(req));
req.version = 11; req.version = 11;
req.method(http::verb::post); req.method(http::verb::post);
req.target("/"); req.target("/");
BOOST_BEAST_EXPECT(! is_upgrade(req)); BEAST_EXPECT(! is_upgrade(req));
req.method(http::verb::get); req.method(http::verb::get);
req.insert("Connection", "upgrade"); req.insert("Connection", "upgrade");
BOOST_BEAST_EXPECT(! is_upgrade(req)); BEAST_EXPECT(! is_upgrade(req));
req.insert("Upgrade", "websocket"); req.insert("Upgrade", "websocket");
BOOST_BEAST_EXPECT(! is_upgrade(req)); BEAST_EXPECT(! is_upgrade(req));
req.insert("Sec-WebSocket-Version", "13"); req.insert("Sec-WebSocket-Version", "13");
BOOST_BEAST_EXPECT(is_upgrade(req)); BEAST_EXPECT(is_upgrade(req));
} }
void void

148
test/websocket/stream.cpp
View File

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

112
test/websocket/utf8_checker.cpp
View File

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

22
test/zlib/deflate_stream.cpp
View File

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

10
test/zlib/error.cpp
View File

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