ceph/src/boost/libs/asio/test/buffer.cpp

   1 //
   2 // buffer.cpp
   3 // ~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 // Disable autolinking for unit tests.
  12 #if !defined(BOOST_ALL_NO_LIB)
  13 #define BOOST_ALL_NO_LIB 1
  14 #endif // !defined(BOOST_ALL_NO_LIB)
  15
  16 // Test that header file is self-contained.
  17 #include <boost/asio/buffer.hpp>
  18
  19 #include "unit_test.hpp"
  20
  21 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
  22 # include <boost/array.hpp>
  23 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
  24
  25 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
  26 # include <array>
  27 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
  28
  29 //------------------------------------------------------------------------------
  30
  31 // buffer_compile test
  32 // ~~~~~~~~~~~~~~~~~~~
  33 // The following test checks that all overloads of the buffer function compile
  34 // and link correctly. Runtime failures are ignored.
  35
  36 namespace buffer_compile {
  37
  38 using namespace boost::asio;
  39
  40 void test()
  41 {
  42   try
  43   {
  44     char raw_data[1024];
  45     const char const_raw_data[1024] = "";
  46     void* void_ptr_data = raw_data;
  47     const void* const_void_ptr_data = const_raw_data;
  48 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
  49     boost::array<char, 1024> array_data;
  50     const boost::array<char, 1024>& const_array_data_1 = array_data;
  51     boost::array<const char, 1024> const_array_data_2 = { { 0 } };
  52 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
  53 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
  54     std::array<char, 1024> std_array_data;
  55     const std::array<char, 1024>& const_std_array_data_1 = std_array_data;
  56     std::array<const char, 1024> const_std_array_data_2 = { { 0 } };
  57 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
  58     std::vector<char> vector_data(1024);
  59     const std::vector<char>& const_vector_data = vector_data;
  60     std::string string_data(1024, ' ');
  61     const std::string const_string_data(1024, ' ');
  62     std::vector<mutable_buffer> mutable_buffer_sequence;
  63     std::vector<const_buffer> const_buffer_sequence;
  64 #if defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
  65 # if defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
  66     std::experimental::string_view string_view_data(string_data);
  67 # else // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
  68     std::string_view string_view_data(string_data);
  69 # endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
  70 #endif // defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
  71
  72     // mutable_buffer constructors.
  73
  74     mutable_buffer mb1;
  75     mutable_buffer mb2(void_ptr_data, 1024);
  76     mutable_buffer mb3(mb1);
  77
  78     // mutable_buffer functions.
  79
  80     void* ptr1 = mb1.data();
  81     (void)ptr1;
  82
  83     std::size_t n1 = mb1.size();
  84     (void)n1;
  85
  86     // mutable_buffer operators.
  87
  88     mb1 += 128;
  89     mb1 = mb2 + 128;
  90     mb1 = 128 + mb2;
  91
  92 #if !defined(BOOST_ASIO_NO_DEPRECATED)
  93
  94     // mutable_buffers_1 constructors.
  95
  96     mutable_buffers_1 mbc1(mb1);
  97     mutable_buffers_1 mbc2(mbc1);
  98
  99     // mutable_buffers_1 functions.
 100
 101     mutable_buffers_1::const_iterator iter1 = mbc1.begin();
 102     (void)iter1;
 103     mutable_buffers_1::const_iterator iter2 = mbc1.end();
 104     (void)iter2;
 105
 106 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 107
 108     // const_buffer constructors.
 109
 110     const_buffer cb1;
 111     const_buffer cb2(const_void_ptr_data, 1024);
 112     const_buffer cb3(cb1);
 113     const_buffer cb4(mb1);
 114
 115     // const_buffer functions.
 116
 117     const void* ptr2 = cb1.data();
 118     (void)ptr2;
 119
 120     std::size_t n2 = cb1.size();
 121     (void)n2;
 122
 123     // const_buffer operators.
 124
 125     cb1 += 128;
 126     cb1 = cb2 + 128;
 127     cb1 = 128 + cb2;
 128
 129 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 130
 131     // const_buffers_1 constructors.
 132
 133     const_buffers_1 cbc1(cb1);
 134     const_buffers_1 cbc2(cbc1);
 135
 136     // const_buffers_1 functions.
 137
 138     const_buffers_1::const_iterator iter3 = cbc1.begin();
 139     (void)iter3;
 140     const_buffers_1::const_iterator iter4 = cbc1.end();
 141     (void)iter4;
 142
 143 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 144
 145     // buffer_size function overloads.
 146
 147     std::size_t size1 = buffer_size(mb1);
 148     (void)size1;
 149     std::size_t size2 = buffer_size(cb1);
 150     (void)size2;
 151 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 152     std::size_t size3 = buffer_size(mbc1);
 153     (void)size3;
 154     std::size_t size4 = buffer_size(cbc1);
 155     (void)size4;
 156 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 157     std::size_t size5 = buffer_size(mutable_buffer_sequence);
 158     (void)size5;
 159     std::size_t size6 = buffer_size(const_buffer_sequence);
 160     (void)size6;
 161
 162     // buffer_cast function overloads.
 163
 164 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 165     void* ptr3 = buffer_cast<void*>(mb1);
 166     (void)ptr3;
 167     const void* ptr4 = buffer_cast<const void*>(cb1);
 168     (void)ptr4;
 169 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 170
 171     // buffer function overloads.
 172
 173     mb1 = buffer(mb2);
 174     mb1 = buffer(mb2, 128);
 175     cb1 = buffer(cb2);
 176     cb1 = buffer(cb2, 128);
 177     mb1 = buffer(void_ptr_data, 1024);
 178     cb1 = buffer(const_void_ptr_data, 1024);
 179     mb1 = buffer(raw_data);
 180     mb1 = buffer(raw_data, 1024);
 181     cb1 = buffer(const_raw_data);
 182     cb1 = buffer(const_raw_data, 1024);
 183 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
 184     mb1 = buffer(array_data);
 185     mb1 = buffer(array_data, 1024);
 186     cb1 = buffer(const_array_data_1);
 187     cb1 = buffer(const_array_data_1, 1024);
 188     cb1 = buffer(const_array_data_2);
 189     cb1 = buffer(const_array_data_2, 1024);
 190 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
 191 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
 192     mb1 = buffer(std_array_data);
 193     mb1 = buffer(std_array_data, 1024);
 194     cb1 = buffer(const_std_array_data_1);
 195     cb1 = buffer(const_std_array_data_1, 1024);
 196     cb1 = buffer(const_std_array_data_2);
 197     cb1 = buffer(const_std_array_data_2, 1024);
 198 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
 199     mb1 = buffer(vector_data);
 200     mb1 = buffer(vector_data, 1024);
 201     cb1 = buffer(const_vector_data);
 202     cb1 = buffer(const_vector_data, 1024);
 203     mb1 = buffer(string_data);
 204     mb1 = buffer(string_data, 1024);
 205     cb1 = buffer(const_string_data);
 206     cb1 = buffer(const_string_data, 1024);
 207 #if defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
 208     cb1 = buffer(string_view_data);
 209     cb1 = buffer(string_view_data, 1024);
 210 #endif // defined(BOOST_ASIO_HAS_STD_STRING_VIEW)
 211
 212     // buffer_copy function overloads.
 213
 214     std::size_t size7 = buffer_copy(mb1, cb2);
 215     (void)size7;
 216 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 217     std::size_t size8 = buffer_copy(mb1, cbc2);
 218     (void)size8;
 219 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 220     std::size_t size9 = buffer_copy(mb1, mb2);
 221     (void)size9;
 222 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 223     std::size_t size10 = buffer_copy(mb1, mbc2);
 224     (void)size10;
 225 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 226     std::size_t size11 = buffer_copy(mb1, const_buffer_sequence);
 227     (void)size11;
 228 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 229     std::size_t size12 = buffer_copy(mbc1, cb2);
 230     (void)size12;
 231     std::size_t size13 = buffer_copy(mbc1, cbc2);
 232     (void)size13;
 233     std::size_t size14 = buffer_copy(mbc1, mb2);
 234     (void)size14;
 235     std::size_t size15 = buffer_copy(mbc1, mbc2);
 236     (void)size15;
 237     std::size_t size16 = buffer_copy(mbc1, const_buffer_sequence);
 238     (void)size16;
 239 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 240     std::size_t size17 = buffer_copy(mutable_buffer_sequence, cb2);
 241     (void)size17;
 242 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 243     std::size_t size18 = buffer_copy(mutable_buffer_sequence, cbc2);
 244     (void)size18;
 245 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 246     std::size_t size19 = buffer_copy(mutable_buffer_sequence, mb2);
 247     (void)size19;
 248 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 249     std::size_t size20 = buffer_copy(mutable_buffer_sequence, mbc2);
 250     (void)size20;
 251 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 252     std::size_t size21 = buffer_copy(
 253         mutable_buffer_sequence, const_buffer_sequence);
 254     (void)size21;
 255     std::size_t size22 = buffer_copy(mb1, cb2, 128);
 256     (void)size22;
 257 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 258     std::size_t size23 = buffer_copy(mb1, cbc2, 128);
 259     (void)size23;
 260 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 261     std::size_t size24 = buffer_copy(mb1, mb2, 128);
 262     (void)size24;
 263 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 264     std::size_t size25 = buffer_copy(mb1, mbc2, 128);
 265     (void)size25;
 266 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 267     std::size_t size26 = buffer_copy(mb1, const_buffer_sequence, 128);
 268     (void)size26;
 269 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 270     std::size_t size27 = buffer_copy(mbc1, cb2, 128);
 271     (void)size27;
 272     std::size_t size28 = buffer_copy(mbc1, cbc2, 128);
 273     (void)size28;
 274     std::size_t size29 = buffer_copy(mbc1, mb2, 128);
 275     (void)size29;
 276     std::size_t size30 = buffer_copy(mbc1, mbc2, 128);
 277     (void)size30;
 278     std::size_t size31 = buffer_copy(mbc1, const_buffer_sequence, 128);
 279     (void)size31;
 280 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 281     std::size_t size32 = buffer_copy(mutable_buffer_sequence, cb2, 128);
 282     (void)size32;
 283 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 284     std::size_t size33 = buffer_copy(mutable_buffer_sequence, cbc2, 128);
 285     (void)size33;
 286 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 287     std::size_t size34 = buffer_copy(mutable_buffer_sequence, mb2, 128);
 288     (void)size34;
 289 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 290     std::size_t size35 = buffer_copy(mutable_buffer_sequence, mbc2, 128);
 291     (void)size35;
 292 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 293     std::size_t size36 = buffer_copy(
 294         mutable_buffer_sequence, const_buffer_sequence, 128);
 295     (void)size36;
 296
 297     // dynamic_buffer function overloads.
 298
 299     dynamic_string_buffer<char, std::string::traits_type,
 300       std::string::allocator_type> db1 = dynamic_buffer(string_data);
 301     (void)db1;
 302     dynamic_string_buffer<char, std::string::traits_type,
 303       std::string::allocator_type> db2 = dynamic_buffer(string_data, 1024);
 304     (void)db2;
 305     dynamic_vector_buffer<char, std::allocator<char> >
 306       db3 = dynamic_buffer(vector_data);
 307     (void)db3;
 308     dynamic_vector_buffer<char, std::allocator<char> >
 309       db4 = dynamic_buffer(vector_data, 1024);
 310     (void)db4;
 311
 312     // dynamic_buffer member functions.
 313
 314     std::size_t size37 = db1.size();
 315     (void)size37;
 316     std::size_t size38 = db3.size();
 317     (void)size38;
 318
 319     std::size_t size39 = db1.max_size();
 320     (void)size39;
 321     std::size_t size40 = db3.max_size();
 322     (void)size40;
 323
 324     dynamic_string_buffer<char, std::string::traits_type,
 325       std::string::allocator_type>::const_buffers_type
 326         cb5 = db1.data();
 327     (void)cb5;
 328     dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type
 329       cb6 = db3.data();
 330     (void)cb6;
 331
 332     dynamic_string_buffer<char, std::string::traits_type,
 333       std::string::allocator_type>::mutable_buffers_type mb5
 334         = db1.prepare(1024);
 335     (void)mb5;
 336     dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type
 337       mb6 = db3.prepare(1024);
 338     (void)mb6;
 339
 340     db1.commit(1024);
 341     db3.commit(1024);
 342
 343     db1.consume(1024);
 344     db3.consume(1024);
 345   }
 346   catch (std::exception&)
 347   {
 348   }
 349 }
 350
 351 } // namespace buffer_compile
 352
 353 //------------------------------------------------------------------------------
 354
 355 namespace buffer_copy_runtime {
 356
 357 using namespace boost::asio;
 358 using namespace std;
 359
 360 void test()
 361 {
 362   char dest_data[256];
 363   char source_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 364
 365   memset(dest_data, 0, sizeof(dest_data));
 366   mutable_buffer mb1 = boost::asio::buffer(dest_data);
 367   mutable_buffer mb2 = boost::asio::buffer(source_data);
 368   std::size_t n = buffer_copy(mb1, mb2);
 369   BOOST_ASIO_CHECK(n == sizeof(source_data));
 370   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 371
 372   memset(dest_data, 0, sizeof(dest_data));
 373   mb1 = boost::asio::buffer(dest_data);
 374   const_buffer cb1 = boost::asio::buffer(source_data);
 375   n = buffer_copy(mb1, cb1);
 376   BOOST_ASIO_CHECK(n == sizeof(source_data));
 377   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 378
 379 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 380   memset(dest_data, 0, sizeof(dest_data));
 381   mb1 = boost::asio::buffer(dest_data);
 382   mutable_buffers_1 mbc1 = boost::asio::buffer(source_data);
 383   n = buffer_copy(mb1, mbc1);
 384   BOOST_ASIO_CHECK(n == sizeof(source_data));
 385   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 386
 387   memset(dest_data, 0, sizeof(dest_data));
 388   mb1 = boost::asio::buffer(dest_data);
 389   const_buffers_1 cbc1 = const_buffers_1(boost::asio::buffer(source_data));
 390   n = buffer_copy(mb1, cbc1);
 391   BOOST_ASIO_CHECK(n == sizeof(source_data));
 392   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 393
 394   memset(dest_data, 0, sizeof(dest_data));
 395   mbc1 = boost::asio::buffer(dest_data);
 396   mb1 = boost::asio::buffer(source_data);
 397   n = buffer_copy(mbc1, mb1);
 398   BOOST_ASIO_CHECK(n == sizeof(source_data));
 399   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 400
 401   memset(dest_data, 0, sizeof(dest_data));
 402   mbc1 = boost::asio::buffer(dest_data);
 403   cb1 = boost::asio::buffer(source_data);
 404   n = buffer_copy(mbc1, cb1);
 405   BOOST_ASIO_CHECK(n == sizeof(source_data));
 406   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 407
 408   memset(dest_data, 0, sizeof(dest_data));
 409   mbc1 = boost::asio::buffer(dest_data);
 410   mutable_buffers_1 mbc2 = boost::asio::buffer(source_data);
 411   n = buffer_copy(mbc1, mbc2);
 412   BOOST_ASIO_CHECK(n == sizeof(source_data));
 413   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 414
 415   memset(dest_data, 0, sizeof(dest_data));
 416   mbc1 = boost::asio::buffer(dest_data);
 417   cbc1 = const_buffers_1(boost::asio::buffer(source_data));
 418   n = buffer_copy(mbc1, cbc1);
 419   BOOST_ASIO_CHECK(n == sizeof(source_data));
 420   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 421 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 422
 423   memset(dest_data, 0, sizeof(dest_data));
 424   mb1 = boost::asio::buffer(dest_data);
 425   std::vector<mutable_buffer> mv1;
 426   mv1.push_back(boost::asio::buffer(source_data, 5));
 427   mv1.push_back(boost::asio::buffer(source_data) + 5);
 428   n = buffer_copy(mb1, mv1);
 429   BOOST_ASIO_CHECK(n == sizeof(source_data));
 430   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 431
 432   memset(dest_data, 0, sizeof(dest_data));
 433   mb1 = boost::asio::buffer(dest_data);
 434   std::vector<const_buffer> cv1;
 435   cv1.push_back(boost::asio::buffer(source_data, 6));
 436   cv1.push_back(boost::asio::buffer(source_data) + 6);
 437   n = buffer_copy(mb1, cv1);
 438   BOOST_ASIO_CHECK(n == sizeof(source_data));
 439   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 440
 441   memset(dest_data, 0, sizeof(dest_data));
 442   mv1.clear();
 443   mv1.push_back(boost::asio::buffer(dest_data, 7));
 444   mv1.push_back(boost::asio::buffer(dest_data) + 7);
 445   cb1 = boost::asio::buffer(source_data);
 446   n = buffer_copy(mv1, cb1);
 447   BOOST_ASIO_CHECK(n == sizeof(source_data));
 448   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 449
 450   memset(dest_data, 0, sizeof(dest_data));
 451   mv1.clear();
 452   mv1.push_back(boost::asio::buffer(dest_data, 7));
 453   mv1.push_back(boost::asio::buffer(dest_data) + 7);
 454   cv1.clear();
 455   cv1.push_back(boost::asio::buffer(source_data, 8));
 456   cv1.push_back(boost::asio::buffer(source_data) + 8);
 457   n = buffer_copy(mv1, cv1);
 458   BOOST_ASIO_CHECK(n == sizeof(source_data));
 459   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 460
 461   memset(dest_data, 0, sizeof(dest_data));
 462   mb1 = boost::asio::buffer(dest_data);
 463   mb2 = boost::asio::buffer(source_data);
 464   n = buffer_copy(mb1, mb2, 10);
 465   BOOST_ASIO_CHECK(n == 10);
 466   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 467
 468   memset(dest_data, 0, sizeof(dest_data));
 469   mb1 = boost::asio::buffer(dest_data);
 470   cb1 = boost::asio::buffer(source_data);
 471   n = buffer_copy(mb1, cb1, 10);
 472   BOOST_ASIO_CHECK(n == 10);
 473   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 474
 475 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 476   memset(dest_data, 0, sizeof(dest_data));
 477   mb1 = boost::asio::buffer(dest_data);
 478   mbc1 = boost::asio::buffer(source_data);
 479   n = buffer_copy(mb1, mbc1, 10);
 480   BOOST_ASIO_CHECK(n == 10);
 481   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 482
 483   memset(dest_data, 0, sizeof(dest_data));
 484   mb1 = boost::asio::buffer(dest_data);
 485   cbc1 = const_buffers_1(boost::asio::buffer(source_data));
 486   n = buffer_copy(mb1, cbc1, 10);
 487   BOOST_ASIO_CHECK(n == 10);
 488   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 489
 490   memset(dest_data, 0, sizeof(dest_data));
 491   mbc1 = boost::asio::buffer(dest_data);
 492   mb1 = boost::asio::buffer(source_data);
 493   n = buffer_copy(mbc1, mb1, 10);
 494   BOOST_ASIO_CHECK(n == 10);
 495   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 496
 497   memset(dest_data, 0, sizeof(dest_data));
 498   mbc1 = boost::asio::buffer(dest_data);
 499   cb1 = boost::asio::buffer(source_data);
 500   n = buffer_copy(mbc1, cb1, 10);
 501   BOOST_ASIO_CHECK(n == 10);
 502   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 503
 504   memset(dest_data, 0, sizeof(dest_data));
 505   mbc1 = boost::asio::buffer(dest_data);
 506   mbc2 = boost::asio::buffer(source_data);
 507   n = buffer_copy(mbc1, mbc2, 10);
 508   BOOST_ASIO_CHECK(n == 10);
 509   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 510
 511   memset(dest_data, 0, sizeof(dest_data));
 512   mbc1 = boost::asio::buffer(dest_data);
 513   cbc1 = const_buffers_1(boost::asio::buffer(source_data));
 514   n = buffer_copy(mbc1, cbc1, 10);
 515   BOOST_ASIO_CHECK(n == 10);
 516   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 517 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 518
 519   memset(dest_data, 0, sizeof(dest_data));
 520   mb1 = boost::asio::buffer(dest_data);
 521   mv1.clear();
 522   mv1.push_back(boost::asio::buffer(source_data, 5));
 523   mv1.push_back(boost::asio::buffer(source_data) + 5);
 524   n = buffer_copy(mb1, mv1, 10);
 525   BOOST_ASIO_CHECK(n == 10);
 526   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 527
 528   memset(dest_data, 0, sizeof(dest_data));
 529   mb1 = boost::asio::buffer(dest_data);
 530   cv1.clear();
 531   cv1.push_back(boost::asio::buffer(source_data, 6));
 532   cv1.push_back(boost::asio::buffer(source_data) + 6);
 533   n = buffer_copy(mb1, cv1, 10);
 534   BOOST_ASIO_CHECK(n == 10);
 535   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 536
 537   memset(dest_data, 0, sizeof(dest_data));
 538   mv1.clear();
 539   mv1.push_back(boost::asio::buffer(dest_data, 7));
 540   mv1.push_back(boost::asio::buffer(dest_data) + 7);
 541   cb1 = boost::asio::buffer(source_data);
 542   n = buffer_copy(mv1, cb1, 10);
 543   BOOST_ASIO_CHECK(n == 10);
 544   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 545
 546   memset(dest_data, 0, sizeof(dest_data));
 547   mv1.clear();
 548   mv1.push_back(boost::asio::buffer(dest_data, 7));
 549   mv1.push_back(boost::asio::buffer(dest_data) + 7);
 550   cv1.clear();
 551   cv1.push_back(boost::asio::buffer(source_data, 8));
 552   cv1.push_back(boost::asio::buffer(source_data) + 8);
 553   n = buffer_copy(mv1, cv1, 10);
 554   BOOST_ASIO_CHECK(n == 10);
 555   BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
 556 }
 557
 558 } // namespace buffer_copy_runtime
 559
 560 //------------------------------------------------------------------------------
 561
 562 BOOST_ASIO_TEST_SUITE
 563 (
 564   "buffer",
 565   BOOST_ASIO_COMPILE_TEST_CASE(buffer_compile::test)
 566   BOOST_ASIO_TEST_CASE(buffer_copy_runtime::test)
 567 )