boost/asio
2
0
Fork 0
mirror of https://github.com/boostorg/asio.git synced 2026-01-19 04:02:09 +00:00
Code Issues Projects Releases Wiki Activity

Initial merge of Networking TS compatibility.

Browse Source 
Merged from chriskohlhoff/asio master branch as of commit
4a4d28b0d24c53236e229bd1b5f378c9964b1ebb.
This commit is contained in:
Christopher Kohlhoff
2017-10-23 14:27:36 +11:00
parent b002097359
commit b60e92b13e
617 changed files with 43380 additions and 21694 deletions
Download Patch File Download Diff File Expand all files Collapse all files

335
test/buffer.cpp
View File

@@ -57,9 +57,17 @@ void test()
#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
std::vector<char> vector_data(1024);
const std::vector<char>& const_vector_data = vector_data;
const std::string string_data(1024, ' ');
std::string string_data(1024, ' ');
const std::string const_string_data(1024, ' ');
std::vector<mutable_buffer> mutable_buffer_sequence;
std::vector<const_buffer> const_buffer_sequence;
#if defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
# if defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_data(string_data);
# else // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::string_view string_view_data(string_data);
# endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
#endif // defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
// mutable_buffer constructors.
@@ -67,11 +75,22 @@ void test()
mutable_buffer mb2(void_ptr_data, 1024);
mutable_buffer mb3(mb1);
// mutable_buffer functions.
void* ptr1 = mb1.data();
(void)ptr1;
std::size_t n1 = mb1.size();
(void)n1;
// mutable_buffer operators.
mb1 += 128;
mb1 = mb2 + 128;
mb1 = 128 + mb2;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
// mutable_buffers_1 constructors.
mutable_buffers_1 mbc1(mb1);
@@ -84,6 +103,8 @@ void test()
mutable_buffers_1::const_iterator iter2 = mbc1.end();
(void)iter2;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
// const_buffer constructors.
const_buffer cb1;
@@ -91,11 +112,22 @@ void test()
const_buffer cb3(cb1);
const_buffer cb4(mb1);
// const_buffer functions.
const void* ptr2 = cb1.data();
(void)ptr2;
std::size_t n2 = cb1.size();
(void)n2;
// const_buffer operators.
cb1 += 128;
cb1 = cb2 + 128;
cb1 = 128 + cb2;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
// const_buffers_1 constructors.
const_buffers_1 cbc1(cb1);
@@ -108,16 +140,20 @@ void test()
const_buffers_1::const_iterator iter4 = cbc1.end();
(void)iter4;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
// buffer_size function overloads.
std::size_t size1 = buffer_size(mb1);
(void)size1;
std::size_t size2 = buffer_size(cb1);
(void)size2;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size3 = buffer_size(mbc1);
(void)size3;
std::size_t size4 = buffer_size(cbc1);
(void)size4;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size5 = buffer_size(mutable_buffer_sequence);
(void)size5;
std::size_t size6 = buffer_size(const_buffer_sequence);
@@ -125,10 +161,12 @@ void test()
// buffer_cast function overloads.
void* ptr1 = buffer_cast<void*>(mb1);
(void)ptr1;
const void* ptr2 = buffer_cast<const void*>(cb1);
(void)ptr2;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
void* ptr3 = buffer_cast<void*>(mb1);
(void)ptr3;
const void* ptr4 = buffer_cast<const void*>(cb1);
(void)ptr4;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
// buffer function overloads.
@@ -162,21 +200,32 @@ void test()
mb1 = buffer(vector_data, 1024);
cb1 = buffer(const_vector_data);
cb1 = buffer(const_vector_data, 1024);
cb1 = buffer(string_data);
cb1 = buffer(string_data, 1024);
mb1 = buffer(string_data);
mb1 = buffer(string_data, 1024);
cb1 = buffer(const_string_data);
cb1 = buffer(const_string_data, 1024);
#if defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
cb1 = buffer(string_view_data);
cb1 = buffer(string_view_data, 1024);
#endif // defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
// buffer_copy function overloads.
std::size_t size7 = buffer_copy(mb1, cb2);
(void)size7;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size8 = buffer_copy(mb1, cbc2);
(void)size8;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size9 = buffer_copy(mb1, mb2);
(void)size9;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size10 = buffer_copy(mb1, mbc2);
(void)size10;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size11 = buffer_copy(mb1, const_buffer_sequence);
(void)size11;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size12 = buffer_copy(mbc1, cb2);
(void)size12;
std::size_t size13 = buffer_copy(mbc1, cbc2);
@@ -187,27 +236,37 @@ void test()
(void)size15;
std::size_t size16 = buffer_copy(mbc1, const_buffer_sequence);
(void)size16;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size17 = buffer_copy(mutable_buffer_sequence, cb2);
(void)size17;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size18 = buffer_copy(mutable_buffer_sequence, cbc2);
(void)size18;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size19 = buffer_copy(mutable_buffer_sequence, mb2);
(void)size19;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size20 = buffer_copy(mutable_buffer_sequence, mbc2);
(void)size20;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size21 = buffer_copy(
mutable_buffer_sequence, const_buffer_sequence);
(void)size21;
std::size_t size22 = buffer_copy(mb1, cb2, 128);
(void)size22;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size23 = buffer_copy(mb1, cbc2, 128);
(void)size23;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size24 = buffer_copy(mb1, mb2, 128);
(void)size24;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size25 = buffer_copy(mb1, mbc2, 128);
(void)size25;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size26 = buffer_copy(mb1, const_buffer_sequence, 128);
(void)size26;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size27 = buffer_copy(mbc1, cb2, 128);
(void)size27;
std::size_t size28 = buffer_copy(mbc1, cbc2, 128);
@@ -218,17 +277,71 @@ void test()
(void)size30;
std::size_t size31 = buffer_copy(mbc1, const_buffer_sequence, 128);
(void)size31;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size32 = buffer_copy(mutable_buffer_sequence, cb2, 128);
(void)size32;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size33 = buffer_copy(mutable_buffer_sequence, cbc2, 128);
(void)size33;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size34 = buffer_copy(mutable_buffer_sequence, mb2, 128);
(void)size34;
#if !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size35 = buffer_copy(mutable_buffer_sequence, mbc2, 128);
(void)size35;
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
std::size_t size36 = buffer_copy(
mutable_buffer_sequence, const_buffer_sequence, 128);
(void)size36;
// dynamic_buffer function overloads.
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> db1 = dynamic_buffer(string_data);
(void)db1;
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> db2 = dynamic_buffer(string_data, 1024);
(void)db2;
dynamic_vector_buffer<char, std::allocator<char> >
db3 = dynamic_buffer(vector_data);
(void)db3;
dynamic_vector_buffer<char, std::allocator<char> >
db4 = dynamic_buffer(vector_data, 1024);
(void)db4;
// dynamic_buffer member functions.
std::size_t size37 = db1.size();
(void)size37;
std::size_t size38 = db3.size();
(void)size38;
std::size_t size39 = db1.max_size();
(void)size39;
std::size_t size40 = db3.max_size();
(void)size40;
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type>::const_buffers_type
cb5 = db1.data();
(void)cb5;
dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type
cb6 = db3.data();
(void)cb6;
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type>::mutable_buffers_type mb5
= db1.prepare(1024);
(void)mb5;
dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type
mb6 = db3.prepare(1024);
(void)mb6;
db1.commit(1024);
db3.commit(1024);
db1.consume(1024);
db3.consume(1024);
}
catch (std::exception&)
{
@@ -239,8 +352,216 @@ void test()
//------------------------------------------------------------------------------
namespace buffer_copy_runtime {
using namespace boost::asio;
using namespace std;
void test()
{
char dest_data[256];
char source_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
memset(dest_data, 0, sizeof(dest_data));
mutable_buffer mb1 = boost::asio::buffer(dest_data);
mutable_buffer mb2 = boost::asio::buffer(source_data);
std::size_t n = buffer_copy(mb1, mb2);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
const_buffer cb1 = boost::asio::buffer(source_data);
n = buffer_copy(mb1, cb1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#if !defined(BOOST_ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
mutable_buffers_1 mbc1 = boost::asio::buffer(source_data);
n = buffer_copy(mb1, mbc1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
const_buffers_1 cbc1 = const_buffers_1(boost::asio::buffer(source_data));
n = buffer_copy(mb1, cbc1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
mb1 = boost::asio::buffer(source_data);
n = buffer_copy(mbc1, mb1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
cb1 = boost::asio::buffer(source_data);
n = buffer_copy(mbc1, cb1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
mutable_buffers_1 mbc2 = boost::asio::buffer(source_data);
n = buffer_copy(mbc1, mbc2);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
cbc1 = const_buffers_1(boost::asio::buffer(source_data));
n = buffer_copy(mbc1, cbc1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
std::vector<mutable_buffer> mv1;
mv1.push_back(boost::asio::buffer(source_data, 5));
mv1.push_back(boost::asio::buffer(source_data) + 5);
n = buffer_copy(mb1, mv1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
std::vector<const_buffer> cv1;
cv1.push_back(boost::asio::buffer(source_data, 6));
cv1.push_back(boost::asio::buffer(source_data) + 6);
n = buffer_copy(mb1, cv1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(boost::asio::buffer(dest_data, 7));
mv1.push_back(boost::asio::buffer(dest_data) + 7);
cb1 = boost::asio::buffer(source_data);
n = buffer_copy(mv1, cb1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(boost::asio::buffer(dest_data, 7));
mv1.push_back(boost::asio::buffer(dest_data) + 7);
cv1.clear();
cv1.push_back(boost::asio::buffer(source_data, 8));
cv1.push_back(boost::asio::buffer(source_data) + 8);
n = buffer_copy(mv1, cv1);
BOOST_ASIO_CHECK(n == sizeof(source_data));
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
mb2 = boost::asio::buffer(source_data);
n = buffer_copy(mb1, mb2, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
cb1 = boost::asio::buffer(source_data);
n = buffer_copy(mb1, cb1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#if !defined(BOOST_ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
mbc1 = boost::asio::buffer(source_data);
n = buffer_copy(mb1, mbc1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
cbc1 = const_buffers_1(boost::asio::buffer(source_data));
n = buffer_copy(mb1, cbc1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
mb1 = boost::asio::buffer(source_data);
n = buffer_copy(mbc1, mb1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
cb1 = boost::asio::buffer(source_data);
n = buffer_copy(mbc1, cb1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
mbc2 = boost::asio::buffer(source_data);
n = buffer_copy(mbc1, mbc2, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = boost::asio::buffer(dest_data);
cbc1 = const_buffers_1(boost::asio::buffer(source_data));
n = buffer_copy(mbc1, cbc1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
mv1.clear();
mv1.push_back(boost::asio::buffer(source_data, 5));
mv1.push_back(boost::asio::buffer(source_data) + 5);
n = buffer_copy(mb1, mv1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = boost::asio::buffer(dest_data);
cv1.clear();
cv1.push_back(boost::asio::buffer(source_data, 6));
cv1.push_back(boost::asio::buffer(source_data) + 6);
n = buffer_copy(mb1, cv1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(boost::asio::buffer(dest_data, 7));
mv1.push_back(boost::asio::buffer(dest_data) + 7);
cb1 = boost::asio::buffer(source_data);
n = buffer_copy(mv1, cb1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(boost::asio::buffer(dest_data, 7));
mv1.push_back(boost::asio::buffer(dest_data) + 7);
cv1.clear();
cv1.push_back(boost::asio::buffer(source_data, 8));
cv1.push_back(boost::asio::buffer(source_data) + 8);
n = buffer_copy(mv1, cv1, 10);
BOOST_ASIO_CHECK(n == 10);
BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
}
} // namespace buffer_copy_runtime
//------------------------------------------------------------------------------
BOOST_ASIO_TEST_SUITE
(
"buffer",
BOOST_ASIO_COMPILE_TEST_CASE(buffer_compile::test)
BOOST_ASIO_TEST_CASE(buffer_copy_runtime::test)
)