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