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

   1 //
   2 // read.cpp
   3 // ~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2022 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/read.hpp>
  18
  19 #include <cstring>
  20 #include <vector>
  21 #include "archetypes/async_result.hpp"
  22 #include <boost/asio/io_context.hpp>
  23 #include <boost/asio/post.hpp>
  24 #include <boost/asio/streambuf.hpp>
  25 #include "unit_test.hpp"
  26
  27 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
  28 # include <boost/bind/bind.hpp>
  29 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
  30 # include <functional>
  31 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
  32
  33 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
  34 #include <boost/array.hpp>
  35 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
  36
  37 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
  38 # include <array>
  39 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
  40
  41 using namespace std; // For memcmp, memcpy and memset.
  42
  43 class test_stream
  44 {
  45 public:
  46   typedef boost::asio::io_context::executor_type executor_type;
  47
  48   test_stream(boost::asio::io_context& io_context)
  49     : io_context_(io_context),
  50       length_(0),
  51       position_(0),
  52       next_read_length_(0)
  53   {
  54   }
  55
  56   executor_type get_executor() BOOST_ASIO_NOEXCEPT
  57   {
  58     return io_context_.get_executor();
  59   }
  60
  61   void reset(const void* data, size_t length)
  62   {
  63     BOOST_ASIO_CHECK(length <= max_length);
  64
  65     memcpy(data_, data, length);
  66     length_ = length;
  67     position_ = 0;
  68     next_read_length_ = length;
  69   }
  70
  71   void next_read_length(size_t length)
  72   {
  73     next_read_length_ = length;
  74   }
  75
  76   template <typename Iterator>
  77   bool check_buffers(Iterator begin, Iterator end, size_t length)
  78   {
  79     if (length != position_)
  80       return false;
  81
  82     Iterator iter = begin;
  83     size_t checked_length = 0;
  84     for (; iter != end && checked_length < length; ++iter)
  85     {
  86       size_t buffer_length = boost::asio::buffer_size(*iter);
  87       if (buffer_length > length - checked_length)
  88         buffer_length = length - checked_length;
  89       if (memcmp(data_ + checked_length, iter->data(), buffer_length) != 0)
  90         return false;
  91       checked_length += buffer_length;
  92     }
  93
  94     return true;
  95   }
  96
  97   template <typename Const_Buffers>
  98   bool check_buffers(const Const_Buffers& buffers, size_t length)
  99   {
 100     return check_buffers(boost::asio::buffer_sequence_begin(buffers),
 101         boost::asio::buffer_sequence_end(buffers), length);
 102   }
 103
 104   template <typename Mutable_Buffers>
 105   size_t read_some(const Mutable_Buffers& buffers)
 106   {
 107     size_t n = boost::asio::buffer_copy(buffers,
 108         boost::asio::buffer(data_, length_) + position_,
 109         next_read_length_);
 110     position_ += n;
 111     return n;
 112   }
 113
 114   template <typename Mutable_Buffers>
 115   size_t read_some(const Mutable_Buffers& buffers,
 116       boost::system::error_code& ec)
 117   {
 118     ec = boost::system::error_code();
 119     return read_some(buffers);
 120   }
 121
 122   template <typename Mutable_Buffers, typename Handler>
 123   void async_read_some(const Mutable_Buffers& buffers,
 124       BOOST_ASIO_MOVE_ARG(Handler) handler)
 125   {
 126     size_t bytes_transferred = read_some(buffers);
 127     boost::asio::post(get_executor(),
 128         boost::asio::detail::bind_handler(
 129           BOOST_ASIO_MOVE_CAST(Handler)(handler),
 130           boost::system::error_code(), bytes_transferred));
 131   }
 132
 133 private:
 134   boost::asio::io_context& io_context_;
 135   enum { max_length = 8192 };
 136   char data_[max_length];
 137   size_t length_;
 138   size_t position_;
 139   size_t next_read_length_;
 140 };
 141
 142 static const char read_data[]
 143   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 144
 145 void test_2_arg_zero_buffers_read()
 146 {
 147   boost::asio::io_context ioc;
 148   test_stream s(ioc);
 149   std::vector<boost::asio::mutable_buffer> buffers;
 150
 151   size_t bytes_transferred = boost::asio::read(s, buffers);
 152   BOOST_ASIO_CHECK(bytes_transferred == 0);
 153 }
 154
 155 void test_2_arg_mutable_buffer_read()
 156 {
 157   boost::asio::io_context ioc;
 158   test_stream s(ioc);
 159   char read_buf[sizeof(read_data)];
 160   boost::asio::mutable_buffer buffers
 161     = boost::asio::buffer(read_buf, sizeof(read_buf));
 162
 163   s.reset(read_data, sizeof(read_data));
 164   memset(read_buf, 0, sizeof(read_buf));
 165   size_t bytes_transferred = boost::asio::read(s, buffers);
 166   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 167   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 168
 169   s.reset(read_data, sizeof(read_data));
 170   s.next_read_length(1);
 171   memset(read_buf, 0, sizeof(read_buf));
 172   bytes_transferred = boost::asio::read(s, buffers);
 173   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 174   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 175
 176   s.reset(read_data, sizeof(read_data));
 177   s.next_read_length(10);
 178   memset(read_buf, 0, sizeof(read_buf));
 179   bytes_transferred = boost::asio::read(s, buffers);
 180   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 181   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 182 }
 183
 184 void test_2_arg_vector_buffers_read()
 185 {
 186   boost::asio::io_context ioc;
 187   test_stream s(ioc);
 188   char read_buf[sizeof(read_data)];
 189   std::vector<boost::asio::mutable_buffer> buffers;
 190   buffers.push_back(boost::asio::buffer(read_buf, 32));
 191   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
 192   buffers.push_back(boost::asio::buffer(read_buf) + 39);
 193
 194   s.reset(read_data, sizeof(read_data));
 195   memset(read_buf, 0, sizeof(read_buf));
 196   size_t bytes_transferred = boost::asio::read(s, buffers);
 197   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 198   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 199
 200   s.reset(read_data, sizeof(read_data));
 201   s.next_read_length(1);
 202   memset(read_buf, 0, sizeof(read_buf));
 203   bytes_transferred = boost::asio::read(s, buffers);
 204   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 205   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 206
 207   s.reset(read_data, sizeof(read_data));
 208   s.next_read_length(10);
 209   memset(read_buf, 0, sizeof(read_buf));
 210   bytes_transferred = boost::asio::read(s, buffers);
 211   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 212   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 213 }
 214
 215 void test_2_arg_dynamic_string_read()
 216 {
 217   boost::asio::io_context ioc;
 218   test_stream s(ioc);
 219   std::string data;
 220   boost::asio::dynamic_string_buffer<char, std::string::traits_type,
 221     std::string::allocator_type> sb
 222       = boost::asio::dynamic_buffer(data, sizeof(read_data));
 223
 224   s.reset(read_data, sizeof(read_data));
 225   sb.consume(sb.size());
 226   size_t bytes_transferred = boost::asio::read(s, sb);
 227   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 228   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 229   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 230
 231   s.reset(read_data, sizeof(read_data));
 232   s.next_read_length(1);
 233   sb.consume(sb.size());
 234   bytes_transferred = boost::asio::read(s, sb);
 235   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 236   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 237   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 238
 239   s.reset(read_data, sizeof(read_data));
 240   s.next_read_length(10);
 241   sb.consume(sb.size());
 242   bytes_transferred = boost::asio::read(s, sb);
 243   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 244   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 245   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 246 }
 247
 248 void test_2_arg_streambuf_read()
 249 {
 250 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 251   boost::asio::io_context ioc;
 252   test_stream s(ioc);
 253   boost::asio::streambuf sb(sizeof(read_data));
 254
 255   s.reset(read_data, sizeof(read_data));
 256   sb.consume(sb.size());
 257   size_t bytes_transferred = boost::asio::read(s, sb);
 258   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 259   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 260   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 261
 262   s.reset(read_data, sizeof(read_data));
 263   s.next_read_length(1);
 264   sb.consume(sb.size());
 265   bytes_transferred = boost::asio::read(s, sb);
 266   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 267   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 268   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 269
 270   s.reset(read_data, sizeof(read_data));
 271   s.next_read_length(10);
 272   sb.consume(sb.size());
 273   bytes_transferred = boost::asio::read(s, sb);
 274   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 275   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 276   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 277 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 278 }
 279
 280 void test_3_arg_nothrow_zero_buffers_read()
 281 {
 282   boost::asio::io_context ioc;
 283   test_stream s(ioc);
 284   std::vector<boost::asio::mutable_buffer> buffers;
 285
 286   boost::system::error_code error;
 287   size_t bytes_transferred = boost::asio::read(s, buffers, error);
 288   BOOST_ASIO_CHECK(bytes_transferred == 0);
 289   BOOST_ASIO_CHECK(!error);
 290 }
 291
 292 void test_3_arg_nothrow_mutable_buffer_read()
 293 {
 294   boost::asio::io_context ioc;
 295   test_stream s(ioc);
 296   char read_buf[sizeof(read_data)];
 297   boost::asio::mutable_buffer buffers
 298     = boost::asio::buffer(read_buf, sizeof(read_buf));
 299
 300   s.reset(read_data, sizeof(read_data));
 301   memset(read_buf, 0, sizeof(read_buf));
 302   boost::system::error_code error;
 303   size_t bytes_transferred = boost::asio::read(s, buffers, error);
 304   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 305   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 306   BOOST_ASIO_CHECK(!error);
 307
 308   s.reset(read_data, sizeof(read_data));
 309   s.next_read_length(1);
 310   memset(read_buf, 0, sizeof(read_buf));
 311   bytes_transferred = boost::asio::read(s, buffers, error);
 312   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 313   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 314   BOOST_ASIO_CHECK(!error);
 315
 316   s.reset(read_data, sizeof(read_data));
 317   s.next_read_length(10);
 318   memset(read_buf, 0, sizeof(read_buf));
 319   bytes_transferred = boost::asio::read(s, buffers, error);
 320   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 321   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 322   BOOST_ASIO_CHECK(!error);
 323 }
 324
 325 void test_3_arg_nothrow_vector_buffers_read()
 326 {
 327   boost::asio::io_context ioc;
 328   test_stream s(ioc);
 329   char read_buf[sizeof(read_data)];
 330   std::vector<boost::asio::mutable_buffer> buffers;
 331   buffers.push_back(boost::asio::buffer(read_buf, 32));
 332   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
 333   buffers.push_back(boost::asio::buffer(read_buf) + 39);
 334
 335   s.reset(read_data, sizeof(read_data));
 336   memset(read_buf, 0, sizeof(read_buf));
 337   boost::system::error_code error;
 338   size_t bytes_transferred = boost::asio::read(s, buffers, error);
 339   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 340   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 341   BOOST_ASIO_CHECK(!error);
 342
 343   s.reset(read_data, sizeof(read_data));
 344   s.next_read_length(1);
 345   memset(read_buf, 0, sizeof(read_buf));
 346   bytes_transferred = boost::asio::read(s, buffers, error);
 347   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 348   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 349   BOOST_ASIO_CHECK(!error);
 350
 351   s.reset(read_data, sizeof(read_data));
 352   s.next_read_length(10);
 353   memset(read_buf, 0, sizeof(read_buf));
 354   bytes_transferred = boost::asio::read(s, buffers, error);
 355   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 356   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 357   BOOST_ASIO_CHECK(!error);
 358 }
 359
 360 void test_3_arg_nothrow_dynamic_string_read()
 361 {
 362   boost::asio::io_context ioc;
 363   test_stream s(ioc);
 364   std::string data;
 365   boost::asio::dynamic_string_buffer<char, std::string::traits_type,
 366     std::string::allocator_type> sb
 367       = boost::asio::dynamic_buffer(data, sizeof(read_data));
 368
 369   s.reset(read_data, sizeof(read_data));
 370   sb.consume(sb.size());
 371   boost::system::error_code error;
 372   size_t bytes_transferred = boost::asio::read(s, sb, error);
 373   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 374   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 375   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 376   BOOST_ASIO_CHECK(!error);
 377
 378   s.reset(read_data, sizeof(read_data));
 379   s.next_read_length(1);
 380   sb.consume(sb.size());
 381   bytes_transferred = boost::asio::read(s, sb, error);
 382   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 383   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 384   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 385   BOOST_ASIO_CHECK(!error);
 386
 387   s.reset(read_data, sizeof(read_data));
 388   s.next_read_length(10);
 389   sb.consume(sb.size());
 390   bytes_transferred = boost::asio::read(s, sb, error);
 391   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 392   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 393   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 394   BOOST_ASIO_CHECK(!error);
 395 }
 396
 397 void test_3_arg_nothrow_streambuf_read()
 398 {
 399 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 400   boost::asio::io_context ioc;
 401   test_stream s(ioc);
 402   boost::asio::streambuf sb(sizeof(read_data));
 403
 404   s.reset(read_data, sizeof(read_data));
 405   sb.consume(sb.size());
 406   boost::system::error_code error;
 407   size_t bytes_transferred = boost::asio::read(s, sb, error);
 408   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 409   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 410   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 411   BOOST_ASIO_CHECK(!error);
 412
 413   s.reset(read_data, sizeof(read_data));
 414   s.next_read_length(1);
 415   sb.consume(sb.size());
 416   bytes_transferred = boost::asio::read(s, sb, error);
 417   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 418   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 419   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 420   BOOST_ASIO_CHECK(!error);
 421
 422   s.reset(read_data, sizeof(read_data));
 423   s.next_read_length(10);
 424   sb.consume(sb.size());
 425   bytes_transferred = boost::asio::read(s, sb, error);
 426   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 427   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 428   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 429   BOOST_ASIO_CHECK(!error);
 430 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 431 }
 432
 433 bool old_style_transfer_all(const boost::system::error_code& ec,
 434     size_t /*bytes_transferred*/)
 435 {
 436   return !!ec;
 437 }
 438
 439 struct short_transfer
 440 {
 441   short_transfer() {}
 442 #if defined(BOOST_ASIO_HAS_MOVE)
 443   short_transfer(short_transfer&&) {}
 444 #else // defined(BOOST_ASIO_HAS_MOVE)
 445   short_transfer(const short_transfer&) {}
 446 #endif // defined(BOOST_ASIO_HAS_MOVE)
 447   size_t operator()(const boost::system::error_code& ec,
 448       size_t /*bytes_transferred*/)
 449   {
 450     return !!ec ? 0 : 3;
 451   }
 452 };
 453
 454 void test_3_arg_mutable_buffer_read()
 455 {
 456   boost::asio::io_context ioc;
 457   test_stream s(ioc);
 458   char read_buf[sizeof(read_data)];
 459   boost::asio::mutable_buffer buffers
 460     = boost::asio::buffer(read_buf, sizeof(read_buf));
 461
 462   s.reset(read_data, sizeof(read_data));
 463   memset(read_buf, 0, sizeof(read_buf));
 464   size_t bytes_transferred = boost::asio::read(s, buffers,
 465       boost::asio::transfer_all());
 466   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 467   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 468
 469   s.reset(read_data, sizeof(read_data));
 470   s.next_read_length(1);
 471   memset(read_buf, 0, sizeof(read_buf));
 472   bytes_transferred = boost::asio::read(s, buffers,
 473       boost::asio::transfer_all());
 474   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 475   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 476
 477   s.reset(read_data, sizeof(read_data));
 478   s.next_read_length(10);
 479   memset(read_buf, 0, sizeof(read_buf));
 480   bytes_transferred = boost::asio::read(s, buffers,
 481       boost::asio::transfer_all());
 482   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 483   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 484
 485   s.reset(read_data, sizeof(read_data));
 486   memset(read_buf, 0, sizeof(read_buf));
 487   bytes_transferred = boost::asio::read(s, buffers,
 488       boost::asio::transfer_at_least(1));
 489   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 490   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 491
 492   s.reset(read_data, sizeof(read_data));
 493   s.next_read_length(1);
 494   memset(read_buf, 0, sizeof(read_buf));
 495   bytes_transferred = boost::asio::read(s, buffers,
 496       boost::asio::transfer_at_least(1));
 497   BOOST_ASIO_CHECK(bytes_transferred == 1);
 498   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 499
 500   s.reset(read_data, sizeof(read_data));
 501   s.next_read_length(10);
 502   memset(read_buf, 0, sizeof(read_buf));
 503   bytes_transferred = boost::asio::read(s, buffers,
 504       boost::asio::transfer_at_least(1));
 505   BOOST_ASIO_CHECK(bytes_transferred == 10);
 506   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 507
 508   s.reset(read_data, sizeof(read_data));
 509   memset(read_buf, 0, sizeof(read_buf));
 510   bytes_transferred = boost::asio::read(s, buffers,
 511       boost::asio::transfer_at_least(10));
 512   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 513   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 514
 515   s.reset(read_data, sizeof(read_data));
 516   s.next_read_length(1);
 517   memset(read_buf, 0, sizeof(read_buf));
 518   bytes_transferred = boost::asio::read(s, buffers,
 519       boost::asio::transfer_at_least(10));
 520   BOOST_ASIO_CHECK(bytes_transferred == 10);
 521   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 522
 523   s.reset(read_data, sizeof(read_data));
 524   s.next_read_length(10);
 525   memset(read_buf, 0, sizeof(read_buf));
 526   bytes_transferred = boost::asio::read(s, buffers,
 527       boost::asio::transfer_at_least(10));
 528   BOOST_ASIO_CHECK(bytes_transferred == 10);
 529   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 530
 531   s.reset(read_data, sizeof(read_data));
 532   memset(read_buf, 0, sizeof(read_buf));
 533   bytes_transferred = boost::asio::read(s, buffers,
 534       boost::asio::transfer_at_least(42));
 535   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 536   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 537
 538   s.reset(read_data, sizeof(read_data));
 539   s.next_read_length(1);
 540   memset(read_buf, 0, sizeof(read_buf));
 541   bytes_transferred = boost::asio::read(s, buffers,
 542       boost::asio::transfer_at_least(42));
 543   BOOST_ASIO_CHECK(bytes_transferred == 42);
 544   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 545
 546   s.reset(read_data, sizeof(read_data));
 547   s.next_read_length(10);
 548   memset(read_buf, 0, sizeof(read_buf));
 549   bytes_transferred = boost::asio::read(s, buffers,
 550       boost::asio::transfer_at_least(42));
 551   BOOST_ASIO_CHECK(bytes_transferred == 50);
 552   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
 553
 554   s.reset(read_data, sizeof(read_data));
 555   memset(read_buf, 0, sizeof(read_buf));
 556   bytes_transferred = boost::asio::read(s, buffers,
 557       boost::asio::transfer_exactly(1));
 558   BOOST_ASIO_CHECK(bytes_transferred == 1);
 559   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 560
 561   s.reset(read_data, sizeof(read_data));
 562   s.next_read_length(1);
 563   memset(read_buf, 0, sizeof(read_buf));
 564   bytes_transferred = boost::asio::read(s, buffers,
 565       boost::asio::transfer_exactly(1));
 566   BOOST_ASIO_CHECK(bytes_transferred == 1);
 567   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 568
 569   s.reset(read_data, sizeof(read_data));
 570   s.next_read_length(10);
 571   memset(read_buf, 0, sizeof(read_buf));
 572   bytes_transferred = boost::asio::read(s, buffers,
 573       boost::asio::transfer_exactly(1));
 574   BOOST_ASIO_CHECK(bytes_transferred == 1);
 575   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 576
 577   s.reset(read_data, sizeof(read_data));
 578   memset(read_buf, 0, sizeof(read_buf));
 579   bytes_transferred = boost::asio::read(s, buffers,
 580       boost::asio::transfer_exactly(10));
 581   BOOST_ASIO_CHECK(bytes_transferred == 10);
 582   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 583
 584   s.reset(read_data, sizeof(read_data));
 585   s.next_read_length(1);
 586   memset(read_buf, 0, sizeof(read_buf));
 587   bytes_transferred = boost::asio::read(s, buffers,
 588       boost::asio::transfer_exactly(10));
 589   BOOST_ASIO_CHECK(bytes_transferred == 10);
 590   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 591
 592   s.reset(read_data, sizeof(read_data));
 593   s.next_read_length(10);
 594   memset(read_buf, 0, sizeof(read_buf));
 595   bytes_transferred = boost::asio::read(s, buffers,
 596       boost::asio::transfer_exactly(10));
 597   BOOST_ASIO_CHECK(bytes_transferred == 10);
 598   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 599
 600   s.reset(read_data, sizeof(read_data));
 601   memset(read_buf, 0, sizeof(read_buf));
 602   bytes_transferred = boost::asio::read(s, buffers,
 603       boost::asio::transfer_exactly(42));
 604   BOOST_ASIO_CHECK(bytes_transferred == 42);
 605   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 606
 607   s.reset(read_data, sizeof(read_data));
 608   s.next_read_length(1);
 609   memset(read_buf, 0, sizeof(read_buf));
 610   bytes_transferred = boost::asio::read(s, buffers,
 611       boost::asio::transfer_exactly(42));
 612   BOOST_ASIO_CHECK(bytes_transferred == 42);
 613   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 614
 615   s.reset(read_data, sizeof(read_data));
 616   s.next_read_length(10);
 617   memset(read_buf, 0, sizeof(read_buf));
 618   bytes_transferred = boost::asio::read(s, buffers,
 619       boost::asio::transfer_exactly(42));
 620   BOOST_ASIO_CHECK(bytes_transferred == 42);
 621   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 622
 623   s.reset(read_data, sizeof(read_data));
 624   memset(read_buf, 0, sizeof(read_buf));
 625   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 626   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 627   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 628
 629   s.reset(read_data, sizeof(read_data));
 630   s.next_read_length(1);
 631   memset(read_buf, 0, sizeof(read_buf));
 632   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 633   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 634   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 635
 636   s.reset(read_data, sizeof(read_data));
 637   s.next_read_length(10);
 638   memset(read_buf, 0, sizeof(read_buf));
 639   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 640   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 641   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 642
 643   s.reset(read_data, sizeof(read_data));
 644   memset(read_buf, 0, sizeof(read_buf));
 645   bytes_transferred = boost::asio::read(s, buffers, short_transfer());
 646   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 647   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 648
 649   s.reset(read_data, sizeof(read_data));
 650   s.next_read_length(1);
 651   memset(read_buf, 0, sizeof(read_buf));
 652   bytes_transferred = boost::asio::read(s, buffers, short_transfer());
 653   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 654   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 655
 656   s.reset(read_data, sizeof(read_data));
 657   s.next_read_length(10);
 658   memset(read_buf, 0, sizeof(read_buf));
 659   bytes_transferred = boost::asio::read(s, buffers, short_transfer());
 660   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 661   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 662 }
 663
 664 void test_3_arg_vector_buffers_read()
 665 {
 666   boost::asio::io_context ioc;
 667   test_stream s(ioc);
 668   char read_buf[sizeof(read_data)];
 669   std::vector<boost::asio::mutable_buffer> buffers;
 670   buffers.push_back(boost::asio::buffer(read_buf, 32));
 671   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
 672   buffers.push_back(boost::asio::buffer(read_buf) + 39);
 673
 674   s.reset(read_data, sizeof(read_data));
 675   memset(read_buf, 0, sizeof(read_buf));
 676   size_t bytes_transferred = boost::asio::read(s, buffers,
 677       boost::asio::transfer_all());
 678   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 679   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 680
 681   s.reset(read_data, sizeof(read_data));
 682   s.next_read_length(1);
 683   memset(read_buf, 0, sizeof(read_buf));
 684   bytes_transferred = boost::asio::read(s, buffers,
 685       boost::asio::transfer_all());
 686   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 687   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 688
 689   s.reset(read_data, sizeof(read_data));
 690   s.next_read_length(10);
 691   memset(read_buf, 0, sizeof(read_buf));
 692   bytes_transferred = boost::asio::read(s, buffers,
 693       boost::asio::transfer_all());
 694   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 695   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 696
 697   s.reset(read_data, sizeof(read_data));
 698   memset(read_buf, 0, sizeof(read_buf));
 699   bytes_transferred = boost::asio::read(s, buffers,
 700       boost::asio::transfer_at_least(1));
 701   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 702   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 703
 704   s.reset(read_data, sizeof(read_data));
 705   s.next_read_length(1);
 706   memset(read_buf, 0, sizeof(read_buf));
 707   bytes_transferred = boost::asio::read(s, buffers,
 708       boost::asio::transfer_at_least(1));
 709   BOOST_ASIO_CHECK(bytes_transferred == 1);
 710   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 711
 712   s.reset(read_data, sizeof(read_data));
 713   s.next_read_length(10);
 714   memset(read_buf, 0, sizeof(read_buf));
 715   bytes_transferred = boost::asio::read(s, buffers,
 716       boost::asio::transfer_at_least(1));
 717   BOOST_ASIO_CHECK(bytes_transferred == 10);
 718   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 719
 720   s.reset(read_data, sizeof(read_data));
 721   memset(read_buf, 0, sizeof(read_buf));
 722   bytes_transferred = boost::asio::read(s, buffers,
 723       boost::asio::transfer_at_least(10));
 724   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 725   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 726
 727   s.reset(read_data, sizeof(read_data));
 728   s.next_read_length(1);
 729   memset(read_buf, 0, sizeof(read_buf));
 730   bytes_transferred = boost::asio::read(s, buffers,
 731       boost::asio::transfer_at_least(10));
 732   BOOST_ASIO_CHECK(bytes_transferred == 10);
 733   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 734
 735   s.reset(read_data, sizeof(read_data));
 736   s.next_read_length(10);
 737   memset(read_buf, 0, sizeof(read_buf));
 738   bytes_transferred = boost::asio::read(s, buffers,
 739       boost::asio::transfer_at_least(10));
 740   BOOST_ASIO_CHECK(bytes_transferred == 10);
 741   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 742
 743   s.reset(read_data, sizeof(read_data));
 744   memset(read_buf, 0, sizeof(read_buf));
 745   bytes_transferred = boost::asio::read(s, buffers,
 746       boost::asio::transfer_at_least(42));
 747   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 748   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 749
 750   s.reset(read_data, sizeof(read_data));
 751   s.next_read_length(1);
 752   memset(read_buf, 0, sizeof(read_buf));
 753   bytes_transferred = boost::asio::read(s, buffers,
 754       boost::asio::transfer_at_least(42));
 755   BOOST_ASIO_CHECK(bytes_transferred == 42);
 756   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 757
 758   s.reset(read_data, sizeof(read_data));
 759   s.next_read_length(10);
 760   memset(read_buf, 0, sizeof(read_buf));
 761   bytes_transferred = boost::asio::read(s, buffers,
 762       boost::asio::transfer_at_least(42));
 763   BOOST_ASIO_CHECK(bytes_transferred == 50);
 764   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
 765
 766   s.reset(read_data, sizeof(read_data));
 767   memset(read_buf, 0, sizeof(read_buf));
 768   bytes_transferred = boost::asio::read(s, buffers,
 769       boost::asio::transfer_exactly(1));
 770   BOOST_ASIO_CHECK(bytes_transferred == 1);
 771   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 772
 773   s.reset(read_data, sizeof(read_data));
 774   s.next_read_length(1);
 775   memset(read_buf, 0, sizeof(read_buf));
 776   bytes_transferred = boost::asio::read(s, buffers,
 777       boost::asio::transfer_exactly(1));
 778   BOOST_ASIO_CHECK(bytes_transferred == 1);
 779   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 780
 781   s.reset(read_data, sizeof(read_data));
 782   s.next_read_length(10);
 783   memset(read_buf, 0, sizeof(read_buf));
 784   bytes_transferred = boost::asio::read(s, buffers,
 785       boost::asio::transfer_exactly(1));
 786   BOOST_ASIO_CHECK(bytes_transferred == 1);
 787   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 788
 789   s.reset(read_data, sizeof(read_data));
 790   memset(read_buf, 0, sizeof(read_buf));
 791   bytes_transferred = boost::asio::read(s, buffers,
 792       boost::asio::transfer_exactly(10));
 793   BOOST_ASIO_CHECK(bytes_transferred == 10);
 794   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 795
 796   s.reset(read_data, sizeof(read_data));
 797   s.next_read_length(1);
 798   memset(read_buf, 0, sizeof(read_buf));
 799   bytes_transferred = boost::asio::read(s, buffers,
 800       boost::asio::transfer_exactly(10));
 801   BOOST_ASIO_CHECK(bytes_transferred == 10);
 802   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 803
 804   s.reset(read_data, sizeof(read_data));
 805   s.next_read_length(10);
 806   memset(read_buf, 0, sizeof(read_buf));
 807   bytes_transferred = boost::asio::read(s, buffers,
 808       boost::asio::transfer_exactly(10));
 809   BOOST_ASIO_CHECK(bytes_transferred == 10);
 810   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 811
 812   s.reset(read_data, sizeof(read_data));
 813   memset(read_buf, 0, sizeof(read_buf));
 814   bytes_transferred = boost::asio::read(s, buffers,
 815       boost::asio::transfer_exactly(42));
 816   BOOST_ASIO_CHECK(bytes_transferred == 42);
 817   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 818
 819   s.reset(read_data, sizeof(read_data));
 820   s.next_read_length(1);
 821   memset(read_buf, 0, sizeof(read_buf));
 822   bytes_transferred = boost::asio::read(s, buffers,
 823       boost::asio::transfer_exactly(42));
 824   BOOST_ASIO_CHECK(bytes_transferred == 42);
 825   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 826
 827   s.reset(read_data, sizeof(read_data));
 828   s.next_read_length(10);
 829   memset(read_buf, 0, sizeof(read_buf));
 830   bytes_transferred = boost::asio::read(s, buffers,
 831       boost::asio::transfer_exactly(42));
 832   BOOST_ASIO_CHECK(bytes_transferred == 42);
 833   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 834
 835   s.reset(read_data, sizeof(read_data));
 836   memset(read_buf, 0, sizeof(read_buf));
 837   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 838   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 839   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 840
 841   s.reset(read_data, sizeof(read_data));
 842   s.next_read_length(1);
 843   memset(read_buf, 0, sizeof(read_buf));
 844   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 845   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 846   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 847
 848   s.reset(read_data, sizeof(read_data));
 849   s.next_read_length(10);
 850   memset(read_buf, 0, sizeof(read_buf));
 851   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 852   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 853   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 854
 855   s.reset(read_data, sizeof(read_data));
 856   memset(read_buf, 0, sizeof(read_buf));
 857   bytes_transferred = boost::asio::read(s, buffers, short_transfer());
 858   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 859   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 860
 861   s.reset(read_data, sizeof(read_data));
 862   s.next_read_length(1);
 863   memset(read_buf, 0, sizeof(read_buf));
 864   bytes_transferred = boost::asio::read(s, buffers, short_transfer());
 865   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 866   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 867
 868   s.reset(read_data, sizeof(read_data));
 869   s.next_read_length(10);
 870   memset(read_buf, 0, sizeof(read_buf));
 871   bytes_transferred = boost::asio::read(s, buffers, short_transfer());
 872   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 873   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 874 }
 875
 876 void test_3_arg_dynamic_string_read()
 877 {
 878   boost::asio::io_context ioc;
 879   test_stream s(ioc);
 880   std::string data;
 881   boost::asio::dynamic_string_buffer<char, std::string::traits_type,
 882     std::string::allocator_type> sb
 883       = boost::asio::dynamic_buffer(data, sizeof(read_data));
 884
 885   s.reset(read_data, sizeof(read_data));
 886   sb.consume(sb.size());
 887   size_t bytes_transferred = boost::asio::read(s, sb,
 888       boost::asio::transfer_all());
 889   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 890   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 891   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 892
 893   s.reset(read_data, sizeof(read_data));
 894   s.next_read_length(1);
 895   sb.consume(sb.size());
 896   bytes_transferred = boost::asio::read(s, sb,
 897       boost::asio::transfer_all());
 898   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 899   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 900   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 901
 902   s.reset(read_data, sizeof(read_data));
 903   s.next_read_length(10);
 904   sb.consume(sb.size());
 905   bytes_transferred = boost::asio::read(s, sb,
 906       boost::asio::transfer_all());
 907   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 908   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 909   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 910
 911   s.reset(read_data, sizeof(read_data));
 912   sb.consume(sb.size());
 913   bytes_transferred = boost::asio::read(s, sb,
 914       boost::asio::transfer_at_least(1));
 915   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 916   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 917   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 918
 919   s.reset(read_data, sizeof(read_data));
 920   s.next_read_length(1);
 921   sb.consume(sb.size());
 922   bytes_transferred = boost::asio::read(s, sb,
 923       boost::asio::transfer_at_least(1));
 924   BOOST_ASIO_CHECK(bytes_transferred == 1);
 925   BOOST_ASIO_CHECK(sb.size() == 1);
 926   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
 927
 928   s.reset(read_data, sizeof(read_data));
 929   s.next_read_length(10);
 930   sb.consume(sb.size());
 931   bytes_transferred = boost::asio::read(s, sb,
 932       boost::asio::transfer_at_least(1));
 933   BOOST_ASIO_CHECK(bytes_transferred == 10);
 934   BOOST_ASIO_CHECK(sb.size() == 10);
 935   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
 936
 937   s.reset(read_data, sizeof(read_data));
 938   sb.consume(sb.size());
 939   bytes_transferred = boost::asio::read(s, sb,
 940       boost::asio::transfer_at_least(10));
 941   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 942   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 943   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 944
 945   s.reset(read_data, sizeof(read_data));
 946   s.next_read_length(1);
 947   sb.consume(sb.size());
 948   bytes_transferred = boost::asio::read(s, sb,
 949       boost::asio::transfer_at_least(10));
 950   BOOST_ASIO_CHECK(bytes_transferred == 10);
 951   BOOST_ASIO_CHECK(sb.size() == 10);
 952   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
 953
 954   s.reset(read_data, sizeof(read_data));
 955   s.next_read_length(10);
 956   sb.consume(sb.size());
 957   bytes_transferred = boost::asio::read(s, sb,
 958       boost::asio::transfer_at_least(10));
 959   BOOST_ASIO_CHECK(bytes_transferred == 10);
 960   BOOST_ASIO_CHECK(sb.size() == 10);
 961   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
 962
 963   s.reset(read_data, sizeof(read_data));
 964   sb.consume(sb.size());
 965   bytes_transferred = boost::asio::read(s, sb,
 966       boost::asio::transfer_at_least(42));
 967   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 968   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 969   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
 970
 971   s.reset(read_data, sizeof(read_data));
 972   s.next_read_length(1);
 973   sb.consume(sb.size());
 974   bytes_transferred = boost::asio::read(s, sb,
 975       boost::asio::transfer_at_least(42));
 976   BOOST_ASIO_CHECK(bytes_transferred == 42);
 977   BOOST_ASIO_CHECK(sb.size() == 42);
 978   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
 979
 980   s.reset(read_data, sizeof(read_data));
 981   s.next_read_length(10);
 982   sb.consume(sb.size());
 983   bytes_transferred = boost::asio::read(s, sb,
 984       boost::asio::transfer_at_least(42));
 985   BOOST_ASIO_CHECK(bytes_transferred == 50);
 986   BOOST_ASIO_CHECK(sb.size() == 50);
 987   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
 988
 989   s.reset(read_data, sizeof(read_data));
 990   sb.consume(sb.size());
 991   bytes_transferred = boost::asio::read(s, sb,
 992       boost::asio::transfer_exactly(1));
 993   BOOST_ASIO_CHECK(bytes_transferred == 1);
 994   BOOST_ASIO_CHECK(sb.size() == 1);
 995   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
 996
 997   s.reset(read_data, sizeof(read_data));
 998   s.next_read_length(1);
 999   sb.consume(sb.size());
1000   bytes_transferred = boost::asio::read(s, sb,
1001       boost::asio::transfer_exactly(1));
1002   BOOST_ASIO_CHECK(bytes_transferred == 1);
1003   BOOST_ASIO_CHECK(sb.size() == 1);
1004   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
1005
1006   s.reset(read_data, sizeof(read_data));
1007   s.next_read_length(10);
1008   sb.consume(sb.size());
1009   bytes_transferred = boost::asio::read(s, sb,
1010       boost::asio::transfer_exactly(1));
1011   BOOST_ASIO_CHECK(bytes_transferred == 1);
1012   BOOST_ASIO_CHECK(sb.size() == 1);
1013   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
1014
1015   s.reset(read_data, sizeof(read_data));
1016   sb.consume(sb.size());
1017   bytes_transferred = boost::asio::read(s, sb,
1018       boost::asio::transfer_exactly(10));
1019   BOOST_ASIO_CHECK(bytes_transferred == 10);
1020   BOOST_ASIO_CHECK(sb.size() == 10);
1021   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1022
1023   s.reset(read_data, sizeof(read_data));
1024   s.next_read_length(1);
1025   sb.consume(sb.size());
1026   bytes_transferred = boost::asio::read(s, sb,
1027       boost::asio::transfer_exactly(10));
1028   BOOST_ASIO_CHECK(bytes_transferred == 10);
1029   BOOST_ASIO_CHECK(sb.size() == 10);
1030   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1031
1032   s.reset(read_data, sizeof(read_data));
1033   s.next_read_length(10);
1034   sb.consume(sb.size());
1035   bytes_transferred = boost::asio::read(s, sb,
1036       boost::asio::transfer_exactly(10));
1037   BOOST_ASIO_CHECK(bytes_transferred == 10);
1038   BOOST_ASIO_CHECK(sb.size() == 10);
1039   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1040
1041   s.reset(read_data, sizeof(read_data));
1042   sb.consume(sb.size());
1043   bytes_transferred = boost::asio::read(s, sb,
1044       boost::asio::transfer_exactly(42));
1045   BOOST_ASIO_CHECK(bytes_transferred == 42);
1046   BOOST_ASIO_CHECK(sb.size() == 42);
1047   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1048
1049   s.reset(read_data, sizeof(read_data));
1050   s.next_read_length(1);
1051   sb.consume(sb.size());
1052   bytes_transferred = boost::asio::read(s, sb,
1053       boost::asio::transfer_exactly(42));
1054   BOOST_ASIO_CHECK(bytes_transferred == 42);
1055   BOOST_ASIO_CHECK(sb.size() == 42);
1056   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1057
1058   s.reset(read_data, sizeof(read_data));
1059   s.next_read_length(10);
1060   sb.consume(sb.size());
1061   bytes_transferred = boost::asio::read(s, sb,
1062       boost::asio::transfer_exactly(42));
1063   BOOST_ASIO_CHECK(bytes_transferred == 42);
1064   BOOST_ASIO_CHECK(sb.size() == 42);
1065   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1066
1067   s.reset(read_data, sizeof(read_data));
1068   sb.consume(sb.size());
1069   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
1070   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1071   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1072   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1073
1074   s.reset(read_data, sizeof(read_data));
1075   s.next_read_length(1);
1076   sb.consume(sb.size());
1077   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
1078   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1079   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1080   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1081
1082   s.reset(read_data, sizeof(read_data));
1083   s.next_read_length(10);
1084   sb.consume(sb.size());
1085   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
1086   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1087   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1088   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1089
1090   s.reset(read_data, sizeof(read_data));
1091   sb.consume(sb.size());
1092   bytes_transferred = boost::asio::read(s, sb, short_transfer());
1093   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1094   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1095   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1096
1097   s.reset(read_data, sizeof(read_data));
1098   s.next_read_length(1);
1099   sb.consume(sb.size());
1100   bytes_transferred = boost::asio::read(s, sb, short_transfer());
1101   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1102   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1103   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1104
1105   s.reset(read_data, sizeof(read_data));
1106   s.next_read_length(10);
1107   sb.consume(sb.size());
1108   bytes_transferred = boost::asio::read(s, sb, short_transfer());
1109   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1110   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1111   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1112 }
1113
1114 void test_3_arg_streambuf_read()
1115 {
1116 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
1117   boost::asio::io_context ioc;
1118   test_stream s(ioc);
1119   boost::asio::streambuf sb(sizeof(read_data));
1120
1121   s.reset(read_data, sizeof(read_data));
1122   sb.consume(sb.size());
1123   size_t bytes_transferred = boost::asio::read(s, sb,
1124       boost::asio::transfer_all());
1125   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1126   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1127   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1128
1129   s.reset(read_data, sizeof(read_data));
1130   s.next_read_length(1);
1131   sb.consume(sb.size());
1132   bytes_transferred = boost::asio::read(s, sb,
1133       boost::asio::transfer_all());
1134   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1135   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1136   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1137
1138   s.reset(read_data, sizeof(read_data));
1139   s.next_read_length(10);
1140   sb.consume(sb.size());
1141   bytes_transferred = boost::asio::read(s, sb,
1142       boost::asio::transfer_all());
1143   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1144   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1145   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1146
1147   s.reset(read_data, sizeof(read_data));
1148   sb.consume(sb.size());
1149   bytes_transferred = boost::asio::read(s, sb,
1150       boost::asio::transfer_at_least(1));
1151   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1152   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1153   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1154
1155   s.reset(read_data, sizeof(read_data));
1156   s.next_read_length(1);
1157   sb.consume(sb.size());
1158   bytes_transferred = boost::asio::read(s, sb,
1159       boost::asio::transfer_at_least(1));
1160   BOOST_ASIO_CHECK(bytes_transferred == 1);
1161   BOOST_ASIO_CHECK(sb.size() == 1);
1162   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1163
1164   s.reset(read_data, sizeof(read_data));
1165   s.next_read_length(10);
1166   sb.consume(sb.size());
1167   bytes_transferred = boost::asio::read(s, sb,
1168       boost::asio::transfer_at_least(1));
1169   BOOST_ASIO_CHECK(bytes_transferred == 10);
1170   BOOST_ASIO_CHECK(sb.size() == 10);
1171   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1172
1173   s.reset(read_data, sizeof(read_data));
1174   sb.consume(sb.size());
1175   bytes_transferred = boost::asio::read(s, sb,
1176       boost::asio::transfer_at_least(10));
1177   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1178   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1179   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1180
1181   s.reset(read_data, sizeof(read_data));
1182   s.next_read_length(1);
1183   sb.consume(sb.size());
1184   bytes_transferred = boost::asio::read(s, sb,
1185       boost::asio::transfer_at_least(10));
1186   BOOST_ASIO_CHECK(bytes_transferred == 10);
1187   BOOST_ASIO_CHECK(sb.size() == 10);
1188   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1189
1190   s.reset(read_data, sizeof(read_data));
1191   s.next_read_length(10);
1192   sb.consume(sb.size());
1193   bytes_transferred = boost::asio::read(s, sb,
1194       boost::asio::transfer_at_least(10));
1195   BOOST_ASIO_CHECK(bytes_transferred == 10);
1196   BOOST_ASIO_CHECK(sb.size() == 10);
1197   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1198
1199   s.reset(read_data, sizeof(read_data));
1200   sb.consume(sb.size());
1201   bytes_transferred = boost::asio::read(s, sb,
1202       boost::asio::transfer_at_least(42));
1203   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1204   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1205   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1206
1207   s.reset(read_data, sizeof(read_data));
1208   s.next_read_length(1);
1209   sb.consume(sb.size());
1210   bytes_transferred = boost::asio::read(s, sb,
1211       boost::asio::transfer_at_least(42));
1212   BOOST_ASIO_CHECK(bytes_transferred == 42);
1213   BOOST_ASIO_CHECK(sb.size() == 42);
1214   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1215
1216   s.reset(read_data, sizeof(read_data));
1217   s.next_read_length(10);
1218   sb.consume(sb.size());
1219   bytes_transferred = boost::asio::read(s, sb,
1220       boost::asio::transfer_at_least(42));
1221   BOOST_ASIO_CHECK(bytes_transferred == 50);
1222   BOOST_ASIO_CHECK(sb.size() == 50);
1223   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
1224
1225   s.reset(read_data, sizeof(read_data));
1226   sb.consume(sb.size());
1227   bytes_transferred = boost::asio::read(s, sb,
1228       boost::asio::transfer_exactly(1));
1229   BOOST_ASIO_CHECK(bytes_transferred == 1);
1230   BOOST_ASIO_CHECK(sb.size() == 1);
1231   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1232
1233   s.reset(read_data, sizeof(read_data));
1234   s.next_read_length(1);
1235   sb.consume(sb.size());
1236   bytes_transferred = boost::asio::read(s, sb,
1237       boost::asio::transfer_exactly(1));
1238   BOOST_ASIO_CHECK(bytes_transferred == 1);
1239   BOOST_ASIO_CHECK(sb.size() == 1);
1240   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1241
1242   s.reset(read_data, sizeof(read_data));
1243   s.next_read_length(10);
1244   sb.consume(sb.size());
1245   bytes_transferred = boost::asio::read(s, sb,
1246       boost::asio::transfer_exactly(1));
1247   BOOST_ASIO_CHECK(bytes_transferred == 1);
1248   BOOST_ASIO_CHECK(sb.size() == 1);
1249   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1250
1251   s.reset(read_data, sizeof(read_data));
1252   sb.consume(sb.size());
1253   bytes_transferred = boost::asio::read(s, sb,
1254       boost::asio::transfer_exactly(10));
1255   BOOST_ASIO_CHECK(bytes_transferred == 10);
1256   BOOST_ASIO_CHECK(sb.size() == 10);
1257   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1258
1259   s.reset(read_data, sizeof(read_data));
1260   s.next_read_length(1);
1261   sb.consume(sb.size());
1262   bytes_transferred = boost::asio::read(s, sb,
1263       boost::asio::transfer_exactly(10));
1264   BOOST_ASIO_CHECK(bytes_transferred == 10);
1265   BOOST_ASIO_CHECK(sb.size() == 10);
1266   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1267
1268   s.reset(read_data, sizeof(read_data));
1269   s.next_read_length(10);
1270   sb.consume(sb.size());
1271   bytes_transferred = boost::asio::read(s, sb,
1272       boost::asio::transfer_exactly(10));
1273   BOOST_ASIO_CHECK(bytes_transferred == 10);
1274   BOOST_ASIO_CHECK(sb.size() == 10);
1275   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1276
1277   s.reset(read_data, sizeof(read_data));
1278   sb.consume(sb.size());
1279   bytes_transferred = boost::asio::read(s, sb,
1280       boost::asio::transfer_exactly(42));
1281   BOOST_ASIO_CHECK(bytes_transferred == 42);
1282   BOOST_ASIO_CHECK(sb.size() == 42);
1283   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1284
1285   s.reset(read_data, sizeof(read_data));
1286   s.next_read_length(1);
1287   sb.consume(sb.size());
1288   bytes_transferred = boost::asio::read(s, sb,
1289       boost::asio::transfer_exactly(42));
1290   BOOST_ASIO_CHECK(bytes_transferred == 42);
1291   BOOST_ASIO_CHECK(sb.size() == 42);
1292   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1293
1294   s.reset(read_data, sizeof(read_data));
1295   s.next_read_length(10);
1296   sb.consume(sb.size());
1297   bytes_transferred = boost::asio::read(s, sb,
1298       boost::asio::transfer_exactly(42));
1299   BOOST_ASIO_CHECK(bytes_transferred == 42);
1300   BOOST_ASIO_CHECK(sb.size() == 42);
1301   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1302
1303   s.reset(read_data, sizeof(read_data));
1304   sb.consume(sb.size());
1305   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
1306   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1307   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1308   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1309
1310   s.reset(read_data, sizeof(read_data));
1311   s.next_read_length(1);
1312   sb.consume(sb.size());
1313   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
1314   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1315   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1316   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1317
1318   s.reset(read_data, sizeof(read_data));
1319   s.next_read_length(10);
1320   sb.consume(sb.size());
1321   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
1322   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1323   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1324   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1325
1326   s.reset(read_data, sizeof(read_data));
1327   sb.consume(sb.size());
1328   bytes_transferred = boost::asio::read(s, sb, short_transfer());
1329   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1330   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1331   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1332
1333   s.reset(read_data, sizeof(read_data));
1334   s.next_read_length(1);
1335   sb.consume(sb.size());
1336   bytes_transferred = boost::asio::read(s, sb, short_transfer());
1337   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1338   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1339   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1340
1341   s.reset(read_data, sizeof(read_data));
1342   s.next_read_length(10);
1343   sb.consume(sb.size());
1344   bytes_transferred = boost::asio::read(s, sb, short_transfer());
1345   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1346   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1347   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1348 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
1349 }
1350
1351 void test_4_arg_mutable_buffer_read()
1352 {
1353   boost::asio::io_context ioc;
1354   test_stream s(ioc);
1355   char read_buf[sizeof(read_data)];
1356   boost::asio::mutable_buffer buffers
1357     = boost::asio::buffer(read_buf, sizeof(read_buf));
1358
1359   s.reset(read_data, sizeof(read_data));
1360   memset(read_buf, 0, sizeof(read_buf));
1361   boost::system::error_code error;
1362   size_t bytes_transferred = boost::asio::read(s, buffers,
1363       boost::asio::transfer_all(), error);
1364   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1365   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1366   BOOST_ASIO_CHECK(!error);
1367
1368   s.reset(read_data, sizeof(read_data));
1369   s.next_read_length(1);
1370   memset(read_buf, 0, sizeof(read_buf));
1371   error = boost::system::error_code();
1372   bytes_transferred = boost::asio::read(s, buffers,
1373       boost::asio::transfer_all(), error);
1374   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1375   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1376   BOOST_ASIO_CHECK(!error);
1377
1378   s.reset(read_data, sizeof(read_data));
1379   s.next_read_length(10);
1380   memset(read_buf, 0, sizeof(read_buf));
1381   error = boost::system::error_code();
1382   bytes_transferred = boost::asio::read(s, buffers,
1383       boost::asio::transfer_all(), error);
1384   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1385   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1386   BOOST_ASIO_CHECK(!error);
1387
1388   s.reset(read_data, sizeof(read_data));
1389   memset(read_buf, 0, sizeof(read_buf));
1390   error = boost::system::error_code();
1391   bytes_transferred = boost::asio::read(s, buffers,
1392       boost::asio::transfer_at_least(1), error);
1393   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1394   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1395   BOOST_ASIO_CHECK(!error);
1396
1397   s.reset(read_data, sizeof(read_data));
1398   s.next_read_length(1);
1399   memset(read_buf, 0, sizeof(read_buf));
1400   error = boost::system::error_code();
1401   bytes_transferred = boost::asio::read(s, buffers,
1402       boost::asio::transfer_at_least(1), error);
1403   BOOST_ASIO_CHECK(bytes_transferred == 1);
1404   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1405   BOOST_ASIO_CHECK(!error);
1406
1407   s.reset(read_data, sizeof(read_data));
1408   s.next_read_length(10);
1409   memset(read_buf, 0, sizeof(read_buf));
1410   error = boost::system::error_code();
1411   bytes_transferred = boost::asio::read(s, buffers,
1412       boost::asio::transfer_at_least(1), error);
1413   BOOST_ASIO_CHECK(bytes_transferred == 10);
1414   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1415   BOOST_ASIO_CHECK(!error);
1416
1417   s.reset(read_data, sizeof(read_data));
1418   memset(read_buf, 0, sizeof(read_buf));
1419   error = boost::system::error_code();
1420   bytes_transferred = boost::asio::read(s, buffers,
1421       boost::asio::transfer_at_least(10), error);
1422   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1423   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1424   BOOST_ASIO_CHECK(!error);
1425
1426   s.reset(read_data, sizeof(read_data));
1427   s.next_read_length(1);
1428   memset(read_buf, 0, sizeof(read_buf));
1429   error = boost::system::error_code();
1430   bytes_transferred = boost::asio::read(s, buffers,
1431       boost::asio::transfer_at_least(10), error);
1432   BOOST_ASIO_CHECK(bytes_transferred == 10);
1433   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1434   BOOST_ASIO_CHECK(!error);
1435
1436   s.reset(read_data, sizeof(read_data));
1437   s.next_read_length(10);
1438   memset(read_buf, 0, sizeof(read_buf));
1439   error = boost::system::error_code();
1440   bytes_transferred = boost::asio::read(s, buffers,
1441       boost::asio::transfer_at_least(10), error);
1442   BOOST_ASIO_CHECK(bytes_transferred == 10);
1443   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1444   BOOST_ASIO_CHECK(!error);
1445
1446   s.reset(read_data, sizeof(read_data));
1447   memset(read_buf, 0, sizeof(read_buf));
1448   error = boost::system::error_code();
1449   bytes_transferred = boost::asio::read(s, buffers,
1450       boost::asio::transfer_at_least(42), error);
1451   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1452   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1453   BOOST_ASIO_CHECK(!error);
1454
1455   s.reset(read_data, sizeof(read_data));
1456   s.next_read_length(1);
1457   memset(read_buf, 0, sizeof(read_buf));
1458   error = boost::system::error_code();
1459   bytes_transferred = boost::asio::read(s, buffers,
1460       boost::asio::transfer_at_least(42), error);
1461   BOOST_ASIO_CHECK(bytes_transferred == 42);
1462   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1463   BOOST_ASIO_CHECK(!error);
1464
1465   s.reset(read_data, sizeof(read_data));
1466   s.next_read_length(10);
1467   memset(read_buf, 0, sizeof(read_buf));
1468   error = boost::system::error_code();
1469   bytes_transferred = boost::asio::read(s, buffers,
1470       boost::asio::transfer_at_least(42), error);
1471   BOOST_ASIO_CHECK(bytes_transferred == 50);
1472   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1473   BOOST_ASIO_CHECK(!error);
1474
1475   s.reset(read_data, sizeof(read_data));
1476   memset(read_buf, 0, sizeof(read_buf));
1477   error = boost::system::error_code();
1478   bytes_transferred = boost::asio::read(s, buffers,
1479       boost::asio::transfer_exactly(1), error);
1480   BOOST_ASIO_CHECK(bytes_transferred == 1);
1481   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1482   BOOST_ASIO_CHECK(!error);
1483
1484   s.reset(read_data, sizeof(read_data));
1485   s.next_read_length(1);
1486   memset(read_buf, 0, sizeof(read_buf));
1487   error = boost::system::error_code();
1488   bytes_transferred = boost::asio::read(s, buffers,
1489       boost::asio::transfer_exactly(1), error);
1490   BOOST_ASIO_CHECK(bytes_transferred == 1);
1491   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1492   BOOST_ASIO_CHECK(!error);
1493
1494   s.reset(read_data, sizeof(read_data));
1495   s.next_read_length(10);
1496   memset(read_buf, 0, sizeof(read_buf));
1497   error = boost::system::error_code();
1498   bytes_transferred = boost::asio::read(s, buffers,
1499       boost::asio::transfer_exactly(1), error);
1500   BOOST_ASIO_CHECK(bytes_transferred == 1);
1501   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1502   BOOST_ASIO_CHECK(!error);
1503
1504   s.reset(read_data, sizeof(read_data));
1505   memset(read_buf, 0, sizeof(read_buf));
1506   error = boost::system::error_code();
1507   bytes_transferred = boost::asio::read(s, buffers,
1508       boost::asio::transfer_exactly(10), error);
1509   BOOST_ASIO_CHECK(bytes_transferred == 10);
1510   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1511   BOOST_ASIO_CHECK(!error);
1512
1513   s.reset(read_data, sizeof(read_data));
1514   s.next_read_length(1);
1515   memset(read_buf, 0, sizeof(read_buf));
1516   error = boost::system::error_code();
1517   bytes_transferred = boost::asio::read(s, buffers,
1518       boost::asio::transfer_exactly(10), error);
1519   BOOST_ASIO_CHECK(bytes_transferred == 10);
1520   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1521   BOOST_ASIO_CHECK(!error);
1522
1523   s.reset(read_data, sizeof(read_data));
1524   s.next_read_length(10);
1525   memset(read_buf, 0, sizeof(read_buf));
1526   error = boost::system::error_code();
1527   bytes_transferred = boost::asio::read(s, buffers,
1528       boost::asio::transfer_exactly(10), error);
1529   BOOST_ASIO_CHECK(bytes_transferred == 10);
1530   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1531   BOOST_ASIO_CHECK(!error);
1532
1533   s.reset(read_data, sizeof(read_data));
1534   memset(read_buf, 0, sizeof(read_buf));
1535   error = boost::system::error_code();
1536   bytes_transferred = boost::asio::read(s, buffers,
1537       boost::asio::transfer_exactly(42), error);
1538   BOOST_ASIO_CHECK(bytes_transferred == 42);
1539   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1540   BOOST_ASIO_CHECK(!error);
1541
1542   s.reset(read_data, sizeof(read_data));
1543   s.next_read_length(1);
1544   memset(read_buf, 0, sizeof(read_buf));
1545   error = boost::system::error_code();
1546   bytes_transferred = boost::asio::read(s, buffers,
1547       boost::asio::transfer_exactly(42), error);
1548   BOOST_ASIO_CHECK(bytes_transferred == 42);
1549   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1550   BOOST_ASIO_CHECK(!error);
1551
1552   s.reset(read_data, sizeof(read_data));
1553   s.next_read_length(10);
1554   memset(read_buf, 0, sizeof(read_buf));
1555   error = boost::system::error_code();
1556   bytes_transferred = boost::asio::read(s, buffers,
1557       boost::asio::transfer_exactly(42), error);
1558   BOOST_ASIO_CHECK(bytes_transferred == 42);
1559   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1560   BOOST_ASIO_CHECK(!error);
1561
1562   s.reset(read_data, sizeof(read_data));
1563   memset(read_buf, 0, sizeof(read_buf));
1564   bytes_transferred = boost::asio::read(s, buffers,
1565       old_style_transfer_all, error);
1566   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1567   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1568   BOOST_ASIO_CHECK(!error);
1569
1570   s.reset(read_data, sizeof(read_data));
1571   s.next_read_length(1);
1572   memset(read_buf, 0, sizeof(read_buf));
1573   error = boost::system::error_code();
1574   bytes_transferred = boost::asio::read(s, buffers,
1575       old_style_transfer_all, error);
1576   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1577   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1578   BOOST_ASIO_CHECK(!error);
1579
1580   s.reset(read_data, sizeof(read_data));
1581   s.next_read_length(10);
1582   memset(read_buf, 0, sizeof(read_buf));
1583   error = boost::system::error_code();
1584   bytes_transferred = boost::asio::read(s, buffers,
1585       old_style_transfer_all, error);
1586   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1587   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1588   BOOST_ASIO_CHECK(!error);
1589
1590   s.reset(read_data, sizeof(read_data));
1591   memset(read_buf, 0, sizeof(read_buf));
1592   bytes_transferred = boost::asio::read(s, buffers, short_transfer(), error);
1593   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1594   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1595   BOOST_ASIO_CHECK(!error);
1596
1597   s.reset(read_data, sizeof(read_data));
1598   s.next_read_length(1);
1599   memset(read_buf, 0, sizeof(read_buf));
1600   error = boost::system::error_code();
1601   bytes_transferred = boost::asio::read(s, buffers, short_transfer(), error);
1602   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1603   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1604   BOOST_ASIO_CHECK(!error);
1605
1606   s.reset(read_data, sizeof(read_data));
1607   s.next_read_length(10);
1608   memset(read_buf, 0, sizeof(read_buf));
1609   error = boost::system::error_code();
1610   bytes_transferred = boost::asio::read(s, buffers, short_transfer(), error);
1611   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1612   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1613   BOOST_ASIO_CHECK(!error);
1614 }
1615
1616 void test_4_arg_vector_buffers_read()
1617 {
1618   boost::asio::io_context ioc;
1619   test_stream s(ioc);
1620   char read_buf[sizeof(read_data)];
1621   std::vector<boost::asio::mutable_buffer> buffers;
1622   buffers.push_back(boost::asio::buffer(read_buf, 32));
1623   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
1624   buffers.push_back(boost::asio::buffer(read_buf) + 39);
1625
1626   s.reset(read_data, sizeof(read_data));
1627   memset(read_buf, 0, sizeof(read_buf));
1628   boost::system::error_code error;
1629   size_t bytes_transferred = boost::asio::read(s, buffers,
1630       boost::asio::transfer_all(), error);
1631   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1632   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1633   BOOST_ASIO_CHECK(!error);
1634
1635   s.reset(read_data, sizeof(read_data));
1636   s.next_read_length(1);
1637   memset(read_buf, 0, sizeof(read_buf));
1638   error = boost::system::error_code();
1639   bytes_transferred = boost::asio::read(s, buffers,
1640       boost::asio::transfer_all(), error);
1641   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1642   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1643   BOOST_ASIO_CHECK(!error);
1644
1645   s.reset(read_data, sizeof(read_data));
1646   s.next_read_length(10);
1647   memset(read_buf, 0, sizeof(read_buf));
1648   error = boost::system::error_code();
1649   bytes_transferred = boost::asio::read(s, buffers,
1650       boost::asio::transfer_all(), error);
1651   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1652   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1653   BOOST_ASIO_CHECK(!error);
1654
1655   s.reset(read_data, sizeof(read_data));
1656   memset(read_buf, 0, sizeof(read_buf));
1657   error = boost::system::error_code();
1658   bytes_transferred = boost::asio::read(s, buffers,
1659       boost::asio::transfer_at_least(1), error);
1660   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1661   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1662   BOOST_ASIO_CHECK(!error);
1663
1664   s.reset(read_data, sizeof(read_data));
1665   s.next_read_length(1);
1666   memset(read_buf, 0, sizeof(read_buf));
1667   error = boost::system::error_code();
1668   bytes_transferred = boost::asio::read(s, buffers,
1669       boost::asio::transfer_at_least(1), error);
1670   BOOST_ASIO_CHECK(bytes_transferred == 1);
1671   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1672   BOOST_ASIO_CHECK(!error);
1673
1674   s.reset(read_data, sizeof(read_data));
1675   s.next_read_length(10);
1676   memset(read_buf, 0, sizeof(read_buf));
1677   error = boost::system::error_code();
1678   bytes_transferred = boost::asio::read(s, buffers,
1679       boost::asio::transfer_at_least(1), error);
1680   BOOST_ASIO_CHECK(bytes_transferred == 10);
1681   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1682   BOOST_ASIO_CHECK(!error);
1683
1684   s.reset(read_data, sizeof(read_data));
1685   memset(read_buf, 0, sizeof(read_buf));
1686   error = boost::system::error_code();
1687   bytes_transferred = boost::asio::read(s, buffers,
1688       boost::asio::transfer_at_least(10), error);
1689   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1690   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1691   BOOST_ASIO_CHECK(!error);
1692
1693   s.reset(read_data, sizeof(read_data));
1694   s.next_read_length(1);
1695   memset(read_buf, 0, sizeof(read_buf));
1696   error = boost::system::error_code();
1697   bytes_transferred = boost::asio::read(s, buffers,
1698       boost::asio::transfer_at_least(10), error);
1699   BOOST_ASIO_CHECK(bytes_transferred == 10);
1700   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1701   BOOST_ASIO_CHECK(!error);
1702
1703   s.reset(read_data, sizeof(read_data));
1704   s.next_read_length(10);
1705   memset(read_buf, 0, sizeof(read_buf));
1706   error = boost::system::error_code();
1707   bytes_transferred = boost::asio::read(s, buffers,
1708       boost::asio::transfer_at_least(10), error);
1709   BOOST_ASIO_CHECK(bytes_transferred == 10);
1710   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1711   BOOST_ASIO_CHECK(!error);
1712
1713   s.reset(read_data, sizeof(read_data));
1714   memset(read_buf, 0, sizeof(read_buf));
1715   error = boost::system::error_code();
1716   bytes_transferred = boost::asio::read(s, buffers,
1717       boost::asio::transfer_at_least(42), error);
1718   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1719   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1720   BOOST_ASIO_CHECK(!error);
1721
1722   s.reset(read_data, sizeof(read_data));
1723   s.next_read_length(1);
1724   memset(read_buf, 0, sizeof(read_buf));
1725   error = boost::system::error_code();
1726   bytes_transferred = boost::asio::read(s, buffers,
1727       boost::asio::transfer_at_least(42), error);
1728   BOOST_ASIO_CHECK(bytes_transferred == 42);
1729   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1730   BOOST_ASIO_CHECK(!error);
1731
1732   s.reset(read_data, sizeof(read_data));
1733   s.next_read_length(10);
1734   memset(read_buf, 0, sizeof(read_buf));
1735   error = boost::system::error_code();
1736   bytes_transferred = boost::asio::read(s, buffers,
1737       boost::asio::transfer_at_least(42), error);
1738   BOOST_ASIO_CHECK(bytes_transferred == 50);
1739   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1740   BOOST_ASIO_CHECK(!error);
1741
1742   s.reset(read_data, sizeof(read_data));
1743   memset(read_buf, 0, sizeof(read_buf));
1744   error = boost::system::error_code();
1745   bytes_transferred = boost::asio::read(s, buffers,
1746       boost::asio::transfer_exactly(1), error);
1747   BOOST_ASIO_CHECK(bytes_transferred == 1);
1748   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1749   BOOST_ASIO_CHECK(!error);
1750
1751   s.reset(read_data, sizeof(read_data));
1752   s.next_read_length(1);
1753   memset(read_buf, 0, sizeof(read_buf));
1754   error = boost::system::error_code();
1755   bytes_transferred = boost::asio::read(s, buffers,
1756       boost::asio::transfer_exactly(1), error);
1757   BOOST_ASIO_CHECK(bytes_transferred == 1);
1758   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1759   BOOST_ASIO_CHECK(!error);
1760
1761   s.reset(read_data, sizeof(read_data));
1762   s.next_read_length(10);
1763   memset(read_buf, 0, sizeof(read_buf));
1764   error = boost::system::error_code();
1765   bytes_transferred = boost::asio::read(s, buffers,
1766       boost::asio::transfer_exactly(1), error);
1767   BOOST_ASIO_CHECK(bytes_transferred == 1);
1768   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1769   BOOST_ASIO_CHECK(!error);
1770
1771   s.reset(read_data, sizeof(read_data));
1772   memset(read_buf, 0, sizeof(read_buf));
1773   error = boost::system::error_code();
1774   bytes_transferred = boost::asio::read(s, buffers,
1775       boost::asio::transfer_exactly(10), error);
1776   BOOST_ASIO_CHECK(bytes_transferred == 10);
1777   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1778   BOOST_ASIO_CHECK(!error);
1779
1780   s.reset(read_data, sizeof(read_data));
1781   s.next_read_length(1);
1782   memset(read_buf, 0, sizeof(read_buf));
1783   error = boost::system::error_code();
1784   bytes_transferred = boost::asio::read(s, buffers,
1785       boost::asio::transfer_exactly(10), error);
1786   BOOST_ASIO_CHECK(bytes_transferred == 10);
1787   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1788   BOOST_ASIO_CHECK(!error);
1789
1790   s.reset(read_data, sizeof(read_data));
1791   s.next_read_length(10);
1792   memset(read_buf, 0, sizeof(read_buf));
1793   error = boost::system::error_code();
1794   bytes_transferred = boost::asio::read(s, buffers,
1795       boost::asio::transfer_exactly(10), error);
1796   BOOST_ASIO_CHECK(bytes_transferred == 10);
1797   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1798   BOOST_ASIO_CHECK(!error);
1799
1800   s.reset(read_data, sizeof(read_data));
1801   memset(read_buf, 0, sizeof(read_buf));
1802   error = boost::system::error_code();
1803   bytes_transferred = boost::asio::read(s, buffers,
1804       boost::asio::transfer_exactly(42), error);
1805   BOOST_ASIO_CHECK(bytes_transferred == 42);
1806   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1807   BOOST_ASIO_CHECK(!error);
1808
1809   s.reset(read_data, sizeof(read_data));
1810   s.next_read_length(1);
1811   memset(read_buf, 0, sizeof(read_buf));
1812   error = boost::system::error_code();
1813   bytes_transferred = boost::asio::read(s, buffers,
1814       boost::asio::transfer_exactly(42), error);
1815   BOOST_ASIO_CHECK(bytes_transferred == 42);
1816   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1817   BOOST_ASIO_CHECK(!error);
1818
1819   s.reset(read_data, sizeof(read_data));
1820   s.next_read_length(10);
1821   memset(read_buf, 0, sizeof(read_buf));
1822   error = boost::system::error_code();
1823   bytes_transferred = boost::asio::read(s, buffers,
1824       boost::asio::transfer_exactly(42), error);
1825   BOOST_ASIO_CHECK(bytes_transferred == 42);
1826   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1827   BOOST_ASIO_CHECK(!error);
1828
1829   s.reset(read_data, sizeof(read_data));
1830   memset(read_buf, 0, sizeof(read_buf));
1831   bytes_transferred = boost::asio::read(s, buffers,
1832       old_style_transfer_all, error);
1833   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1834   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1835   BOOST_ASIO_CHECK(!error);
1836
1837   s.reset(read_data, sizeof(read_data));
1838   s.next_read_length(1);
1839   memset(read_buf, 0, sizeof(read_buf));
1840   error = boost::system::error_code();
1841   bytes_transferred = boost::asio::read(s, buffers,
1842       old_style_transfer_all, error);
1843   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1844   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1845   BOOST_ASIO_CHECK(!error);
1846
1847   s.reset(read_data, sizeof(read_data));
1848   s.next_read_length(10);
1849   memset(read_buf, 0, sizeof(read_buf));
1850   error = boost::system::error_code();
1851   bytes_transferred = boost::asio::read(s, buffers,
1852       old_style_transfer_all, error);
1853   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1854   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1855   BOOST_ASIO_CHECK(!error);
1856
1857   s.reset(read_data, sizeof(read_data));
1858   memset(read_buf, 0, sizeof(read_buf));
1859   bytes_transferred = boost::asio::read(s, buffers, short_transfer(), error);
1860   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1861   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1862   BOOST_ASIO_CHECK(!error);
1863
1864   s.reset(read_data, sizeof(read_data));
1865   s.next_read_length(1);
1866   memset(read_buf, 0, sizeof(read_buf));
1867   error = boost::system::error_code();
1868   bytes_transferred = boost::asio::read(s, buffers, short_transfer(), error);
1869   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1870   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1871   BOOST_ASIO_CHECK(!error);
1872
1873   s.reset(read_data, sizeof(read_data));
1874   s.next_read_length(10);
1875   memset(read_buf, 0, sizeof(read_buf));
1876   error = boost::system::error_code();
1877   bytes_transferred = boost::asio::read(s, buffers, short_transfer(), error);
1878   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1879   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1880   BOOST_ASIO_CHECK(!error);
1881 }
1882
1883 void test_4_arg_dynamic_string_read()
1884 {
1885   boost::asio::io_context ioc;
1886   test_stream s(ioc);
1887   std::string data;
1888   boost::asio::dynamic_string_buffer<char, std::string::traits_type,
1889     std::string::allocator_type> sb
1890       = boost::asio::dynamic_buffer(data, sizeof(read_data));
1891
1892   s.reset(read_data, sizeof(read_data));
1893   sb.consume(sb.size());
1894   boost::system::error_code error;
1895   size_t bytes_transferred = boost::asio::read(s, sb,
1896       boost::asio::transfer_all(), error);
1897   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1898   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1899   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1900   BOOST_ASIO_CHECK(!error);
1901
1902   s.reset(read_data, sizeof(read_data));
1903   s.next_read_length(1);
1904   sb.consume(sb.size());
1905   error = boost::system::error_code();
1906   bytes_transferred = boost::asio::read(s, sb,
1907       boost::asio::transfer_all(), error);
1908   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1909   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1910   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1911   BOOST_ASIO_CHECK(!error);
1912
1913   s.reset(read_data, sizeof(read_data));
1914   s.next_read_length(10);
1915   sb.consume(sb.size());
1916   error = boost::system::error_code();
1917   bytes_transferred = boost::asio::read(s, sb,
1918       boost::asio::transfer_all(), error);
1919   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1920   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1921   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1922   BOOST_ASIO_CHECK(!error);
1923
1924   s.reset(read_data, sizeof(read_data));
1925   sb.consume(sb.size());
1926   error = boost::system::error_code();
1927   bytes_transferred = boost::asio::read(s, sb,
1928       boost::asio::transfer_at_least(1), error);
1929   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1930   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1931   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1932   BOOST_ASIO_CHECK(!error);
1933
1934   s.reset(read_data, sizeof(read_data));
1935   s.next_read_length(1);
1936   sb.consume(sb.size());
1937   error = boost::system::error_code();
1938   bytes_transferred = boost::asio::read(s, sb,
1939       boost::asio::transfer_at_least(1), error);
1940   BOOST_ASIO_CHECK(bytes_transferred == 1);
1941   BOOST_ASIO_CHECK(sb.size() == 1);
1942   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
1943   BOOST_ASIO_CHECK(!error);
1944
1945   s.reset(read_data, sizeof(read_data));
1946   s.next_read_length(10);
1947   sb.consume(sb.size());
1948   error = boost::system::error_code();
1949   bytes_transferred = boost::asio::read(s, sb,
1950       boost::asio::transfer_at_least(1), error);
1951   BOOST_ASIO_CHECK(bytes_transferred == 10);
1952   BOOST_ASIO_CHECK(sb.size() == 10);
1953   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1954   BOOST_ASIO_CHECK(!error);
1955
1956   s.reset(read_data, sizeof(read_data));
1957   sb.consume(sb.size());
1958   error = boost::system::error_code();
1959   bytes_transferred = boost::asio::read(s, sb,
1960       boost::asio::transfer_at_least(10), error);
1961   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1962   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1963   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1964   BOOST_ASIO_CHECK(!error);
1965
1966   s.reset(read_data, sizeof(read_data));
1967   s.next_read_length(1);
1968   sb.consume(sb.size());
1969   error = boost::system::error_code();
1970   bytes_transferred = boost::asio::read(s, sb,
1971       boost::asio::transfer_at_least(10), error);
1972   BOOST_ASIO_CHECK(bytes_transferred == 10);
1973   BOOST_ASIO_CHECK(sb.size() == 10);
1974   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1975   BOOST_ASIO_CHECK(!error);
1976
1977   s.reset(read_data, sizeof(read_data));
1978   s.next_read_length(10);
1979   sb.consume(sb.size());
1980   error = boost::system::error_code();
1981   bytes_transferred = boost::asio::read(s, sb,
1982       boost::asio::transfer_at_least(10), error);
1983   BOOST_ASIO_CHECK(bytes_transferred == 10);
1984   BOOST_ASIO_CHECK(sb.size() == 10);
1985   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1986   BOOST_ASIO_CHECK(!error);
1987
1988   s.reset(read_data, sizeof(read_data));
1989   sb.consume(sb.size());
1990   error = boost::system::error_code();
1991   bytes_transferred = boost::asio::read(s, sb,
1992       boost::asio::transfer_at_least(42), error);
1993   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1994   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1995   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1996   BOOST_ASIO_CHECK(!error);
1997
1998   s.reset(read_data, sizeof(read_data));
1999   s.next_read_length(1);
2000   sb.consume(sb.size());
2001   error = boost::system::error_code();
2002   bytes_transferred = boost::asio::read(s, sb,
2003       boost::asio::transfer_at_least(42), error);
2004   BOOST_ASIO_CHECK(bytes_transferred == 42);
2005   BOOST_ASIO_CHECK(sb.size() == 42);
2006   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2007   BOOST_ASIO_CHECK(!error);
2008
2009   s.reset(read_data, sizeof(read_data));
2010   s.next_read_length(10);
2011   sb.consume(sb.size());
2012   error = boost::system::error_code();
2013   bytes_transferred = boost::asio::read(s, sb,
2014       boost::asio::transfer_at_least(42), error);
2015   BOOST_ASIO_CHECK(bytes_transferred == 50);
2016   BOOST_ASIO_CHECK(sb.size() == 50);
2017   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
2018   BOOST_ASIO_CHECK(!error);
2019
2020   s.reset(read_data, sizeof(read_data));
2021   sb.consume(sb.size());
2022   error = boost::system::error_code();
2023   bytes_transferred = boost::asio::read(s, sb,
2024       boost::asio::transfer_exactly(1), error);
2025   BOOST_ASIO_CHECK(bytes_transferred == 1);
2026   BOOST_ASIO_CHECK(sb.size() == 1);
2027   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
2028   BOOST_ASIO_CHECK(!error);
2029
2030   s.reset(read_data, sizeof(read_data));
2031   s.next_read_length(1);
2032   sb.consume(sb.size());
2033   error = boost::system::error_code();
2034   bytes_transferred = boost::asio::read(s, sb,
2035       boost::asio::transfer_exactly(1), error);
2036   BOOST_ASIO_CHECK(bytes_transferred == 1);
2037   BOOST_ASIO_CHECK(sb.size() == 1);
2038   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
2039   BOOST_ASIO_CHECK(!error);
2040
2041   s.reset(read_data, sizeof(read_data));
2042   s.next_read_length(10);
2043   sb.consume(sb.size());
2044   error = boost::system::error_code();
2045   bytes_transferred = boost::asio::read(s, sb,
2046       boost::asio::transfer_exactly(1), error);
2047   BOOST_ASIO_CHECK(bytes_transferred == 1);
2048   BOOST_ASIO_CHECK(sb.size() == 1);
2049   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
2050   BOOST_ASIO_CHECK(!error);
2051
2052   s.reset(read_data, sizeof(read_data));
2053   sb.consume(sb.size());
2054   error = boost::system::error_code();
2055   bytes_transferred = boost::asio::read(s, sb,
2056       boost::asio::transfer_exactly(10), error);
2057   BOOST_ASIO_CHECK(bytes_transferred == 10);
2058   BOOST_ASIO_CHECK(sb.size() == 10);
2059   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
2060   BOOST_ASIO_CHECK(!error);
2061
2062   s.reset(read_data, sizeof(read_data));
2063   s.next_read_length(1);
2064   sb.consume(sb.size());
2065   error = boost::system::error_code();
2066   bytes_transferred = boost::asio::read(s, sb,
2067       boost::asio::transfer_exactly(10), error);
2068   BOOST_ASIO_CHECK(bytes_transferred == 10);
2069   BOOST_ASIO_CHECK(sb.size() == 10);
2070   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
2071   BOOST_ASIO_CHECK(!error);
2072
2073   s.reset(read_data, sizeof(read_data));
2074   s.next_read_length(10);
2075   sb.consume(sb.size());
2076   error = boost::system::error_code();
2077   bytes_transferred = boost::asio::read(s, sb,
2078       boost::asio::transfer_exactly(10), error);
2079   BOOST_ASIO_CHECK(bytes_transferred == 10);
2080   BOOST_ASIO_CHECK(sb.size() == 10);
2081   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
2082   BOOST_ASIO_CHECK(!error);
2083
2084   s.reset(read_data, sizeof(read_data));
2085   sb.consume(sb.size());
2086   error = boost::system::error_code();
2087   bytes_transferred = boost::asio::read(s, sb,
2088       boost::asio::transfer_exactly(42), error);
2089   BOOST_ASIO_CHECK(bytes_transferred == 42);
2090   BOOST_ASIO_CHECK(sb.size() == 42);
2091   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2092   BOOST_ASIO_CHECK(!error);
2093
2094   s.reset(read_data, sizeof(read_data));
2095   s.next_read_length(1);
2096   sb.consume(sb.size());
2097   error = boost::system::error_code();
2098   bytes_transferred = boost::asio::read(s, sb,
2099       boost::asio::transfer_exactly(42), error);
2100   BOOST_ASIO_CHECK(bytes_transferred == 42);
2101   BOOST_ASIO_CHECK(sb.size() == 42);
2102   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2103   BOOST_ASIO_CHECK(!error);
2104
2105   s.reset(read_data, sizeof(read_data));
2106   s.next_read_length(10);
2107   sb.consume(sb.size());
2108   error = boost::system::error_code();
2109   bytes_transferred = boost::asio::read(s, sb,
2110       boost::asio::transfer_exactly(42), error);
2111   BOOST_ASIO_CHECK(bytes_transferred == 42);
2112   BOOST_ASIO_CHECK(sb.size() == 42);
2113   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2114   BOOST_ASIO_CHECK(!error);
2115
2116   s.reset(read_data, sizeof(read_data));
2117   sb.consume(sb.size());
2118   bytes_transferred = boost::asio::read(s, sb,
2119       old_style_transfer_all, error);
2120   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2121   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2122   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2123   BOOST_ASIO_CHECK(!error);
2124
2125   s.reset(read_data, sizeof(read_data));
2126   s.next_read_length(1);
2127   sb.consume(sb.size());
2128   error = boost::system::error_code();
2129   bytes_transferred = boost::asio::read(s, sb,
2130       old_style_transfer_all, error);
2131   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2132   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2133   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2134   BOOST_ASIO_CHECK(!error);
2135
2136   s.reset(read_data, sizeof(read_data));
2137   s.next_read_length(10);
2138   sb.consume(sb.size());
2139   error = boost::system::error_code();
2140   bytes_transferred = boost::asio::read(s, sb,
2141       old_style_transfer_all, error);
2142   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2143   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2144   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2145   BOOST_ASIO_CHECK(!error);
2146
2147   s.reset(read_data, sizeof(read_data));
2148   sb.consume(sb.size());
2149   bytes_transferred = boost::asio::read(s, sb, short_transfer(), error);
2150   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2151   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2152   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2153   BOOST_ASIO_CHECK(!error);
2154
2155   s.reset(read_data, sizeof(read_data));
2156   s.next_read_length(1);
2157   sb.consume(sb.size());
2158   error = boost::system::error_code();
2159   bytes_transferred = boost::asio::read(s, sb, short_transfer(), error);
2160   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2161   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2162   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2163   BOOST_ASIO_CHECK(!error);
2164
2165   s.reset(read_data, sizeof(read_data));
2166   s.next_read_length(10);
2167   sb.consume(sb.size());
2168   error = boost::system::error_code();
2169   bytes_transferred = boost::asio::read(s, sb, short_transfer(), error);
2170   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2171   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2172   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2173   BOOST_ASIO_CHECK(!error);
2174 }
2175
2176 void test_4_arg_streambuf_read()
2177 {
2178 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2179   boost::asio::io_context ioc;
2180   test_stream s(ioc);
2181   boost::asio::streambuf sb(sizeof(read_data));
2182
2183   s.reset(read_data, sizeof(read_data));
2184   sb.consume(sb.size());
2185   boost::system::error_code error;
2186   size_t bytes_transferred = boost::asio::read(s, sb,
2187       boost::asio::transfer_all(), error);
2188   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2189   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2190   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2191   BOOST_ASIO_CHECK(!error);
2192
2193   s.reset(read_data, sizeof(read_data));
2194   s.next_read_length(1);
2195   sb.consume(sb.size());
2196   error = boost::system::error_code();
2197   bytes_transferred = boost::asio::read(s, sb,
2198       boost::asio::transfer_all(), error);
2199   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2200   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2201   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2202   BOOST_ASIO_CHECK(!error);
2203
2204   s.reset(read_data, sizeof(read_data));
2205   s.next_read_length(10);
2206   sb.consume(sb.size());
2207   error = boost::system::error_code();
2208   bytes_transferred = boost::asio::read(s, sb,
2209       boost::asio::transfer_all(), error);
2210   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2211   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2212   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2213   BOOST_ASIO_CHECK(!error);
2214
2215   s.reset(read_data, sizeof(read_data));
2216   sb.consume(sb.size());
2217   error = boost::system::error_code();
2218   bytes_transferred = boost::asio::read(s, sb,
2219       boost::asio::transfer_at_least(1), error);
2220   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2221   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2222   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2223   BOOST_ASIO_CHECK(!error);
2224
2225   s.reset(read_data, sizeof(read_data));
2226   s.next_read_length(1);
2227   sb.consume(sb.size());
2228   error = boost::system::error_code();
2229   bytes_transferred = boost::asio::read(s, sb,
2230       boost::asio::transfer_at_least(1), error);
2231   BOOST_ASIO_CHECK(bytes_transferred == 1);
2232   BOOST_ASIO_CHECK(sb.size() == 1);
2233   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2234   BOOST_ASIO_CHECK(!error);
2235
2236   s.reset(read_data, sizeof(read_data));
2237   s.next_read_length(10);
2238   sb.consume(sb.size());
2239   error = boost::system::error_code();
2240   bytes_transferred = boost::asio::read(s, sb,
2241       boost::asio::transfer_at_least(1), error);
2242   BOOST_ASIO_CHECK(bytes_transferred == 10);
2243   BOOST_ASIO_CHECK(sb.size() == 10);
2244   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2245   BOOST_ASIO_CHECK(!error);
2246
2247   s.reset(read_data, sizeof(read_data));
2248   sb.consume(sb.size());
2249   error = boost::system::error_code();
2250   bytes_transferred = boost::asio::read(s, sb,
2251       boost::asio::transfer_at_least(10), error);
2252   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2253   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2254   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2255   BOOST_ASIO_CHECK(!error);
2256
2257   s.reset(read_data, sizeof(read_data));
2258   s.next_read_length(1);
2259   sb.consume(sb.size());
2260   error = boost::system::error_code();
2261   bytes_transferred = boost::asio::read(s, sb,
2262       boost::asio::transfer_at_least(10), error);
2263   BOOST_ASIO_CHECK(bytes_transferred == 10);
2264   BOOST_ASIO_CHECK(sb.size() == 10);
2265   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2266   BOOST_ASIO_CHECK(!error);
2267
2268   s.reset(read_data, sizeof(read_data));
2269   s.next_read_length(10);
2270   sb.consume(sb.size());
2271   error = boost::system::error_code();
2272   bytes_transferred = boost::asio::read(s, sb,
2273       boost::asio::transfer_at_least(10), error);
2274   BOOST_ASIO_CHECK(bytes_transferred == 10);
2275   BOOST_ASIO_CHECK(sb.size() == 10);
2276   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2277   BOOST_ASIO_CHECK(!error);
2278
2279   s.reset(read_data, sizeof(read_data));
2280   sb.consume(sb.size());
2281   error = boost::system::error_code();
2282   bytes_transferred = boost::asio::read(s, sb,
2283       boost::asio::transfer_at_least(42), error);
2284   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2285   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2286   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2287   BOOST_ASIO_CHECK(!error);
2288
2289   s.reset(read_data, sizeof(read_data));
2290   s.next_read_length(1);
2291   sb.consume(sb.size());
2292   error = boost::system::error_code();
2293   bytes_transferred = boost::asio::read(s, sb,
2294       boost::asio::transfer_at_least(42), error);
2295   BOOST_ASIO_CHECK(bytes_transferred == 42);
2296   BOOST_ASIO_CHECK(sb.size() == 42);
2297   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2298   BOOST_ASIO_CHECK(!error);
2299
2300   s.reset(read_data, sizeof(read_data));
2301   s.next_read_length(10);
2302   sb.consume(sb.size());
2303   error = boost::system::error_code();
2304   bytes_transferred = boost::asio::read(s, sb,
2305       boost::asio::transfer_at_least(42), error);
2306   BOOST_ASIO_CHECK(bytes_transferred == 50);
2307   BOOST_ASIO_CHECK(sb.size() == 50);
2308   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
2309   BOOST_ASIO_CHECK(!error);
2310
2311   s.reset(read_data, sizeof(read_data));
2312   sb.consume(sb.size());
2313   error = boost::system::error_code();
2314   bytes_transferred = boost::asio::read(s, sb,
2315       boost::asio::transfer_exactly(1), error);
2316   BOOST_ASIO_CHECK(bytes_transferred == 1);
2317   BOOST_ASIO_CHECK(sb.size() == 1);
2318   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2319   BOOST_ASIO_CHECK(!error);
2320
2321   s.reset(read_data, sizeof(read_data));
2322   s.next_read_length(1);
2323   sb.consume(sb.size());
2324   error = boost::system::error_code();
2325   bytes_transferred = boost::asio::read(s, sb,
2326       boost::asio::transfer_exactly(1), error);
2327   BOOST_ASIO_CHECK(bytes_transferred == 1);
2328   BOOST_ASIO_CHECK(sb.size() == 1);
2329   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2330   BOOST_ASIO_CHECK(!error);
2331
2332   s.reset(read_data, sizeof(read_data));
2333   s.next_read_length(10);
2334   sb.consume(sb.size());
2335   error = boost::system::error_code();
2336   bytes_transferred = boost::asio::read(s, sb,
2337       boost::asio::transfer_exactly(1), error);
2338   BOOST_ASIO_CHECK(bytes_transferred == 1);
2339   BOOST_ASIO_CHECK(sb.size() == 1);
2340   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2341   BOOST_ASIO_CHECK(!error);
2342
2343   s.reset(read_data, sizeof(read_data));
2344   sb.consume(sb.size());
2345   error = boost::system::error_code();
2346   bytes_transferred = boost::asio::read(s, sb,
2347       boost::asio::transfer_exactly(10), error);
2348   BOOST_ASIO_CHECK(bytes_transferred == 10);
2349   BOOST_ASIO_CHECK(sb.size() == 10);
2350   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2351   BOOST_ASIO_CHECK(!error);
2352
2353   s.reset(read_data, sizeof(read_data));
2354   s.next_read_length(1);
2355   sb.consume(sb.size());
2356   error = boost::system::error_code();
2357   bytes_transferred = boost::asio::read(s, sb,
2358       boost::asio::transfer_exactly(10), error);
2359   BOOST_ASIO_CHECK(bytes_transferred == 10);
2360   BOOST_ASIO_CHECK(sb.size() == 10);
2361   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2362   BOOST_ASIO_CHECK(!error);
2363
2364   s.reset(read_data, sizeof(read_data));
2365   s.next_read_length(10);
2366   sb.consume(sb.size());
2367   error = boost::system::error_code();
2368   bytes_transferred = boost::asio::read(s, sb,
2369       boost::asio::transfer_exactly(10), error);
2370   BOOST_ASIO_CHECK(bytes_transferred == 10);
2371   BOOST_ASIO_CHECK(sb.size() == 10);
2372   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2373   BOOST_ASIO_CHECK(!error);
2374
2375   s.reset(read_data, sizeof(read_data));
2376   sb.consume(sb.size());
2377   error = boost::system::error_code();
2378   bytes_transferred = boost::asio::read(s, sb,
2379       boost::asio::transfer_exactly(42), error);
2380   BOOST_ASIO_CHECK(bytes_transferred == 42);
2381   BOOST_ASIO_CHECK(sb.size() == 42);
2382   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2383   BOOST_ASIO_CHECK(!error);
2384
2385   s.reset(read_data, sizeof(read_data));
2386   s.next_read_length(1);
2387   sb.consume(sb.size());
2388   error = boost::system::error_code();
2389   bytes_transferred = boost::asio::read(s, sb,
2390       boost::asio::transfer_exactly(42), error);
2391   BOOST_ASIO_CHECK(bytes_transferred == 42);
2392   BOOST_ASIO_CHECK(sb.size() == 42);
2393   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2394   BOOST_ASIO_CHECK(!error);
2395
2396   s.reset(read_data, sizeof(read_data));
2397   s.next_read_length(10);
2398   sb.consume(sb.size());
2399   error = boost::system::error_code();
2400   bytes_transferred = boost::asio::read(s, sb,
2401       boost::asio::transfer_exactly(42), error);
2402   BOOST_ASIO_CHECK(bytes_transferred == 42);
2403   BOOST_ASIO_CHECK(sb.size() == 42);
2404   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2405   BOOST_ASIO_CHECK(!error);
2406
2407   s.reset(read_data, sizeof(read_data));
2408   sb.consume(sb.size());
2409   bytes_transferred = boost::asio::read(s, sb,
2410       old_style_transfer_all, error);
2411   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2412   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2413   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2414   BOOST_ASIO_CHECK(!error);
2415
2416   s.reset(read_data, sizeof(read_data));
2417   s.next_read_length(1);
2418   sb.consume(sb.size());
2419   error = boost::system::error_code();
2420   bytes_transferred = boost::asio::read(s, sb,
2421       old_style_transfer_all, error);
2422   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2423   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2424   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2425   BOOST_ASIO_CHECK(!error);
2426
2427   s.reset(read_data, sizeof(read_data));
2428   s.next_read_length(10);
2429   sb.consume(sb.size());
2430   error = boost::system::error_code();
2431   bytes_transferred = boost::asio::read(s, sb,
2432       old_style_transfer_all, error);
2433   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2434   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2435   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2436   BOOST_ASIO_CHECK(!error);
2437
2438   s.reset(read_data, sizeof(read_data));
2439   sb.consume(sb.size());
2440   bytes_transferred = boost::asio::read(s, sb, short_transfer(), error);
2441   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2442   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2443   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2444   BOOST_ASIO_CHECK(!error);
2445
2446   s.reset(read_data, sizeof(read_data));
2447   s.next_read_length(1);
2448   sb.consume(sb.size());
2449   error = boost::system::error_code();
2450   bytes_transferred = boost::asio::read(s, sb, short_transfer(), error);
2451   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2452   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2453   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2454   BOOST_ASIO_CHECK(!error);
2455
2456   s.reset(read_data, sizeof(read_data));
2457   s.next_read_length(10);
2458   sb.consume(sb.size());
2459   error = boost::system::error_code();
2460   bytes_transferred = boost::asio::read(s, sb, short_transfer(), error);
2461   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2462   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2463   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2464   BOOST_ASIO_CHECK(!error);
2465 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2466 }
2467
2468 void async_read_handler(const boost::system::error_code& e,
2469     size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
2470 {
2471   *called = true;
2472   BOOST_ASIO_CHECK(!e);
2473   BOOST_ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
2474 }
2475
2476 void test_3_arg_mutable_buffer_async_read()
2477 {
2478 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2479   namespace bindns = boost;
2480 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2481   namespace bindns = std;
2482 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2483   using bindns::placeholders::_1;
2484   using bindns::placeholders::_2;
2485
2486   boost::asio::io_context ioc;
2487   test_stream s(ioc);
2488   char read_buf[sizeof(read_data)];
2489   boost::asio::mutable_buffer buffers
2490     = boost::asio::buffer(read_buf, sizeof(read_buf));
2491
2492   s.reset(read_data, sizeof(read_data));
2493   memset(read_buf, 0, sizeof(read_buf));
2494   bool called = false;
2495   boost::asio::async_read(s, buffers,
2496       bindns::bind(async_read_handler,
2497         _1, _2, sizeof(read_data), &called));
2498   ioc.restart();
2499   ioc.run();
2500   BOOST_ASIO_CHECK(called);
2501   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2502
2503   s.reset(read_data, sizeof(read_data));
2504   s.next_read_length(1);
2505   memset(read_buf, 0, sizeof(read_buf));
2506   called = false;
2507   boost::asio::async_read(s, buffers,
2508       bindns::bind(async_read_handler,
2509         _1, _2, sizeof(read_data), &called));
2510   ioc.restart();
2511   ioc.run();
2512   BOOST_ASIO_CHECK(called);
2513   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2514
2515   s.reset(read_data, sizeof(read_data));
2516   s.next_read_length(10);
2517   memset(read_buf, 0, sizeof(read_buf));
2518   called = false;
2519   boost::asio::async_read(s, buffers,
2520       bindns::bind(async_read_handler,
2521         _1, _2, sizeof(read_data), &called));
2522   ioc.restart();
2523   ioc.run();
2524   BOOST_ASIO_CHECK(called);
2525   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2526
2527   s.reset(read_data, sizeof(read_data));
2528   memset(read_buf, 0, sizeof(read_buf));
2529   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
2530   BOOST_ASIO_CHECK(i == 42);
2531   ioc.restart();
2532   ioc.run();
2533   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2534 }
2535
2536 void test_3_arg_boost_array_buffers_async_read()
2537 {
2538 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2539   namespace bindns = boost;
2540 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2541   namespace bindns = std;
2542 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2543   using bindns::placeholders::_1;
2544   using bindns::placeholders::_2;
2545
2546 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2547   boost::asio::io_context ioc;
2548   test_stream s(ioc);
2549   char read_buf[sizeof(read_data)];
2550   boost::array<boost::asio::mutable_buffer, 2> buffers = { {
2551     boost::asio::buffer(read_buf, 32),
2552     boost::asio::buffer(read_buf) + 32 } };
2553
2554   s.reset(read_data, sizeof(read_data));
2555   memset(read_buf, 0, sizeof(read_buf));
2556   bool called = false;
2557   boost::asio::async_read(s, buffers,
2558       bindns::bind(async_read_handler,
2559         _1, _2, sizeof(read_data), &called));
2560   ioc.restart();
2561   ioc.run();
2562   BOOST_ASIO_CHECK(called);
2563   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2564
2565   s.reset(read_data, sizeof(read_data));
2566   s.next_read_length(1);
2567   memset(read_buf, 0, sizeof(read_buf));
2568   called = false;
2569   boost::asio::async_read(s, buffers,
2570       bindns::bind(async_read_handler,
2571         _1, _2, sizeof(read_data), &called));
2572   ioc.restart();
2573   ioc.run();
2574   BOOST_ASIO_CHECK(called);
2575   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2576
2577   s.reset(read_data, sizeof(read_data));
2578   s.next_read_length(10);
2579   memset(read_buf, 0, sizeof(read_buf));
2580   called = false;
2581   boost::asio::async_read(s, buffers,
2582       bindns::bind(async_read_handler,
2583         _1, _2, sizeof(read_data), &called));
2584   ioc.restart();
2585   ioc.run();
2586   BOOST_ASIO_CHECK(called);
2587   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2588
2589   s.reset(read_data, sizeof(read_data));
2590   memset(read_buf, 0, sizeof(read_buf));
2591   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
2592   BOOST_ASIO_CHECK(i == 42);
2593   ioc.restart();
2594   ioc.run();
2595   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2596 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2597 }
2598
2599 void test_3_arg_std_array_buffers_async_read()
2600 {
2601 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2602   namespace bindns = boost;
2603 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2604   namespace bindns = std;
2605 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2606   using bindns::placeholders::_1;
2607   using bindns::placeholders::_2;
2608
2609 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
2610   boost::asio::io_context ioc;
2611   test_stream s(ioc);
2612   char read_buf[sizeof(read_data)];
2613   std::array<boost::asio::mutable_buffer, 2> buffers = { {
2614     boost::asio::buffer(read_buf, 32),
2615     boost::asio::buffer(read_buf) + 32 } };
2616
2617   s.reset(read_data, sizeof(read_data));
2618   memset(read_buf, 0, sizeof(read_buf));
2619   bool called = false;
2620   boost::asio::async_read(s, buffers,
2621       bindns::bind(async_read_handler,
2622         _1, _2, sizeof(read_data), &called));
2623   ioc.restart();
2624   ioc.run();
2625   BOOST_ASIO_CHECK(called);
2626   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2627
2628   s.reset(read_data, sizeof(read_data));
2629   s.next_read_length(1);
2630   memset(read_buf, 0, sizeof(read_buf));
2631   called = false;
2632   boost::asio::async_read(s, buffers,
2633       bindns::bind(async_read_handler,
2634         _1, _2, sizeof(read_data), &called));
2635   ioc.restart();
2636   ioc.run();
2637   BOOST_ASIO_CHECK(called);
2638   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2639
2640   s.reset(read_data, sizeof(read_data));
2641   s.next_read_length(10);
2642   memset(read_buf, 0, sizeof(read_buf));
2643   called = false;
2644   boost::asio::async_read(s, buffers,
2645       bindns::bind(async_read_handler,
2646         _1, _2, sizeof(read_data), &called));
2647   ioc.restart();
2648   ioc.run();
2649   BOOST_ASIO_CHECK(called);
2650   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2651
2652   s.reset(read_data, sizeof(read_data));
2653   memset(read_buf, 0, sizeof(read_buf));
2654   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
2655   BOOST_ASIO_CHECK(i == 42);
2656   ioc.restart();
2657   ioc.run();
2658   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2659 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
2660 }
2661
2662 void test_3_arg_vector_buffers_async_read()
2663 {
2664 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2665   namespace bindns = boost;
2666 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2667   namespace bindns = std;
2668 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2669   using bindns::placeholders::_1;
2670   using bindns::placeholders::_2;
2671
2672   boost::asio::io_context ioc;
2673   test_stream s(ioc);
2674   char read_buf[sizeof(read_data)];
2675   std::vector<boost::asio::mutable_buffer> buffers;
2676   buffers.push_back(boost::asio::buffer(read_buf, 32));
2677   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
2678   buffers.push_back(boost::asio::buffer(read_buf) + 39);
2679
2680   s.reset(read_data, sizeof(read_data));
2681   memset(read_buf, 0, sizeof(read_buf));
2682   bool called = false;
2683   boost::asio::async_read(s, buffers,
2684       bindns::bind(async_read_handler,
2685         _1, _2, sizeof(read_data), &called));
2686   ioc.restart();
2687   ioc.run();
2688   BOOST_ASIO_CHECK(called);
2689   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2690
2691   s.reset(read_data, sizeof(read_data));
2692   s.next_read_length(1);
2693   memset(read_buf, 0, sizeof(read_buf));
2694   called = false;
2695   boost::asio::async_read(s, buffers,
2696       bindns::bind(async_read_handler,
2697         _1, _2, sizeof(read_data), &called));
2698   ioc.restart();
2699   ioc.run();
2700   BOOST_ASIO_CHECK(called);
2701   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2702
2703   s.reset(read_data, sizeof(read_data));
2704   s.next_read_length(10);
2705   memset(read_buf, 0, sizeof(read_buf));
2706   called = false;
2707   boost::asio::async_read(s, buffers,
2708       bindns::bind(async_read_handler,
2709         _1, _2, sizeof(read_data), &called));
2710   ioc.restart();
2711   ioc.run();
2712   BOOST_ASIO_CHECK(called);
2713   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2714
2715   s.reset(read_data, sizeof(read_data));
2716   memset(read_buf, 0, sizeof(read_buf));
2717   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
2718   BOOST_ASIO_CHECK(i == 42);
2719   ioc.restart();
2720   ioc.run();
2721   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2722 }
2723
2724 void test_3_arg_dynamic_string_async_read()
2725 {
2726 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2727   namespace bindns = boost;
2728 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2729   namespace bindns = std;
2730 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2731   using bindns::placeholders::_1;
2732   using bindns::placeholders::_2;
2733
2734   boost::asio::io_context ioc;
2735   test_stream s(ioc);
2736   std::string data;
2737   boost::asio::dynamic_string_buffer<char, std::string::traits_type,
2738     std::string::allocator_type> sb
2739       = boost::asio::dynamic_buffer(data, sizeof(read_data));
2740
2741   s.reset(read_data, sizeof(read_data));
2742   sb.consume(sb.size());
2743   bool called = false;
2744   boost::asio::async_read(s, sb,
2745       bindns::bind(async_read_handler,
2746         _1, _2, sizeof(read_data), &called));
2747   ioc.restart();
2748   ioc.run();
2749   BOOST_ASIO_CHECK(called);
2750   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2751   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2752
2753   s.reset(read_data, sizeof(read_data));
2754   s.next_read_length(1);
2755   sb.consume(sb.size());
2756   called = false;
2757   boost::asio::async_read(s, sb,
2758       bindns::bind(async_read_handler,
2759         _1, _2, sizeof(read_data), &called));
2760   ioc.restart();
2761   ioc.run();
2762   BOOST_ASIO_CHECK(called);
2763   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2764   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2765
2766   s.reset(read_data, sizeof(read_data));
2767   s.next_read_length(10);
2768   sb.consume(sb.size());
2769   called = false;
2770   boost::asio::async_read(s, sb,
2771       bindns::bind(async_read_handler,
2772         _1, _2, sizeof(read_data), &called));
2773   ioc.restart();
2774   ioc.run();
2775   BOOST_ASIO_CHECK(called);
2776   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2777   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2778
2779   s.reset(read_data, sizeof(read_data));
2780   sb.consume(sb.size());
2781   int i = boost::asio::async_read(s, sb, archetypes::lazy_handler());
2782   BOOST_ASIO_CHECK(i == 42);
2783   ioc.restart();
2784   ioc.run();
2785   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2786   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2787 }
2788
2789 void test_3_arg_streambuf_async_read()
2790 {
2791 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2792 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2793   namespace bindns = boost;
2794 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2795   namespace bindns = std;
2796 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2797   using bindns::placeholders::_1;
2798   using bindns::placeholders::_2;
2799
2800   boost::asio::io_context ioc;
2801   test_stream s(ioc);
2802   boost::asio::streambuf sb(sizeof(read_data));
2803
2804   s.reset(read_data, sizeof(read_data));
2805   sb.consume(sb.size());
2806   bool called = false;
2807   boost::asio::async_read(s, sb,
2808       bindns::bind(async_read_handler,
2809         _1, _2, sizeof(read_data), &called));
2810   ioc.restart();
2811   ioc.run();
2812   BOOST_ASIO_CHECK(called);
2813   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2814   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2815
2816   s.reset(read_data, sizeof(read_data));
2817   s.next_read_length(1);
2818   sb.consume(sb.size());
2819   called = false;
2820   boost::asio::async_read(s, sb,
2821       bindns::bind(async_read_handler,
2822         _1, _2, sizeof(read_data), &called));
2823   ioc.restart();
2824   ioc.run();
2825   BOOST_ASIO_CHECK(called);
2826   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2827   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2828
2829   s.reset(read_data, sizeof(read_data));
2830   s.next_read_length(10);
2831   sb.consume(sb.size());
2832   called = false;
2833   boost::asio::async_read(s, sb,
2834       bindns::bind(async_read_handler,
2835         _1, _2, sizeof(read_data), &called));
2836   ioc.restart();
2837   ioc.run();
2838   BOOST_ASIO_CHECK(called);
2839   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2840   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2841
2842   s.reset(read_data, sizeof(read_data));
2843   sb.consume(sb.size());
2844   int i = boost::asio::async_read(s, sb, archetypes::lazy_handler());
2845   BOOST_ASIO_CHECK(i == 42);
2846   ioc.restart();
2847   ioc.run();
2848   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2849   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2850 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2851 }
2852
2853 void test_4_arg_mutable_buffer_async_read()
2854 {
2855 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2856   namespace bindns = boost;
2857 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2858   namespace bindns = std;
2859 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2860   using bindns::placeholders::_1;
2861   using bindns::placeholders::_2;
2862
2863   boost::asio::io_context ioc;
2864   test_stream s(ioc);
2865   char read_buf[sizeof(read_data)];
2866   boost::asio::mutable_buffer buffers
2867     = boost::asio::buffer(read_buf, sizeof(read_buf));
2868
2869   s.reset(read_data, sizeof(read_data));
2870   memset(read_buf, 0, sizeof(read_buf));
2871   bool called = false;
2872   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2873       bindns::bind(async_read_handler,
2874         _1, _2, sizeof(read_data), &called));
2875   ioc.restart();
2876   ioc.run();
2877   BOOST_ASIO_CHECK(called);
2878   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2879
2880   s.reset(read_data, sizeof(read_data));
2881   s.next_read_length(1);
2882   memset(read_buf, 0, sizeof(read_buf));
2883   called = false;
2884   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2885       bindns::bind(async_read_handler,
2886         _1, _2, sizeof(read_data), &called));
2887   ioc.restart();
2888   ioc.run();
2889   BOOST_ASIO_CHECK(called);
2890   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2891
2892   s.reset(read_data, sizeof(read_data));
2893   s.next_read_length(10);
2894   memset(read_buf, 0, sizeof(read_buf));
2895   called = false;
2896   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2897       bindns::bind(async_read_handler,
2898         _1, _2, sizeof(read_data), &called));
2899   ioc.restart();
2900   ioc.run();
2901   BOOST_ASIO_CHECK(called);
2902   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2903
2904   s.reset(read_data, sizeof(read_data));
2905   memset(read_buf, 0, sizeof(read_buf));
2906   called = false;
2907   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2908       bindns::bind(async_read_handler,
2909         _1, _2, sizeof(read_data), &called));
2910   ioc.restart();
2911   ioc.run();
2912   BOOST_ASIO_CHECK(called);
2913   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2914
2915   s.reset(read_data, sizeof(read_data));
2916   s.next_read_length(1);
2917   memset(read_buf, 0, sizeof(read_buf));
2918   called = false;
2919   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2920       bindns::bind(async_read_handler,
2921         _1, _2, 1, &called));
2922   ioc.restart();
2923   ioc.run();
2924   BOOST_ASIO_CHECK(called);
2925   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2926
2927   s.reset(read_data, sizeof(read_data));
2928   s.next_read_length(10);
2929   memset(read_buf, 0, sizeof(read_buf));
2930   called = false;
2931   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2932       bindns::bind(async_read_handler,
2933         _1, _2, 10, &called));
2934   ioc.restart();
2935   ioc.run();
2936   BOOST_ASIO_CHECK(called);
2937   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2938
2939   s.reset(read_data, sizeof(read_data));
2940   memset(read_buf, 0, sizeof(read_buf));
2941   called = false;
2942   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2943       bindns::bind(async_read_handler,
2944         _1, _2, sizeof(read_data), &called));
2945   ioc.restart();
2946   ioc.run();
2947   BOOST_ASIO_CHECK(called);
2948   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2949
2950   s.reset(read_data, sizeof(read_data));
2951   s.next_read_length(1);
2952   memset(read_buf, 0, sizeof(read_buf));
2953   called = false;
2954   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2955       bindns::bind(async_read_handler,
2956         _1, _2, 10, &called));
2957   ioc.restart();
2958   ioc.run();
2959   BOOST_ASIO_CHECK(called);
2960   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2961
2962   s.reset(read_data, sizeof(read_data));
2963   s.next_read_length(10);
2964   memset(read_buf, 0, sizeof(read_buf));
2965   called = false;
2966   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2967       bindns::bind(async_read_handler,
2968         _1, _2, 10, &called));
2969   ioc.restart();
2970   ioc.run();
2971   BOOST_ASIO_CHECK(called);
2972   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2973
2974   s.reset(read_data, sizeof(read_data));
2975   memset(read_buf, 0, sizeof(read_buf));
2976   called = false;
2977   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2978       bindns::bind(async_read_handler,
2979         _1, _2, sizeof(read_data), &called));
2980   ioc.restart();
2981   ioc.run();
2982   BOOST_ASIO_CHECK(called);
2983   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2984
2985   s.reset(read_data, sizeof(read_data));
2986   s.next_read_length(1);
2987   memset(read_buf, 0, sizeof(read_buf));
2988   called = false;
2989   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2990       bindns::bind(async_read_handler,
2991         _1, _2, 42, &called));
2992   ioc.restart();
2993   ioc.run();
2994   BOOST_ASIO_CHECK(called);
2995   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2996
2997   s.reset(read_data, sizeof(read_data));
2998   s.next_read_length(10);
2999   memset(read_buf, 0, sizeof(read_buf));
3000   called = false;
3001   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3002       bindns::bind(async_read_handler,
3003         _1, _2, 50, &called));
3004   ioc.restart();
3005   ioc.run();
3006   BOOST_ASIO_CHECK(called);
3007   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3008
3009   s.reset(read_data, sizeof(read_data));
3010   memset(read_buf, 0, sizeof(read_buf));
3011   called = false;
3012   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3013       bindns::bind(async_read_handler,
3014         _1, _2, 1, &called));
3015   ioc.restart();
3016   ioc.run();
3017   BOOST_ASIO_CHECK(called);
3018   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3019
3020   s.reset(read_data, sizeof(read_data));
3021   s.next_read_length(1);
3022   memset(read_buf, 0, sizeof(read_buf));
3023   called = false;
3024   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3025       bindns::bind(async_read_handler,
3026         _1, _2, 1, &called));
3027   ioc.restart();
3028   ioc.run();
3029   BOOST_ASIO_CHECK(called);
3030   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3031
3032   s.reset(read_data, sizeof(read_data));
3033   s.next_read_length(10);
3034   memset(read_buf, 0, sizeof(read_buf));
3035   called = false;
3036   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3037       bindns::bind(async_read_handler,
3038         _1, _2, 1, &called));
3039   ioc.restart();
3040   ioc.run();
3041   BOOST_ASIO_CHECK(called);
3042   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3043
3044   s.reset(read_data, sizeof(read_data));
3045   memset(read_buf, 0, sizeof(read_buf));
3046   called = false;
3047   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3048       bindns::bind(async_read_handler,
3049         _1, _2, 10, &called));
3050   ioc.restart();
3051   ioc.run();
3052   BOOST_ASIO_CHECK(called);
3053   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3054
3055   s.reset(read_data, sizeof(read_data));
3056   s.next_read_length(1);
3057   memset(read_buf, 0, sizeof(read_buf));
3058   called = false;
3059   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3060       bindns::bind(async_read_handler,
3061         _1, _2, 10, &called));
3062   ioc.restart();
3063   ioc.run();
3064   BOOST_ASIO_CHECK(called);
3065   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3066
3067   s.reset(read_data, sizeof(read_data));
3068   s.next_read_length(10);
3069   memset(read_buf, 0, sizeof(read_buf));
3070   called = false;
3071   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3072       bindns::bind(async_read_handler,
3073         _1, _2, 10, &called));
3074   ioc.restart();
3075   ioc.run();
3076   BOOST_ASIO_CHECK(called);
3077   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3078
3079   s.reset(read_data, sizeof(read_data));
3080   memset(read_buf, 0, sizeof(read_buf));
3081   called = false;
3082   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3083       bindns::bind(async_read_handler,
3084         _1, _2, 42, &called));
3085   ioc.restart();
3086   ioc.run();
3087   BOOST_ASIO_CHECK(called);
3088   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3089
3090   s.reset(read_data, sizeof(read_data));
3091   s.next_read_length(1);
3092   memset(read_buf, 0, sizeof(read_buf));
3093   called = false;
3094   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3095       bindns::bind(async_read_handler,
3096         _1, _2, 42, &called));
3097   ioc.restart();
3098   ioc.run();
3099   BOOST_ASIO_CHECK(called);
3100   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3101
3102   s.reset(read_data, sizeof(read_data));
3103   s.next_read_length(10);
3104   memset(read_buf, 0, sizeof(read_buf));
3105   called = false;
3106   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3107       bindns::bind(async_read_handler,
3108         _1, _2, 42, &called));
3109   ioc.restart();
3110   ioc.run();
3111   BOOST_ASIO_CHECK(called);
3112   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3113
3114   s.reset(read_data, sizeof(read_data));
3115   memset(read_buf, 0, sizeof(read_buf));
3116   called = false;
3117   boost::asio::async_read(s, buffers, old_style_transfer_all,
3118       bindns::bind(async_read_handler,
3119         _1, _2, sizeof(read_data), &called));
3120   ioc.restart();
3121   ioc.run();
3122   BOOST_ASIO_CHECK(called);
3123   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3124
3125   s.reset(read_data, sizeof(read_data));
3126   s.next_read_length(1);
3127   memset(read_buf, 0, sizeof(read_buf));
3128   called = false;
3129   boost::asio::async_read(s, buffers, old_style_transfer_all,
3130       bindns::bind(async_read_handler,
3131         _1, _2, sizeof(read_data), &called));
3132   ioc.restart();
3133   ioc.run();
3134   BOOST_ASIO_CHECK(called);
3135   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3136
3137   s.reset(read_data, sizeof(read_data));
3138   s.next_read_length(10);
3139   memset(read_buf, 0, sizeof(read_buf));
3140   called = false;
3141   boost::asio::async_read(s, buffers, old_style_transfer_all,
3142       bindns::bind(async_read_handler,
3143         _1, _2, sizeof(read_data), &called));
3144   ioc.restart();
3145   ioc.run();
3146   BOOST_ASIO_CHECK(called);
3147   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3148
3149   s.reset(read_data, sizeof(read_data));
3150   memset(read_buf, 0, sizeof(read_buf));
3151   called = false;
3152   boost::asio::async_read(s, buffers, short_transfer(),
3153       bindns::bind(async_read_handler,
3154         _1, _2, sizeof(read_data), &called));
3155   ioc.restart();
3156   ioc.run();
3157   BOOST_ASIO_CHECK(called);
3158   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3159
3160   s.reset(read_data, sizeof(read_data));
3161   s.next_read_length(1);
3162   memset(read_buf, 0, sizeof(read_buf));
3163   called = false;
3164   boost::asio::async_read(s, buffers, short_transfer(),
3165       bindns::bind(async_read_handler,
3166         _1, _2, sizeof(read_data), &called));
3167   ioc.restart();
3168   ioc.run();
3169   BOOST_ASIO_CHECK(called);
3170   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3171
3172   s.reset(read_data, sizeof(read_data));
3173   s.next_read_length(10);
3174   memset(read_buf, 0, sizeof(read_buf));
3175   called = false;
3176   boost::asio::async_read(s, buffers, short_transfer(),
3177       bindns::bind(async_read_handler,
3178         _1, _2, sizeof(read_data), &called));
3179   ioc.restart();
3180   ioc.run();
3181   BOOST_ASIO_CHECK(called);
3182   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3183
3184   s.reset(read_data, sizeof(read_data));
3185   memset(read_buf, 0, sizeof(read_buf));
3186   int i = boost::asio::async_read(s, buffers,
3187       short_transfer(), archetypes::lazy_handler());
3188   BOOST_ASIO_CHECK(i == 42);
3189   ioc.restart();
3190   ioc.run();
3191   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3192 }
3193
3194 void test_4_arg_boost_array_buffers_async_read()
3195 {
3196 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3197   namespace bindns = boost;
3198 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3199   namespace bindns = std;
3200 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3201   using bindns::placeholders::_1;
3202   using bindns::placeholders::_2;
3203
3204 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
3205   boost::asio::io_context ioc;
3206   test_stream s(ioc);
3207   char read_buf[sizeof(read_data)];
3208   boost::array<boost::asio::mutable_buffer, 2> buffers = { {
3209     boost::asio::buffer(read_buf, 32),
3210     boost::asio::buffer(read_buf) + 32 } };
3211
3212   s.reset(read_data, sizeof(read_data));
3213   memset(read_buf, 0, sizeof(read_buf));
3214   bool called = false;
3215   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3216       bindns::bind(async_read_handler,
3217         _1, _2, sizeof(read_data), &called));
3218   ioc.restart();
3219   ioc.run();
3220   BOOST_ASIO_CHECK(called);
3221   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3222
3223   s.reset(read_data, sizeof(read_data));
3224   s.next_read_length(1);
3225   memset(read_buf, 0, sizeof(read_buf));
3226   called = false;
3227   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3228       bindns::bind(async_read_handler,
3229         _1, _2, sizeof(read_data), &called));
3230   ioc.restart();
3231   ioc.run();
3232   BOOST_ASIO_CHECK(called);
3233   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3234
3235   s.reset(read_data, sizeof(read_data));
3236   s.next_read_length(10);
3237   memset(read_buf, 0, sizeof(read_buf));
3238   called = false;
3239   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3240       bindns::bind(async_read_handler,
3241         _1, _2, sizeof(read_data), &called));
3242   ioc.restart();
3243   ioc.run();
3244   BOOST_ASIO_CHECK(called);
3245   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3246
3247   s.reset(read_data, sizeof(read_data));
3248   memset(read_buf, 0, sizeof(read_buf));
3249   called = false;
3250   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3251       bindns::bind(async_read_handler,
3252         _1, _2, sizeof(read_data), &called));
3253   ioc.restart();
3254   ioc.run();
3255   BOOST_ASIO_CHECK(called);
3256   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3257
3258   s.reset(read_data, sizeof(read_data));
3259   s.next_read_length(1);
3260   memset(read_buf, 0, sizeof(read_buf));
3261   called = false;
3262   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3263       bindns::bind(async_read_handler,
3264         _1, _2, 1, &called));
3265   ioc.restart();
3266   ioc.run();
3267   BOOST_ASIO_CHECK(called);
3268   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3269
3270   s.reset(read_data, sizeof(read_data));
3271   s.next_read_length(10);
3272   memset(read_buf, 0, sizeof(read_buf));
3273   called = false;
3274   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3275       bindns::bind(async_read_handler,
3276         _1, _2, 10, &called));
3277   ioc.restart();
3278   ioc.run();
3279   BOOST_ASIO_CHECK(called);
3280   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3281
3282   s.reset(read_data, sizeof(read_data));
3283   memset(read_buf, 0, sizeof(read_buf));
3284   called = false;
3285   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3286       bindns::bind(async_read_handler,
3287         _1, _2, sizeof(read_data), &called));
3288   ioc.restart();
3289   ioc.run();
3290   BOOST_ASIO_CHECK(called);
3291   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3292
3293   s.reset(read_data, sizeof(read_data));
3294   s.next_read_length(1);
3295   memset(read_buf, 0, sizeof(read_buf));
3296   called = false;
3297   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3298       bindns::bind(async_read_handler,
3299         _1, _2, 10, &called));
3300   ioc.restart();
3301   ioc.run();
3302   BOOST_ASIO_CHECK(called);
3303   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3304
3305   s.reset(read_data, sizeof(read_data));
3306   s.next_read_length(10);
3307   memset(read_buf, 0, sizeof(read_buf));
3308   called = false;
3309   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3310       bindns::bind(async_read_handler,
3311         _1, _2, 10, &called));
3312   ioc.restart();
3313   ioc.run();
3314   BOOST_ASIO_CHECK(called);
3315   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3316
3317   s.reset(read_data, sizeof(read_data));
3318   memset(read_buf, 0, sizeof(read_buf));
3319   called = false;
3320   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3321       bindns::bind(async_read_handler,
3322         _1, _2, sizeof(read_data), &called));
3323   ioc.restart();
3324   ioc.run();
3325   BOOST_ASIO_CHECK(called);
3326   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3327
3328   s.reset(read_data, sizeof(read_data));
3329   s.next_read_length(1);
3330   memset(read_buf, 0, sizeof(read_buf));
3331   called = false;
3332   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3333       bindns::bind(async_read_handler,
3334         _1, _2, 42, &called));
3335   ioc.restart();
3336   ioc.run();
3337   BOOST_ASIO_CHECK(called);
3338   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3339
3340   s.reset(read_data, sizeof(read_data));
3341   s.next_read_length(10);
3342   memset(read_buf, 0, sizeof(read_buf));
3343   called = false;
3344   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3345       bindns::bind(async_read_handler,
3346         _1, _2, 50, &called));
3347   ioc.restart();
3348   ioc.run();
3349   BOOST_ASIO_CHECK(called);
3350   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3351
3352   s.reset(read_data, sizeof(read_data));
3353   memset(read_buf, 0, sizeof(read_buf));
3354   called = false;
3355   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3356       bindns::bind(async_read_handler,
3357         _1, _2, 1, &called));
3358   ioc.restart();
3359   ioc.run();
3360   BOOST_ASIO_CHECK(called);
3361   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3362
3363   s.reset(read_data, sizeof(read_data));
3364   s.next_read_length(1);
3365   memset(read_buf, 0, sizeof(read_buf));
3366   called = false;
3367   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3368       bindns::bind(async_read_handler,
3369         _1, _2, 1, &called));
3370   ioc.restart();
3371   ioc.run();
3372   BOOST_ASIO_CHECK(called);
3373   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3374
3375   s.reset(read_data, sizeof(read_data));
3376   s.next_read_length(10);
3377   memset(read_buf, 0, sizeof(read_buf));
3378   called = false;
3379   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3380       bindns::bind(async_read_handler,
3381         _1, _2, 1, &called));
3382   ioc.restart();
3383   ioc.run();
3384   BOOST_ASIO_CHECK(called);
3385   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3386
3387   s.reset(read_data, sizeof(read_data));
3388   memset(read_buf, 0, sizeof(read_buf));
3389   called = false;
3390   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3391       bindns::bind(async_read_handler,
3392         _1, _2, 10, &called));
3393   ioc.restart();
3394   ioc.run();
3395   BOOST_ASIO_CHECK(called);
3396   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3397
3398   s.reset(read_data, sizeof(read_data));
3399   s.next_read_length(1);
3400   memset(read_buf, 0, sizeof(read_buf));
3401   called = false;
3402   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3403       bindns::bind(async_read_handler,
3404         _1, _2, 10, &called));
3405   ioc.restart();
3406   ioc.run();
3407   BOOST_ASIO_CHECK(called);
3408   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3409
3410   s.reset(read_data, sizeof(read_data));
3411   s.next_read_length(10);
3412   memset(read_buf, 0, sizeof(read_buf));
3413   called = false;
3414   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3415       bindns::bind(async_read_handler,
3416         _1, _2, 10, &called));
3417   ioc.restart();
3418   ioc.run();
3419   BOOST_ASIO_CHECK(called);
3420   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3421
3422   s.reset(read_data, sizeof(read_data));
3423   memset(read_buf, 0, sizeof(read_buf));
3424   called = false;
3425   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3426       bindns::bind(async_read_handler,
3427         _1, _2, 42, &called));
3428   ioc.restart();
3429   ioc.run();
3430   BOOST_ASIO_CHECK(called);
3431   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3432
3433   s.reset(read_data, sizeof(read_data));
3434   s.next_read_length(1);
3435   memset(read_buf, 0, sizeof(read_buf));
3436   called = false;
3437   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3438       bindns::bind(async_read_handler,
3439         _1, _2, 42, &called));
3440   ioc.restart();
3441   ioc.run();
3442   BOOST_ASIO_CHECK(called);
3443   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3444
3445   s.reset(read_data, sizeof(read_data));
3446   s.next_read_length(10);
3447   memset(read_buf, 0, sizeof(read_buf));
3448   called = false;
3449   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3450       bindns::bind(async_read_handler,
3451         _1, _2, 42, &called));
3452   ioc.restart();
3453   ioc.run();
3454   BOOST_ASIO_CHECK(called);
3455   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3456
3457   s.reset(read_data, sizeof(read_data));
3458   memset(read_buf, 0, sizeof(read_buf));
3459   called = false;
3460   boost::asio::async_read(s, buffers, old_style_transfer_all,
3461       bindns::bind(async_read_handler,
3462         _1, _2, sizeof(read_data), &called));
3463   ioc.restart();
3464   ioc.run();
3465   BOOST_ASIO_CHECK(called);
3466   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3467
3468   s.reset(read_data, sizeof(read_data));
3469   s.next_read_length(1);
3470   memset(read_buf, 0, sizeof(read_buf));
3471   called = false;
3472   boost::asio::async_read(s, buffers, old_style_transfer_all,
3473       bindns::bind(async_read_handler,
3474         _1, _2, sizeof(read_data), &called));
3475   ioc.restart();
3476   ioc.run();
3477   BOOST_ASIO_CHECK(called);
3478   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3479
3480   s.reset(read_data, sizeof(read_data));
3481   s.next_read_length(10);
3482   memset(read_buf, 0, sizeof(read_buf));
3483   called = false;
3484   boost::asio::async_read(s, buffers, old_style_transfer_all,
3485       bindns::bind(async_read_handler,
3486         _1, _2, sizeof(read_data), &called));
3487   ioc.restart();
3488   ioc.run();
3489   BOOST_ASIO_CHECK(called);
3490   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3491
3492   s.reset(read_data, sizeof(read_data));
3493   memset(read_buf, 0, sizeof(read_buf));
3494   called = false;
3495   boost::asio::async_read(s, buffers, short_transfer(),
3496       bindns::bind(async_read_handler,
3497         _1, _2, sizeof(read_data), &called));
3498   ioc.restart();
3499   ioc.run();
3500   BOOST_ASIO_CHECK(called);
3501   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3502
3503   s.reset(read_data, sizeof(read_data));
3504   s.next_read_length(1);
3505   memset(read_buf, 0, sizeof(read_buf));
3506   called = false;
3507   boost::asio::async_read(s, buffers, short_transfer(),
3508       bindns::bind(async_read_handler,
3509         _1, _2, sizeof(read_data), &called));
3510   ioc.restart();
3511   ioc.run();
3512   BOOST_ASIO_CHECK(called);
3513   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3514
3515   s.reset(read_data, sizeof(read_data));
3516   s.next_read_length(10);
3517   memset(read_buf, 0, sizeof(read_buf));
3518   called = false;
3519   boost::asio::async_read(s, buffers, short_transfer(),
3520       bindns::bind(async_read_handler,
3521         _1, _2, sizeof(read_data), &called));
3522   ioc.restart();
3523   ioc.run();
3524   BOOST_ASIO_CHECK(called);
3525   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3526
3527   s.reset(read_data, sizeof(read_data));
3528   memset(read_buf, 0, sizeof(read_buf));
3529   int i = boost::asio::async_read(s, buffers,
3530       short_transfer(), archetypes::lazy_handler());
3531   BOOST_ASIO_CHECK(i == 42);
3532   ioc.restart();
3533   ioc.run();
3534   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3535 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
3536 }
3537
3538 void test_4_arg_std_array_buffers_async_read()
3539 {
3540 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3541   namespace bindns = boost;
3542 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3543   namespace bindns = std;
3544 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3545   using bindns::placeholders::_1;
3546   using bindns::placeholders::_2;
3547
3548 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
3549   boost::asio::io_context ioc;
3550   test_stream s(ioc);
3551   char read_buf[sizeof(read_data)];
3552   std::array<boost::asio::mutable_buffer, 2> buffers = { {
3553     boost::asio::buffer(read_buf, 32),
3554     boost::asio::buffer(read_buf) + 32 } };
3555
3556   s.reset(read_data, sizeof(read_data));
3557   memset(read_buf, 0, sizeof(read_buf));
3558   bool called = false;
3559   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3560       bindns::bind(async_read_handler,
3561         _1, _2, sizeof(read_data), &called));
3562   ioc.restart();
3563   ioc.run();
3564   BOOST_ASIO_CHECK(called);
3565   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3566
3567   s.reset(read_data, sizeof(read_data));
3568   s.next_read_length(1);
3569   memset(read_buf, 0, sizeof(read_buf));
3570   called = false;
3571   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3572       bindns::bind(async_read_handler,
3573         _1, _2, sizeof(read_data), &called));
3574   ioc.restart();
3575   ioc.run();
3576   BOOST_ASIO_CHECK(called);
3577   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3578
3579   s.reset(read_data, sizeof(read_data));
3580   s.next_read_length(10);
3581   memset(read_buf, 0, sizeof(read_buf));
3582   called = false;
3583   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3584       bindns::bind(async_read_handler,
3585         _1, _2, sizeof(read_data), &called));
3586   ioc.restart();
3587   ioc.run();
3588   BOOST_ASIO_CHECK(called);
3589   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3590
3591   s.reset(read_data, sizeof(read_data));
3592   memset(read_buf, 0, sizeof(read_buf));
3593   called = false;
3594   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3595       bindns::bind(async_read_handler,
3596         _1, _2, sizeof(read_data), &called));
3597   ioc.restart();
3598   ioc.run();
3599   BOOST_ASIO_CHECK(called);
3600   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3601
3602   s.reset(read_data, sizeof(read_data));
3603   s.next_read_length(1);
3604   memset(read_buf, 0, sizeof(read_buf));
3605   called = false;
3606   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3607       bindns::bind(async_read_handler,
3608         _1, _2, 1, &called));
3609   ioc.restart();
3610   ioc.run();
3611   BOOST_ASIO_CHECK(called);
3612   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3613
3614   s.reset(read_data, sizeof(read_data));
3615   s.next_read_length(10);
3616   memset(read_buf, 0, sizeof(read_buf));
3617   called = false;
3618   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3619       bindns::bind(async_read_handler,
3620         _1, _2, 10, &called));
3621   ioc.restart();
3622   ioc.run();
3623   BOOST_ASIO_CHECK(called);
3624   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3625
3626   s.reset(read_data, sizeof(read_data));
3627   memset(read_buf, 0, sizeof(read_buf));
3628   called = false;
3629   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3630       bindns::bind(async_read_handler,
3631         _1, _2, sizeof(read_data), &called));
3632   ioc.restart();
3633   ioc.run();
3634   BOOST_ASIO_CHECK(called);
3635   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3636
3637   s.reset(read_data, sizeof(read_data));
3638   s.next_read_length(1);
3639   memset(read_buf, 0, sizeof(read_buf));
3640   called = false;
3641   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3642       bindns::bind(async_read_handler,
3643         _1, _2, 10, &called));
3644   ioc.restart();
3645   ioc.run();
3646   BOOST_ASIO_CHECK(called);
3647   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3648
3649   s.reset(read_data, sizeof(read_data));
3650   s.next_read_length(10);
3651   memset(read_buf, 0, sizeof(read_buf));
3652   called = false;
3653   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3654       bindns::bind(async_read_handler,
3655         _1, _2, 10, &called));
3656   ioc.restart();
3657   ioc.run();
3658   BOOST_ASIO_CHECK(called);
3659   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3660
3661   s.reset(read_data, sizeof(read_data));
3662   memset(read_buf, 0, sizeof(read_buf));
3663   called = false;
3664   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3665       bindns::bind(async_read_handler,
3666         _1, _2, sizeof(read_data), &called));
3667   ioc.restart();
3668   ioc.run();
3669   BOOST_ASIO_CHECK(called);
3670   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3671
3672   s.reset(read_data, sizeof(read_data));
3673   s.next_read_length(1);
3674   memset(read_buf, 0, sizeof(read_buf));
3675   called = false;
3676   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3677       bindns::bind(async_read_handler,
3678         _1, _2, 42, &called));
3679   ioc.restart();
3680   ioc.run();
3681   BOOST_ASIO_CHECK(called);
3682   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3683
3684   s.reset(read_data, sizeof(read_data));
3685   s.next_read_length(10);
3686   memset(read_buf, 0, sizeof(read_buf));
3687   called = false;
3688   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3689       bindns::bind(async_read_handler,
3690         _1, _2, 50, &called));
3691   ioc.restart();
3692   ioc.run();
3693   BOOST_ASIO_CHECK(called);
3694   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3695
3696   s.reset(read_data, sizeof(read_data));
3697   memset(read_buf, 0, sizeof(read_buf));
3698   called = false;
3699   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3700       bindns::bind(async_read_handler,
3701         _1, _2, 1, &called));
3702   ioc.restart();
3703   ioc.run();
3704   BOOST_ASIO_CHECK(called);
3705   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3706
3707   s.reset(read_data, sizeof(read_data));
3708   s.next_read_length(1);
3709   memset(read_buf, 0, sizeof(read_buf));
3710   called = false;
3711   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3712       bindns::bind(async_read_handler,
3713         _1, _2, 1, &called));
3714   ioc.restart();
3715   ioc.run();
3716   BOOST_ASIO_CHECK(called);
3717   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3718
3719   s.reset(read_data, sizeof(read_data));
3720   s.next_read_length(10);
3721   memset(read_buf, 0, sizeof(read_buf));
3722   called = false;
3723   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3724       bindns::bind(async_read_handler,
3725         _1, _2, 1, &called));
3726   ioc.restart();
3727   ioc.run();
3728   BOOST_ASIO_CHECK(called);
3729   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3730
3731   s.reset(read_data, sizeof(read_data));
3732   memset(read_buf, 0, sizeof(read_buf));
3733   called = false;
3734   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3735       bindns::bind(async_read_handler,
3736         _1, _2, 10, &called));
3737   ioc.restart();
3738   ioc.run();
3739   BOOST_ASIO_CHECK(called);
3740   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3741
3742   s.reset(read_data, sizeof(read_data));
3743   s.next_read_length(1);
3744   memset(read_buf, 0, sizeof(read_buf));
3745   called = false;
3746   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3747       bindns::bind(async_read_handler,
3748         _1, _2, 10, &called));
3749   ioc.restart();
3750   ioc.run();
3751   BOOST_ASIO_CHECK(called);
3752   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3753
3754   s.reset(read_data, sizeof(read_data));
3755   s.next_read_length(10);
3756   memset(read_buf, 0, sizeof(read_buf));
3757   called = false;
3758   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3759       bindns::bind(async_read_handler,
3760         _1, _2, 10, &called));
3761   ioc.restart();
3762   ioc.run();
3763   BOOST_ASIO_CHECK(called);
3764   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3765
3766   s.reset(read_data, sizeof(read_data));
3767   memset(read_buf, 0, sizeof(read_buf));
3768   called = false;
3769   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3770       bindns::bind(async_read_handler,
3771         _1, _2, 42, &called));
3772   ioc.restart();
3773   ioc.run();
3774   BOOST_ASIO_CHECK(called);
3775   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3776
3777   s.reset(read_data, sizeof(read_data));
3778   s.next_read_length(1);
3779   memset(read_buf, 0, sizeof(read_buf));
3780   called = false;
3781   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3782       bindns::bind(async_read_handler,
3783         _1, _2, 42, &called));
3784   ioc.restart();
3785   ioc.run();
3786   BOOST_ASIO_CHECK(called);
3787   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3788
3789   s.reset(read_data, sizeof(read_data));
3790   s.next_read_length(10);
3791   memset(read_buf, 0, sizeof(read_buf));
3792   called = false;
3793   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3794       bindns::bind(async_read_handler,
3795         _1, _2, 42, &called));
3796   ioc.restart();
3797   ioc.run();
3798   BOOST_ASIO_CHECK(called);
3799   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3800
3801   s.reset(read_data, sizeof(read_data));
3802   memset(read_buf, 0, sizeof(read_buf));
3803   called = false;
3804   boost::asio::async_read(s, buffers, old_style_transfer_all,
3805       bindns::bind(async_read_handler,
3806         _1, _2, sizeof(read_data), &called));
3807   ioc.restart();
3808   ioc.run();
3809   BOOST_ASIO_CHECK(called);
3810   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3811
3812   s.reset(read_data, sizeof(read_data));
3813   s.next_read_length(1);
3814   memset(read_buf, 0, sizeof(read_buf));
3815   called = false;
3816   boost::asio::async_read(s, buffers, old_style_transfer_all,
3817       bindns::bind(async_read_handler,
3818         _1, _2, sizeof(read_data), &called));
3819   ioc.restart();
3820   ioc.run();
3821   BOOST_ASIO_CHECK(called);
3822   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3823
3824   s.reset(read_data, sizeof(read_data));
3825   s.next_read_length(10);
3826   memset(read_buf, 0, sizeof(read_buf));
3827   called = false;
3828   boost::asio::async_read(s, buffers, old_style_transfer_all,
3829       bindns::bind(async_read_handler,
3830         _1, _2, sizeof(read_data), &called));
3831   ioc.restart();
3832   ioc.run();
3833   BOOST_ASIO_CHECK(called);
3834   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3835
3836   s.reset(read_data, sizeof(read_data));
3837   memset(read_buf, 0, sizeof(read_buf));
3838   called = false;
3839   boost::asio::async_read(s, buffers, short_transfer(),
3840       bindns::bind(async_read_handler,
3841         _1, _2, sizeof(read_data), &called));
3842   ioc.restart();
3843   ioc.run();
3844   BOOST_ASIO_CHECK(called);
3845   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3846
3847   s.reset(read_data, sizeof(read_data));
3848   s.next_read_length(1);
3849   memset(read_buf, 0, sizeof(read_buf));
3850   called = false;
3851   boost::asio::async_read(s, buffers, short_transfer(),
3852       bindns::bind(async_read_handler,
3853         _1, _2, sizeof(read_data), &called));
3854   ioc.restart();
3855   ioc.run();
3856   BOOST_ASIO_CHECK(called);
3857   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3858
3859   s.reset(read_data, sizeof(read_data));
3860   s.next_read_length(10);
3861   memset(read_buf, 0, sizeof(read_buf));
3862   called = false;
3863   boost::asio::async_read(s, buffers, short_transfer(),
3864       bindns::bind(async_read_handler,
3865         _1, _2, sizeof(read_data), &called));
3866   ioc.restart();
3867   ioc.run();
3868   BOOST_ASIO_CHECK(called);
3869   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3870
3871   s.reset(read_data, sizeof(read_data));
3872   memset(read_buf, 0, sizeof(read_buf));
3873   int i = boost::asio::async_read(s, buffers,
3874       short_transfer(), archetypes::lazy_handler());
3875   BOOST_ASIO_CHECK(i == 42);
3876   ioc.restart();
3877   ioc.run();
3878   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3879 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
3880 }
3881
3882 void test_4_arg_vector_buffers_async_read()
3883 {
3884 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3885   namespace bindns = boost;
3886 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3887   namespace bindns = std;
3888 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3889   using bindns::placeholders::_1;
3890   using bindns::placeholders::_2;
3891
3892   boost::asio::io_context ioc;
3893   test_stream s(ioc);
3894   char read_buf[sizeof(read_data)];
3895   std::vector<boost::asio::mutable_buffer> buffers;
3896   buffers.push_back(boost::asio::buffer(read_buf, 32));
3897   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
3898   buffers.push_back(boost::asio::buffer(read_buf) + 39);
3899
3900   s.reset(read_data, sizeof(read_data));
3901   memset(read_buf, 0, sizeof(read_buf));
3902   bool called = false;
3903   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3904       bindns::bind(async_read_handler,
3905         _1, _2, sizeof(read_data), &called));
3906   ioc.restart();
3907   ioc.run();
3908   BOOST_ASIO_CHECK(called);
3909   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3910
3911   s.reset(read_data, sizeof(read_data));
3912   s.next_read_length(1);
3913   memset(read_buf, 0, sizeof(read_buf));
3914   called = false;
3915   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3916       bindns::bind(async_read_handler,
3917         _1, _2, sizeof(read_data), &called));
3918   ioc.restart();
3919   ioc.run();
3920   BOOST_ASIO_CHECK(called);
3921   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3922
3923   s.reset(read_data, sizeof(read_data));
3924   s.next_read_length(10);
3925   memset(read_buf, 0, sizeof(read_buf));
3926   called = false;
3927   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3928       bindns::bind(async_read_handler,
3929         _1, _2, sizeof(read_data), &called));
3930   ioc.restart();
3931   ioc.run();
3932   BOOST_ASIO_CHECK(called);
3933   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3934
3935   s.reset(read_data, sizeof(read_data));
3936   memset(read_buf, 0, sizeof(read_buf));
3937   called = false;
3938   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3939       bindns::bind(async_read_handler,
3940         _1, _2, sizeof(read_data), &called));
3941   ioc.restart();
3942   ioc.run();
3943   BOOST_ASIO_CHECK(called);
3944   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3945
3946   s.reset(read_data, sizeof(read_data));
3947   s.next_read_length(1);
3948   memset(read_buf, 0, sizeof(read_buf));
3949   called = false;
3950   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3951       bindns::bind(async_read_handler,
3952         _1, _2, 1, &called));
3953   ioc.restart();
3954   ioc.run();
3955   BOOST_ASIO_CHECK(called);
3956   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3957
3958   s.reset(read_data, sizeof(read_data));
3959   s.next_read_length(10);
3960   memset(read_buf, 0, sizeof(read_buf));
3961   called = false;
3962   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3963       bindns::bind(async_read_handler,
3964         _1, _2, 10, &called));
3965   ioc.restart();
3966   ioc.run();
3967   BOOST_ASIO_CHECK(called);
3968   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3969
3970   s.reset(read_data, sizeof(read_data));
3971   memset(read_buf, 0, sizeof(read_buf));
3972   called = false;
3973   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3974       bindns::bind(async_read_handler,
3975         _1, _2, sizeof(read_data), &called));
3976   ioc.restart();
3977   ioc.run();
3978   BOOST_ASIO_CHECK(called);
3979   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3980
3981   s.reset(read_data, sizeof(read_data));
3982   s.next_read_length(1);
3983   memset(read_buf, 0, sizeof(read_buf));
3984   called = false;
3985   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3986       bindns::bind(async_read_handler,
3987         _1, _2, 10, &called));
3988   ioc.restart();
3989   ioc.run();
3990   BOOST_ASIO_CHECK(called);
3991   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3992
3993   s.reset(read_data, sizeof(read_data));
3994   s.next_read_length(10);
3995   memset(read_buf, 0, sizeof(read_buf));
3996   called = false;
3997   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3998       bindns::bind(async_read_handler,
3999         _1, _2, 10, &called));
4000   ioc.restart();
4001   ioc.run();
4002   BOOST_ASIO_CHECK(called);
4003   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4004
4005   s.reset(read_data, sizeof(read_data));
4006   memset(read_buf, 0, sizeof(read_buf));
4007   called = false;
4008   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
4009       bindns::bind(async_read_handler,
4010         _1, _2, sizeof(read_data), &called));
4011   ioc.restart();
4012   ioc.run();
4013   BOOST_ASIO_CHECK(called);
4014   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4015
4016   s.reset(read_data, sizeof(read_data));
4017   s.next_read_length(1);
4018   memset(read_buf, 0, sizeof(read_buf));
4019   called = false;
4020   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
4021       bindns::bind(async_read_handler,
4022         _1, _2, 42, &called));
4023   ioc.restart();
4024   ioc.run();
4025   BOOST_ASIO_CHECK(called);
4026   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
4027
4028   s.reset(read_data, sizeof(read_data));
4029   s.next_read_length(10);
4030   memset(read_buf, 0, sizeof(read_buf));
4031   called = false;
4032   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
4033       bindns::bind(async_read_handler,
4034         _1, _2, 50, &called));
4035   ioc.restart();
4036   ioc.run();
4037   BOOST_ASIO_CHECK(called);
4038   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
4039
4040   s.reset(read_data, sizeof(read_data));
4041   memset(read_buf, 0, sizeof(read_buf));
4042   called = false;
4043   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
4044       bindns::bind(async_read_handler,
4045         _1, _2, 1, &called));
4046   ioc.restart();
4047   ioc.run();
4048   BOOST_ASIO_CHECK(called);
4049   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
4050
4051   s.reset(read_data, sizeof(read_data));
4052   s.next_read_length(1);
4053   memset(read_buf, 0, sizeof(read_buf));
4054   called = false;
4055   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
4056       bindns::bind(async_read_handler,
4057         _1, _2, 1, &called));
4058   ioc.restart();
4059   ioc.run();
4060   BOOST_ASIO_CHECK(called);
4061   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
4062
4063   s.reset(read_data, sizeof(read_data));
4064   s.next_read_length(10);
4065   memset(read_buf, 0, sizeof(read_buf));
4066   called = false;
4067   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
4068       bindns::bind(async_read_handler,
4069         _1, _2, 1, &called));
4070   ioc.restart();
4071   ioc.run();
4072   BOOST_ASIO_CHECK(called);
4073   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
4074
4075   s.reset(read_data, sizeof(read_data));
4076   memset(read_buf, 0, sizeof(read_buf));
4077   called = false;
4078   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
4079       bindns::bind(async_read_handler,
4080         _1, _2, 10, &called));
4081   ioc.restart();
4082   ioc.run();
4083   BOOST_ASIO_CHECK(called);
4084   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4085
4086   s.reset(read_data, sizeof(read_data));
4087   s.next_read_length(1);
4088   memset(read_buf, 0, sizeof(read_buf));
4089   called = false;
4090   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
4091       bindns::bind(async_read_handler,
4092         _1, _2, 10, &called));
4093   ioc.restart();
4094   ioc.run();
4095   BOOST_ASIO_CHECK(called);
4096   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4097
4098   s.reset(read_data, sizeof(read_data));
4099   s.next_read_length(10);
4100   memset(read_buf, 0, sizeof(read_buf));
4101   called = false;
4102   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
4103       bindns::bind(async_read_handler,
4104         _1, _2, 10, &called));
4105   ioc.restart();
4106   ioc.run();
4107   BOOST_ASIO_CHECK(called);
4108   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4109
4110   s.reset(read_data, sizeof(read_data));
4111   memset(read_buf, 0, sizeof(read_buf));
4112   called = false;
4113   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
4114       bindns::bind(async_read_handler,
4115         _1, _2, 42, &called));
4116   ioc.restart();
4117   ioc.run();
4118   BOOST_ASIO_CHECK(called);
4119   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
4120
4121   s.reset(read_data, sizeof(read_data));
4122   s.next_read_length(1);
4123   memset(read_buf, 0, sizeof(read_buf));
4124   called = false;
4125   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
4126       bindns::bind(async_read_handler,
4127         _1, _2, 42, &called));
4128   ioc.restart();
4129   ioc.run();
4130   BOOST_ASIO_CHECK(called);
4131   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
4132
4133   s.reset(read_data, sizeof(read_data));
4134   s.next_read_length(10);
4135   memset(read_buf, 0, sizeof(read_buf));
4136   called = false;
4137   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
4138       bindns::bind(async_read_handler,
4139         _1, _2, 42, &called));
4140   ioc.restart();
4141   ioc.run();
4142   BOOST_ASIO_CHECK(called);
4143   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
4144
4145   s.reset(read_data, sizeof(read_data));
4146   memset(read_buf, 0, sizeof(read_buf));
4147   called = false;
4148   boost::asio::async_read(s, buffers, old_style_transfer_all,
4149       bindns::bind(async_read_handler,
4150         _1, _2, sizeof(read_data), &called));
4151   ioc.restart();
4152   ioc.run();
4153   BOOST_ASIO_CHECK(called);
4154   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4155
4156   s.reset(read_data, sizeof(read_data));
4157   s.next_read_length(1);
4158   memset(read_buf, 0, sizeof(read_buf));
4159   called = false;
4160   boost::asio::async_read(s, buffers, old_style_transfer_all,
4161       bindns::bind(async_read_handler,
4162         _1, _2, sizeof(read_data), &called));
4163   ioc.restart();
4164   ioc.run();
4165   BOOST_ASIO_CHECK(called);
4166   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4167
4168   s.reset(read_data, sizeof(read_data));
4169   s.next_read_length(10);
4170   memset(read_buf, 0, sizeof(read_buf));
4171   called = false;
4172   boost::asio::async_read(s, buffers, old_style_transfer_all,
4173       bindns::bind(async_read_handler,
4174         _1, _2, sizeof(read_data), &called));
4175   ioc.restart();
4176   ioc.run();
4177   BOOST_ASIO_CHECK(called);
4178   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4179
4180   s.reset(read_data, sizeof(read_data));
4181   memset(read_buf, 0, sizeof(read_buf));
4182   called = false;
4183   boost::asio::async_read(s, buffers, short_transfer(),
4184       bindns::bind(async_read_handler,
4185         _1, _2, sizeof(read_data), &called));
4186   ioc.restart();
4187   ioc.run();
4188   BOOST_ASIO_CHECK(called);
4189   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4190
4191   s.reset(read_data, sizeof(read_data));
4192   s.next_read_length(1);
4193   memset(read_buf, 0, sizeof(read_buf));
4194   called = false;
4195   boost::asio::async_read(s, buffers, short_transfer(),
4196       bindns::bind(async_read_handler,
4197         _1, _2, sizeof(read_data), &called));
4198   ioc.restart();
4199   ioc.run();
4200   BOOST_ASIO_CHECK(called);
4201   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4202
4203   s.reset(read_data, sizeof(read_data));
4204   s.next_read_length(10);
4205   memset(read_buf, 0, sizeof(read_buf));
4206   called = false;
4207   boost::asio::async_read(s, buffers, short_transfer(),
4208       bindns::bind(async_read_handler,
4209         _1, _2, sizeof(read_data), &called));
4210   ioc.restart();
4211   ioc.run();
4212   BOOST_ASIO_CHECK(called);
4213   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4214
4215   s.reset(read_data, sizeof(read_data));
4216   memset(read_buf, 0, sizeof(read_buf));
4217   int i = boost::asio::async_read(s, buffers,
4218       short_transfer(), archetypes::lazy_handler());
4219   BOOST_ASIO_CHECK(i == 42);
4220   ioc.restart();
4221   ioc.run();
4222   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4223 }
4224
4225 void test_4_arg_dynamic_string_async_read()
4226 {
4227 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
4228   namespace bindns = boost;
4229 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
4230   namespace bindns = std;
4231 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
4232   using bindns::placeholders::_1;
4233   using bindns::placeholders::_2;
4234
4235   boost::asio::io_context ioc;
4236   test_stream s(ioc);
4237   std::string data;
4238   boost::asio::dynamic_string_buffer<char, std::string::traits_type,
4239     std::string::allocator_type> sb
4240       = boost::asio::dynamic_buffer(data, sizeof(read_data));
4241
4242   s.reset(read_data, sizeof(read_data));
4243   sb.consume(sb.size());
4244   bool called = false;
4245   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
4246       bindns::bind(async_read_handler,
4247         _1, _2, sizeof(read_data), &called));
4248   ioc.restart();
4249   ioc.run();
4250   BOOST_ASIO_CHECK(called);
4251   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4252   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4253
4254   s.reset(read_data, sizeof(read_data));
4255   s.next_read_length(1);
4256   sb.consume(sb.size());
4257   called = false;
4258   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
4259       bindns::bind(async_read_handler,
4260         _1, _2, sizeof(read_data), &called));
4261   ioc.restart();
4262   ioc.run();
4263   BOOST_ASIO_CHECK(called);
4264   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4265   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4266
4267   s.reset(read_data, sizeof(read_data));
4268   s.next_read_length(10);
4269   sb.consume(sb.size());
4270   called = false;
4271   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
4272       bindns::bind(async_read_handler,
4273         _1, _2, sizeof(read_data), &called));
4274   ioc.restart();
4275   ioc.run();
4276   BOOST_ASIO_CHECK(called);
4277   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4278   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4279
4280   s.reset(read_data, sizeof(read_data));
4281   sb.consume(sb.size());
4282   called = false;
4283   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
4284       bindns::bind(async_read_handler,
4285         _1, _2, sizeof(read_data), &called));
4286   ioc.restart();
4287   ioc.run();
4288   BOOST_ASIO_CHECK(called);
4289   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4290   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4291
4292   s.reset(read_data, sizeof(read_data));
4293   s.next_read_length(1);
4294   sb.consume(sb.size());
4295   called = false;
4296   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
4297       bindns::bind(async_read_handler,
4298         _1, _2, 1, &called));
4299   ioc.restart();
4300   ioc.run();
4301   BOOST_ASIO_CHECK(called);
4302   BOOST_ASIO_CHECK(sb.size() == 1);
4303   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4304
4305   s.reset(read_data, sizeof(read_data));
4306   s.next_read_length(10);
4307   sb.consume(sb.size());
4308   called = false;
4309   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
4310       bindns::bind(async_read_handler,
4311         _1, _2, 10, &called));
4312   ioc.restart();
4313   ioc.run();
4314   BOOST_ASIO_CHECK(called);
4315   BOOST_ASIO_CHECK(sb.size() == 10);
4316   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4317
4318   s.reset(read_data, sizeof(read_data));
4319   sb.consume(sb.size());
4320   called = false;
4321   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
4322       bindns::bind(async_read_handler,
4323         _1, _2, sizeof(read_data), &called));
4324   ioc.restart();
4325   ioc.run();
4326   BOOST_ASIO_CHECK(called);
4327   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4328   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4329
4330   s.reset(read_data, sizeof(read_data));
4331   s.next_read_length(1);
4332   sb.consume(sb.size());
4333   called = false;
4334   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
4335       bindns::bind(async_read_handler,
4336         _1, _2, 10, &called));
4337   ioc.restart();
4338   ioc.run();
4339   BOOST_ASIO_CHECK(called);
4340   BOOST_ASIO_CHECK(sb.size() == 10);
4341   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4342
4343   s.reset(read_data, sizeof(read_data));
4344   s.next_read_length(10);
4345   sb.consume(sb.size());
4346   called = false;
4347   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
4348       bindns::bind(async_read_handler,
4349         _1, _2, 10, &called));
4350   ioc.restart();
4351   ioc.run();
4352   BOOST_ASIO_CHECK(called);
4353   BOOST_ASIO_CHECK(sb.size() == 10);
4354   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4355
4356   s.reset(read_data, sizeof(read_data));
4357   sb.consume(sb.size());
4358   called = false;
4359   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
4360       bindns::bind(async_read_handler,
4361         _1, _2, sizeof(read_data), &called));
4362   ioc.restart();
4363   ioc.run();
4364   BOOST_ASIO_CHECK(called);
4365   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4366   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4367
4368   s.reset(read_data, sizeof(read_data));
4369   s.next_read_length(1);
4370   sb.consume(sb.size());
4371   called = false;
4372   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
4373       bindns::bind(async_read_handler,
4374         _1, _2, 42, &called));
4375   ioc.restart();
4376   ioc.run();
4377   BOOST_ASIO_CHECK(called);
4378   BOOST_ASIO_CHECK(sb.size() == 42);
4379   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4380
4381   s.reset(read_data, sizeof(read_data));
4382   s.next_read_length(10);
4383   sb.consume(sb.size());
4384   called = false;
4385   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
4386       bindns::bind(async_read_handler,
4387         _1, _2, 50, &called));
4388   ioc.restart();
4389   ioc.run();
4390   BOOST_ASIO_CHECK(called);
4391   BOOST_ASIO_CHECK(sb.size() == 50);
4392   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
4393
4394   s.reset(read_data, sizeof(read_data));
4395   sb.consume(sb.size());
4396   called = false;
4397   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
4398       bindns::bind(async_read_handler,
4399         _1, _2, 1, &called));
4400   ioc.restart();
4401   ioc.run();
4402   BOOST_ASIO_CHECK(called);
4403   BOOST_ASIO_CHECK(sb.size() == 1);
4404   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4405
4406   s.reset(read_data, sizeof(read_data));
4407   s.next_read_length(1);
4408   sb.consume(sb.size());
4409   called = false;
4410   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
4411       bindns::bind(async_read_handler,
4412         _1, _2, 1, &called));
4413   ioc.restart();
4414   ioc.run();
4415   BOOST_ASIO_CHECK(called);
4416   BOOST_ASIO_CHECK(sb.size() == 1);
4417   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4418
4419   s.reset(read_data, sizeof(read_data));
4420   s.next_read_length(10);
4421   sb.consume(sb.size());
4422   called = false;
4423   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
4424       bindns::bind(async_read_handler,
4425         _1, _2, 1, &called));
4426   ioc.restart();
4427   ioc.run();
4428   BOOST_ASIO_CHECK(called);
4429   BOOST_ASIO_CHECK(sb.size() == 1);
4430   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4431
4432   s.reset(read_data, sizeof(read_data));
4433   sb.consume(sb.size());
4434   called = false;
4435   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
4436       bindns::bind(async_read_handler,
4437         _1, _2, 10, &called));
4438   ioc.restart();
4439   ioc.run();
4440   BOOST_ASIO_CHECK(called);
4441   BOOST_ASIO_CHECK(sb.size() == 10);
4442   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4443
4444   s.reset(read_data, sizeof(read_data));
4445   s.next_read_length(1);
4446   sb.consume(sb.size());
4447   called = false;
4448   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
4449       bindns::bind(async_read_handler,
4450         _1, _2, 10, &called));
4451   ioc.restart();
4452   ioc.run();
4453   BOOST_ASIO_CHECK(called);
4454   BOOST_ASIO_CHECK(sb.size() == 10);
4455   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4456
4457   s.reset(read_data, sizeof(read_data));
4458   s.next_read_length(10);
4459   sb.consume(sb.size());
4460   called = false;
4461   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
4462       bindns::bind(async_read_handler,
4463         _1, _2, 10, &called));
4464   ioc.restart();
4465   ioc.run();
4466   BOOST_ASIO_CHECK(called);
4467   BOOST_ASIO_CHECK(sb.size() == 10);
4468   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4469
4470   s.reset(read_data, sizeof(read_data));
4471   sb.consume(sb.size());
4472   called = false;
4473   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
4474       bindns::bind(async_read_handler,
4475         _1, _2, 42, &called));
4476   ioc.restart();
4477   ioc.run();
4478   BOOST_ASIO_CHECK(called);
4479   BOOST_ASIO_CHECK(sb.size() == 42);
4480   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4481
4482   s.reset(read_data, sizeof(read_data));
4483   s.next_read_length(1);
4484   sb.consume(sb.size());
4485   called = false;
4486   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
4487       bindns::bind(async_read_handler,
4488         _1, _2, 42, &called));
4489   ioc.restart();
4490   ioc.run();
4491   BOOST_ASIO_CHECK(called);
4492   BOOST_ASIO_CHECK(sb.size() == 42);
4493   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4494
4495   s.reset(read_data, sizeof(read_data));
4496   s.next_read_length(10);
4497   sb.consume(sb.size());
4498   called = false;
4499   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
4500       bindns::bind(async_read_handler,
4501         _1, _2, 42, &called));
4502   ioc.restart();
4503   ioc.run();
4504   BOOST_ASIO_CHECK(called);
4505   BOOST_ASIO_CHECK(sb.size() == 42);
4506   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4507
4508   s.reset(read_data, sizeof(read_data));
4509   sb.consume(sb.size());
4510   called = false;
4511   boost::asio::async_read(s, sb, old_style_transfer_all,
4512       bindns::bind(async_read_handler,
4513         _1, _2, sizeof(read_data), &called));
4514   ioc.restart();
4515   ioc.run();
4516   BOOST_ASIO_CHECK(called);
4517   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4518   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4519
4520   s.reset(read_data, sizeof(read_data));
4521   s.next_read_length(1);
4522   sb.consume(sb.size());
4523   called = false;
4524   boost::asio::async_read(s, sb, old_style_transfer_all,
4525       bindns::bind(async_read_handler,
4526         _1, _2, sizeof(read_data), &called));
4527   ioc.restart();
4528   ioc.run();
4529   BOOST_ASIO_CHECK(called);
4530   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4531   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4532
4533   s.reset(read_data, sizeof(read_data));
4534   s.next_read_length(10);
4535   sb.consume(sb.size());
4536   called = false;
4537   boost::asio::async_read(s, sb, old_style_transfer_all,
4538       bindns::bind(async_read_handler,
4539         _1, _2, sizeof(read_data), &called));
4540   ioc.restart();
4541   ioc.run();
4542   BOOST_ASIO_CHECK(called);
4543   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4544   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4545
4546   s.reset(read_data, sizeof(read_data));
4547   sb.consume(sb.size());
4548   called = false;
4549   boost::asio::async_read(s, sb, short_transfer(),
4550       bindns::bind(async_read_handler,
4551         _1, _2, sizeof(read_data), &called));
4552   ioc.restart();
4553   ioc.run();
4554   BOOST_ASIO_CHECK(called);
4555   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4556   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4557
4558   s.reset(read_data, sizeof(read_data));
4559   s.next_read_length(1);
4560   sb.consume(sb.size());
4561   called = false;
4562   boost::asio::async_read(s, sb, short_transfer(),
4563       bindns::bind(async_read_handler,
4564         _1, _2, sizeof(read_data), &called));
4565   ioc.restart();
4566   ioc.run();
4567   BOOST_ASIO_CHECK(called);
4568   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4569   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4570
4571   s.reset(read_data, sizeof(read_data));
4572   s.next_read_length(10);
4573   sb.consume(sb.size());
4574   called = false;
4575   boost::asio::async_read(s, sb, short_transfer(),
4576       bindns::bind(async_read_handler,
4577         _1, _2, sizeof(read_data), &called));
4578   ioc.restart();
4579   ioc.run();
4580   BOOST_ASIO_CHECK(called);
4581   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4582   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4583
4584   s.reset(read_data, sizeof(read_data));
4585   sb.consume(sb.size());
4586   int i = boost::asio::async_read(s, sb,
4587       short_transfer(), archetypes::lazy_handler());
4588   BOOST_ASIO_CHECK(i == 42);
4589   ioc.restart();
4590   ioc.run();
4591   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4592   BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4593 }
4594
4595 void test_4_arg_streambuf_async_read()
4596 {
4597 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
4598 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
4599   namespace bindns = boost;
4600 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
4601   namespace bindns = std;
4602 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
4603   using bindns::placeholders::_1;
4604   using bindns::placeholders::_2;
4605
4606   boost::asio::io_context ioc;
4607   test_stream s(ioc);
4608   boost::asio::streambuf sb(sizeof(read_data));
4609
4610   s.reset(read_data, sizeof(read_data));
4611   sb.consume(sb.size());
4612   bool called = false;
4613   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
4614       bindns::bind(async_read_handler,
4615         _1, _2, sizeof(read_data), &called));
4616   ioc.restart();
4617   ioc.run();
4618   BOOST_ASIO_CHECK(called);
4619   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4620   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4621
4622   s.reset(read_data, sizeof(read_data));
4623   s.next_read_length(1);
4624   sb.consume(sb.size());
4625   called = false;
4626   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
4627       bindns::bind(async_read_handler,
4628         _1, _2, sizeof(read_data), &called));
4629   ioc.restart();
4630   ioc.run();
4631   BOOST_ASIO_CHECK(called);
4632   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4633   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4634
4635   s.reset(read_data, sizeof(read_data));
4636   s.next_read_length(10);
4637   sb.consume(sb.size());
4638   called = false;
4639   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
4640       bindns::bind(async_read_handler,
4641         _1, _2, sizeof(read_data), &called));
4642   ioc.restart();
4643   ioc.run();
4644   BOOST_ASIO_CHECK(called);
4645   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4646   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4647
4648   s.reset(read_data, sizeof(read_data));
4649   sb.consume(sb.size());
4650   called = false;
4651   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
4652       bindns::bind(async_read_handler,
4653         _1, _2, sizeof(read_data), &called));
4654   ioc.restart();
4655   ioc.run();
4656   BOOST_ASIO_CHECK(called);
4657   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4658   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4659
4660   s.reset(read_data, sizeof(read_data));
4661   s.next_read_length(1);
4662   sb.consume(sb.size());
4663   called = false;
4664   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
4665       bindns::bind(async_read_handler,
4666         _1, _2, 1, &called));
4667   ioc.restart();
4668   ioc.run();
4669   BOOST_ASIO_CHECK(called);
4670   BOOST_ASIO_CHECK(sb.size() == 1);
4671   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4672
4673   s.reset(read_data, sizeof(read_data));
4674   s.next_read_length(10);
4675   sb.consume(sb.size());
4676   called = false;
4677   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
4678       bindns::bind(async_read_handler,
4679         _1, _2, 10, &called));
4680   ioc.restart();
4681   ioc.run();
4682   BOOST_ASIO_CHECK(called);
4683   BOOST_ASIO_CHECK(sb.size() == 10);
4684   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4685
4686   s.reset(read_data, sizeof(read_data));
4687   sb.consume(sb.size());
4688   called = false;
4689   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
4690       bindns::bind(async_read_handler,
4691         _1, _2, sizeof(read_data), &called));
4692   ioc.restart();
4693   ioc.run();
4694   BOOST_ASIO_CHECK(called);
4695   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4696   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4697
4698   s.reset(read_data, sizeof(read_data));
4699   s.next_read_length(1);
4700   sb.consume(sb.size());
4701   called = false;
4702   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
4703       bindns::bind(async_read_handler,
4704         _1, _2, 10, &called));
4705   ioc.restart();
4706   ioc.run();
4707   BOOST_ASIO_CHECK(called);
4708   BOOST_ASIO_CHECK(sb.size() == 10);
4709   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4710
4711   s.reset(read_data, sizeof(read_data));
4712   s.next_read_length(10);
4713   sb.consume(sb.size());
4714   called = false;
4715   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
4716       bindns::bind(async_read_handler,
4717         _1, _2, 10, &called));
4718   ioc.restart();
4719   ioc.run();
4720   BOOST_ASIO_CHECK(called);
4721   BOOST_ASIO_CHECK(sb.size() == 10);
4722   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4723
4724   s.reset(read_data, sizeof(read_data));
4725   sb.consume(sb.size());
4726   called = false;
4727   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
4728       bindns::bind(async_read_handler,
4729         _1, _2, sizeof(read_data), &called));
4730   ioc.restart();
4731   ioc.run();
4732   BOOST_ASIO_CHECK(called);
4733   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4734   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4735
4736   s.reset(read_data, sizeof(read_data));
4737   s.next_read_length(1);
4738   sb.consume(sb.size());
4739   called = false;
4740   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
4741       bindns::bind(async_read_handler,
4742         _1, _2, 42, &called));
4743   ioc.restart();
4744   ioc.run();
4745   BOOST_ASIO_CHECK(called);
4746   BOOST_ASIO_CHECK(sb.size() == 42);
4747   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4748
4749   s.reset(read_data, sizeof(read_data));
4750   s.next_read_length(10);
4751   sb.consume(sb.size());
4752   called = false;
4753   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
4754       bindns::bind(async_read_handler,
4755         _1, _2, 50, &called));
4756   ioc.restart();
4757   ioc.run();
4758   BOOST_ASIO_CHECK(called);
4759   BOOST_ASIO_CHECK(sb.size() == 50);
4760   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
4761
4762   s.reset(read_data, sizeof(read_data));
4763   sb.consume(sb.size());
4764   called = false;
4765   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
4766       bindns::bind(async_read_handler,
4767         _1, _2, 1, &called));
4768   ioc.restart();
4769   ioc.run();
4770   BOOST_ASIO_CHECK(called);
4771   BOOST_ASIO_CHECK(sb.size() == 1);
4772   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4773
4774   s.reset(read_data, sizeof(read_data));
4775   s.next_read_length(1);
4776   sb.consume(sb.size());
4777   called = false;
4778   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
4779       bindns::bind(async_read_handler,
4780         _1, _2, 1, &called));
4781   ioc.restart();
4782   ioc.run();
4783   BOOST_ASIO_CHECK(called);
4784   BOOST_ASIO_CHECK(sb.size() == 1);
4785   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4786
4787   s.reset(read_data, sizeof(read_data));
4788   s.next_read_length(10);
4789   sb.consume(sb.size());
4790   called = false;
4791   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
4792       bindns::bind(async_read_handler,
4793         _1, _2, 1, &called));
4794   ioc.restart();
4795   ioc.run();
4796   BOOST_ASIO_CHECK(called);
4797   BOOST_ASIO_CHECK(sb.size() == 1);
4798   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4799
4800   s.reset(read_data, sizeof(read_data));
4801   sb.consume(sb.size());
4802   called = false;
4803   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
4804       bindns::bind(async_read_handler,
4805         _1, _2, 10, &called));
4806   ioc.restart();
4807   ioc.run();
4808   BOOST_ASIO_CHECK(called);
4809   BOOST_ASIO_CHECK(sb.size() == 10);
4810   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4811
4812   s.reset(read_data, sizeof(read_data));
4813   s.next_read_length(1);
4814   sb.consume(sb.size());
4815   called = false;
4816   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
4817       bindns::bind(async_read_handler,
4818         _1, _2, 10, &called));
4819   ioc.restart();
4820   ioc.run();
4821   BOOST_ASIO_CHECK(called);
4822   BOOST_ASIO_CHECK(sb.size() == 10);
4823   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4824
4825   s.reset(read_data, sizeof(read_data));
4826   s.next_read_length(10);
4827   sb.consume(sb.size());
4828   called = false;
4829   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
4830       bindns::bind(async_read_handler,
4831         _1, _2, 10, &called));
4832   ioc.restart();
4833   ioc.run();
4834   BOOST_ASIO_CHECK(called);
4835   BOOST_ASIO_CHECK(sb.size() == 10);
4836   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4837
4838   s.reset(read_data, sizeof(read_data));
4839   sb.consume(sb.size());
4840   called = false;
4841   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
4842       bindns::bind(async_read_handler,
4843         _1, _2, 42, &called));
4844   ioc.restart();
4845   ioc.run();
4846   BOOST_ASIO_CHECK(called);
4847   BOOST_ASIO_CHECK(sb.size() == 42);
4848   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4849
4850   s.reset(read_data, sizeof(read_data));
4851   s.next_read_length(1);
4852   sb.consume(sb.size());
4853   called = false;
4854   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
4855       bindns::bind(async_read_handler,
4856         _1, _2, 42, &called));
4857   ioc.restart();
4858   ioc.run();
4859   BOOST_ASIO_CHECK(called);
4860   BOOST_ASIO_CHECK(sb.size() == 42);
4861   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4862
4863   s.reset(read_data, sizeof(read_data));
4864   s.next_read_length(10);
4865   sb.consume(sb.size());
4866   called = false;
4867   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
4868       bindns::bind(async_read_handler,
4869         _1, _2, 42, &called));
4870   ioc.restart();
4871   ioc.run();
4872   BOOST_ASIO_CHECK(called);
4873   BOOST_ASIO_CHECK(sb.size() == 42);
4874   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4875
4876   s.reset(read_data, sizeof(read_data));
4877   sb.consume(sb.size());
4878   called = false;
4879   boost::asio::async_read(s, sb, old_style_transfer_all,
4880       bindns::bind(async_read_handler,
4881         _1, _2, sizeof(read_data), &called));
4882   ioc.restart();
4883   ioc.run();
4884   BOOST_ASIO_CHECK(called);
4885   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4886   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4887
4888   s.reset(read_data, sizeof(read_data));
4889   s.next_read_length(1);
4890   sb.consume(sb.size());
4891   called = false;
4892   boost::asio::async_read(s, sb, old_style_transfer_all,
4893       bindns::bind(async_read_handler,
4894         _1, _2, sizeof(read_data), &called));
4895   ioc.restart();
4896   ioc.run();
4897   BOOST_ASIO_CHECK(called);
4898   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4899   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4900
4901   s.reset(read_data, sizeof(read_data));
4902   s.next_read_length(10);
4903   sb.consume(sb.size());
4904   called = false;
4905   boost::asio::async_read(s, sb, old_style_transfer_all,
4906       bindns::bind(async_read_handler,
4907         _1, _2, sizeof(read_data), &called));
4908   ioc.restart();
4909   ioc.run();
4910   BOOST_ASIO_CHECK(called);
4911   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4912   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4913
4914   s.reset(read_data, sizeof(read_data));
4915   sb.consume(sb.size());
4916   called = false;
4917   boost::asio::async_read(s, sb, short_transfer(),
4918       bindns::bind(async_read_handler,
4919         _1, _2, sizeof(read_data), &called));
4920   ioc.restart();
4921   ioc.run();
4922   BOOST_ASIO_CHECK(called);
4923   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4924   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4925
4926   s.reset(read_data, sizeof(read_data));
4927   s.next_read_length(1);
4928   sb.consume(sb.size());
4929   called = false;
4930   boost::asio::async_read(s, sb, short_transfer(),
4931       bindns::bind(async_read_handler,
4932         _1, _2, sizeof(read_data), &called));
4933   ioc.restart();
4934   ioc.run();
4935   BOOST_ASIO_CHECK(called);
4936   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4937   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4938
4939   s.reset(read_data, sizeof(read_data));
4940   s.next_read_length(10);
4941   sb.consume(sb.size());
4942   called = false;
4943   boost::asio::async_read(s, sb, short_transfer(),
4944       bindns::bind(async_read_handler,
4945         _1, _2, sizeof(read_data), &called));
4946   ioc.restart();
4947   ioc.run();
4948   BOOST_ASIO_CHECK(called);
4949   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4950   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4951
4952   s.reset(read_data, sizeof(read_data));
4953   sb.consume(sb.size());
4954   int i = boost::asio::async_read(s, sb,
4955       short_transfer(), archetypes::lazy_handler());
4956   BOOST_ASIO_CHECK(i == 42);
4957   ioc.restart();
4958   ioc.run();
4959   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4960   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4961 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
4962 }
4963
4964 BOOST_ASIO_TEST_SUITE
4965 (
4966   "read",
4967   BOOST_ASIO_TEST_CASE(test_2_arg_zero_buffers_read)
4968   BOOST_ASIO_TEST_CASE(test_2_arg_mutable_buffer_read)
4969   BOOST_ASIO_TEST_CASE(test_2_arg_vector_buffers_read)
4970   BOOST_ASIO_TEST_CASE(test_2_arg_dynamic_string_read)
4971   BOOST_ASIO_TEST_CASE(test_2_arg_streambuf_read)
4972   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_read)
4973   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_read)
4974   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_read)
4975   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_dynamic_string_read)
4976   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_streambuf_read)
4977   BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_read)
4978   BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_read)
4979   BOOST_ASIO_TEST_CASE(test_3_arg_dynamic_string_read)
4980   BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_read)
4981   BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_read)
4982   BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_read)
4983   BOOST_ASIO_TEST_CASE(test_4_arg_dynamic_string_read)
4984   BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_read)
4985   BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_read)
4986   BOOST_ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_read)
4987   BOOST_ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_read)
4988   BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_async_read)
4989   BOOST_ASIO_TEST_CASE(test_3_arg_dynamic_string_async_read)
4990   BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_async_read)
4991   BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read)
4992   BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read)
4993   BOOST_ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read)
4994   BOOST_ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read)
4995   BOOST_ASIO_TEST_CASE(test_4_arg_dynamic_string_async_read)
4996   BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_async_read)
4997 )