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

   1 //
   2 // read.cpp
   3 // ~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 // Disable autolinking for unit tests.
  12 #if !defined(BOOST_ALL_NO_LIB)
  13 #define BOOST_ALL_NO_LIB 1
  14 #endif // !defined(BOOST_ALL_NO_LIB)
  15
  16 // Test that header file is self-contained.
  17 #include <boost/asio/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.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, Handler handler)
 124   {
 125     size_t bytes_transferred = read_some(buffers);
 126     boost::asio::post(get_executor(),
 127         boost::asio::detail::bind_handler(
 128           BOOST_ASIO_MOVE_CAST(Handler)(handler),
 129           boost::system::error_code(), bytes_transferred));
 130   }
 131
 132 private:
 133   boost::asio::io_context& io_context_;
 134   enum { max_length = 8192 };
 135   char data_[max_length];
 136   size_t length_;
 137   size_t position_;
 138   size_t next_read_length_;
 139 };
 140
 141 static const char read_data[]
 142   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 143
 144 void test_2_arg_zero_buffers_read()
 145 {
 146   boost::asio::io_context ioc;
 147   test_stream s(ioc);
 148   std::vector<boost::asio::mutable_buffer> buffers;
 149
 150   size_t bytes_transferred = boost::asio::read(s, buffers);
 151   BOOST_ASIO_CHECK(bytes_transferred == 0);
 152 }
 153
 154 void test_2_arg_mutable_buffer_read()
 155 {
 156   boost::asio::io_context ioc;
 157   test_stream s(ioc);
 158   char read_buf[sizeof(read_data)];
 159   boost::asio::mutable_buffer buffers
 160     = boost::asio::buffer(read_buf, sizeof(read_buf));
 161
 162   s.reset(read_data, sizeof(read_data));
 163   memset(read_buf, 0, sizeof(read_buf));
 164   size_t bytes_transferred = boost::asio::read(s, buffers);
 165   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 166   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 167
 168   s.reset(read_data, sizeof(read_data));
 169   s.next_read_length(1);
 170   memset(read_buf, 0, sizeof(read_buf));
 171   bytes_transferred = boost::asio::read(s, buffers);
 172   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 173   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 174
 175   s.reset(read_data, sizeof(read_data));
 176   s.next_read_length(10);
 177   memset(read_buf, 0, sizeof(read_buf));
 178   bytes_transferred = boost::asio::read(s, buffers);
 179   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 180   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 181 }
 182
 183 void test_2_arg_vector_buffers_read()
 184 {
 185   boost::asio::io_context ioc;
 186   test_stream s(ioc);
 187   char read_buf[sizeof(read_data)];
 188   std::vector<boost::asio::mutable_buffer> buffers;
 189   buffers.push_back(boost::asio::buffer(read_buf, 32));
 190   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
 191   buffers.push_back(boost::asio::buffer(read_buf) + 39);
 192
 193   s.reset(read_data, sizeof(read_data));
 194   memset(read_buf, 0, sizeof(read_buf));
 195   size_t bytes_transferred = boost::asio::read(s, buffers);
 196   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 197   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 198
 199   s.reset(read_data, sizeof(read_data));
 200   s.next_read_length(1);
 201   memset(read_buf, 0, sizeof(read_buf));
 202   bytes_transferred = boost::asio::read(s, buffers);
 203   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 204   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 205
 206   s.reset(read_data, sizeof(read_data));
 207   s.next_read_length(10);
 208   memset(read_buf, 0, sizeof(read_buf));
 209   bytes_transferred = boost::asio::read(s, buffers);
 210   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 211   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 212 }
 213
 214 void test_2_arg_streambuf_read()
 215 {
 216   boost::asio::io_context ioc;
 217   test_stream s(ioc);
 218   boost::asio::streambuf sb(sizeof(read_data));
 219
 220   s.reset(read_data, sizeof(read_data));
 221   sb.consume(sb.size());
 222   size_t bytes_transferred = boost::asio::read(s, sb);
 223   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 224   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 225   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 226
 227   s.reset(read_data, sizeof(read_data));
 228   s.next_read_length(1);
 229   sb.consume(sb.size());
 230   bytes_transferred = boost::asio::read(s, sb);
 231   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 232   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 233   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 234
 235   s.reset(read_data, sizeof(read_data));
 236   s.next_read_length(10);
 237   sb.consume(sb.size());
 238   bytes_transferred = boost::asio::read(s, sb);
 239   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 240   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 241   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 242 }
 243
 244 void test_3_arg_nothrow_zero_buffers_read()
 245 {
 246   boost::asio::io_context ioc;
 247   test_stream s(ioc);
 248   std::vector<boost::asio::mutable_buffer> buffers;
 249
 250   boost::system::error_code error;
 251   size_t bytes_transferred = boost::asio::read(s, buffers, error);
 252   BOOST_ASIO_CHECK(bytes_transferred == 0);
 253   BOOST_ASIO_CHECK(!error);
 254 }
 255
 256 void test_3_arg_nothrow_mutable_buffer_read()
 257 {
 258   boost::asio::io_context ioc;
 259   test_stream s(ioc);
 260   char read_buf[sizeof(read_data)];
 261   boost::asio::mutable_buffer buffers
 262     = boost::asio::buffer(read_buf, sizeof(read_buf));
 263
 264   s.reset(read_data, sizeof(read_data));
 265   memset(read_buf, 0, sizeof(read_buf));
 266   boost::system::error_code error;
 267   size_t bytes_transferred = boost::asio::read(s, buffers, error);
 268   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 269   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 270   BOOST_ASIO_CHECK(!error);
 271
 272   s.reset(read_data, sizeof(read_data));
 273   s.next_read_length(1);
 274   memset(read_buf, 0, sizeof(read_buf));
 275   bytes_transferred = boost::asio::read(s, buffers, error);
 276   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 277   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 278   BOOST_ASIO_CHECK(!error);
 279
 280   s.reset(read_data, sizeof(read_data));
 281   s.next_read_length(10);
 282   memset(read_buf, 0, sizeof(read_buf));
 283   bytes_transferred = boost::asio::read(s, buffers, error);
 284   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 285   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 286   BOOST_ASIO_CHECK(!error);
 287 }
 288
 289 void test_3_arg_nothrow_vector_buffers_read()
 290 {
 291   boost::asio::io_context ioc;
 292   test_stream s(ioc);
 293   char read_buf[sizeof(read_data)];
 294   std::vector<boost::asio::mutable_buffer> buffers;
 295   buffers.push_back(boost::asio::buffer(read_buf, 32));
 296   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
 297   buffers.push_back(boost::asio::buffer(read_buf) + 39);
 298
 299   s.reset(read_data, sizeof(read_data));
 300   memset(read_buf, 0, sizeof(read_buf));
 301   boost::system::error_code error;
 302   size_t bytes_transferred = boost::asio::read(s, buffers, error);
 303   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 304   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 305   BOOST_ASIO_CHECK(!error);
 306
 307   s.reset(read_data, sizeof(read_data));
 308   s.next_read_length(1);
 309   memset(read_buf, 0, sizeof(read_buf));
 310   bytes_transferred = boost::asio::read(s, buffers, error);
 311   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 312   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 313   BOOST_ASIO_CHECK(!error);
 314
 315   s.reset(read_data, sizeof(read_data));
 316   s.next_read_length(10);
 317   memset(read_buf, 0, sizeof(read_buf));
 318   bytes_transferred = boost::asio::read(s, buffers, error);
 319   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 320   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 321   BOOST_ASIO_CHECK(!error);
 322 }
 323
 324 void test_3_arg_nothrow_streambuf_read()
 325 {
 326   boost::asio::io_context ioc;
 327   test_stream s(ioc);
 328   boost::asio::streambuf sb(sizeof(read_data));
 329
 330   s.reset(read_data, sizeof(read_data));
 331   sb.consume(sb.size());
 332   boost::system::error_code error;
 333   size_t bytes_transferred = boost::asio::read(s, sb, error);
 334   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 335   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 336   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 337   BOOST_ASIO_CHECK(!error);
 338
 339   s.reset(read_data, sizeof(read_data));
 340   s.next_read_length(1);
 341   sb.consume(sb.size());
 342   bytes_transferred = boost::asio::read(s, sb, error);
 343   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 344   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 345   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 346   BOOST_ASIO_CHECK(!error);
 347
 348   s.reset(read_data, sizeof(read_data));
 349   s.next_read_length(10);
 350   sb.consume(sb.size());
 351   bytes_transferred = boost::asio::read(s, sb, error);
 352   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 353   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 354   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 355   BOOST_ASIO_CHECK(!error);
 356 }
 357
 358 bool old_style_transfer_all(const boost::system::error_code& ec,
 359     size_t /*bytes_transferred*/)
 360 {
 361   return !!ec;
 362 }
 363
 364 size_t short_transfer(const boost::system::error_code& ec,
 365     size_t /*bytes_transferred*/)
 366 {
 367   return !!ec ? 0 : 3;
 368 }
 369
 370 void test_3_arg_mutable_buffer_read()
 371 {
 372   boost::asio::io_context ioc;
 373   test_stream s(ioc);
 374   char read_buf[sizeof(read_data)];
 375   boost::asio::mutable_buffer buffers
 376     = boost::asio::buffer(read_buf, sizeof(read_buf));
 377
 378   s.reset(read_data, sizeof(read_data));
 379   memset(read_buf, 0, sizeof(read_buf));
 380   size_t bytes_transferred = boost::asio::read(s, buffers,
 381       boost::asio::transfer_all());
 382   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 383   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 384
 385   s.reset(read_data, sizeof(read_data));
 386   s.next_read_length(1);
 387   memset(read_buf, 0, sizeof(read_buf));
 388   bytes_transferred = boost::asio::read(s, buffers,
 389       boost::asio::transfer_all());
 390   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 391   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 392
 393   s.reset(read_data, sizeof(read_data));
 394   s.next_read_length(10);
 395   memset(read_buf, 0, sizeof(read_buf));
 396   bytes_transferred = boost::asio::read(s, buffers,
 397       boost::asio::transfer_all());
 398   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 399   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 400
 401   s.reset(read_data, sizeof(read_data));
 402   memset(read_buf, 0, sizeof(read_buf));
 403   bytes_transferred = boost::asio::read(s, buffers,
 404       boost::asio::transfer_at_least(1));
 405   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 406   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 407
 408   s.reset(read_data, sizeof(read_data));
 409   s.next_read_length(1);
 410   memset(read_buf, 0, sizeof(read_buf));
 411   bytes_transferred = boost::asio::read(s, buffers,
 412       boost::asio::transfer_at_least(1));
 413   BOOST_ASIO_CHECK(bytes_transferred == 1);
 414   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 415
 416   s.reset(read_data, sizeof(read_data));
 417   s.next_read_length(10);
 418   memset(read_buf, 0, sizeof(read_buf));
 419   bytes_transferred = boost::asio::read(s, buffers,
 420       boost::asio::transfer_at_least(1));
 421   BOOST_ASIO_CHECK(bytes_transferred == 10);
 422   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 423
 424   s.reset(read_data, sizeof(read_data));
 425   memset(read_buf, 0, sizeof(read_buf));
 426   bytes_transferred = boost::asio::read(s, buffers,
 427       boost::asio::transfer_at_least(10));
 428   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 429   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 430
 431   s.reset(read_data, sizeof(read_data));
 432   s.next_read_length(1);
 433   memset(read_buf, 0, sizeof(read_buf));
 434   bytes_transferred = boost::asio::read(s, buffers,
 435       boost::asio::transfer_at_least(10));
 436   BOOST_ASIO_CHECK(bytes_transferred == 10);
 437   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 438
 439   s.reset(read_data, sizeof(read_data));
 440   s.next_read_length(10);
 441   memset(read_buf, 0, sizeof(read_buf));
 442   bytes_transferred = boost::asio::read(s, buffers,
 443       boost::asio::transfer_at_least(10));
 444   BOOST_ASIO_CHECK(bytes_transferred == 10);
 445   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 446
 447   s.reset(read_data, sizeof(read_data));
 448   memset(read_buf, 0, sizeof(read_buf));
 449   bytes_transferred = boost::asio::read(s, buffers,
 450       boost::asio::transfer_at_least(42));
 451   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 452   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 453
 454   s.reset(read_data, sizeof(read_data));
 455   s.next_read_length(1);
 456   memset(read_buf, 0, sizeof(read_buf));
 457   bytes_transferred = boost::asio::read(s, buffers,
 458       boost::asio::transfer_at_least(42));
 459   BOOST_ASIO_CHECK(bytes_transferred == 42);
 460   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 461
 462   s.reset(read_data, sizeof(read_data));
 463   s.next_read_length(10);
 464   memset(read_buf, 0, sizeof(read_buf));
 465   bytes_transferred = boost::asio::read(s, buffers,
 466       boost::asio::transfer_at_least(42));
 467   BOOST_ASIO_CHECK(bytes_transferred == 50);
 468   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
 469
 470   s.reset(read_data, sizeof(read_data));
 471   memset(read_buf, 0, sizeof(read_buf));
 472   bytes_transferred = boost::asio::read(s, buffers,
 473       boost::asio::transfer_exactly(1));
 474   BOOST_ASIO_CHECK(bytes_transferred == 1);
 475   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 476
 477   s.reset(read_data, sizeof(read_data));
 478   s.next_read_length(1);
 479   memset(read_buf, 0, sizeof(read_buf));
 480   bytes_transferred = boost::asio::read(s, buffers,
 481       boost::asio::transfer_exactly(1));
 482   BOOST_ASIO_CHECK(bytes_transferred == 1);
 483   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 484
 485   s.reset(read_data, sizeof(read_data));
 486   s.next_read_length(10);
 487   memset(read_buf, 0, sizeof(read_buf));
 488   bytes_transferred = boost::asio::read(s, buffers,
 489       boost::asio::transfer_exactly(1));
 490   BOOST_ASIO_CHECK(bytes_transferred == 1);
 491   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 492
 493   s.reset(read_data, sizeof(read_data));
 494   memset(read_buf, 0, sizeof(read_buf));
 495   bytes_transferred = boost::asio::read(s, buffers,
 496       boost::asio::transfer_exactly(10));
 497   BOOST_ASIO_CHECK(bytes_transferred == 10);
 498   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 499
 500   s.reset(read_data, sizeof(read_data));
 501   s.next_read_length(1);
 502   memset(read_buf, 0, sizeof(read_buf));
 503   bytes_transferred = boost::asio::read(s, buffers,
 504       boost::asio::transfer_exactly(10));
 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   s.next_read_length(10);
 510   memset(read_buf, 0, sizeof(read_buf));
 511   bytes_transferred = boost::asio::read(s, buffers,
 512       boost::asio::transfer_exactly(10));
 513   BOOST_ASIO_CHECK(bytes_transferred == 10);
 514   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 515
 516   s.reset(read_data, sizeof(read_data));
 517   memset(read_buf, 0, sizeof(read_buf));
 518   bytes_transferred = boost::asio::read(s, buffers,
 519       boost::asio::transfer_exactly(42));
 520   BOOST_ASIO_CHECK(bytes_transferred == 42);
 521   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 522
 523   s.reset(read_data, sizeof(read_data));
 524   s.next_read_length(1);
 525   memset(read_buf, 0, sizeof(read_buf));
 526   bytes_transferred = boost::asio::read(s, buffers,
 527       boost::asio::transfer_exactly(42));
 528   BOOST_ASIO_CHECK(bytes_transferred == 42);
 529   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 530
 531   s.reset(read_data, sizeof(read_data));
 532   s.next_read_length(10);
 533   memset(read_buf, 0, sizeof(read_buf));
 534   bytes_transferred = boost::asio::read(s, buffers,
 535       boost::asio::transfer_exactly(42));
 536   BOOST_ASIO_CHECK(bytes_transferred == 42);
 537   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 538
 539   s.reset(read_data, sizeof(read_data));
 540   memset(read_buf, 0, sizeof(read_buf));
 541   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 542   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 543   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 544
 545   s.reset(read_data, sizeof(read_data));
 546   s.next_read_length(1);
 547   memset(read_buf, 0, sizeof(read_buf));
 548   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 549   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 550   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 551
 552   s.reset(read_data, sizeof(read_data));
 553   s.next_read_length(10);
 554   memset(read_buf, 0, sizeof(read_buf));
 555   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 556   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 557   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 558
 559   s.reset(read_data, sizeof(read_data));
 560   memset(read_buf, 0, sizeof(read_buf));
 561   bytes_transferred = boost::asio::read(s, buffers, short_transfer);
 562   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 563   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 564
 565   s.reset(read_data, sizeof(read_data));
 566   s.next_read_length(1);
 567   memset(read_buf, 0, sizeof(read_buf));
 568   bytes_transferred = boost::asio::read(s, buffers, short_transfer);
 569   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 570   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 571
 572   s.reset(read_data, sizeof(read_data));
 573   s.next_read_length(10);
 574   memset(read_buf, 0, sizeof(read_buf));
 575   bytes_transferred = boost::asio::read(s, buffers, short_transfer);
 576   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 577   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 578 }
 579
 580 void test_3_arg_vector_buffers_read()
 581 {
 582   boost::asio::io_context ioc;
 583   test_stream s(ioc);
 584   char read_buf[sizeof(read_data)];
 585   std::vector<boost::asio::mutable_buffer> buffers;
 586   buffers.push_back(boost::asio::buffer(read_buf, 32));
 587   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
 588   buffers.push_back(boost::asio::buffer(read_buf) + 39);
 589
 590   s.reset(read_data, sizeof(read_data));
 591   memset(read_buf, 0, sizeof(read_buf));
 592   size_t bytes_transferred = boost::asio::read(s, buffers,
 593       boost::asio::transfer_all());
 594   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 595   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 596
 597   s.reset(read_data, sizeof(read_data));
 598   s.next_read_length(1);
 599   memset(read_buf, 0, sizeof(read_buf));
 600   bytes_transferred = boost::asio::read(s, buffers,
 601       boost::asio::transfer_all());
 602   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 603   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 604
 605   s.reset(read_data, sizeof(read_data));
 606   s.next_read_length(10);
 607   memset(read_buf, 0, sizeof(read_buf));
 608   bytes_transferred = boost::asio::read(s, buffers,
 609       boost::asio::transfer_all());
 610   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 611   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 612
 613   s.reset(read_data, sizeof(read_data));
 614   memset(read_buf, 0, sizeof(read_buf));
 615   bytes_transferred = boost::asio::read(s, buffers,
 616       boost::asio::transfer_at_least(1));
 617   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 618   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 619
 620   s.reset(read_data, sizeof(read_data));
 621   s.next_read_length(1);
 622   memset(read_buf, 0, sizeof(read_buf));
 623   bytes_transferred = boost::asio::read(s, buffers,
 624       boost::asio::transfer_at_least(1));
 625   BOOST_ASIO_CHECK(bytes_transferred == 1);
 626   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 627
 628   s.reset(read_data, sizeof(read_data));
 629   s.next_read_length(10);
 630   memset(read_buf, 0, sizeof(read_buf));
 631   bytes_transferred = boost::asio::read(s, buffers,
 632       boost::asio::transfer_at_least(1));
 633   BOOST_ASIO_CHECK(bytes_transferred == 10);
 634   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 635
 636   s.reset(read_data, sizeof(read_data));
 637   memset(read_buf, 0, sizeof(read_buf));
 638   bytes_transferred = boost::asio::read(s, buffers,
 639       boost::asio::transfer_at_least(10));
 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   s.next_read_length(1);
 645   memset(read_buf, 0, sizeof(read_buf));
 646   bytes_transferred = boost::asio::read(s, buffers,
 647       boost::asio::transfer_at_least(10));
 648   BOOST_ASIO_CHECK(bytes_transferred == 10);
 649   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 650
 651   s.reset(read_data, sizeof(read_data));
 652   s.next_read_length(10);
 653   memset(read_buf, 0, sizeof(read_buf));
 654   bytes_transferred = boost::asio::read(s, buffers,
 655       boost::asio::transfer_at_least(10));
 656   BOOST_ASIO_CHECK(bytes_transferred == 10);
 657   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 658
 659   s.reset(read_data, sizeof(read_data));
 660   memset(read_buf, 0, sizeof(read_buf));
 661   bytes_transferred = boost::asio::read(s, buffers,
 662       boost::asio::transfer_at_least(42));
 663   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 664   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 665
 666   s.reset(read_data, sizeof(read_data));
 667   s.next_read_length(1);
 668   memset(read_buf, 0, sizeof(read_buf));
 669   bytes_transferred = boost::asio::read(s, buffers,
 670       boost::asio::transfer_at_least(42));
 671   BOOST_ASIO_CHECK(bytes_transferred == 42);
 672   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 673
 674   s.reset(read_data, sizeof(read_data));
 675   s.next_read_length(10);
 676   memset(read_buf, 0, sizeof(read_buf));
 677   bytes_transferred = boost::asio::read(s, buffers,
 678       boost::asio::transfer_at_least(42));
 679   BOOST_ASIO_CHECK(bytes_transferred == 50);
 680   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
 681
 682   s.reset(read_data, sizeof(read_data));
 683   memset(read_buf, 0, sizeof(read_buf));
 684   bytes_transferred = boost::asio::read(s, buffers,
 685       boost::asio::transfer_exactly(1));
 686   BOOST_ASIO_CHECK(bytes_transferred == 1);
 687   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 688
 689   s.reset(read_data, sizeof(read_data));
 690   s.next_read_length(1);
 691   memset(read_buf, 0, sizeof(read_buf));
 692   bytes_transferred = boost::asio::read(s, buffers,
 693       boost::asio::transfer_exactly(1));
 694   BOOST_ASIO_CHECK(bytes_transferred == 1);
 695   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 696
 697   s.reset(read_data, sizeof(read_data));
 698   s.next_read_length(10);
 699   memset(read_buf, 0, sizeof(read_buf));
 700   bytes_transferred = boost::asio::read(s, buffers,
 701       boost::asio::transfer_exactly(1));
 702   BOOST_ASIO_CHECK(bytes_transferred == 1);
 703   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
 704
 705   s.reset(read_data, sizeof(read_data));
 706   memset(read_buf, 0, sizeof(read_buf));
 707   bytes_transferred = boost::asio::read(s, buffers,
 708       boost::asio::transfer_exactly(10));
 709   BOOST_ASIO_CHECK(bytes_transferred == 10);
 710   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 711
 712   s.reset(read_data, sizeof(read_data));
 713   s.next_read_length(1);
 714   memset(read_buf, 0, sizeof(read_buf));
 715   bytes_transferred = boost::asio::read(s, buffers,
 716       boost::asio::transfer_exactly(10));
 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   s.next_read_length(10);
 722   memset(read_buf, 0, sizeof(read_buf));
 723   bytes_transferred = boost::asio::read(s, buffers,
 724       boost::asio::transfer_exactly(10));
 725   BOOST_ASIO_CHECK(bytes_transferred == 10);
 726   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
 727
 728   s.reset(read_data, sizeof(read_data));
 729   memset(read_buf, 0, sizeof(read_buf));
 730   bytes_transferred = boost::asio::read(s, buffers,
 731       boost::asio::transfer_exactly(42));
 732   BOOST_ASIO_CHECK(bytes_transferred == 42);
 733   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 734
 735   s.reset(read_data, sizeof(read_data));
 736   s.next_read_length(1);
 737   memset(read_buf, 0, sizeof(read_buf));
 738   bytes_transferred = boost::asio::read(s, buffers,
 739       boost::asio::transfer_exactly(42));
 740   BOOST_ASIO_CHECK(bytes_transferred == 42);
 741   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 742
 743   s.reset(read_data, sizeof(read_data));
 744   s.next_read_length(10);
 745   memset(read_buf, 0, sizeof(read_buf));
 746   bytes_transferred = boost::asio::read(s, buffers,
 747       boost::asio::transfer_exactly(42));
 748   BOOST_ASIO_CHECK(bytes_transferred == 42);
 749   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
 750
 751   s.reset(read_data, sizeof(read_data));
 752   memset(read_buf, 0, sizeof(read_buf));
 753   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 754   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 755   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 756
 757   s.reset(read_data, sizeof(read_data));
 758   s.next_read_length(1);
 759   memset(read_buf, 0, sizeof(read_buf));
 760   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 761   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 762   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 763
 764   s.reset(read_data, sizeof(read_data));
 765   s.next_read_length(10);
 766   memset(read_buf, 0, sizeof(read_buf));
 767   bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
 768   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 769   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 770
 771   s.reset(read_data, sizeof(read_data));
 772   memset(read_buf, 0, sizeof(read_buf));
 773   bytes_transferred = boost::asio::read(s, buffers, short_transfer);
 774   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 775   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 776
 777   s.reset(read_data, sizeof(read_data));
 778   s.next_read_length(1);
 779   memset(read_buf, 0, sizeof(read_buf));
 780   bytes_transferred = boost::asio::read(s, buffers, short_transfer);
 781   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 782   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 783
 784   s.reset(read_data, sizeof(read_data));
 785   s.next_read_length(10);
 786   memset(read_buf, 0, sizeof(read_buf));
 787   bytes_transferred = boost::asio::read(s, buffers, short_transfer);
 788   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 789   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
 790 }
 791
 792 void test_3_arg_streambuf_read()
 793 {
 794   boost::asio::io_context ioc;
 795   test_stream s(ioc);
 796   boost::asio::streambuf sb(sizeof(read_data));
 797
 798   s.reset(read_data, sizeof(read_data));
 799   sb.consume(sb.size());
 800   size_t bytes_transferred = boost::asio::read(s, sb,
 801       boost::asio::transfer_all());
 802   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 803   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 804   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 805
 806   s.reset(read_data, sizeof(read_data));
 807   s.next_read_length(1);
 808   sb.consume(sb.size());
 809   bytes_transferred = boost::asio::read(s, sb,
 810       boost::asio::transfer_all());
 811   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 812   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 813   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 814
 815   s.reset(read_data, sizeof(read_data));
 816   s.next_read_length(10);
 817   sb.consume(sb.size());
 818   bytes_transferred = boost::asio::read(s, sb,
 819       boost::asio::transfer_all());
 820   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 821   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 822   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 823
 824   s.reset(read_data, sizeof(read_data));
 825   sb.consume(sb.size());
 826   bytes_transferred = boost::asio::read(s, sb,
 827       boost::asio::transfer_at_least(1));
 828   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 829   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 830   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 831
 832   s.reset(read_data, sizeof(read_data));
 833   s.next_read_length(1);
 834   sb.consume(sb.size());
 835   bytes_transferred = boost::asio::read(s, sb,
 836       boost::asio::transfer_at_least(1));
 837   BOOST_ASIO_CHECK(bytes_transferred == 1);
 838   BOOST_ASIO_CHECK(sb.size() == 1);
 839   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
 840
 841   s.reset(read_data, sizeof(read_data));
 842   s.next_read_length(10);
 843   sb.consume(sb.size());
 844   bytes_transferred = boost::asio::read(s, sb,
 845       boost::asio::transfer_at_least(1));
 846   BOOST_ASIO_CHECK(bytes_transferred == 10);
 847   BOOST_ASIO_CHECK(sb.size() == 10);
 848   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
 849
 850   s.reset(read_data, sizeof(read_data));
 851   sb.consume(sb.size());
 852   bytes_transferred = boost::asio::read(s, sb,
 853       boost::asio::transfer_at_least(10));
 854   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 855   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 856   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 857
 858   s.reset(read_data, sizeof(read_data));
 859   s.next_read_length(1);
 860   sb.consume(sb.size());
 861   bytes_transferred = boost::asio::read(s, sb,
 862       boost::asio::transfer_at_least(10));
 863   BOOST_ASIO_CHECK(bytes_transferred == 10);
 864   BOOST_ASIO_CHECK(sb.size() == 10);
 865   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
 866
 867   s.reset(read_data, sizeof(read_data));
 868   s.next_read_length(10);
 869   sb.consume(sb.size());
 870   bytes_transferred = boost::asio::read(s, sb,
 871       boost::asio::transfer_at_least(10));
 872   BOOST_ASIO_CHECK(bytes_transferred == 10);
 873   BOOST_ASIO_CHECK(sb.size() == 10);
 874   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
 875
 876   s.reset(read_data, sizeof(read_data));
 877   sb.consume(sb.size());
 878   bytes_transferred = boost::asio::read(s, sb,
 879       boost::asio::transfer_at_least(42));
 880   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 881   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 882   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 883
 884   s.reset(read_data, sizeof(read_data));
 885   s.next_read_length(1);
 886   sb.consume(sb.size());
 887   bytes_transferred = boost::asio::read(s, sb,
 888       boost::asio::transfer_at_least(42));
 889   BOOST_ASIO_CHECK(bytes_transferred == 42);
 890   BOOST_ASIO_CHECK(sb.size() == 42);
 891   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
 892
 893   s.reset(read_data, sizeof(read_data));
 894   s.next_read_length(10);
 895   sb.consume(sb.size());
 896   bytes_transferred = boost::asio::read(s, sb,
 897       boost::asio::transfer_at_least(42));
 898   BOOST_ASIO_CHECK(bytes_transferred == 50);
 899   BOOST_ASIO_CHECK(sb.size() == 50);
 900   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
 901
 902   s.reset(read_data, sizeof(read_data));
 903   sb.consume(sb.size());
 904   bytes_transferred = boost::asio::read(s, sb,
 905       boost::asio::transfer_exactly(1));
 906   BOOST_ASIO_CHECK(bytes_transferred == 1);
 907   BOOST_ASIO_CHECK(sb.size() == 1);
 908   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
 909
 910   s.reset(read_data, sizeof(read_data));
 911   s.next_read_length(1);
 912   sb.consume(sb.size());
 913   bytes_transferred = boost::asio::read(s, sb,
 914       boost::asio::transfer_exactly(1));
 915   BOOST_ASIO_CHECK(bytes_transferred == 1);
 916   BOOST_ASIO_CHECK(sb.size() == 1);
 917   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
 918
 919   s.reset(read_data, sizeof(read_data));
 920   s.next_read_length(10);
 921   sb.consume(sb.size());
 922   bytes_transferred = boost::asio::read(s, sb,
 923       boost::asio::transfer_exactly(1));
 924   BOOST_ASIO_CHECK(bytes_transferred == 1);
 925   BOOST_ASIO_CHECK(sb.size() == 1);
 926   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
 927
 928   s.reset(read_data, sizeof(read_data));
 929   sb.consume(sb.size());
 930   bytes_transferred = boost::asio::read(s, sb,
 931       boost::asio::transfer_exactly(10));
 932   BOOST_ASIO_CHECK(bytes_transferred == 10);
 933   BOOST_ASIO_CHECK(sb.size() == 10);
 934   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
 935
 936   s.reset(read_data, sizeof(read_data));
 937   s.next_read_length(1);
 938   sb.consume(sb.size());
 939   bytes_transferred = boost::asio::read(s, sb,
 940       boost::asio::transfer_exactly(10));
 941   BOOST_ASIO_CHECK(bytes_transferred == 10);
 942   BOOST_ASIO_CHECK(sb.size() == 10);
 943   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
 944
 945   s.reset(read_data, sizeof(read_data));
 946   s.next_read_length(10);
 947   sb.consume(sb.size());
 948   bytes_transferred = boost::asio::read(s, sb,
 949       boost::asio::transfer_exactly(10));
 950   BOOST_ASIO_CHECK(bytes_transferred == 10);
 951   BOOST_ASIO_CHECK(sb.size() == 10);
 952   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
 953
 954   s.reset(read_data, sizeof(read_data));
 955   sb.consume(sb.size());
 956   bytes_transferred = boost::asio::read(s, sb,
 957       boost::asio::transfer_exactly(42));
 958   BOOST_ASIO_CHECK(bytes_transferred == 42);
 959   BOOST_ASIO_CHECK(sb.size() == 42);
 960   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
 961
 962   s.reset(read_data, sizeof(read_data));
 963   s.next_read_length(1);
 964   sb.consume(sb.size());
 965   bytes_transferred = boost::asio::read(s, sb,
 966       boost::asio::transfer_exactly(42));
 967   BOOST_ASIO_CHECK(bytes_transferred == 42);
 968   BOOST_ASIO_CHECK(sb.size() == 42);
 969   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
 970
 971   s.reset(read_data, sizeof(read_data));
 972   s.next_read_length(10);
 973   sb.consume(sb.size());
 974   bytes_transferred = boost::asio::read(s, sb,
 975       boost::asio::transfer_exactly(42));
 976   BOOST_ASIO_CHECK(bytes_transferred == 42);
 977   BOOST_ASIO_CHECK(sb.size() == 42);
 978   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
 979
 980   s.reset(read_data, sizeof(read_data));
 981   sb.consume(sb.size());
 982   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
 983   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 984   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 985   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 986
 987   s.reset(read_data, sizeof(read_data));
 988   s.next_read_length(1);
 989   sb.consume(sb.size());
 990   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
 991   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 992   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 993   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
 994
 995   s.reset(read_data, sizeof(read_data));
 996   s.next_read_length(10);
 997   sb.consume(sb.size());
 998   bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
 999   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1000   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1001   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1002
1003   s.reset(read_data, sizeof(read_data));
1004   sb.consume(sb.size());
1005   bytes_transferred = boost::asio::read(s, sb, short_transfer);
1006   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1007   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1008   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1009
1010   s.reset(read_data, sizeof(read_data));
1011   s.next_read_length(1);
1012   sb.consume(sb.size());
1013   bytes_transferred = boost::asio::read(s, sb, short_transfer);
1014   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1015   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1016   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1017
1018   s.reset(read_data, sizeof(read_data));
1019   s.next_read_length(10);
1020   sb.consume(sb.size());
1021   bytes_transferred = boost::asio::read(s, sb, short_transfer);
1022   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1023   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1024   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1025 }
1026
1027 void test_4_arg_mutable_buffer_read()
1028 {
1029   boost::asio::io_context ioc;
1030   test_stream s(ioc);
1031   char read_buf[sizeof(read_data)];
1032   boost::asio::mutable_buffer buffers
1033     = boost::asio::buffer(read_buf, sizeof(read_buf));
1034
1035   s.reset(read_data, sizeof(read_data));
1036   memset(read_buf, 0, sizeof(read_buf));
1037   boost::system::error_code error;
1038   size_t bytes_transferred = boost::asio::read(s, buffers,
1039       boost::asio::transfer_all(), error);
1040   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1041   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1042   BOOST_ASIO_CHECK(!error);
1043
1044   s.reset(read_data, sizeof(read_data));
1045   s.next_read_length(1);
1046   memset(read_buf, 0, sizeof(read_buf));
1047   error = boost::system::error_code();
1048   bytes_transferred = boost::asio::read(s, buffers,
1049       boost::asio::transfer_all(), error);
1050   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1051   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1052   BOOST_ASIO_CHECK(!error);
1053
1054   s.reset(read_data, sizeof(read_data));
1055   s.next_read_length(10);
1056   memset(read_buf, 0, sizeof(read_buf));
1057   error = boost::system::error_code();
1058   bytes_transferred = boost::asio::read(s, buffers,
1059       boost::asio::transfer_all(), error);
1060   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1061   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1062   BOOST_ASIO_CHECK(!error);
1063
1064   s.reset(read_data, sizeof(read_data));
1065   memset(read_buf, 0, sizeof(read_buf));
1066   error = boost::system::error_code();
1067   bytes_transferred = boost::asio::read(s, buffers,
1068       boost::asio::transfer_at_least(1), error);
1069   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1070   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1071   BOOST_ASIO_CHECK(!error);
1072
1073   s.reset(read_data, sizeof(read_data));
1074   s.next_read_length(1);
1075   memset(read_buf, 0, sizeof(read_buf));
1076   error = boost::system::error_code();
1077   bytes_transferred = boost::asio::read(s, buffers,
1078       boost::asio::transfer_at_least(1), error);
1079   BOOST_ASIO_CHECK(bytes_transferred == 1);
1080   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1081   BOOST_ASIO_CHECK(!error);
1082
1083   s.reset(read_data, sizeof(read_data));
1084   s.next_read_length(10);
1085   memset(read_buf, 0, sizeof(read_buf));
1086   error = boost::system::error_code();
1087   bytes_transferred = boost::asio::read(s, buffers,
1088       boost::asio::transfer_at_least(1), error);
1089   BOOST_ASIO_CHECK(bytes_transferred == 10);
1090   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1091   BOOST_ASIO_CHECK(!error);
1092
1093   s.reset(read_data, sizeof(read_data));
1094   memset(read_buf, 0, sizeof(read_buf));
1095   error = boost::system::error_code();
1096   bytes_transferred = boost::asio::read(s, buffers,
1097       boost::asio::transfer_at_least(10), error);
1098   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1099   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1100   BOOST_ASIO_CHECK(!error);
1101
1102   s.reset(read_data, sizeof(read_data));
1103   s.next_read_length(1);
1104   memset(read_buf, 0, sizeof(read_buf));
1105   error = boost::system::error_code();
1106   bytes_transferred = boost::asio::read(s, buffers,
1107       boost::asio::transfer_at_least(10), error);
1108   BOOST_ASIO_CHECK(bytes_transferred == 10);
1109   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1110   BOOST_ASIO_CHECK(!error);
1111
1112   s.reset(read_data, sizeof(read_data));
1113   s.next_read_length(10);
1114   memset(read_buf, 0, sizeof(read_buf));
1115   error = boost::system::error_code();
1116   bytes_transferred = boost::asio::read(s, buffers,
1117       boost::asio::transfer_at_least(10), error);
1118   BOOST_ASIO_CHECK(bytes_transferred == 10);
1119   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1120   BOOST_ASIO_CHECK(!error);
1121
1122   s.reset(read_data, sizeof(read_data));
1123   memset(read_buf, 0, sizeof(read_buf));
1124   error = boost::system::error_code();
1125   bytes_transferred = boost::asio::read(s, buffers,
1126       boost::asio::transfer_at_least(42), error);
1127   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1128   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1129   BOOST_ASIO_CHECK(!error);
1130
1131   s.reset(read_data, sizeof(read_data));
1132   s.next_read_length(1);
1133   memset(read_buf, 0, sizeof(read_buf));
1134   error = boost::system::error_code();
1135   bytes_transferred = boost::asio::read(s, buffers,
1136       boost::asio::transfer_at_least(42), error);
1137   BOOST_ASIO_CHECK(bytes_transferred == 42);
1138   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1139   BOOST_ASIO_CHECK(!error);
1140
1141   s.reset(read_data, sizeof(read_data));
1142   s.next_read_length(10);
1143   memset(read_buf, 0, sizeof(read_buf));
1144   error = boost::system::error_code();
1145   bytes_transferred = boost::asio::read(s, buffers,
1146       boost::asio::transfer_at_least(42), error);
1147   BOOST_ASIO_CHECK(bytes_transferred == 50);
1148   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1149   BOOST_ASIO_CHECK(!error);
1150
1151   s.reset(read_data, sizeof(read_data));
1152   memset(read_buf, 0, sizeof(read_buf));
1153   error = boost::system::error_code();
1154   bytes_transferred = boost::asio::read(s, buffers,
1155       boost::asio::transfer_exactly(1), error);
1156   BOOST_ASIO_CHECK(bytes_transferred == 1);
1157   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1158   BOOST_ASIO_CHECK(!error);
1159
1160   s.reset(read_data, sizeof(read_data));
1161   s.next_read_length(1);
1162   memset(read_buf, 0, sizeof(read_buf));
1163   error = boost::system::error_code();
1164   bytes_transferred = boost::asio::read(s, buffers,
1165       boost::asio::transfer_exactly(1), error);
1166   BOOST_ASIO_CHECK(bytes_transferred == 1);
1167   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1168   BOOST_ASIO_CHECK(!error);
1169
1170   s.reset(read_data, sizeof(read_data));
1171   s.next_read_length(10);
1172   memset(read_buf, 0, sizeof(read_buf));
1173   error = boost::system::error_code();
1174   bytes_transferred = boost::asio::read(s, buffers,
1175       boost::asio::transfer_exactly(1), error);
1176   BOOST_ASIO_CHECK(bytes_transferred == 1);
1177   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1178   BOOST_ASIO_CHECK(!error);
1179
1180   s.reset(read_data, sizeof(read_data));
1181   memset(read_buf, 0, sizeof(read_buf));
1182   error = boost::system::error_code();
1183   bytes_transferred = boost::asio::read(s, buffers,
1184       boost::asio::transfer_exactly(10), error);
1185   BOOST_ASIO_CHECK(bytes_transferred == 10);
1186   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1187   BOOST_ASIO_CHECK(!error);
1188
1189   s.reset(read_data, sizeof(read_data));
1190   s.next_read_length(1);
1191   memset(read_buf, 0, sizeof(read_buf));
1192   error = boost::system::error_code();
1193   bytes_transferred = boost::asio::read(s, buffers,
1194       boost::asio::transfer_exactly(10), error);
1195   BOOST_ASIO_CHECK(bytes_transferred == 10);
1196   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1197   BOOST_ASIO_CHECK(!error);
1198
1199   s.reset(read_data, sizeof(read_data));
1200   s.next_read_length(10);
1201   memset(read_buf, 0, sizeof(read_buf));
1202   error = boost::system::error_code();
1203   bytes_transferred = boost::asio::read(s, buffers,
1204       boost::asio::transfer_exactly(10), error);
1205   BOOST_ASIO_CHECK(bytes_transferred == 10);
1206   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1207   BOOST_ASIO_CHECK(!error);
1208
1209   s.reset(read_data, sizeof(read_data));
1210   memset(read_buf, 0, sizeof(read_buf));
1211   error = boost::system::error_code();
1212   bytes_transferred = boost::asio::read(s, buffers,
1213       boost::asio::transfer_exactly(42), error);
1214   BOOST_ASIO_CHECK(bytes_transferred == 42);
1215   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1216   BOOST_ASIO_CHECK(!error);
1217
1218   s.reset(read_data, sizeof(read_data));
1219   s.next_read_length(1);
1220   memset(read_buf, 0, sizeof(read_buf));
1221   error = boost::system::error_code();
1222   bytes_transferred = boost::asio::read(s, buffers,
1223       boost::asio::transfer_exactly(42), error);
1224   BOOST_ASIO_CHECK(bytes_transferred == 42);
1225   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1226   BOOST_ASIO_CHECK(!error);
1227
1228   s.reset(read_data, sizeof(read_data));
1229   s.next_read_length(10);
1230   memset(read_buf, 0, sizeof(read_buf));
1231   error = boost::system::error_code();
1232   bytes_transferred = boost::asio::read(s, buffers,
1233       boost::asio::transfer_exactly(42), error);
1234   BOOST_ASIO_CHECK(bytes_transferred == 42);
1235   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1236   BOOST_ASIO_CHECK(!error);
1237
1238   s.reset(read_data, sizeof(read_data));
1239   memset(read_buf, 0, sizeof(read_buf));
1240   bytes_transferred = boost::asio::read(s, buffers,
1241       old_style_transfer_all, error);
1242   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1243   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1244   BOOST_ASIO_CHECK(!error);
1245
1246   s.reset(read_data, sizeof(read_data));
1247   s.next_read_length(1);
1248   memset(read_buf, 0, sizeof(read_buf));
1249   error = boost::system::error_code();
1250   bytes_transferred = boost::asio::read(s, buffers,
1251       old_style_transfer_all, error);
1252   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1253   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1254   BOOST_ASIO_CHECK(!error);
1255
1256   s.reset(read_data, sizeof(read_data));
1257   s.next_read_length(10);
1258   memset(read_buf, 0, sizeof(read_buf));
1259   error = boost::system::error_code();
1260   bytes_transferred = boost::asio::read(s, buffers,
1261       old_style_transfer_all, error);
1262   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1263   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1264   BOOST_ASIO_CHECK(!error);
1265
1266   s.reset(read_data, sizeof(read_data));
1267   memset(read_buf, 0, sizeof(read_buf));
1268   bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
1269   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1270   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1271   BOOST_ASIO_CHECK(!error);
1272
1273   s.reset(read_data, sizeof(read_data));
1274   s.next_read_length(1);
1275   memset(read_buf, 0, sizeof(read_buf));
1276   error = boost::system::error_code();
1277   bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
1278   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1279   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1280   BOOST_ASIO_CHECK(!error);
1281
1282   s.reset(read_data, sizeof(read_data));
1283   s.next_read_length(10);
1284   memset(read_buf, 0, sizeof(read_buf));
1285   error = boost::system::error_code();
1286   bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
1287   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1288   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1289   BOOST_ASIO_CHECK(!error);
1290 }
1291
1292 void test_4_arg_vector_buffers_read()
1293 {
1294   boost::asio::io_context ioc;
1295   test_stream s(ioc);
1296   char read_buf[sizeof(read_data)];
1297   std::vector<boost::asio::mutable_buffer> buffers;
1298   buffers.push_back(boost::asio::buffer(read_buf, 32));
1299   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
1300   buffers.push_back(boost::asio::buffer(read_buf) + 39);
1301
1302   s.reset(read_data, sizeof(read_data));
1303   memset(read_buf, 0, sizeof(read_buf));
1304   boost::system::error_code error;
1305   size_t bytes_transferred = boost::asio::read(s, buffers,
1306       boost::asio::transfer_all(), error);
1307   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1308   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1309   BOOST_ASIO_CHECK(!error);
1310
1311   s.reset(read_data, sizeof(read_data));
1312   s.next_read_length(1);
1313   memset(read_buf, 0, sizeof(read_buf));
1314   error = boost::system::error_code();
1315   bytes_transferred = boost::asio::read(s, buffers,
1316       boost::asio::transfer_all(), error);
1317   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1318   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1319   BOOST_ASIO_CHECK(!error);
1320
1321   s.reset(read_data, sizeof(read_data));
1322   s.next_read_length(10);
1323   memset(read_buf, 0, sizeof(read_buf));
1324   error = boost::system::error_code();
1325   bytes_transferred = boost::asio::read(s, buffers,
1326       boost::asio::transfer_all(), error);
1327   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1328   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1329   BOOST_ASIO_CHECK(!error);
1330
1331   s.reset(read_data, sizeof(read_data));
1332   memset(read_buf, 0, sizeof(read_buf));
1333   error = boost::system::error_code();
1334   bytes_transferred = boost::asio::read(s, buffers,
1335       boost::asio::transfer_at_least(1), error);
1336   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1337   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1338   BOOST_ASIO_CHECK(!error);
1339
1340   s.reset(read_data, sizeof(read_data));
1341   s.next_read_length(1);
1342   memset(read_buf, 0, sizeof(read_buf));
1343   error = boost::system::error_code();
1344   bytes_transferred = boost::asio::read(s, buffers,
1345       boost::asio::transfer_at_least(1), error);
1346   BOOST_ASIO_CHECK(bytes_transferred == 1);
1347   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1348   BOOST_ASIO_CHECK(!error);
1349
1350   s.reset(read_data, sizeof(read_data));
1351   s.next_read_length(10);
1352   memset(read_buf, 0, sizeof(read_buf));
1353   error = boost::system::error_code();
1354   bytes_transferred = boost::asio::read(s, buffers,
1355       boost::asio::transfer_at_least(1), error);
1356   BOOST_ASIO_CHECK(bytes_transferred == 10);
1357   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1358   BOOST_ASIO_CHECK(!error);
1359
1360   s.reset(read_data, sizeof(read_data));
1361   memset(read_buf, 0, sizeof(read_buf));
1362   error = boost::system::error_code();
1363   bytes_transferred = boost::asio::read(s, buffers,
1364       boost::asio::transfer_at_least(10), error);
1365   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1366   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1367   BOOST_ASIO_CHECK(!error);
1368
1369   s.reset(read_data, sizeof(read_data));
1370   s.next_read_length(1);
1371   memset(read_buf, 0, sizeof(read_buf));
1372   error = boost::system::error_code();
1373   bytes_transferred = boost::asio::read(s, buffers,
1374       boost::asio::transfer_at_least(10), error);
1375   BOOST_ASIO_CHECK(bytes_transferred == 10);
1376   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1377   BOOST_ASIO_CHECK(!error);
1378
1379   s.reset(read_data, sizeof(read_data));
1380   s.next_read_length(10);
1381   memset(read_buf, 0, sizeof(read_buf));
1382   error = boost::system::error_code();
1383   bytes_transferred = boost::asio::read(s, buffers,
1384       boost::asio::transfer_at_least(10), error);
1385   BOOST_ASIO_CHECK(bytes_transferred == 10);
1386   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1387   BOOST_ASIO_CHECK(!error);
1388
1389   s.reset(read_data, sizeof(read_data));
1390   memset(read_buf, 0, sizeof(read_buf));
1391   error = boost::system::error_code();
1392   bytes_transferred = boost::asio::read(s, buffers,
1393       boost::asio::transfer_at_least(42), error);
1394   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1395   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1396   BOOST_ASIO_CHECK(!error);
1397
1398   s.reset(read_data, sizeof(read_data));
1399   s.next_read_length(1);
1400   memset(read_buf, 0, sizeof(read_buf));
1401   error = boost::system::error_code();
1402   bytes_transferred = boost::asio::read(s, buffers,
1403       boost::asio::transfer_at_least(42), error);
1404   BOOST_ASIO_CHECK(bytes_transferred == 42);
1405   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1406   BOOST_ASIO_CHECK(!error);
1407
1408   s.reset(read_data, sizeof(read_data));
1409   s.next_read_length(10);
1410   memset(read_buf, 0, sizeof(read_buf));
1411   error = boost::system::error_code();
1412   bytes_transferred = boost::asio::read(s, buffers,
1413       boost::asio::transfer_at_least(42), error);
1414   BOOST_ASIO_CHECK(bytes_transferred == 50);
1415   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1416   BOOST_ASIO_CHECK(!error);
1417
1418   s.reset(read_data, sizeof(read_data));
1419   memset(read_buf, 0, sizeof(read_buf));
1420   error = boost::system::error_code();
1421   bytes_transferred = boost::asio::read(s, buffers,
1422       boost::asio::transfer_exactly(1), error);
1423   BOOST_ASIO_CHECK(bytes_transferred == 1);
1424   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1425   BOOST_ASIO_CHECK(!error);
1426
1427   s.reset(read_data, sizeof(read_data));
1428   s.next_read_length(1);
1429   memset(read_buf, 0, sizeof(read_buf));
1430   error = boost::system::error_code();
1431   bytes_transferred = boost::asio::read(s, buffers,
1432       boost::asio::transfer_exactly(1), error);
1433   BOOST_ASIO_CHECK(bytes_transferred == 1);
1434   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1435   BOOST_ASIO_CHECK(!error);
1436
1437   s.reset(read_data, sizeof(read_data));
1438   s.next_read_length(10);
1439   memset(read_buf, 0, sizeof(read_buf));
1440   error = boost::system::error_code();
1441   bytes_transferred = boost::asio::read(s, buffers,
1442       boost::asio::transfer_exactly(1), error);
1443   BOOST_ASIO_CHECK(bytes_transferred == 1);
1444   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1445   BOOST_ASIO_CHECK(!error);
1446
1447   s.reset(read_data, sizeof(read_data));
1448   memset(read_buf, 0, sizeof(read_buf));
1449   error = boost::system::error_code();
1450   bytes_transferred = boost::asio::read(s, buffers,
1451       boost::asio::transfer_exactly(10), error);
1452   BOOST_ASIO_CHECK(bytes_transferred == 10);
1453   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1454   BOOST_ASIO_CHECK(!error);
1455
1456   s.reset(read_data, sizeof(read_data));
1457   s.next_read_length(1);
1458   memset(read_buf, 0, sizeof(read_buf));
1459   error = boost::system::error_code();
1460   bytes_transferred = boost::asio::read(s, buffers,
1461       boost::asio::transfer_exactly(10), error);
1462   BOOST_ASIO_CHECK(bytes_transferred == 10);
1463   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1464   BOOST_ASIO_CHECK(!error);
1465
1466   s.reset(read_data, sizeof(read_data));
1467   s.next_read_length(10);
1468   memset(read_buf, 0, sizeof(read_buf));
1469   error = boost::system::error_code();
1470   bytes_transferred = boost::asio::read(s, buffers,
1471       boost::asio::transfer_exactly(10), error);
1472   BOOST_ASIO_CHECK(bytes_transferred == 10);
1473   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1474   BOOST_ASIO_CHECK(!error);
1475
1476   s.reset(read_data, sizeof(read_data));
1477   memset(read_buf, 0, sizeof(read_buf));
1478   error = boost::system::error_code();
1479   bytes_transferred = boost::asio::read(s, buffers,
1480       boost::asio::transfer_exactly(42), error);
1481   BOOST_ASIO_CHECK(bytes_transferred == 42);
1482   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1483   BOOST_ASIO_CHECK(!error);
1484
1485   s.reset(read_data, sizeof(read_data));
1486   s.next_read_length(1);
1487   memset(read_buf, 0, sizeof(read_buf));
1488   error = boost::system::error_code();
1489   bytes_transferred = boost::asio::read(s, buffers,
1490       boost::asio::transfer_exactly(42), error);
1491   BOOST_ASIO_CHECK(bytes_transferred == 42);
1492   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1493   BOOST_ASIO_CHECK(!error);
1494
1495   s.reset(read_data, sizeof(read_data));
1496   s.next_read_length(10);
1497   memset(read_buf, 0, sizeof(read_buf));
1498   error = boost::system::error_code();
1499   bytes_transferred = boost::asio::read(s, buffers,
1500       boost::asio::transfer_exactly(42), error);
1501   BOOST_ASIO_CHECK(bytes_transferred == 42);
1502   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1503   BOOST_ASIO_CHECK(!error);
1504
1505   s.reset(read_data, sizeof(read_data));
1506   memset(read_buf, 0, sizeof(read_buf));
1507   bytes_transferred = boost::asio::read(s, buffers,
1508       old_style_transfer_all, error);
1509   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1510   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
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       old_style_transfer_all, error);
1519   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1520   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
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       old_style_transfer_all, error);
1529   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1530   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1531   BOOST_ASIO_CHECK(!error);
1532
1533   s.reset(read_data, sizeof(read_data));
1534   memset(read_buf, 0, sizeof(read_buf));
1535   bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
1536   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1537   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1538   BOOST_ASIO_CHECK(!error);
1539
1540   s.reset(read_data, sizeof(read_data));
1541   s.next_read_length(1);
1542   memset(read_buf, 0, sizeof(read_buf));
1543   error = boost::system::error_code();
1544   bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
1545   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1546   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1547   BOOST_ASIO_CHECK(!error);
1548
1549   s.reset(read_data, sizeof(read_data));
1550   s.next_read_length(10);
1551   memset(read_buf, 0, sizeof(read_buf));
1552   error = boost::system::error_code();
1553   bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
1554   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1555   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1556   BOOST_ASIO_CHECK(!error);
1557 }
1558
1559 void test_4_arg_streambuf_read()
1560 {
1561   boost::asio::io_context ioc;
1562   test_stream s(ioc);
1563   boost::asio::streambuf sb(sizeof(read_data));
1564
1565   s.reset(read_data, sizeof(read_data));
1566   sb.consume(sb.size());
1567   boost::system::error_code error;
1568   size_t bytes_transferred = boost::asio::read(s, sb,
1569       boost::asio::transfer_all(), error);
1570   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1571   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1572   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1573   BOOST_ASIO_CHECK(!error);
1574
1575   s.reset(read_data, sizeof(read_data));
1576   s.next_read_length(1);
1577   sb.consume(sb.size());
1578   error = boost::system::error_code();
1579   bytes_transferred = boost::asio::read(s, sb,
1580       boost::asio::transfer_all(), error);
1581   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1582   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1583   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1584   BOOST_ASIO_CHECK(!error);
1585
1586   s.reset(read_data, sizeof(read_data));
1587   s.next_read_length(10);
1588   sb.consume(sb.size());
1589   error = boost::system::error_code();
1590   bytes_transferred = boost::asio::read(s, sb,
1591       boost::asio::transfer_all(), error);
1592   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1593   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1594   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1595   BOOST_ASIO_CHECK(!error);
1596
1597   s.reset(read_data, sizeof(read_data));
1598   sb.consume(sb.size());
1599   error = boost::system::error_code();
1600   bytes_transferred = boost::asio::read(s, sb,
1601       boost::asio::transfer_at_least(1), error);
1602   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1603   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1604   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1605   BOOST_ASIO_CHECK(!error);
1606
1607   s.reset(read_data, sizeof(read_data));
1608   s.next_read_length(1);
1609   sb.consume(sb.size());
1610   error = boost::system::error_code();
1611   bytes_transferred = boost::asio::read(s, sb,
1612       boost::asio::transfer_at_least(1), error);
1613   BOOST_ASIO_CHECK(bytes_transferred == 1);
1614   BOOST_ASIO_CHECK(sb.size() == 1);
1615   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1616   BOOST_ASIO_CHECK(!error);
1617
1618   s.reset(read_data, sizeof(read_data));
1619   s.next_read_length(10);
1620   sb.consume(sb.size());
1621   error = boost::system::error_code();
1622   bytes_transferred = boost::asio::read(s, sb,
1623       boost::asio::transfer_at_least(1), error);
1624   BOOST_ASIO_CHECK(bytes_transferred == 10);
1625   BOOST_ASIO_CHECK(sb.size() == 10);
1626   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1627   BOOST_ASIO_CHECK(!error);
1628
1629   s.reset(read_data, sizeof(read_data));
1630   sb.consume(sb.size());
1631   error = boost::system::error_code();
1632   bytes_transferred = boost::asio::read(s, sb,
1633       boost::asio::transfer_at_least(10), error);
1634   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1635   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1636   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1637   BOOST_ASIO_CHECK(!error);
1638
1639   s.reset(read_data, sizeof(read_data));
1640   s.next_read_length(1);
1641   sb.consume(sb.size());
1642   error = boost::system::error_code();
1643   bytes_transferred = boost::asio::read(s, sb,
1644       boost::asio::transfer_at_least(10), error);
1645   BOOST_ASIO_CHECK(bytes_transferred == 10);
1646   BOOST_ASIO_CHECK(sb.size() == 10);
1647   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1648   BOOST_ASIO_CHECK(!error);
1649
1650   s.reset(read_data, sizeof(read_data));
1651   s.next_read_length(10);
1652   sb.consume(sb.size());
1653   error = boost::system::error_code();
1654   bytes_transferred = boost::asio::read(s, sb,
1655       boost::asio::transfer_at_least(10), error);
1656   BOOST_ASIO_CHECK(bytes_transferred == 10);
1657   BOOST_ASIO_CHECK(sb.size() == 10);
1658   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1659   BOOST_ASIO_CHECK(!error);
1660
1661   s.reset(read_data, sizeof(read_data));
1662   sb.consume(sb.size());
1663   error = boost::system::error_code();
1664   bytes_transferred = boost::asio::read(s, sb,
1665       boost::asio::transfer_at_least(42), error);
1666   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1667   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1668   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1669   BOOST_ASIO_CHECK(!error);
1670
1671   s.reset(read_data, sizeof(read_data));
1672   s.next_read_length(1);
1673   sb.consume(sb.size());
1674   error = boost::system::error_code();
1675   bytes_transferred = boost::asio::read(s, sb,
1676       boost::asio::transfer_at_least(42), error);
1677   BOOST_ASIO_CHECK(bytes_transferred == 42);
1678   BOOST_ASIO_CHECK(sb.size() == 42);
1679   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1680   BOOST_ASIO_CHECK(!error);
1681
1682   s.reset(read_data, sizeof(read_data));
1683   s.next_read_length(10);
1684   sb.consume(sb.size());
1685   error = boost::system::error_code();
1686   bytes_transferred = boost::asio::read(s, sb,
1687       boost::asio::transfer_at_least(42), error);
1688   BOOST_ASIO_CHECK(bytes_transferred == 50);
1689   BOOST_ASIO_CHECK(sb.size() == 50);
1690   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
1691   BOOST_ASIO_CHECK(!error);
1692
1693   s.reset(read_data, sizeof(read_data));
1694   sb.consume(sb.size());
1695   error = boost::system::error_code();
1696   bytes_transferred = boost::asio::read(s, sb,
1697       boost::asio::transfer_exactly(1), error);
1698   BOOST_ASIO_CHECK(bytes_transferred == 1);
1699   BOOST_ASIO_CHECK(sb.size() == 1);
1700   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1701   BOOST_ASIO_CHECK(!error);
1702
1703   s.reset(read_data, sizeof(read_data));
1704   s.next_read_length(1);
1705   sb.consume(sb.size());
1706   error = boost::system::error_code();
1707   bytes_transferred = boost::asio::read(s, sb,
1708       boost::asio::transfer_exactly(1), error);
1709   BOOST_ASIO_CHECK(bytes_transferred == 1);
1710   BOOST_ASIO_CHECK(sb.size() == 1);
1711   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1712   BOOST_ASIO_CHECK(!error);
1713
1714   s.reset(read_data, sizeof(read_data));
1715   s.next_read_length(10);
1716   sb.consume(sb.size());
1717   error = boost::system::error_code();
1718   bytes_transferred = boost::asio::read(s, sb,
1719       boost::asio::transfer_exactly(1), error);
1720   BOOST_ASIO_CHECK(bytes_transferred == 1);
1721   BOOST_ASIO_CHECK(sb.size() == 1);
1722   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1723   BOOST_ASIO_CHECK(!error);
1724
1725   s.reset(read_data, sizeof(read_data));
1726   sb.consume(sb.size());
1727   error = boost::system::error_code();
1728   bytes_transferred = boost::asio::read(s, sb,
1729       boost::asio::transfer_exactly(10), error);
1730   BOOST_ASIO_CHECK(bytes_transferred == 10);
1731   BOOST_ASIO_CHECK(sb.size() == 10);
1732   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1733   BOOST_ASIO_CHECK(!error);
1734
1735   s.reset(read_data, sizeof(read_data));
1736   s.next_read_length(1);
1737   sb.consume(sb.size());
1738   error = boost::system::error_code();
1739   bytes_transferred = boost::asio::read(s, sb,
1740       boost::asio::transfer_exactly(10), error);
1741   BOOST_ASIO_CHECK(bytes_transferred == 10);
1742   BOOST_ASIO_CHECK(sb.size() == 10);
1743   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1744   BOOST_ASIO_CHECK(!error);
1745
1746   s.reset(read_data, sizeof(read_data));
1747   s.next_read_length(10);
1748   sb.consume(sb.size());
1749   error = boost::system::error_code();
1750   bytes_transferred = boost::asio::read(s, sb,
1751       boost::asio::transfer_exactly(10), error);
1752   BOOST_ASIO_CHECK(bytes_transferred == 10);
1753   BOOST_ASIO_CHECK(sb.size() == 10);
1754   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1755   BOOST_ASIO_CHECK(!error);
1756
1757   s.reset(read_data, sizeof(read_data));
1758   sb.consume(sb.size());
1759   error = boost::system::error_code();
1760   bytes_transferred = boost::asio::read(s, sb,
1761       boost::asio::transfer_exactly(42), error);
1762   BOOST_ASIO_CHECK(bytes_transferred == 42);
1763   BOOST_ASIO_CHECK(sb.size() == 42);
1764   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1765   BOOST_ASIO_CHECK(!error);
1766
1767   s.reset(read_data, sizeof(read_data));
1768   s.next_read_length(1);
1769   sb.consume(sb.size());
1770   error = boost::system::error_code();
1771   bytes_transferred = boost::asio::read(s, sb,
1772       boost::asio::transfer_exactly(42), error);
1773   BOOST_ASIO_CHECK(bytes_transferred == 42);
1774   BOOST_ASIO_CHECK(sb.size() == 42);
1775   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1776   BOOST_ASIO_CHECK(!error);
1777
1778   s.reset(read_data, sizeof(read_data));
1779   s.next_read_length(10);
1780   sb.consume(sb.size());
1781   error = boost::system::error_code();
1782   bytes_transferred = boost::asio::read(s, sb,
1783       boost::asio::transfer_exactly(42), error);
1784   BOOST_ASIO_CHECK(bytes_transferred == 42);
1785   BOOST_ASIO_CHECK(sb.size() == 42);
1786   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1787   BOOST_ASIO_CHECK(!error);
1788
1789   s.reset(read_data, sizeof(read_data));
1790   sb.consume(sb.size());
1791   bytes_transferred = boost::asio::read(s, sb,
1792       old_style_transfer_all, error);
1793   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1794   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1795   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1796   BOOST_ASIO_CHECK(!error);
1797
1798   s.reset(read_data, sizeof(read_data));
1799   s.next_read_length(1);
1800   sb.consume(sb.size());
1801   error = boost::system::error_code();
1802   bytes_transferred = boost::asio::read(s, sb,
1803       old_style_transfer_all, error);
1804   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1805   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1806   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1807   BOOST_ASIO_CHECK(!error);
1808
1809   s.reset(read_data, sizeof(read_data));
1810   s.next_read_length(10);
1811   sb.consume(sb.size());
1812   error = boost::system::error_code();
1813   bytes_transferred = boost::asio::read(s, sb,
1814       old_style_transfer_all, error);
1815   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1816   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1817   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1818   BOOST_ASIO_CHECK(!error);
1819
1820   s.reset(read_data, sizeof(read_data));
1821   sb.consume(sb.size());
1822   bytes_transferred = boost::asio::read(s, sb, short_transfer, error);
1823   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1824   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1825   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1826   BOOST_ASIO_CHECK(!error);
1827
1828   s.reset(read_data, sizeof(read_data));
1829   s.next_read_length(1);
1830   sb.consume(sb.size());
1831   error = boost::system::error_code();
1832   bytes_transferred = boost::asio::read(s, sb, short_transfer, error);
1833   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1834   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1835   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1836   BOOST_ASIO_CHECK(!error);
1837
1838   s.reset(read_data, sizeof(read_data));
1839   s.next_read_length(10);
1840   sb.consume(sb.size());
1841   error = boost::system::error_code();
1842   bytes_transferred = boost::asio::read(s, sb, short_transfer, error);
1843   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1844   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1845   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1846   BOOST_ASIO_CHECK(!error);
1847 }
1848
1849 void async_read_handler(const boost::system::error_code& e,
1850     size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
1851 {
1852   *called = true;
1853   BOOST_ASIO_CHECK(!e);
1854   BOOST_ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
1855 }
1856
1857 void test_3_arg_mutable_buffer_async_read()
1858 {
1859 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
1860   namespace bindns = boost;
1861 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1862   namespace bindns = std;
1863   using std::placeholders::_1;
1864   using std::placeholders::_2;
1865 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1866
1867   boost::asio::io_context ioc;
1868   test_stream s(ioc);
1869   char read_buf[sizeof(read_data)];
1870   boost::asio::mutable_buffer buffers
1871     = boost::asio::buffer(read_buf, sizeof(read_buf));
1872
1873   s.reset(read_data, sizeof(read_data));
1874   memset(read_buf, 0, sizeof(read_buf));
1875   bool called = false;
1876   boost::asio::async_read(s, buffers,
1877       bindns::bind(async_read_handler,
1878         _1, _2, sizeof(read_data), &called));
1879   ioc.restart();
1880   ioc.run();
1881   BOOST_ASIO_CHECK(called);
1882   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1883
1884   s.reset(read_data, sizeof(read_data));
1885   s.next_read_length(1);
1886   memset(read_buf, 0, sizeof(read_buf));
1887   called = false;
1888   boost::asio::async_read(s, buffers,
1889       bindns::bind(async_read_handler,
1890         _1, _2, sizeof(read_data), &called));
1891   ioc.restart();
1892   ioc.run();
1893   BOOST_ASIO_CHECK(called);
1894   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1895
1896   s.reset(read_data, sizeof(read_data));
1897   s.next_read_length(10);
1898   memset(read_buf, 0, sizeof(read_buf));
1899   called = false;
1900   boost::asio::async_read(s, buffers,
1901       bindns::bind(async_read_handler,
1902         _1, _2, sizeof(read_data), &called));
1903   ioc.restart();
1904   ioc.run();
1905   BOOST_ASIO_CHECK(called);
1906   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1907
1908   s.reset(read_data, sizeof(read_data));
1909   memset(read_buf, 0, sizeof(read_buf));
1910   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
1911   BOOST_ASIO_CHECK(i == 42);
1912   ioc.restart();
1913   ioc.run();
1914   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1915 }
1916
1917 void test_3_arg_boost_array_buffers_async_read()
1918 {
1919 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
1920   namespace bindns = boost;
1921 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1922   namespace bindns = std;
1923   using std::placeholders::_1;
1924   using std::placeholders::_2;
1925 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1926
1927 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
1928   boost::asio::io_context ioc;
1929   test_stream s(ioc);
1930   char read_buf[sizeof(read_data)];
1931   boost::array<boost::asio::mutable_buffer, 2> buffers = { {
1932     boost::asio::buffer(read_buf, 32),
1933     boost::asio::buffer(read_buf) + 32 } };
1934
1935   s.reset(read_data, sizeof(read_data));
1936   memset(read_buf, 0, sizeof(read_buf));
1937   bool called = false;
1938   boost::asio::async_read(s, buffers,
1939       bindns::bind(async_read_handler,
1940         _1, _2, sizeof(read_data), &called));
1941   ioc.restart();
1942   ioc.run();
1943   BOOST_ASIO_CHECK(called);
1944   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1945
1946   s.reset(read_data, sizeof(read_data));
1947   s.next_read_length(1);
1948   memset(read_buf, 0, sizeof(read_buf));
1949   called = false;
1950   boost::asio::async_read(s, buffers,
1951       bindns::bind(async_read_handler,
1952         _1, _2, sizeof(read_data), &called));
1953   ioc.restart();
1954   ioc.run();
1955   BOOST_ASIO_CHECK(called);
1956   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1957
1958   s.reset(read_data, sizeof(read_data));
1959   s.next_read_length(10);
1960   memset(read_buf, 0, sizeof(read_buf));
1961   called = false;
1962   boost::asio::async_read(s, buffers,
1963       bindns::bind(async_read_handler,
1964         _1, _2, sizeof(read_data), &called));
1965   ioc.restart();
1966   ioc.run();
1967   BOOST_ASIO_CHECK(called);
1968   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1969
1970   s.reset(read_data, sizeof(read_data));
1971   memset(read_buf, 0, sizeof(read_buf));
1972   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
1973   BOOST_ASIO_CHECK(i == 42);
1974   ioc.restart();
1975   ioc.run();
1976   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1977 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
1978 }
1979
1980 void test_3_arg_std_array_buffers_async_read()
1981 {
1982 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
1983   namespace bindns = boost;
1984 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1985   namespace bindns = std;
1986   using std::placeholders::_1;
1987   using std::placeholders::_2;
1988 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1989
1990 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
1991   boost::asio::io_context ioc;
1992   test_stream s(ioc);
1993   char read_buf[sizeof(read_data)];
1994   std::array<boost::asio::mutable_buffer, 2> buffers = { {
1995     boost::asio::buffer(read_buf, 32),
1996     boost::asio::buffer(read_buf) + 32 } };
1997
1998   s.reset(read_data, sizeof(read_data));
1999   memset(read_buf, 0, sizeof(read_buf));
2000   bool called = false;
2001   boost::asio::async_read(s, buffers,
2002       bindns::bind(async_read_handler,
2003         _1, _2, sizeof(read_data), &called));
2004   ioc.restart();
2005   ioc.run();
2006   BOOST_ASIO_CHECK(called);
2007   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2008
2009   s.reset(read_data, sizeof(read_data));
2010   s.next_read_length(1);
2011   memset(read_buf, 0, sizeof(read_buf));
2012   called = false;
2013   boost::asio::async_read(s, buffers,
2014       bindns::bind(async_read_handler,
2015         _1, _2, sizeof(read_data), &called));
2016   ioc.restart();
2017   ioc.run();
2018   BOOST_ASIO_CHECK(called);
2019   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2020
2021   s.reset(read_data, sizeof(read_data));
2022   s.next_read_length(10);
2023   memset(read_buf, 0, sizeof(read_buf));
2024   called = false;
2025   boost::asio::async_read(s, buffers,
2026       bindns::bind(async_read_handler,
2027         _1, _2, sizeof(read_data), &called));
2028   ioc.restart();
2029   ioc.run();
2030   BOOST_ASIO_CHECK(called);
2031   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2032
2033   s.reset(read_data, sizeof(read_data));
2034   memset(read_buf, 0, sizeof(read_buf));
2035   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
2036   BOOST_ASIO_CHECK(i == 42);
2037   ioc.restart();
2038   ioc.run();
2039   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2040 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
2041 }
2042
2043 void test_3_arg_vector_buffers_async_read()
2044 {
2045 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2046   namespace bindns = boost;
2047 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2048   namespace bindns = std;
2049   using std::placeholders::_1;
2050   using std::placeholders::_2;
2051 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2052
2053   boost::asio::io_context ioc;
2054   test_stream s(ioc);
2055   char read_buf[sizeof(read_data)];
2056   std::vector<boost::asio::mutable_buffer> buffers;
2057   buffers.push_back(boost::asio::buffer(read_buf, 32));
2058   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
2059   buffers.push_back(boost::asio::buffer(read_buf) + 39);
2060
2061   s.reset(read_data, sizeof(read_data));
2062   memset(read_buf, 0, sizeof(read_buf));
2063   bool called = false;
2064   boost::asio::async_read(s, buffers,
2065       bindns::bind(async_read_handler,
2066         _1, _2, sizeof(read_data), &called));
2067   ioc.restart();
2068   ioc.run();
2069   BOOST_ASIO_CHECK(called);
2070   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2071
2072   s.reset(read_data, sizeof(read_data));
2073   s.next_read_length(1);
2074   memset(read_buf, 0, sizeof(read_buf));
2075   called = false;
2076   boost::asio::async_read(s, buffers,
2077       bindns::bind(async_read_handler,
2078         _1, _2, sizeof(read_data), &called));
2079   ioc.restart();
2080   ioc.run();
2081   BOOST_ASIO_CHECK(called);
2082   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2083
2084   s.reset(read_data, sizeof(read_data));
2085   s.next_read_length(10);
2086   memset(read_buf, 0, sizeof(read_buf));
2087   called = false;
2088   boost::asio::async_read(s, buffers,
2089       bindns::bind(async_read_handler,
2090         _1, _2, sizeof(read_data), &called));
2091   ioc.restart();
2092   ioc.run();
2093   BOOST_ASIO_CHECK(called);
2094   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2095
2096   s.reset(read_data, sizeof(read_data));
2097   memset(read_buf, 0, sizeof(read_buf));
2098   int i = boost::asio::async_read(s, buffers, archetypes::lazy_handler());
2099   BOOST_ASIO_CHECK(i == 42);
2100   ioc.restart();
2101   ioc.run();
2102   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2103 }
2104
2105 void test_3_arg_streambuf_async_read()
2106 {
2107 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2108   namespace bindns = boost;
2109 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2110   namespace bindns = std;
2111   using std::placeholders::_1;
2112   using std::placeholders::_2;
2113 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2114
2115   boost::asio::io_context ioc;
2116   test_stream s(ioc);
2117   boost::asio::streambuf sb(sizeof(read_data));
2118
2119   s.reset(read_data, sizeof(read_data));
2120   sb.consume(sb.size());
2121   bool called = false;
2122   boost::asio::async_read(s, sb,
2123       bindns::bind(async_read_handler,
2124         _1, _2, sizeof(read_data), &called));
2125   ioc.restart();
2126   ioc.run();
2127   BOOST_ASIO_CHECK(called);
2128   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2129   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2130
2131   s.reset(read_data, sizeof(read_data));
2132   s.next_read_length(1);
2133   sb.consume(sb.size());
2134   called = false;
2135   boost::asio::async_read(s, sb,
2136       bindns::bind(async_read_handler,
2137         _1, _2, sizeof(read_data), &called));
2138   ioc.restart();
2139   ioc.run();
2140   BOOST_ASIO_CHECK(called);
2141   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2142   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2143
2144   s.reset(read_data, sizeof(read_data));
2145   s.next_read_length(10);
2146   sb.consume(sb.size());
2147   called = false;
2148   boost::asio::async_read(s, sb,
2149       bindns::bind(async_read_handler,
2150         _1, _2, sizeof(read_data), &called));
2151   ioc.restart();
2152   ioc.run();
2153   BOOST_ASIO_CHECK(called);
2154   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2155   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2156
2157   s.reset(read_data, sizeof(read_data));
2158   sb.consume(sb.size());
2159   int i = boost::asio::async_read(s, sb, archetypes::lazy_handler());
2160   BOOST_ASIO_CHECK(i == 42);
2161   ioc.restart();
2162   ioc.run();
2163   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2164   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2165 }
2166
2167 void test_4_arg_mutable_buffer_async_read()
2168 {
2169 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2170   namespace bindns = boost;
2171 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2172   namespace bindns = std;
2173   using std::placeholders::_1;
2174   using std::placeholders::_2;
2175 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2176
2177   boost::asio::io_context ioc;
2178   test_stream s(ioc);
2179   char read_buf[sizeof(read_data)];
2180   boost::asio::mutable_buffer buffers
2181     = boost::asio::buffer(read_buf, sizeof(read_buf));
2182
2183   s.reset(read_data, sizeof(read_data));
2184   memset(read_buf, 0, sizeof(read_buf));
2185   bool called = false;
2186   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2187       bindns::bind(async_read_handler,
2188         _1, _2, sizeof(read_data), &called));
2189   ioc.restart();
2190   ioc.run();
2191   BOOST_ASIO_CHECK(called);
2192   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2193
2194   s.reset(read_data, sizeof(read_data));
2195   s.next_read_length(1);
2196   memset(read_buf, 0, sizeof(read_buf));
2197   called = false;
2198   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2199       bindns::bind(async_read_handler,
2200         _1, _2, sizeof(read_data), &called));
2201   ioc.restart();
2202   ioc.run();
2203   BOOST_ASIO_CHECK(called);
2204   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2205
2206   s.reset(read_data, sizeof(read_data));
2207   s.next_read_length(10);
2208   memset(read_buf, 0, sizeof(read_buf));
2209   called = false;
2210   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2211       bindns::bind(async_read_handler,
2212         _1, _2, sizeof(read_data), &called));
2213   ioc.restart();
2214   ioc.run();
2215   BOOST_ASIO_CHECK(called);
2216   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2217
2218   s.reset(read_data, sizeof(read_data));
2219   memset(read_buf, 0, sizeof(read_buf));
2220   called = false;
2221   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2222       bindns::bind(async_read_handler,
2223         _1, _2, sizeof(read_data), &called));
2224   ioc.restart();
2225   ioc.run();
2226   BOOST_ASIO_CHECK(called);
2227   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2228
2229   s.reset(read_data, sizeof(read_data));
2230   s.next_read_length(1);
2231   memset(read_buf, 0, sizeof(read_buf));
2232   called = false;
2233   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2234       bindns::bind(async_read_handler,
2235         _1, _2, 1, &called));
2236   ioc.restart();
2237   ioc.run();
2238   BOOST_ASIO_CHECK(called);
2239   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2240
2241   s.reset(read_data, sizeof(read_data));
2242   s.next_read_length(10);
2243   memset(read_buf, 0, sizeof(read_buf));
2244   called = false;
2245   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2246       bindns::bind(async_read_handler,
2247         _1, _2, 10, &called));
2248   ioc.restart();
2249   ioc.run();
2250   BOOST_ASIO_CHECK(called);
2251   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2252
2253   s.reset(read_data, sizeof(read_data));
2254   memset(read_buf, 0, sizeof(read_buf));
2255   called = false;
2256   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2257       bindns::bind(async_read_handler,
2258         _1, _2, sizeof(read_data), &called));
2259   ioc.restart();
2260   ioc.run();
2261   BOOST_ASIO_CHECK(called);
2262   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2263
2264   s.reset(read_data, sizeof(read_data));
2265   s.next_read_length(1);
2266   memset(read_buf, 0, sizeof(read_buf));
2267   called = false;
2268   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2269       bindns::bind(async_read_handler,
2270         _1, _2, 10, &called));
2271   ioc.restart();
2272   ioc.run();
2273   BOOST_ASIO_CHECK(called);
2274   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2275
2276   s.reset(read_data, sizeof(read_data));
2277   s.next_read_length(10);
2278   memset(read_buf, 0, sizeof(read_buf));
2279   called = false;
2280   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2281       bindns::bind(async_read_handler,
2282         _1, _2, 10, &called));
2283   ioc.restart();
2284   ioc.run();
2285   BOOST_ASIO_CHECK(called);
2286   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2287
2288   s.reset(read_data, sizeof(read_data));
2289   memset(read_buf, 0, sizeof(read_buf));
2290   called = false;
2291   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2292       bindns::bind(async_read_handler,
2293         _1, _2, sizeof(read_data), &called));
2294   ioc.restart();
2295   ioc.run();
2296   BOOST_ASIO_CHECK(called);
2297   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2298
2299   s.reset(read_data, sizeof(read_data));
2300   s.next_read_length(1);
2301   memset(read_buf, 0, sizeof(read_buf));
2302   called = false;
2303   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2304       bindns::bind(async_read_handler,
2305         _1, _2, 42, &called));
2306   ioc.restart();
2307   ioc.run();
2308   BOOST_ASIO_CHECK(called);
2309   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2310
2311   s.reset(read_data, sizeof(read_data));
2312   s.next_read_length(10);
2313   memset(read_buf, 0, sizeof(read_buf));
2314   called = false;
2315   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2316       bindns::bind(async_read_handler,
2317         _1, _2, 50, &called));
2318   ioc.restart();
2319   ioc.run();
2320   BOOST_ASIO_CHECK(called);
2321   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
2322
2323   s.reset(read_data, sizeof(read_data));
2324   memset(read_buf, 0, sizeof(read_buf));
2325   called = false;
2326   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
2327       bindns::bind(async_read_handler,
2328         _1, _2, 1, &called));
2329   ioc.restart();
2330   ioc.run();
2331   BOOST_ASIO_CHECK(called);
2332   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2333
2334   s.reset(read_data, sizeof(read_data));
2335   s.next_read_length(1);
2336   memset(read_buf, 0, sizeof(read_buf));
2337   called = false;
2338   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
2339       bindns::bind(async_read_handler,
2340         _1, _2, 1, &called));
2341   ioc.restart();
2342   ioc.run();
2343   BOOST_ASIO_CHECK(called);
2344   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2345
2346   s.reset(read_data, sizeof(read_data));
2347   s.next_read_length(10);
2348   memset(read_buf, 0, sizeof(read_buf));
2349   called = false;
2350   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
2351       bindns::bind(async_read_handler,
2352         _1, _2, 1, &called));
2353   ioc.restart();
2354   ioc.run();
2355   BOOST_ASIO_CHECK(called);
2356   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2357
2358   s.reset(read_data, sizeof(read_data));
2359   memset(read_buf, 0, sizeof(read_buf));
2360   called = false;
2361   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
2362       bindns::bind(async_read_handler,
2363         _1, _2, 10, &called));
2364   ioc.restart();
2365   ioc.run();
2366   BOOST_ASIO_CHECK(called);
2367   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2368
2369   s.reset(read_data, sizeof(read_data));
2370   s.next_read_length(1);
2371   memset(read_buf, 0, sizeof(read_buf));
2372   called = false;
2373   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
2374       bindns::bind(async_read_handler,
2375         _1, _2, 10, &called));
2376   ioc.restart();
2377   ioc.run();
2378   BOOST_ASIO_CHECK(called);
2379   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2380
2381   s.reset(read_data, sizeof(read_data));
2382   s.next_read_length(10);
2383   memset(read_buf, 0, sizeof(read_buf));
2384   called = false;
2385   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
2386       bindns::bind(async_read_handler,
2387         _1, _2, 10, &called));
2388   ioc.restart();
2389   ioc.run();
2390   BOOST_ASIO_CHECK(called);
2391   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2392
2393   s.reset(read_data, sizeof(read_data));
2394   memset(read_buf, 0, sizeof(read_buf));
2395   called = false;
2396   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
2397       bindns::bind(async_read_handler,
2398         _1, _2, 42, &called));
2399   ioc.restart();
2400   ioc.run();
2401   BOOST_ASIO_CHECK(called);
2402   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2403
2404   s.reset(read_data, sizeof(read_data));
2405   s.next_read_length(1);
2406   memset(read_buf, 0, sizeof(read_buf));
2407   called = false;
2408   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
2409       bindns::bind(async_read_handler,
2410         _1, _2, 42, &called));
2411   ioc.restart();
2412   ioc.run();
2413   BOOST_ASIO_CHECK(called);
2414   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2415
2416   s.reset(read_data, sizeof(read_data));
2417   s.next_read_length(10);
2418   memset(read_buf, 0, sizeof(read_buf));
2419   called = false;
2420   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
2421       bindns::bind(async_read_handler,
2422         _1, _2, 42, &called));
2423   ioc.restart();
2424   ioc.run();
2425   BOOST_ASIO_CHECK(called);
2426   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2427
2428   s.reset(read_data, sizeof(read_data));
2429   memset(read_buf, 0, sizeof(read_buf));
2430   called = false;
2431   boost::asio::async_read(s, buffers, old_style_transfer_all,
2432       bindns::bind(async_read_handler,
2433         _1, _2, sizeof(read_data), &called));
2434   ioc.restart();
2435   ioc.run();
2436   BOOST_ASIO_CHECK(called);
2437   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2438
2439   s.reset(read_data, sizeof(read_data));
2440   s.next_read_length(1);
2441   memset(read_buf, 0, sizeof(read_buf));
2442   called = false;
2443   boost::asio::async_read(s, buffers, old_style_transfer_all,
2444       bindns::bind(async_read_handler,
2445         _1, _2, sizeof(read_data), &called));
2446   ioc.restart();
2447   ioc.run();
2448   BOOST_ASIO_CHECK(called);
2449   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2450
2451   s.reset(read_data, sizeof(read_data));
2452   s.next_read_length(10);
2453   memset(read_buf, 0, sizeof(read_buf));
2454   called = false;
2455   boost::asio::async_read(s, buffers, old_style_transfer_all,
2456       bindns::bind(async_read_handler,
2457         _1, _2, sizeof(read_data), &called));
2458   ioc.restart();
2459   ioc.run();
2460   BOOST_ASIO_CHECK(called);
2461   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2462
2463   s.reset(read_data, sizeof(read_data));
2464   memset(read_buf, 0, sizeof(read_buf));
2465   called = false;
2466   boost::asio::async_read(s, buffers, short_transfer,
2467       bindns::bind(async_read_handler,
2468         _1, _2, sizeof(read_data), &called));
2469   ioc.restart();
2470   ioc.run();
2471   BOOST_ASIO_CHECK(called);
2472   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2473
2474   s.reset(read_data, sizeof(read_data));
2475   s.next_read_length(1);
2476   memset(read_buf, 0, sizeof(read_buf));
2477   called = false;
2478   boost::asio::async_read(s, buffers, short_transfer,
2479       bindns::bind(async_read_handler,
2480         _1, _2, sizeof(read_data), &called));
2481   ioc.restart();
2482   ioc.run();
2483   BOOST_ASIO_CHECK(called);
2484   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2485
2486   s.reset(read_data, sizeof(read_data));
2487   s.next_read_length(10);
2488   memset(read_buf, 0, sizeof(read_buf));
2489   called = false;
2490   boost::asio::async_read(s, buffers, short_transfer,
2491       bindns::bind(async_read_handler,
2492         _1, _2, sizeof(read_data), &called));
2493   ioc.restart();
2494   ioc.run();
2495   BOOST_ASIO_CHECK(called);
2496   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2497
2498   s.reset(read_data, sizeof(read_data));
2499   memset(read_buf, 0, sizeof(read_buf));
2500   int i = boost::asio::async_read(s, buffers,
2501       short_transfer, archetypes::lazy_handler());
2502   BOOST_ASIO_CHECK(i == 42);
2503   ioc.restart();
2504   ioc.run();
2505   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2506 }
2507
2508 void test_4_arg_boost_array_buffers_async_read()
2509 {
2510 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2511   namespace bindns = boost;
2512 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2513   namespace bindns = std;
2514   using std::placeholders::_1;
2515   using std::placeholders::_2;
2516 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2517
2518 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2519   boost::asio::io_context ioc;
2520   test_stream s(ioc);
2521   char read_buf[sizeof(read_data)];
2522   boost::array<boost::asio::mutable_buffer, 2> buffers = { {
2523     boost::asio::buffer(read_buf, 32),
2524     boost::asio::buffer(read_buf) + 32 } };
2525
2526   s.reset(read_data, sizeof(read_data));
2527   memset(read_buf, 0, sizeof(read_buf));
2528   bool called = false;
2529   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2530       bindns::bind(async_read_handler,
2531         _1, _2, sizeof(read_data), &called));
2532   ioc.restart();
2533   ioc.run();
2534   BOOST_ASIO_CHECK(called);
2535   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2536
2537   s.reset(read_data, sizeof(read_data));
2538   s.next_read_length(1);
2539   memset(read_buf, 0, sizeof(read_buf));
2540   called = false;
2541   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2542       bindns::bind(async_read_handler,
2543         _1, _2, sizeof(read_data), &called));
2544   ioc.restart();
2545   ioc.run();
2546   BOOST_ASIO_CHECK(called);
2547   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2548
2549   s.reset(read_data, sizeof(read_data));
2550   s.next_read_length(10);
2551   memset(read_buf, 0, sizeof(read_buf));
2552   called = false;
2553   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2554       bindns::bind(async_read_handler,
2555         _1, _2, sizeof(read_data), &called));
2556   ioc.restart();
2557   ioc.run();
2558   BOOST_ASIO_CHECK(called);
2559   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2560
2561   s.reset(read_data, sizeof(read_data));
2562   memset(read_buf, 0, sizeof(read_buf));
2563   called = false;
2564   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2565       bindns::bind(async_read_handler,
2566         _1, _2, sizeof(read_data), &called));
2567   ioc.restart();
2568   ioc.run();
2569   BOOST_ASIO_CHECK(called);
2570   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2571
2572   s.reset(read_data, sizeof(read_data));
2573   s.next_read_length(1);
2574   memset(read_buf, 0, sizeof(read_buf));
2575   called = false;
2576   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2577       bindns::bind(async_read_handler,
2578         _1, _2, 1, &called));
2579   ioc.restart();
2580   ioc.run();
2581   BOOST_ASIO_CHECK(called);
2582   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2583
2584   s.reset(read_data, sizeof(read_data));
2585   s.next_read_length(10);
2586   memset(read_buf, 0, sizeof(read_buf));
2587   called = false;
2588   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2589       bindns::bind(async_read_handler,
2590         _1, _2, 10, &called));
2591   ioc.restart();
2592   ioc.run();
2593   BOOST_ASIO_CHECK(called);
2594   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2595
2596   s.reset(read_data, sizeof(read_data));
2597   memset(read_buf, 0, sizeof(read_buf));
2598   called = false;
2599   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2600       bindns::bind(async_read_handler,
2601         _1, _2, sizeof(read_data), &called));
2602   ioc.restart();
2603   ioc.run();
2604   BOOST_ASIO_CHECK(called);
2605   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2606
2607   s.reset(read_data, sizeof(read_data));
2608   s.next_read_length(1);
2609   memset(read_buf, 0, sizeof(read_buf));
2610   called = false;
2611   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2612       bindns::bind(async_read_handler,
2613         _1, _2, 10, &called));
2614   ioc.restart();
2615   ioc.run();
2616   BOOST_ASIO_CHECK(called);
2617   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2618
2619   s.reset(read_data, sizeof(read_data));
2620   s.next_read_length(10);
2621   memset(read_buf, 0, sizeof(read_buf));
2622   called = false;
2623   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2624       bindns::bind(async_read_handler,
2625         _1, _2, 10, &called));
2626   ioc.restart();
2627   ioc.run();
2628   BOOST_ASIO_CHECK(called);
2629   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2630
2631   s.reset(read_data, sizeof(read_data));
2632   memset(read_buf, 0, sizeof(read_buf));
2633   called = false;
2634   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2635       bindns::bind(async_read_handler,
2636         _1, _2, sizeof(read_data), &called));
2637   ioc.restart();
2638   ioc.run();
2639   BOOST_ASIO_CHECK(called);
2640   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2641
2642   s.reset(read_data, sizeof(read_data));
2643   s.next_read_length(1);
2644   memset(read_buf, 0, sizeof(read_buf));
2645   called = false;
2646   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2647       bindns::bind(async_read_handler,
2648         _1, _2, 42, &called));
2649   ioc.restart();
2650   ioc.run();
2651   BOOST_ASIO_CHECK(called);
2652   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2653
2654   s.reset(read_data, sizeof(read_data));
2655   s.next_read_length(10);
2656   memset(read_buf, 0, sizeof(read_buf));
2657   called = false;
2658   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2659       bindns::bind(async_read_handler,
2660         _1, _2, 50, &called));
2661   ioc.restart();
2662   ioc.run();
2663   BOOST_ASIO_CHECK(called);
2664   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
2665
2666   s.reset(read_data, sizeof(read_data));
2667   memset(read_buf, 0, sizeof(read_buf));
2668   called = false;
2669   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
2670       bindns::bind(async_read_handler,
2671         _1, _2, 1, &called));
2672   ioc.restart();
2673   ioc.run();
2674   BOOST_ASIO_CHECK(called);
2675   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2676
2677   s.reset(read_data, sizeof(read_data));
2678   s.next_read_length(1);
2679   memset(read_buf, 0, sizeof(read_buf));
2680   called = false;
2681   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
2682       bindns::bind(async_read_handler,
2683         _1, _2, 1, &called));
2684   ioc.restart();
2685   ioc.run();
2686   BOOST_ASIO_CHECK(called);
2687   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2688
2689   s.reset(read_data, sizeof(read_data));
2690   s.next_read_length(10);
2691   memset(read_buf, 0, sizeof(read_buf));
2692   called = false;
2693   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
2694       bindns::bind(async_read_handler,
2695         _1, _2, 1, &called));
2696   ioc.restart();
2697   ioc.run();
2698   BOOST_ASIO_CHECK(called);
2699   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2700
2701   s.reset(read_data, sizeof(read_data));
2702   memset(read_buf, 0, sizeof(read_buf));
2703   called = false;
2704   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
2705       bindns::bind(async_read_handler,
2706         _1, _2, 10, &called));
2707   ioc.restart();
2708   ioc.run();
2709   BOOST_ASIO_CHECK(called);
2710   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2711
2712   s.reset(read_data, sizeof(read_data));
2713   s.next_read_length(1);
2714   memset(read_buf, 0, sizeof(read_buf));
2715   called = false;
2716   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
2717       bindns::bind(async_read_handler,
2718         _1, _2, 10, &called));
2719   ioc.restart();
2720   ioc.run();
2721   BOOST_ASIO_CHECK(called);
2722   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2723
2724   s.reset(read_data, sizeof(read_data));
2725   s.next_read_length(10);
2726   memset(read_buf, 0, sizeof(read_buf));
2727   called = false;
2728   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
2729       bindns::bind(async_read_handler,
2730         _1, _2, 10, &called));
2731   ioc.restart();
2732   ioc.run();
2733   BOOST_ASIO_CHECK(called);
2734   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2735
2736   s.reset(read_data, sizeof(read_data));
2737   memset(read_buf, 0, sizeof(read_buf));
2738   called = false;
2739   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
2740       bindns::bind(async_read_handler,
2741         _1, _2, 42, &called));
2742   ioc.restart();
2743   ioc.run();
2744   BOOST_ASIO_CHECK(called);
2745   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2746
2747   s.reset(read_data, sizeof(read_data));
2748   s.next_read_length(1);
2749   memset(read_buf, 0, sizeof(read_buf));
2750   called = false;
2751   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
2752       bindns::bind(async_read_handler,
2753         _1, _2, 42, &called));
2754   ioc.restart();
2755   ioc.run();
2756   BOOST_ASIO_CHECK(called);
2757   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2758
2759   s.reset(read_data, sizeof(read_data));
2760   s.next_read_length(10);
2761   memset(read_buf, 0, sizeof(read_buf));
2762   called = false;
2763   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
2764       bindns::bind(async_read_handler,
2765         _1, _2, 42, &called));
2766   ioc.restart();
2767   ioc.run();
2768   BOOST_ASIO_CHECK(called);
2769   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2770
2771   s.reset(read_data, sizeof(read_data));
2772   memset(read_buf, 0, sizeof(read_buf));
2773   called = false;
2774   boost::asio::async_read(s, buffers, old_style_transfer_all,
2775       bindns::bind(async_read_handler,
2776         _1, _2, sizeof(read_data), &called));
2777   ioc.restart();
2778   ioc.run();
2779   BOOST_ASIO_CHECK(called);
2780   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2781
2782   s.reset(read_data, sizeof(read_data));
2783   s.next_read_length(1);
2784   memset(read_buf, 0, sizeof(read_buf));
2785   called = false;
2786   boost::asio::async_read(s, buffers, old_style_transfer_all,
2787       bindns::bind(async_read_handler,
2788         _1, _2, sizeof(read_data), &called));
2789   ioc.restart();
2790   ioc.run();
2791   BOOST_ASIO_CHECK(called);
2792   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2793
2794   s.reset(read_data, sizeof(read_data));
2795   s.next_read_length(10);
2796   memset(read_buf, 0, sizeof(read_buf));
2797   called = false;
2798   boost::asio::async_read(s, buffers, old_style_transfer_all,
2799       bindns::bind(async_read_handler,
2800         _1, _2, sizeof(read_data), &called));
2801   ioc.restart();
2802   ioc.run();
2803   BOOST_ASIO_CHECK(called);
2804   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2805
2806   s.reset(read_data, sizeof(read_data));
2807   memset(read_buf, 0, sizeof(read_buf));
2808   called = false;
2809   boost::asio::async_read(s, buffers, short_transfer,
2810       bindns::bind(async_read_handler,
2811         _1, _2, sizeof(read_data), &called));
2812   ioc.restart();
2813   ioc.run();
2814   BOOST_ASIO_CHECK(called);
2815   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2816
2817   s.reset(read_data, sizeof(read_data));
2818   s.next_read_length(1);
2819   memset(read_buf, 0, sizeof(read_buf));
2820   called = false;
2821   boost::asio::async_read(s, buffers, short_transfer,
2822       bindns::bind(async_read_handler,
2823         _1, _2, sizeof(read_data), &called));
2824   ioc.restart();
2825   ioc.run();
2826   BOOST_ASIO_CHECK(called);
2827   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2828
2829   s.reset(read_data, sizeof(read_data));
2830   s.next_read_length(10);
2831   memset(read_buf, 0, sizeof(read_buf));
2832   called = false;
2833   boost::asio::async_read(s, buffers, short_transfer,
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(s.check_buffers(buffers, sizeof(read_data)));
2840
2841   s.reset(read_data, sizeof(read_data));
2842   memset(read_buf, 0, sizeof(read_buf));
2843   int i = boost::asio::async_read(s, buffers,
2844       short_transfer, archetypes::lazy_handler());
2845   BOOST_ASIO_CHECK(i == 42);
2846   ioc.restart();
2847   ioc.run();
2848   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2849 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2850 }
2851
2852 void test_4_arg_std_array_buffers_async_read()
2853 {
2854 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
2855   namespace bindns = boost;
2856 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2857   namespace bindns = std;
2858   using std::placeholders::_1;
2859   using std::placeholders::_2;
2860 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2861
2862 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
2863   boost::asio::io_context ioc;
2864   test_stream s(ioc);
2865   char read_buf[sizeof(read_data)];
2866   std::array<boost::asio::mutable_buffer, 2> buffers = { {
2867     boost::asio::buffer(read_buf, 32),
2868     boost::asio::buffer(read_buf) + 32 } };
2869
2870   s.reset(read_data, sizeof(read_data));
2871   memset(read_buf, 0, sizeof(read_buf));
2872   bool called = false;
2873   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2874       bindns::bind(async_read_handler,
2875         _1, _2, sizeof(read_data), &called));
2876   ioc.restart();
2877   ioc.run();
2878   BOOST_ASIO_CHECK(called);
2879   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2880
2881   s.reset(read_data, sizeof(read_data));
2882   s.next_read_length(1);
2883   memset(read_buf, 0, sizeof(read_buf));
2884   called = false;
2885   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2886       bindns::bind(async_read_handler,
2887         _1, _2, sizeof(read_data), &called));
2888   ioc.restart();
2889   ioc.run();
2890   BOOST_ASIO_CHECK(called);
2891   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2892
2893   s.reset(read_data, sizeof(read_data));
2894   s.next_read_length(10);
2895   memset(read_buf, 0, sizeof(read_buf));
2896   called = false;
2897   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
2898       bindns::bind(async_read_handler,
2899         _1, _2, sizeof(read_data), &called));
2900   ioc.restart();
2901   ioc.run();
2902   BOOST_ASIO_CHECK(called);
2903   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2904
2905   s.reset(read_data, sizeof(read_data));
2906   memset(read_buf, 0, sizeof(read_buf));
2907   called = false;
2908   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2909       bindns::bind(async_read_handler,
2910         _1, _2, sizeof(read_data), &called));
2911   ioc.restart();
2912   ioc.run();
2913   BOOST_ASIO_CHECK(called);
2914   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2915
2916   s.reset(read_data, sizeof(read_data));
2917   s.next_read_length(1);
2918   memset(read_buf, 0, sizeof(read_buf));
2919   called = false;
2920   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2921       bindns::bind(async_read_handler,
2922         _1, _2, 1, &called));
2923   ioc.restart();
2924   ioc.run();
2925   BOOST_ASIO_CHECK(called);
2926   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2927
2928   s.reset(read_data, sizeof(read_data));
2929   s.next_read_length(10);
2930   memset(read_buf, 0, sizeof(read_buf));
2931   called = false;
2932   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
2933       bindns::bind(async_read_handler,
2934         _1, _2, 10, &called));
2935   ioc.restart();
2936   ioc.run();
2937   BOOST_ASIO_CHECK(called);
2938   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2939
2940   s.reset(read_data, sizeof(read_data));
2941   memset(read_buf, 0, sizeof(read_buf));
2942   called = false;
2943   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2944       bindns::bind(async_read_handler,
2945         _1, _2, sizeof(read_data), &called));
2946   ioc.restart();
2947   ioc.run();
2948   BOOST_ASIO_CHECK(called);
2949   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2950
2951   s.reset(read_data, sizeof(read_data));
2952   s.next_read_length(1);
2953   memset(read_buf, 0, sizeof(read_buf));
2954   called = false;
2955   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2956       bindns::bind(async_read_handler,
2957         _1, _2, 10, &called));
2958   ioc.restart();
2959   ioc.run();
2960   BOOST_ASIO_CHECK(called);
2961   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2962
2963   s.reset(read_data, sizeof(read_data));
2964   s.next_read_length(10);
2965   memset(read_buf, 0, sizeof(read_buf));
2966   called = false;
2967   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
2968       bindns::bind(async_read_handler,
2969         _1, _2, 10, &called));
2970   ioc.restart();
2971   ioc.run();
2972   BOOST_ASIO_CHECK(called);
2973   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2974
2975   s.reset(read_data, sizeof(read_data));
2976   memset(read_buf, 0, sizeof(read_buf));
2977   called = false;
2978   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2979       bindns::bind(async_read_handler,
2980         _1, _2, sizeof(read_data), &called));
2981   ioc.restart();
2982   ioc.run();
2983   BOOST_ASIO_CHECK(called);
2984   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2985
2986   s.reset(read_data, sizeof(read_data));
2987   s.next_read_length(1);
2988   memset(read_buf, 0, sizeof(read_buf));
2989   called = false;
2990   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
2991       bindns::bind(async_read_handler,
2992         _1, _2, 42, &called));
2993   ioc.restart();
2994   ioc.run();
2995   BOOST_ASIO_CHECK(called);
2996   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2997
2998   s.reset(read_data, sizeof(read_data));
2999   s.next_read_length(10);
3000   memset(read_buf, 0, sizeof(read_buf));
3001   called = false;
3002   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3003       bindns::bind(async_read_handler,
3004         _1, _2, 50, &called));
3005   ioc.restart();
3006   ioc.run();
3007   BOOST_ASIO_CHECK(called);
3008   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3009
3010   s.reset(read_data, sizeof(read_data));
3011   memset(read_buf, 0, sizeof(read_buf));
3012   called = false;
3013   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3014       bindns::bind(async_read_handler,
3015         _1, _2, 1, &called));
3016   ioc.restart();
3017   ioc.run();
3018   BOOST_ASIO_CHECK(called);
3019   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3020
3021   s.reset(read_data, sizeof(read_data));
3022   s.next_read_length(1);
3023   memset(read_buf, 0, sizeof(read_buf));
3024   called = false;
3025   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3026       bindns::bind(async_read_handler,
3027         _1, _2, 1, &called));
3028   ioc.restart();
3029   ioc.run();
3030   BOOST_ASIO_CHECK(called);
3031   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3032
3033   s.reset(read_data, sizeof(read_data));
3034   s.next_read_length(10);
3035   memset(read_buf, 0, sizeof(read_buf));
3036   called = false;
3037   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3038       bindns::bind(async_read_handler,
3039         _1, _2, 1, &called));
3040   ioc.restart();
3041   ioc.run();
3042   BOOST_ASIO_CHECK(called);
3043   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3044
3045   s.reset(read_data, sizeof(read_data));
3046   memset(read_buf, 0, sizeof(read_buf));
3047   called = false;
3048   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3049       bindns::bind(async_read_handler,
3050         _1, _2, 10, &called));
3051   ioc.restart();
3052   ioc.run();
3053   BOOST_ASIO_CHECK(called);
3054   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3055
3056   s.reset(read_data, sizeof(read_data));
3057   s.next_read_length(1);
3058   memset(read_buf, 0, sizeof(read_buf));
3059   called = false;
3060   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3061       bindns::bind(async_read_handler,
3062         _1, _2, 10, &called));
3063   ioc.restart();
3064   ioc.run();
3065   BOOST_ASIO_CHECK(called);
3066   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3067
3068   s.reset(read_data, sizeof(read_data));
3069   s.next_read_length(10);
3070   memset(read_buf, 0, sizeof(read_buf));
3071   called = false;
3072   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3073       bindns::bind(async_read_handler,
3074         _1, _2, 10, &called));
3075   ioc.restart();
3076   ioc.run();
3077   BOOST_ASIO_CHECK(called);
3078   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3079
3080   s.reset(read_data, sizeof(read_data));
3081   memset(read_buf, 0, sizeof(read_buf));
3082   called = false;
3083   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3084       bindns::bind(async_read_handler,
3085         _1, _2, 42, &called));
3086   ioc.restart();
3087   ioc.run();
3088   BOOST_ASIO_CHECK(called);
3089   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3090
3091   s.reset(read_data, sizeof(read_data));
3092   s.next_read_length(1);
3093   memset(read_buf, 0, sizeof(read_buf));
3094   called = false;
3095   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3096       bindns::bind(async_read_handler,
3097         _1, _2, 42, &called));
3098   ioc.restart();
3099   ioc.run();
3100   BOOST_ASIO_CHECK(called);
3101   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3102
3103   s.reset(read_data, sizeof(read_data));
3104   s.next_read_length(10);
3105   memset(read_buf, 0, sizeof(read_buf));
3106   called = false;
3107   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3108       bindns::bind(async_read_handler,
3109         _1, _2, 42, &called));
3110   ioc.restart();
3111   ioc.run();
3112   BOOST_ASIO_CHECK(called);
3113   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3114
3115   s.reset(read_data, sizeof(read_data));
3116   memset(read_buf, 0, sizeof(read_buf));
3117   called = false;
3118   boost::asio::async_read(s, buffers, old_style_transfer_all,
3119       bindns::bind(async_read_handler,
3120         _1, _2, sizeof(read_data), &called));
3121   ioc.restart();
3122   ioc.run();
3123   BOOST_ASIO_CHECK(called);
3124   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3125
3126   s.reset(read_data, sizeof(read_data));
3127   s.next_read_length(1);
3128   memset(read_buf, 0, sizeof(read_buf));
3129   called = false;
3130   boost::asio::async_read(s, buffers, old_style_transfer_all,
3131       bindns::bind(async_read_handler,
3132         _1, _2, sizeof(read_data), &called));
3133   ioc.restart();
3134   ioc.run();
3135   BOOST_ASIO_CHECK(called);
3136   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3137
3138   s.reset(read_data, sizeof(read_data));
3139   s.next_read_length(10);
3140   memset(read_buf, 0, sizeof(read_buf));
3141   called = false;
3142   boost::asio::async_read(s, buffers, old_style_transfer_all,
3143       bindns::bind(async_read_handler,
3144         _1, _2, sizeof(read_data), &called));
3145   ioc.restart();
3146   ioc.run();
3147   BOOST_ASIO_CHECK(called);
3148   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3149
3150   s.reset(read_data, sizeof(read_data));
3151   memset(read_buf, 0, sizeof(read_buf));
3152   called = false;
3153   boost::asio::async_read(s, buffers, short_transfer,
3154       bindns::bind(async_read_handler,
3155         _1, _2, sizeof(read_data), &called));
3156   ioc.restart();
3157   ioc.run();
3158   BOOST_ASIO_CHECK(called);
3159   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3160
3161   s.reset(read_data, sizeof(read_data));
3162   s.next_read_length(1);
3163   memset(read_buf, 0, sizeof(read_buf));
3164   called = false;
3165   boost::asio::async_read(s, buffers, short_transfer,
3166       bindns::bind(async_read_handler,
3167         _1, _2, sizeof(read_data), &called));
3168   ioc.restart();
3169   ioc.run();
3170   BOOST_ASIO_CHECK(called);
3171   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3172
3173   s.reset(read_data, sizeof(read_data));
3174   s.next_read_length(10);
3175   memset(read_buf, 0, sizeof(read_buf));
3176   called = false;
3177   boost::asio::async_read(s, buffers, short_transfer,
3178       bindns::bind(async_read_handler,
3179         _1, _2, sizeof(read_data), &called));
3180   ioc.restart();
3181   ioc.run();
3182   BOOST_ASIO_CHECK(called);
3183   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3184
3185   s.reset(read_data, sizeof(read_data));
3186   memset(read_buf, 0, sizeof(read_buf));
3187   int i = boost::asio::async_read(s, buffers,
3188       short_transfer, archetypes::lazy_handler());
3189   BOOST_ASIO_CHECK(i == 42);
3190   ioc.restart();
3191   ioc.run();
3192   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3193 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
3194 }
3195
3196 void test_4_arg_vector_buffers_async_read()
3197 {
3198 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3199   namespace bindns = boost;
3200 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3201   namespace bindns = std;
3202   using std::placeholders::_1;
3203   using std::placeholders::_2;
3204 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3205
3206   boost::asio::io_context ioc;
3207   test_stream s(ioc);
3208   char read_buf[sizeof(read_data)];
3209   std::vector<boost::asio::mutable_buffer> buffers;
3210   buffers.push_back(boost::asio::buffer(read_buf, 32));
3211   buffers.push_back(boost::asio::buffer(read_buf, 39) + 32);
3212   buffers.push_back(boost::asio::buffer(read_buf) + 39);
3213
3214   s.reset(read_data, sizeof(read_data));
3215   memset(read_buf, 0, sizeof(read_buf));
3216   bool called = false;
3217   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3218       bindns::bind(async_read_handler,
3219         _1, _2, sizeof(read_data), &called));
3220   ioc.restart();
3221   ioc.run();
3222   BOOST_ASIO_CHECK(called);
3223   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3224
3225   s.reset(read_data, sizeof(read_data));
3226   s.next_read_length(1);
3227   memset(read_buf, 0, sizeof(read_buf));
3228   called = false;
3229   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3230       bindns::bind(async_read_handler,
3231         _1, _2, sizeof(read_data), &called));
3232   ioc.restart();
3233   ioc.run();
3234   BOOST_ASIO_CHECK(called);
3235   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3236
3237   s.reset(read_data, sizeof(read_data));
3238   s.next_read_length(10);
3239   memset(read_buf, 0, sizeof(read_buf));
3240   called = false;
3241   boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
3242       bindns::bind(async_read_handler,
3243         _1, _2, sizeof(read_data), &called));
3244   ioc.restart();
3245   ioc.run();
3246   BOOST_ASIO_CHECK(called);
3247   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3248
3249   s.reset(read_data, sizeof(read_data));
3250   memset(read_buf, 0, sizeof(read_buf));
3251   called = false;
3252   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3253       bindns::bind(async_read_handler,
3254         _1, _2, sizeof(read_data), &called));
3255   ioc.restart();
3256   ioc.run();
3257   BOOST_ASIO_CHECK(called);
3258   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3259
3260   s.reset(read_data, sizeof(read_data));
3261   s.next_read_length(1);
3262   memset(read_buf, 0, sizeof(read_buf));
3263   called = false;
3264   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3265       bindns::bind(async_read_handler,
3266         _1, _2, 1, &called));
3267   ioc.restart();
3268   ioc.run();
3269   BOOST_ASIO_CHECK(called);
3270   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3271
3272   s.reset(read_data, sizeof(read_data));
3273   s.next_read_length(10);
3274   memset(read_buf, 0, sizeof(read_buf));
3275   called = false;
3276   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
3277       bindns::bind(async_read_handler,
3278         _1, _2, 10, &called));
3279   ioc.restart();
3280   ioc.run();
3281   BOOST_ASIO_CHECK(called);
3282   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3283
3284   s.reset(read_data, sizeof(read_data));
3285   memset(read_buf, 0, sizeof(read_buf));
3286   called = false;
3287   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3288       bindns::bind(async_read_handler,
3289         _1, _2, sizeof(read_data), &called));
3290   ioc.restart();
3291   ioc.run();
3292   BOOST_ASIO_CHECK(called);
3293   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3294
3295   s.reset(read_data, sizeof(read_data));
3296   s.next_read_length(1);
3297   memset(read_buf, 0, sizeof(read_buf));
3298   called = false;
3299   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3300       bindns::bind(async_read_handler,
3301         _1, _2, 10, &called));
3302   ioc.restart();
3303   ioc.run();
3304   BOOST_ASIO_CHECK(called);
3305   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3306
3307   s.reset(read_data, sizeof(read_data));
3308   s.next_read_length(10);
3309   memset(read_buf, 0, sizeof(read_buf));
3310   called = false;
3311   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
3312       bindns::bind(async_read_handler,
3313         _1, _2, 10, &called));
3314   ioc.restart();
3315   ioc.run();
3316   BOOST_ASIO_CHECK(called);
3317   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3318
3319   s.reset(read_data, sizeof(read_data));
3320   memset(read_buf, 0, sizeof(read_buf));
3321   called = false;
3322   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3323       bindns::bind(async_read_handler,
3324         _1, _2, sizeof(read_data), &called));
3325   ioc.restart();
3326   ioc.run();
3327   BOOST_ASIO_CHECK(called);
3328   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3329
3330   s.reset(read_data, sizeof(read_data));
3331   s.next_read_length(1);
3332   memset(read_buf, 0, sizeof(read_buf));
3333   called = false;
3334   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3335       bindns::bind(async_read_handler,
3336         _1, _2, 42, &called));
3337   ioc.restart();
3338   ioc.run();
3339   BOOST_ASIO_CHECK(called);
3340   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3341
3342   s.reset(read_data, sizeof(read_data));
3343   s.next_read_length(10);
3344   memset(read_buf, 0, sizeof(read_buf));
3345   called = false;
3346   boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
3347       bindns::bind(async_read_handler,
3348         _1, _2, 50, &called));
3349   ioc.restart();
3350   ioc.run();
3351   BOOST_ASIO_CHECK(called);
3352   BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3353
3354   s.reset(read_data, sizeof(read_data));
3355   memset(read_buf, 0, sizeof(read_buf));
3356   called = false;
3357   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3358       bindns::bind(async_read_handler,
3359         _1, _2, 1, &called));
3360   ioc.restart();
3361   ioc.run();
3362   BOOST_ASIO_CHECK(called);
3363   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3364
3365   s.reset(read_data, sizeof(read_data));
3366   s.next_read_length(1);
3367   memset(read_buf, 0, sizeof(read_buf));
3368   called = false;
3369   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3370       bindns::bind(async_read_handler,
3371         _1, _2, 1, &called));
3372   ioc.restart();
3373   ioc.run();
3374   BOOST_ASIO_CHECK(called);
3375   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3376
3377   s.reset(read_data, sizeof(read_data));
3378   s.next_read_length(10);
3379   memset(read_buf, 0, sizeof(read_buf));
3380   called = false;
3381   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(1),
3382       bindns::bind(async_read_handler,
3383         _1, _2, 1, &called));
3384   ioc.restart();
3385   ioc.run();
3386   BOOST_ASIO_CHECK(called);
3387   BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3388
3389   s.reset(read_data, sizeof(read_data));
3390   memset(read_buf, 0, sizeof(read_buf));
3391   called = false;
3392   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3393       bindns::bind(async_read_handler,
3394         _1, _2, 10, &called));
3395   ioc.restart();
3396   ioc.run();
3397   BOOST_ASIO_CHECK(called);
3398   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3399
3400   s.reset(read_data, sizeof(read_data));
3401   s.next_read_length(1);
3402   memset(read_buf, 0, sizeof(read_buf));
3403   called = false;
3404   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3405       bindns::bind(async_read_handler,
3406         _1, _2, 10, &called));
3407   ioc.restart();
3408   ioc.run();
3409   BOOST_ASIO_CHECK(called);
3410   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3411
3412   s.reset(read_data, sizeof(read_data));
3413   s.next_read_length(10);
3414   memset(read_buf, 0, sizeof(read_buf));
3415   called = false;
3416   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(10),
3417       bindns::bind(async_read_handler,
3418         _1, _2, 10, &called));
3419   ioc.restart();
3420   ioc.run();
3421   BOOST_ASIO_CHECK(called);
3422   BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3423
3424   s.reset(read_data, sizeof(read_data));
3425   memset(read_buf, 0, sizeof(read_buf));
3426   called = false;
3427   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3428       bindns::bind(async_read_handler,
3429         _1, _2, 42, &called));
3430   ioc.restart();
3431   ioc.run();
3432   BOOST_ASIO_CHECK(called);
3433   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3434
3435   s.reset(read_data, sizeof(read_data));
3436   s.next_read_length(1);
3437   memset(read_buf, 0, sizeof(read_buf));
3438   called = false;
3439   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3440       bindns::bind(async_read_handler,
3441         _1, _2, 42, &called));
3442   ioc.restart();
3443   ioc.run();
3444   BOOST_ASIO_CHECK(called);
3445   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3446
3447   s.reset(read_data, sizeof(read_data));
3448   s.next_read_length(10);
3449   memset(read_buf, 0, sizeof(read_buf));
3450   called = false;
3451   boost::asio::async_read(s, buffers, boost::asio::transfer_exactly(42),
3452       bindns::bind(async_read_handler,
3453         _1, _2, 42, &called));
3454   ioc.restart();
3455   ioc.run();
3456   BOOST_ASIO_CHECK(called);
3457   BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3458
3459   s.reset(read_data, sizeof(read_data));
3460   memset(read_buf, 0, sizeof(read_buf));
3461   called = false;
3462   boost::asio::async_read(s, buffers, old_style_transfer_all,
3463       bindns::bind(async_read_handler,
3464         _1, _2, sizeof(read_data), &called));
3465   ioc.restart();
3466   ioc.run();
3467   BOOST_ASIO_CHECK(called);
3468   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3469
3470   s.reset(read_data, sizeof(read_data));
3471   s.next_read_length(1);
3472   memset(read_buf, 0, sizeof(read_buf));
3473   called = false;
3474   boost::asio::async_read(s, buffers, old_style_transfer_all,
3475       bindns::bind(async_read_handler,
3476         _1, _2, sizeof(read_data), &called));
3477   ioc.restart();
3478   ioc.run();
3479   BOOST_ASIO_CHECK(called);
3480   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3481
3482   s.reset(read_data, sizeof(read_data));
3483   s.next_read_length(10);
3484   memset(read_buf, 0, sizeof(read_buf));
3485   called = false;
3486   boost::asio::async_read(s, buffers, old_style_transfer_all,
3487       bindns::bind(async_read_handler,
3488         _1, _2, sizeof(read_data), &called));
3489   ioc.restart();
3490   ioc.run();
3491   BOOST_ASIO_CHECK(called);
3492   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3493
3494   s.reset(read_data, sizeof(read_data));
3495   memset(read_buf, 0, sizeof(read_buf));
3496   called = false;
3497   boost::asio::async_read(s, buffers, short_transfer,
3498       bindns::bind(async_read_handler,
3499         _1, _2, sizeof(read_data), &called));
3500   ioc.restart();
3501   ioc.run();
3502   BOOST_ASIO_CHECK(called);
3503   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3504
3505   s.reset(read_data, sizeof(read_data));
3506   s.next_read_length(1);
3507   memset(read_buf, 0, sizeof(read_buf));
3508   called = false;
3509   boost::asio::async_read(s, buffers, short_transfer,
3510       bindns::bind(async_read_handler,
3511         _1, _2, sizeof(read_data), &called));
3512   ioc.restart();
3513   ioc.run();
3514   BOOST_ASIO_CHECK(called);
3515   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3516
3517   s.reset(read_data, sizeof(read_data));
3518   s.next_read_length(10);
3519   memset(read_buf, 0, sizeof(read_buf));
3520   called = false;
3521   boost::asio::async_read(s, buffers, short_transfer,
3522       bindns::bind(async_read_handler,
3523         _1, _2, sizeof(read_data), &called));
3524   ioc.restart();
3525   ioc.run();
3526   BOOST_ASIO_CHECK(called);
3527   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3528
3529   s.reset(read_data, sizeof(read_data));
3530   memset(read_buf, 0, sizeof(read_buf));
3531   int i = boost::asio::async_read(s, buffers,
3532       short_transfer, archetypes::lazy_handler());
3533   BOOST_ASIO_CHECK(i == 42);
3534   ioc.restart();
3535   ioc.run();
3536   BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3537 }
3538
3539 void test_4_arg_streambuf_async_read()
3540 {
3541 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3542   namespace bindns = boost;
3543 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3544   namespace bindns = std;
3545   using std::placeholders::_1;
3546   using std::placeholders::_2;
3547 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3548
3549   boost::asio::io_context ioc;
3550   test_stream s(ioc);
3551   boost::asio::streambuf sb(sizeof(read_data));
3552
3553   s.reset(read_data, sizeof(read_data));
3554   sb.consume(sb.size());
3555   bool called = false;
3556   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
3557       bindns::bind(async_read_handler,
3558         _1, _2, sizeof(read_data), &called));
3559   ioc.restart();
3560   ioc.run();
3561   BOOST_ASIO_CHECK(called);
3562   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3563   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3564
3565   s.reset(read_data, sizeof(read_data));
3566   s.next_read_length(1);
3567   sb.consume(sb.size());
3568   called = false;
3569   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
3570       bindns::bind(async_read_handler,
3571         _1, _2, sizeof(read_data), &called));
3572   ioc.restart();
3573   ioc.run();
3574   BOOST_ASIO_CHECK(called);
3575   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3576   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3577
3578   s.reset(read_data, sizeof(read_data));
3579   s.next_read_length(10);
3580   sb.consume(sb.size());
3581   called = false;
3582   boost::asio::async_read(s, sb, boost::asio::transfer_all(),
3583       bindns::bind(async_read_handler,
3584         _1, _2, sizeof(read_data), &called));
3585   ioc.restart();
3586   ioc.run();
3587   BOOST_ASIO_CHECK(called);
3588   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3589   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3590
3591   s.reset(read_data, sizeof(read_data));
3592   sb.consume(sb.size());
3593   called = false;
3594   boost::asio::async_read(s, sb, 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(sb.size() == sizeof(read_data));
3601   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3602
3603   s.reset(read_data, sizeof(read_data));
3604   s.next_read_length(1);
3605   sb.consume(sb.size());
3606   called = false;
3607   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
3608       bindns::bind(async_read_handler,
3609         _1, _2, 1, &called));
3610   ioc.restart();
3611   ioc.run();
3612   BOOST_ASIO_CHECK(called);
3613   BOOST_ASIO_CHECK(sb.size() == 1);
3614   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
3615
3616   s.reset(read_data, sizeof(read_data));
3617   s.next_read_length(10);
3618   sb.consume(sb.size());
3619   called = false;
3620   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
3621       bindns::bind(async_read_handler,
3622         _1, _2, 10, &called));
3623   ioc.restart();
3624   ioc.run();
3625   BOOST_ASIO_CHECK(called);
3626   BOOST_ASIO_CHECK(sb.size() == 10);
3627   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
3628
3629   s.reset(read_data, sizeof(read_data));
3630   sb.consume(sb.size());
3631   called = false;
3632   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
3633       bindns::bind(async_read_handler,
3634         _1, _2, sizeof(read_data), &called));
3635   ioc.restart();
3636   ioc.run();
3637   BOOST_ASIO_CHECK(called);
3638   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3639   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3640
3641   s.reset(read_data, sizeof(read_data));
3642   s.next_read_length(1);
3643   sb.consume(sb.size());
3644   called = false;
3645   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
3646       bindns::bind(async_read_handler,
3647         _1, _2, 10, &called));
3648   ioc.restart();
3649   ioc.run();
3650   BOOST_ASIO_CHECK(called);
3651   BOOST_ASIO_CHECK(sb.size() == 10);
3652   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
3653
3654   s.reset(read_data, sizeof(read_data));
3655   s.next_read_length(10);
3656   sb.consume(sb.size());
3657   called = false;
3658   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
3659       bindns::bind(async_read_handler,
3660         _1, _2, 10, &called));
3661   ioc.restart();
3662   ioc.run();
3663   BOOST_ASIO_CHECK(called);
3664   BOOST_ASIO_CHECK(sb.size() == 10);
3665   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
3666
3667   s.reset(read_data, sizeof(read_data));
3668   sb.consume(sb.size());
3669   called = false;
3670   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
3671       bindns::bind(async_read_handler,
3672         _1, _2, sizeof(read_data), &called));
3673   ioc.restart();
3674   ioc.run();
3675   BOOST_ASIO_CHECK(called);
3676   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3677   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3678
3679   s.reset(read_data, sizeof(read_data));
3680   s.next_read_length(1);
3681   sb.consume(sb.size());
3682   called = false;
3683   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
3684       bindns::bind(async_read_handler,
3685         _1, _2, 42, &called));
3686   ioc.restart();
3687   ioc.run();
3688   BOOST_ASIO_CHECK(called);
3689   BOOST_ASIO_CHECK(sb.size() == 42);
3690   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
3691
3692   s.reset(read_data, sizeof(read_data));
3693   s.next_read_length(10);
3694   sb.consume(sb.size());
3695   called = false;
3696   boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
3697       bindns::bind(async_read_handler,
3698         _1, _2, 50, &called));
3699   ioc.restart();
3700   ioc.run();
3701   BOOST_ASIO_CHECK(called);
3702   BOOST_ASIO_CHECK(sb.size() == 50);
3703   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
3704
3705   s.reset(read_data, sizeof(read_data));
3706   sb.consume(sb.size());
3707   called = false;
3708   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
3709       bindns::bind(async_read_handler,
3710         _1, _2, 1, &called));
3711   ioc.restart();
3712   ioc.run();
3713   BOOST_ASIO_CHECK(called);
3714   BOOST_ASIO_CHECK(sb.size() == 1);
3715   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
3716
3717   s.reset(read_data, sizeof(read_data));
3718   s.next_read_length(1);
3719   sb.consume(sb.size());
3720   called = false;
3721   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
3722       bindns::bind(async_read_handler,
3723         _1, _2, 1, &called));
3724   ioc.restart();
3725   ioc.run();
3726   BOOST_ASIO_CHECK(called);
3727   BOOST_ASIO_CHECK(sb.size() == 1);
3728   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
3729
3730   s.reset(read_data, sizeof(read_data));
3731   s.next_read_length(10);
3732   sb.consume(sb.size());
3733   called = false;
3734   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(1),
3735       bindns::bind(async_read_handler,
3736         _1, _2, 1, &called));
3737   ioc.restart();
3738   ioc.run();
3739   BOOST_ASIO_CHECK(called);
3740   BOOST_ASIO_CHECK(sb.size() == 1);
3741   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
3742
3743   s.reset(read_data, sizeof(read_data));
3744   sb.consume(sb.size());
3745   called = false;
3746   boost::asio::async_read(s, sb, 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(sb.size() == 10);
3753   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
3754
3755   s.reset(read_data, sizeof(read_data));
3756   s.next_read_length(1);
3757   sb.consume(sb.size());
3758   called = false;
3759   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
3760       bindns::bind(async_read_handler,
3761         _1, _2, 10, &called));
3762   ioc.restart();
3763   ioc.run();
3764   BOOST_ASIO_CHECK(called);
3765   BOOST_ASIO_CHECK(sb.size() == 10);
3766   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
3767
3768   s.reset(read_data, sizeof(read_data));
3769   s.next_read_length(10);
3770   sb.consume(sb.size());
3771   called = false;
3772   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(10),
3773       bindns::bind(async_read_handler,
3774         _1, _2, 10, &called));
3775   ioc.restart();
3776   ioc.run();
3777   BOOST_ASIO_CHECK(called);
3778   BOOST_ASIO_CHECK(sb.size() == 10);
3779   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
3780
3781   s.reset(read_data, sizeof(read_data));
3782   sb.consume(sb.size());
3783   called = false;
3784   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
3785       bindns::bind(async_read_handler,
3786         _1, _2, 42, &called));
3787   ioc.restart();
3788   ioc.run();
3789   BOOST_ASIO_CHECK(called);
3790   BOOST_ASIO_CHECK(sb.size() == 42);
3791   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
3792
3793   s.reset(read_data, sizeof(read_data));
3794   s.next_read_length(1);
3795   sb.consume(sb.size());
3796   called = false;
3797   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
3798       bindns::bind(async_read_handler,
3799         _1, _2, 42, &called));
3800   ioc.restart();
3801   ioc.run();
3802   BOOST_ASIO_CHECK(called);
3803   BOOST_ASIO_CHECK(sb.size() == 42);
3804   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
3805
3806   s.reset(read_data, sizeof(read_data));
3807   s.next_read_length(10);
3808   sb.consume(sb.size());
3809   called = false;
3810   boost::asio::async_read(s, sb, boost::asio::transfer_exactly(42),
3811       bindns::bind(async_read_handler,
3812         _1, _2, 42, &called));
3813   ioc.restart();
3814   ioc.run();
3815   BOOST_ASIO_CHECK(called);
3816   BOOST_ASIO_CHECK(sb.size() == 42);
3817   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
3818
3819   s.reset(read_data, sizeof(read_data));
3820   sb.consume(sb.size());
3821   called = false;
3822   boost::asio::async_read(s, sb, old_style_transfer_all,
3823       bindns::bind(async_read_handler,
3824         _1, _2, sizeof(read_data), &called));
3825   ioc.restart();
3826   ioc.run();
3827   BOOST_ASIO_CHECK(called);
3828   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3829   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3830
3831   s.reset(read_data, sizeof(read_data));
3832   s.next_read_length(1);
3833   sb.consume(sb.size());
3834   called = false;
3835   boost::asio::async_read(s, sb, old_style_transfer_all,
3836       bindns::bind(async_read_handler,
3837         _1, _2, sizeof(read_data), &called));
3838   ioc.restart();
3839   ioc.run();
3840   BOOST_ASIO_CHECK(called);
3841   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3842   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3843
3844   s.reset(read_data, sizeof(read_data));
3845   s.next_read_length(10);
3846   sb.consume(sb.size());
3847   called = false;
3848   boost::asio::async_read(s, sb, old_style_transfer_all,
3849       bindns::bind(async_read_handler,
3850         _1, _2, sizeof(read_data), &called));
3851   ioc.restart();
3852   ioc.run();
3853   BOOST_ASIO_CHECK(called);
3854   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3855   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3856
3857   s.reset(read_data, sizeof(read_data));
3858   sb.consume(sb.size());
3859   called = false;
3860   boost::asio::async_read(s, sb, short_transfer,
3861       bindns::bind(async_read_handler,
3862         _1, _2, sizeof(read_data), &called));
3863   ioc.restart();
3864   ioc.run();
3865   BOOST_ASIO_CHECK(called);
3866   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3867   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3868
3869   s.reset(read_data, sizeof(read_data));
3870   s.next_read_length(1);
3871   sb.consume(sb.size());
3872   called = false;
3873   boost::asio::async_read(s, sb, short_transfer,
3874       bindns::bind(async_read_handler,
3875         _1, _2, sizeof(read_data), &called));
3876   ioc.restart();
3877   ioc.run();
3878   BOOST_ASIO_CHECK(called);
3879   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3880   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3881
3882   s.reset(read_data, sizeof(read_data));
3883   s.next_read_length(10);
3884   sb.consume(sb.size());
3885   called = false;
3886   boost::asio::async_read(s, sb, short_transfer,
3887       bindns::bind(async_read_handler,
3888         _1, _2, sizeof(read_data), &called));
3889   ioc.restart();
3890   ioc.run();
3891   BOOST_ASIO_CHECK(called);
3892   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3893   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3894
3895   s.reset(read_data, sizeof(read_data));
3896   sb.consume(sb.size());
3897   int i = boost::asio::async_read(s, sb,
3898       short_transfer, archetypes::lazy_handler());
3899   BOOST_ASIO_CHECK(i == 42);
3900   ioc.restart();
3901   ioc.run();
3902   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3903   BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
3904 }
3905
3906 BOOST_ASIO_TEST_SUITE
3907 (
3908   "read",
3909   BOOST_ASIO_TEST_CASE(test_2_arg_zero_buffers_read)
3910   BOOST_ASIO_TEST_CASE(test_2_arg_mutable_buffer_read)
3911   BOOST_ASIO_TEST_CASE(test_2_arg_vector_buffers_read)
3912   BOOST_ASIO_TEST_CASE(test_2_arg_streambuf_read)
3913   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_read)
3914   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_read)
3915   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_read)
3916   BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_streambuf_read)
3917   BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_read)
3918   BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_read)
3919   BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_read)
3920   BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_read)
3921   BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_read)
3922   BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_read)
3923   BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_read)
3924   BOOST_ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_read)
3925   BOOST_ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_read)
3926   BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_async_read)
3927   BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_async_read)
3928   BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read)
3929   BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read)
3930   BOOST_ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read)
3931   BOOST_ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read)
3932   BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_async_read)
3933 )