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

   1 //
   2 // read_at.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_at.hpp>
  18
  19 #include <cstring>
  20 #include "archetypes/async_result.hpp"
  21 #include <boost/asio/io_context.hpp>
  22 #include <boost/asio/post.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_random_access_device
  43 {
  44 public:
  45   typedef boost::asio::io_context::executor_type executor_type;
  46
  47   test_random_access_device(boost::asio::io_context& io_context)
  48     : io_context_(io_context),
  49       length_(0),
  50       next_read_length_(0)
  51   {
  52   }
  53
  54   executor_type get_executor() BOOST_ASIO_NOEXCEPT
  55   {
  56     return io_context_.get_executor();
  57   }
  58
  59   void reset(const void* data, size_t length)
  60   {
  61     BOOST_ASIO_CHECK(length <= max_length);
  62
  63     length_ = 0;
  64     while (length_ + length < max_length)
  65     {
  66       memcpy(data_ + length_, data, length);
  67       length_ += length;
  68     }
  69
  70     next_read_length_ = length;
  71   }
  72
  73   void next_read_length(size_t length)
  74   {
  75     next_read_length_ = length;
  76   }
  77
  78   template <typename Iterator>
  79   bool check_buffers(boost::asio::uint64_t offset,
  80       Iterator begin, Iterator end, size_t length)
  81   {
  82     if (offset + length > max_length)
  83       return false;
  84
  85     Iterator iter = begin;
  86     size_t checked_length = 0;
  87     for (; iter != end && checked_length < length; ++iter)
  88     {
  89       size_t buffer_length = boost::asio::buffer_size(*iter);
  90       if (buffer_length > length - checked_length)
  91         buffer_length = length - checked_length;
  92       if (memcmp(data_ + offset + checked_length,
  93             iter->data(), buffer_length) != 0)
  94         return false;
  95       checked_length += buffer_length;
  96     }
  97
  98     return true;
  99   }
 100
 101   template <typename Const_Buffers>
 102   bool check_buffers(boost::asio::uint64_t offset,
 103       const Const_Buffers& buffers, size_t length)
 104   {
 105     return check_buffers(offset, boost::asio::buffer_sequence_begin(buffers),
 106         boost::asio::buffer_sequence_end(buffers), length);
 107   }
 108
 109   template <typename Mutable_Buffers>
 110   size_t read_some_at(boost::asio::uint64_t offset,
 111       const Mutable_Buffers& buffers)
 112   {
 113     return boost::asio::buffer_copy(buffers,
 114         boost::asio::buffer(data_, length_) + offset,
 115         next_read_length_);
 116   }
 117
 118   template <typename Mutable_Buffers>
 119   size_t read_some_at(boost::asio::uint64_t offset,
 120       const Mutable_Buffers& buffers, boost::system::error_code& ec)
 121   {
 122     ec = boost::system::error_code();
 123     return read_some_at(offset, buffers);
 124   }
 125
 126   template <typename Mutable_Buffers, typename Handler>
 127   void async_read_some_at(boost::asio::uint64_t offset,
 128       const Mutable_Buffers& buffers, Handler handler)
 129   {
 130     size_t bytes_transferred = read_some_at(offset, buffers);
 131     boost::asio::post(get_executor(),
 132         boost::asio::detail::bind_handler(
 133           BOOST_ASIO_MOVE_CAST(Handler)(handler),
 134           boost::system::error_code(), bytes_transferred));
 135   }
 136
 137 private:
 138   boost::asio::io_context& io_context_;
 139   enum { max_length = 8192 };
 140   char data_[max_length];
 141   size_t length_;
 142   size_t next_read_length_;
 143 };
 144
 145 static const char read_data[]
 146   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 147
 148 void test_3_arg_mutable_buffer_read_at()
 149 {
 150   boost::asio::io_context ioc;
 151   test_random_access_device s(ioc);
 152   char read_buf[sizeof(read_data)];
 153   boost::asio::mutable_buffer buffers
 154     = boost::asio::buffer(read_buf, sizeof(read_buf));
 155
 156   s.reset(read_data, sizeof(read_data));
 157   memset(read_buf, 0, sizeof(read_buf));
 158   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers);
 159   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 160   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 161
 162   s.reset(read_data, sizeof(read_data));
 163   memset(read_buf, 0, sizeof(read_buf));
 164   bytes_transferred = boost::asio::read_at(s, 1234, buffers);
 165   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 166   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 167
 168   s.reset(read_data, sizeof(read_data));
 169   s.next_read_length(1);
 170   memset(read_buf, 0, sizeof(read_buf));
 171   bytes_transferred = boost::asio::read_at(s, 0, buffers);
 172   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 173   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 174
 175   s.reset(read_data, sizeof(read_data));
 176   s.next_read_length(1);
 177   memset(read_buf, 0, sizeof(read_buf));
 178   bytes_transferred = boost::asio::read_at(s, 1234, buffers);
 179   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 180   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 181
 182   s.reset(read_data, sizeof(read_data));
 183   s.next_read_length(10);
 184   memset(read_buf, 0, sizeof(read_buf));
 185   bytes_transferred = boost::asio::read_at(s, 0, buffers);
 186   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 187   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 188
 189   s.reset(read_data, sizeof(read_data));
 190   s.next_read_length(10);
 191   memset(read_buf, 0, sizeof(read_buf));
 192   bytes_transferred = boost::asio::read_at(s, 1234, buffers);
 193   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 194   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 195 }
 196
 197 void test_3_arg_vector_buffers_read_at()
 198 {
 199   boost::asio::io_context ioc;
 200   test_random_access_device s(ioc);
 201   char read_buf[sizeof(read_data)];
 202   std::vector<boost::asio::mutable_buffer> buffers;
 203   buffers.push_back(boost::asio::buffer(read_buf, 32));
 204   buffers.push_back(boost::asio::buffer(read_buf) + 32);
 205
 206   s.reset(read_data, sizeof(read_data));
 207   memset(read_buf, 0, sizeof(read_buf));
 208   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers);
 209   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 210   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 211
 212   s.reset(read_data, sizeof(read_data));
 213   memset(read_buf, 0, sizeof(read_buf));
 214   bytes_transferred = boost::asio::read_at(s, 1234, buffers);
 215   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 216   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 217
 218   s.reset(read_data, sizeof(read_data));
 219   s.next_read_length(1);
 220   memset(read_buf, 0, sizeof(read_buf));
 221   bytes_transferred = boost::asio::read_at(s, 0, buffers);
 222   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 223   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 224
 225   s.reset(read_data, sizeof(read_data));
 226   s.next_read_length(1);
 227   memset(read_buf, 0, sizeof(read_buf));
 228   bytes_transferred = boost::asio::read_at(s, 1234, buffers);
 229   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 230   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 231
 232   s.reset(read_data, sizeof(read_data));
 233   s.next_read_length(10);
 234   memset(read_buf, 0, sizeof(read_buf));
 235   bytes_transferred = boost::asio::read_at(s, 0, buffers);
 236   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 237   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 238
 239   s.reset(read_data, sizeof(read_data));
 240   s.next_read_length(10);
 241   memset(read_buf, 0, sizeof(read_buf));
 242   bytes_transferred = boost::asio::read_at(s, 1234, buffers);
 243   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 244   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 245 }
 246
 247 void test_3_arg_streambuf_read_at()
 248 {
 249   boost::asio::io_context ioc;
 250   test_random_access_device s(ioc);
 251   boost::asio::streambuf sb(sizeof(read_data));
 252
 253   s.reset(read_data, sizeof(read_data));
 254   sb.consume(sb.size());
 255   size_t bytes_transferred = boost::asio::read_at(s, 0, sb);
 256   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 257   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 258   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
 259
 260   s.reset(read_data, sizeof(read_data));
 261   sb.consume(sb.size());
 262   bytes_transferred = boost::asio::read_at(s, 1234, sb);
 263   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 264   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 265   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
 266
 267   s.reset(read_data, sizeof(read_data));
 268   s.next_read_length(1);
 269   sb.consume(sb.size());
 270   bytes_transferred = boost::asio::read_at(s, 0, sb);
 271   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 272   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 273   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
 274
 275   s.reset(read_data, sizeof(read_data));
 276   s.next_read_length(1);
 277   sb.consume(sb.size());
 278   bytes_transferred = boost::asio::read_at(s, 1234, sb);
 279   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 280   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 281   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
 282
 283   s.reset(read_data, sizeof(read_data));
 284   s.next_read_length(10);
 285   sb.consume(sb.size());
 286   bytes_transferred = boost::asio::read_at(s, 0, sb);
 287   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 288   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 289   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
 290
 291   s.reset(read_data, sizeof(read_data));
 292   s.next_read_length(10);
 293   sb.consume(sb.size());
 294   bytes_transferred = boost::asio::read_at(s, 1234, sb);
 295   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 296   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 297   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
 298 }
 299
 300 void test_4_arg_nothrow_mutable_buffer_read_at()
 301 {
 302   boost::asio::io_context ioc;
 303   test_random_access_device s(ioc);
 304   char read_buf[sizeof(read_data)];
 305   boost::asio::mutable_buffer buffers
 306     = boost::asio::buffer(read_buf, sizeof(read_buf));
 307
 308   s.reset(read_data, sizeof(read_data));
 309   memset(read_buf, 0, sizeof(read_buf));
 310   boost::system::error_code error;
 311   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
 312   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 313   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 314   BOOST_ASIO_CHECK(!error);
 315
 316   s.reset(read_data, sizeof(read_data));
 317   memset(read_buf, 0, sizeof(read_buf));
 318   bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
 319   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 320   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 321   BOOST_ASIO_CHECK(!error);
 322
 323   s.reset(read_data, sizeof(read_data));
 324   s.next_read_length(1);
 325   memset(read_buf, 0, sizeof(read_buf));
 326   bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
 327   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 328   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 329   BOOST_ASIO_CHECK(!error);
 330
 331   s.reset(read_data, sizeof(read_data));
 332   s.next_read_length(1);
 333   memset(read_buf, 0, sizeof(read_buf));
 334   bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
 335   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 336   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 337   BOOST_ASIO_CHECK(!error);
 338
 339   s.reset(read_data, sizeof(read_data));
 340   s.next_read_length(10);
 341   memset(read_buf, 0, sizeof(read_buf));
 342   bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
 343   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 344   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 345   BOOST_ASIO_CHECK(!error);
 346
 347   s.reset(read_data, sizeof(read_data));
 348   s.next_read_length(10);
 349   memset(read_buf, 0, sizeof(read_buf));
 350   bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
 351   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 352   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 353   BOOST_ASIO_CHECK(!error);
 354 }
 355
 356 void test_4_arg_nothrow_vector_buffers_read_at()
 357 {
 358   boost::asio::io_context ioc;
 359   test_random_access_device s(ioc);
 360   char read_buf[sizeof(read_data)];
 361   std::vector<boost::asio::mutable_buffer> buffers;
 362   buffers.push_back(boost::asio::buffer(read_buf, 32));
 363   buffers.push_back(boost::asio::buffer(read_buf) + 32);
 364
 365   s.reset(read_data, sizeof(read_data));
 366   memset(read_buf, 0, sizeof(read_buf));
 367   boost::system::error_code error;
 368   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
 369   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 370   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 371   BOOST_ASIO_CHECK(!error);
 372
 373   s.reset(read_data, sizeof(read_data));
 374   memset(read_buf, 0, sizeof(read_buf));
 375   bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
 376   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 377   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 378   BOOST_ASIO_CHECK(!error);
 379
 380   s.reset(read_data, sizeof(read_data));
 381   s.next_read_length(1);
 382   memset(read_buf, 0, sizeof(read_buf));
 383   bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
 384   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 385   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 386   BOOST_ASIO_CHECK(!error);
 387
 388   s.reset(read_data, sizeof(read_data));
 389   s.next_read_length(1);
 390   memset(read_buf, 0, sizeof(read_buf));
 391   bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
 392   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 393   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 394   BOOST_ASIO_CHECK(!error);
 395
 396   s.reset(read_data, sizeof(read_data));
 397   s.next_read_length(10);
 398   memset(read_buf, 0, sizeof(read_buf));
 399   bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
 400   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 401   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 402   BOOST_ASIO_CHECK(!error);
 403
 404   s.reset(read_data, sizeof(read_data));
 405   s.next_read_length(10);
 406   memset(read_buf, 0, sizeof(read_buf));
 407   bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
 408   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 409   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 410   BOOST_ASIO_CHECK(!error);
 411 }
 412
 413 void test_4_arg_nothrow_streambuf_read_at()
 414 {
 415   boost::asio::io_context ioc;
 416   test_random_access_device s(ioc);
 417   boost::asio::streambuf sb(sizeof(read_data));
 418
 419   s.reset(read_data, sizeof(read_data));
 420   sb.consume(sb.size());
 421   boost::system::error_code error;
 422   size_t bytes_transferred = boost::asio::read_at(s, 0, sb, error);
 423   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 424   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 425   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
 426   BOOST_ASIO_CHECK(!error);
 427
 428   s.reset(read_data, sizeof(read_data));
 429   sb.consume(sb.size());
 430   bytes_transferred = boost::asio::read_at(s, 1234, sb, error);
 431   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 432   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 433   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
 434   BOOST_ASIO_CHECK(!error);
 435
 436   s.reset(read_data, sizeof(read_data));
 437   s.next_read_length(1);
 438   sb.consume(sb.size());
 439   bytes_transferred = boost::asio::read_at(s, 0, sb, error);
 440   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 441   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 442   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
 443   BOOST_ASIO_CHECK(!error);
 444
 445   s.reset(read_data, sizeof(read_data));
 446   s.next_read_length(1);
 447   sb.consume(sb.size());
 448   bytes_transferred = boost::asio::read_at(s, 1234, sb, error);
 449   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 450   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 451   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
 452   BOOST_ASIO_CHECK(!error);
 453
 454   s.reset(read_data, sizeof(read_data));
 455   s.next_read_length(10);
 456   sb.consume(sb.size());
 457   bytes_transferred = boost::asio::read_at(s, 0, sb, error);
 458   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 459   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 460   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
 461   BOOST_ASIO_CHECK(!error);
 462
 463   s.reset(read_data, sizeof(read_data));
 464   s.next_read_length(10);
 465   sb.consume(sb.size());
 466   bytes_transferred = boost::asio::read_at(s, 1234, sb, error);
 467   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 468   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
 469   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
 470   BOOST_ASIO_CHECK(!error);
 471 }
 472
 473 bool old_style_transfer_all(const boost::system::error_code& ec,
 474     size_t /*bytes_transferred*/)
 475 {
 476   return !!ec;
 477 }
 478
 479 size_t short_transfer(const boost::system::error_code& ec,
 480     size_t /*bytes_transferred*/)
 481 {
 482   return !!ec ? 0 : 3;
 483 }
 484
 485 void test_4_arg_mutable_buffer_read_at()
 486 {
 487   boost::asio::io_context ioc;
 488   test_random_access_device s(ioc);
 489   char read_buf[sizeof(read_data)];
 490   boost::asio::mutable_buffer buffers
 491     = boost::asio::buffer(read_buf, sizeof(read_buf));
 492
 493   s.reset(read_data, sizeof(read_data));
 494   memset(read_buf, 0, sizeof(read_buf));
 495   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers,
 496       boost::asio::transfer_all());
 497   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 498   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 499
 500   s.reset(read_data, sizeof(read_data));
 501   memset(read_buf, 0, sizeof(read_buf));
 502   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 503       boost::asio::transfer_all());
 504   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 505   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 506
 507   s.reset(read_data, sizeof(read_data));
 508   s.next_read_length(1);
 509   memset(read_buf, 0, sizeof(read_buf));
 510   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 511       boost::asio::transfer_all());
 512   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 513   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 514
 515   s.reset(read_data, sizeof(read_data));
 516   s.next_read_length(1);
 517   memset(read_buf, 0, sizeof(read_buf));
 518   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 519       boost::asio::transfer_all());
 520   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 521   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 522
 523   s.reset(read_data, sizeof(read_data));
 524   s.next_read_length(10);
 525   memset(read_buf, 0, sizeof(read_buf));
 526   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 527       boost::asio::transfer_all());
 528   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 529   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 530
 531   s.reset(read_data, sizeof(read_data));
 532   s.next_read_length(10);
 533   memset(read_buf, 0, sizeof(read_buf));
 534   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 535       boost::asio::transfer_all());
 536   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 537   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 538
 539   s.reset(read_data, sizeof(read_data));
 540   memset(read_buf, 0, sizeof(read_buf));
 541   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 542       boost::asio::transfer_at_least(1));
 543   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 544   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 545
 546   s.reset(read_data, sizeof(read_data));
 547   memset(read_buf, 0, sizeof(read_buf));
 548   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 549       boost::asio::transfer_at_least(1));
 550   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 551   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 552
 553   s.reset(read_data, sizeof(read_data));
 554   s.next_read_length(1);
 555   memset(read_buf, 0, sizeof(read_buf));
 556   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 557       boost::asio::transfer_at_least(1));
 558   BOOST_ASIO_CHECK(bytes_transferred == 1);
 559   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
 560
 561   s.reset(read_data, sizeof(read_data));
 562   s.next_read_length(1);
 563   memset(read_buf, 0, sizeof(read_buf));
 564   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 565       boost::asio::transfer_at_least(1));
 566   BOOST_ASIO_CHECK(bytes_transferred == 1);
 567   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
 568
 569   s.reset(read_data, sizeof(read_data));
 570   s.next_read_length(10);
 571   memset(read_buf, 0, sizeof(read_buf));
 572   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 573       boost::asio::transfer_at_least(1));
 574   BOOST_ASIO_CHECK(bytes_transferred == 10);
 575   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 576
 577   s.reset(read_data, sizeof(read_data));
 578   s.next_read_length(10);
 579   memset(read_buf, 0, sizeof(read_buf));
 580   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 581       boost::asio::transfer_at_least(1));
 582   BOOST_ASIO_CHECK(bytes_transferred == 10);
 583   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
 584
 585   s.reset(read_data, sizeof(read_data));
 586   memset(read_buf, 0, sizeof(read_buf));
 587   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 588       boost::asio::transfer_at_least(10));
 589   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 590   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 591
 592   s.reset(read_data, sizeof(read_data));
 593   memset(read_buf, 0, sizeof(read_buf));
 594   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 595       boost::asio::transfer_at_least(10));
 596   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 597   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 598
 599   s.reset(read_data, sizeof(read_data));
 600   s.next_read_length(1);
 601   memset(read_buf, 0, sizeof(read_buf));
 602   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 603       boost::asio::transfer_at_least(10));
 604   BOOST_ASIO_CHECK(bytes_transferred == 10);
 605   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 606
 607   s.reset(read_data, sizeof(read_data));
 608   s.next_read_length(1);
 609   memset(read_buf, 0, sizeof(read_buf));
 610   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 611       boost::asio::transfer_at_least(10));
 612   BOOST_ASIO_CHECK(bytes_transferred == 10);
 613   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
 614
 615   s.reset(read_data, sizeof(read_data));
 616   s.next_read_length(10);
 617   memset(read_buf, 0, sizeof(read_buf));
 618   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 619       boost::asio::transfer_at_least(10));
 620   BOOST_ASIO_CHECK(bytes_transferred == 10);
 621   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 622
 623   s.reset(read_data, sizeof(read_data));
 624   s.next_read_length(10);
 625   memset(read_buf, 0, sizeof(read_buf));
 626   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 627       boost::asio::transfer_at_least(10));
 628   BOOST_ASIO_CHECK(bytes_transferred == 10);
 629   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
 630
 631   s.reset(read_data, sizeof(read_data));
 632   memset(read_buf, 0, sizeof(read_buf));
 633   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 634       boost::asio::transfer_at_least(42));
 635   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 636   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 637
 638   s.reset(read_data, sizeof(read_data));
 639   memset(read_buf, 0, sizeof(read_buf));
 640   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 641       boost::asio::transfer_at_least(42));
 642   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 643   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 644
 645   s.reset(read_data, sizeof(read_data));
 646   s.next_read_length(1);
 647   memset(read_buf, 0, sizeof(read_buf));
 648   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 649       boost::asio::transfer_at_least(42));
 650   BOOST_ASIO_CHECK(bytes_transferred == 42);
 651   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
 652
 653   s.reset(read_data, sizeof(read_data));
 654   s.next_read_length(1);
 655   memset(read_buf, 0, sizeof(read_buf));
 656   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 657       boost::asio::transfer_at_least(42));
 658   BOOST_ASIO_CHECK(bytes_transferred == 42);
 659   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
 660
 661   s.reset(read_data, sizeof(read_data));
 662   s.next_read_length(10);
 663   memset(read_buf, 0, sizeof(read_buf));
 664   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 665       boost::asio::transfer_at_least(42));
 666   BOOST_ASIO_CHECK(bytes_transferred == 50);
 667   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
 668
 669   s.reset(read_data, sizeof(read_data));
 670   s.next_read_length(10);
 671   memset(read_buf, 0, sizeof(read_buf));
 672   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 673       boost::asio::transfer_at_least(42));
 674   BOOST_ASIO_CHECK(bytes_transferred == 50);
 675   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
 676
 677   s.reset(read_data, sizeof(read_data));
 678   memset(read_buf, 0, sizeof(read_buf));
 679   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 680       boost::asio::transfer_exactly(1));
 681   BOOST_ASIO_CHECK(bytes_transferred == 1);
 682   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
 683
 684   s.reset(read_data, sizeof(read_data));
 685   memset(read_buf, 0, sizeof(read_buf));
 686   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 687       boost::asio::transfer_exactly(1));
 688   BOOST_ASIO_CHECK(bytes_transferred == 1);
 689   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
 690
 691   s.reset(read_data, sizeof(read_data));
 692   s.next_read_length(1);
 693   memset(read_buf, 0, sizeof(read_buf));
 694   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 695       boost::asio::transfer_exactly(1));
 696   BOOST_ASIO_CHECK(bytes_transferred == 1);
 697   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
 698
 699   s.reset(read_data, sizeof(read_data));
 700   s.next_read_length(1);
 701   memset(read_buf, 0, sizeof(read_buf));
 702   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 703       boost::asio::transfer_exactly(1));
 704   BOOST_ASIO_CHECK(bytes_transferred == 1);
 705   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
 706
 707   s.reset(read_data, sizeof(read_data));
 708   s.next_read_length(10);
 709   memset(read_buf, 0, sizeof(read_buf));
 710   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 711       boost::asio::transfer_exactly(1));
 712   BOOST_ASIO_CHECK(bytes_transferred == 1);
 713   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
 714
 715   s.reset(read_data, sizeof(read_data));
 716   s.next_read_length(10);
 717   memset(read_buf, 0, sizeof(read_buf));
 718   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 719       boost::asio::transfer_exactly(1));
 720   BOOST_ASIO_CHECK(bytes_transferred == 1);
 721   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
 722
 723   s.reset(read_data, sizeof(read_data));
 724   memset(read_buf, 0, sizeof(read_buf));
 725   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 726       boost::asio::transfer_exactly(10));
 727   BOOST_ASIO_CHECK(bytes_transferred == 10);
 728   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 729
 730   s.reset(read_data, sizeof(read_data));
 731   memset(read_buf, 0, sizeof(read_buf));
 732   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 733       boost::asio::transfer_exactly(10));
 734   BOOST_ASIO_CHECK(bytes_transferred == 10);
 735   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
 736
 737   s.reset(read_data, sizeof(read_data));
 738   s.next_read_length(1);
 739   memset(read_buf, 0, sizeof(read_buf));
 740   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 741       boost::asio::transfer_exactly(10));
 742   BOOST_ASIO_CHECK(bytes_transferred == 10);
 743   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 744
 745   s.reset(read_data, sizeof(read_data));
 746   s.next_read_length(1);
 747   memset(read_buf, 0, sizeof(read_buf));
 748   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 749       boost::asio::transfer_exactly(10));
 750   BOOST_ASIO_CHECK(bytes_transferred == 10);
 751   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
 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_at(s, 0, buffers,
 757       boost::asio::transfer_exactly(10));
 758   BOOST_ASIO_CHECK(bytes_transferred == 10);
 759   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 760
 761   s.reset(read_data, sizeof(read_data));
 762   s.next_read_length(10);
 763   memset(read_buf, 0, sizeof(read_buf));
 764   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 765       boost::asio::transfer_exactly(10));
 766   BOOST_ASIO_CHECK(bytes_transferred == 10);
 767   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
 768
 769   s.reset(read_data, sizeof(read_data));
 770   memset(read_buf, 0, sizeof(read_buf));
 771   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 772       boost::asio::transfer_exactly(42));
 773   BOOST_ASIO_CHECK(bytes_transferred == 42);
 774   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
 775
 776   s.reset(read_data, sizeof(read_data));
 777   memset(read_buf, 0, sizeof(read_buf));
 778   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 779       boost::asio::transfer_exactly(42));
 780   BOOST_ASIO_CHECK(bytes_transferred == 42);
 781   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
 782
 783   s.reset(read_data, sizeof(read_data));
 784   s.next_read_length(1);
 785   memset(read_buf, 0, sizeof(read_buf));
 786   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 787       boost::asio::transfer_exactly(42));
 788   BOOST_ASIO_CHECK(bytes_transferred == 42);
 789   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
 790
 791   s.reset(read_data, sizeof(read_data));
 792   s.next_read_length(1);
 793   memset(read_buf, 0, sizeof(read_buf));
 794   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 795       boost::asio::transfer_exactly(42));
 796   BOOST_ASIO_CHECK(bytes_transferred == 42);
 797   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
 798
 799   s.reset(read_data, sizeof(read_data));
 800   s.next_read_length(10);
 801   memset(read_buf, 0, sizeof(read_buf));
 802   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 803       boost::asio::transfer_exactly(42));
 804   BOOST_ASIO_CHECK(bytes_transferred == 42);
 805   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
 806
 807   s.reset(read_data, sizeof(read_data));
 808   s.next_read_length(10);
 809   memset(read_buf, 0, sizeof(read_buf));
 810   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 811       boost::asio::transfer_exactly(42));
 812   BOOST_ASIO_CHECK(bytes_transferred == 42);
 813   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
 814
 815   s.reset(read_data, sizeof(read_data));
 816   memset(read_buf, 0, sizeof(read_buf));
 817   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 818       old_style_transfer_all);
 819   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 820   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 821
 822   s.reset(read_data, sizeof(read_data));
 823   memset(read_buf, 0, sizeof(read_buf));
 824   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 825       old_style_transfer_all);
 826   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 827   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 828
 829   s.reset(read_data, sizeof(read_data));
 830   s.next_read_length(1);
 831   memset(read_buf, 0, sizeof(read_buf));
 832   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 833       old_style_transfer_all);
 834   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 835   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 836
 837   s.reset(read_data, sizeof(read_data));
 838   s.next_read_length(1);
 839   memset(read_buf, 0, sizeof(read_buf));
 840   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 841       old_style_transfer_all);
 842   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 843   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 844
 845   s.reset(read_data, sizeof(read_data));
 846   s.next_read_length(10);
 847   memset(read_buf, 0, sizeof(read_buf));
 848   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 849       old_style_transfer_all);
 850   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 851   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 852
 853   s.reset(read_data, sizeof(read_data));
 854   s.next_read_length(10);
 855   memset(read_buf, 0, sizeof(read_buf));
 856   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 857       old_style_transfer_all);
 858   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 859   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 860
 861   s.reset(read_data, sizeof(read_data));
 862   memset(read_buf, 0, sizeof(read_buf));
 863   bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
 864   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 865   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 866
 867   s.reset(read_data, sizeof(read_data));
 868   memset(read_buf, 0, sizeof(read_buf));
 869   bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
 870   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 871   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 872
 873   s.reset(read_data, sizeof(read_data));
 874   s.next_read_length(1);
 875   memset(read_buf, 0, sizeof(read_buf));
 876   bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
 877   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 878   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 879
 880   s.reset(read_data, sizeof(read_data));
 881   s.next_read_length(1);
 882   memset(read_buf, 0, sizeof(read_buf));
 883   bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
 884   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 885   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 886
 887   s.reset(read_data, sizeof(read_data));
 888   s.next_read_length(10);
 889   memset(read_buf, 0, sizeof(read_buf));
 890   bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
 891   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 892   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 893
 894   s.reset(read_data, sizeof(read_data));
 895   s.next_read_length(10);
 896   memset(read_buf, 0, sizeof(read_buf));
 897   bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
 898   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 899   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 900 }
 901
 902 void test_4_arg_vector_buffers_read_at()
 903 {
 904   boost::asio::io_context ioc;
 905   test_random_access_device s(ioc);
 906   char read_buf[sizeof(read_data)];
 907   std::vector<boost::asio::mutable_buffer> buffers;
 908   buffers.push_back(boost::asio::buffer(read_buf, 32));
 909   buffers.push_back(boost::asio::buffer(read_buf) + 32);
 910
 911   s.reset(read_data, sizeof(read_data));
 912   memset(read_buf, 0, sizeof(read_buf));
 913   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers,
 914       boost::asio::transfer_all());
 915   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 916   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 917
 918   s.reset(read_data, sizeof(read_data));
 919   memset(read_buf, 0, sizeof(read_buf));
 920   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 921       boost::asio::transfer_all());
 922   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 923   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 924
 925   s.reset(read_data, sizeof(read_data));
 926   s.next_read_length(1);
 927   memset(read_buf, 0, sizeof(read_buf));
 928   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 929       boost::asio::transfer_all());
 930   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 931   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 932
 933   s.reset(read_data, sizeof(read_data));
 934   s.next_read_length(1);
 935   memset(read_buf, 0, sizeof(read_buf));
 936   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 937       boost::asio::transfer_all());
 938   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 939   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 940
 941   s.reset(read_data, sizeof(read_data));
 942   s.next_read_length(10);
 943   memset(read_buf, 0, sizeof(read_buf));
 944   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 945       boost::asio::transfer_all());
 946   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 947   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 948
 949   s.reset(read_data, sizeof(read_data));
 950   s.next_read_length(10);
 951   memset(read_buf, 0, sizeof(read_buf));
 952   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 953       boost::asio::transfer_all());
 954   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 955   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 956
 957   s.reset(read_data, sizeof(read_data));
 958   memset(read_buf, 0, sizeof(read_buf));
 959   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 960       boost::asio::transfer_at_least(1));
 961   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 962   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
 963
 964   s.reset(read_data, sizeof(read_data));
 965   memset(read_buf, 0, sizeof(read_buf));
 966   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 967       boost::asio::transfer_at_least(1));
 968   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
 969   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
 970
 971   s.reset(read_data, sizeof(read_data));
 972   s.next_read_length(1);
 973   memset(read_buf, 0, sizeof(read_buf));
 974   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 975       boost::asio::transfer_at_least(1));
 976   BOOST_ASIO_CHECK(bytes_transferred == 1);
 977   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
 978
 979   s.reset(read_data, sizeof(read_data));
 980   s.next_read_length(1);
 981   memset(read_buf, 0, sizeof(read_buf));
 982   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 983       boost::asio::transfer_at_least(1));
 984   BOOST_ASIO_CHECK(bytes_transferred == 1);
 985   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
 986
 987   s.reset(read_data, sizeof(read_data));
 988   s.next_read_length(10);
 989   memset(read_buf, 0, sizeof(read_buf));
 990   bytes_transferred = boost::asio::read_at(s, 0, buffers,
 991       boost::asio::transfer_at_least(1));
 992   BOOST_ASIO_CHECK(bytes_transferred == 10);
 993   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
 994
 995   s.reset(read_data, sizeof(read_data));
 996   s.next_read_length(10);
 997   memset(read_buf, 0, sizeof(read_buf));
 998   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
 999       boost::asio::transfer_at_least(1));
1000   BOOST_ASIO_CHECK(bytes_transferred == 10);
1001   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1002
1003   s.reset(read_data, sizeof(read_data));
1004   memset(read_buf, 0, sizeof(read_buf));
1005   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1006       boost::asio::transfer_at_least(10));
1007   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1008   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1009
1010   s.reset(read_data, sizeof(read_data));
1011   memset(read_buf, 0, sizeof(read_buf));
1012   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1013       boost::asio::transfer_at_least(10));
1014   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1015   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1016
1017   s.reset(read_data, sizeof(read_data));
1018   s.next_read_length(1);
1019   memset(read_buf, 0, sizeof(read_buf));
1020   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1021       boost::asio::transfer_at_least(10));
1022   BOOST_ASIO_CHECK(bytes_transferred == 10);
1023   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1024
1025   s.reset(read_data, sizeof(read_data));
1026   s.next_read_length(1);
1027   memset(read_buf, 0, sizeof(read_buf));
1028   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1029       boost::asio::transfer_at_least(10));
1030   BOOST_ASIO_CHECK(bytes_transferred == 10);
1031   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1032
1033   s.reset(read_data, sizeof(read_data));
1034   s.next_read_length(10);
1035   memset(read_buf, 0, sizeof(read_buf));
1036   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1037       boost::asio::transfer_at_least(10));
1038   BOOST_ASIO_CHECK(bytes_transferred == 10);
1039   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1040
1041   s.reset(read_data, sizeof(read_data));
1042   s.next_read_length(10);
1043   memset(read_buf, 0, sizeof(read_buf));
1044   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1045       boost::asio::transfer_at_least(10));
1046   BOOST_ASIO_CHECK(bytes_transferred == 10);
1047   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1048
1049   s.reset(read_data, sizeof(read_data));
1050   memset(read_buf, 0, sizeof(read_buf));
1051   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1052       boost::asio::transfer_at_least(42));
1053   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1054   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1055
1056   s.reset(read_data, sizeof(read_data));
1057   memset(read_buf, 0, sizeof(read_buf));
1058   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1059       boost::asio::transfer_at_least(42));
1060   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1061   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1062
1063   s.reset(read_data, sizeof(read_data));
1064   s.next_read_length(1);
1065   memset(read_buf, 0, sizeof(read_buf));
1066   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1067       boost::asio::transfer_at_least(42));
1068   BOOST_ASIO_CHECK(bytes_transferred == 42);
1069   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
1070
1071   s.reset(read_data, sizeof(read_data));
1072   s.next_read_length(1);
1073   memset(read_buf, 0, sizeof(read_buf));
1074   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1075       boost::asio::transfer_at_least(42));
1076   BOOST_ASIO_CHECK(bytes_transferred == 42);
1077   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1078
1079   s.reset(read_data, sizeof(read_data));
1080   s.next_read_length(10);
1081   memset(read_buf, 0, sizeof(read_buf));
1082   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1083       boost::asio::transfer_at_least(42));
1084   BOOST_ASIO_CHECK(bytes_transferred == 50);
1085   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
1086
1087   s.reset(read_data, sizeof(read_data));
1088   s.next_read_length(10);
1089   memset(read_buf, 0, sizeof(read_buf));
1090   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1091       boost::asio::transfer_at_least(42));
1092   BOOST_ASIO_CHECK(bytes_transferred == 50);
1093   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
1094
1095   s.reset(read_data, sizeof(read_data));
1096   memset(read_buf, 0, sizeof(read_buf));
1097   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1098       boost::asio::transfer_exactly(1));
1099   BOOST_ASIO_CHECK(bytes_transferred == 1);
1100   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
1101
1102   s.reset(read_data, sizeof(read_data));
1103   memset(read_buf, 0, sizeof(read_buf));
1104   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1105       boost::asio::transfer_exactly(1));
1106   BOOST_ASIO_CHECK(bytes_transferred == 1);
1107   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1108
1109   s.reset(read_data, sizeof(read_data));
1110   s.next_read_length(1);
1111   memset(read_buf, 0, sizeof(read_buf));
1112   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1113       boost::asio::transfer_exactly(1));
1114   BOOST_ASIO_CHECK(bytes_transferred == 1);
1115   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
1116
1117   s.reset(read_data, sizeof(read_data));
1118   s.next_read_length(1);
1119   memset(read_buf, 0, sizeof(read_buf));
1120   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1121       boost::asio::transfer_exactly(1));
1122   BOOST_ASIO_CHECK(bytes_transferred == 1);
1123   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1124
1125   s.reset(read_data, sizeof(read_data));
1126   s.next_read_length(10);
1127   memset(read_buf, 0, sizeof(read_buf));
1128   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1129       boost::asio::transfer_exactly(1));
1130   BOOST_ASIO_CHECK(bytes_transferred == 1);
1131   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
1132
1133   s.reset(read_data, sizeof(read_data));
1134   s.next_read_length(10);
1135   memset(read_buf, 0, sizeof(read_buf));
1136   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1137       boost::asio::transfer_exactly(1));
1138   BOOST_ASIO_CHECK(bytes_transferred == 1);
1139   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1140
1141   s.reset(read_data, sizeof(read_data));
1142   memset(read_buf, 0, sizeof(read_buf));
1143   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1144       boost::asio::transfer_exactly(10));
1145   BOOST_ASIO_CHECK(bytes_transferred == 10);
1146   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1147
1148   s.reset(read_data, sizeof(read_data));
1149   memset(read_buf, 0, sizeof(read_buf));
1150   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1151       boost::asio::transfer_exactly(10));
1152   BOOST_ASIO_CHECK(bytes_transferred == 10);
1153   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1154
1155   s.reset(read_data, sizeof(read_data));
1156   s.next_read_length(1);
1157   memset(read_buf, 0, sizeof(read_buf));
1158   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1159       boost::asio::transfer_exactly(10));
1160   BOOST_ASIO_CHECK(bytes_transferred == 10);
1161   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1162
1163   s.reset(read_data, sizeof(read_data));
1164   s.next_read_length(1);
1165   memset(read_buf, 0, sizeof(read_buf));
1166   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1167       boost::asio::transfer_exactly(10));
1168   BOOST_ASIO_CHECK(bytes_transferred == 10);
1169   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1170
1171   s.reset(read_data, sizeof(read_data));
1172   s.next_read_length(10);
1173   memset(read_buf, 0, sizeof(read_buf));
1174   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1175       boost::asio::transfer_exactly(10));
1176   BOOST_ASIO_CHECK(bytes_transferred == 10);
1177   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1178
1179   s.reset(read_data, sizeof(read_data));
1180   s.next_read_length(10);
1181   memset(read_buf, 0, sizeof(read_buf));
1182   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1183       boost::asio::transfer_exactly(10));
1184   BOOST_ASIO_CHECK(bytes_transferred == 10);
1185   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1186
1187   s.reset(read_data, sizeof(read_data));
1188   memset(read_buf, 0, sizeof(read_buf));
1189   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1190       boost::asio::transfer_exactly(42));
1191   BOOST_ASIO_CHECK(bytes_transferred == 42);
1192   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
1193
1194   s.reset(read_data, sizeof(read_data));
1195   memset(read_buf, 0, sizeof(read_buf));
1196   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1197       boost::asio::transfer_exactly(42));
1198   BOOST_ASIO_CHECK(bytes_transferred == 42);
1199   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1200
1201   s.reset(read_data, sizeof(read_data));
1202   s.next_read_length(1);
1203   memset(read_buf, 0, sizeof(read_buf));
1204   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1205       boost::asio::transfer_exactly(42));
1206   BOOST_ASIO_CHECK(bytes_transferred == 42);
1207   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
1208
1209   s.reset(read_data, sizeof(read_data));
1210   s.next_read_length(1);
1211   memset(read_buf, 0, sizeof(read_buf));
1212   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1213       boost::asio::transfer_exactly(42));
1214   BOOST_ASIO_CHECK(bytes_transferred == 42);
1215   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1216
1217   s.reset(read_data, sizeof(read_data));
1218   s.next_read_length(10);
1219   memset(read_buf, 0, sizeof(read_buf));
1220   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1221       boost::asio::transfer_exactly(42));
1222   BOOST_ASIO_CHECK(bytes_transferred == 42);
1223   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
1224
1225   s.reset(read_data, sizeof(read_data));
1226   s.next_read_length(10);
1227   memset(read_buf, 0, sizeof(read_buf));
1228   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1229       boost::asio::transfer_exactly(42));
1230   BOOST_ASIO_CHECK(bytes_transferred == 42);
1231   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1232
1233   s.reset(read_data, sizeof(read_data));
1234   memset(read_buf, 0, sizeof(read_buf));
1235   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1236       old_style_transfer_all);
1237   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1238   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1239
1240   s.reset(read_data, sizeof(read_data));
1241   memset(read_buf, 0, sizeof(read_buf));
1242   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1243       old_style_transfer_all);
1244   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1245   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1246
1247   s.reset(read_data, sizeof(read_data));
1248   s.next_read_length(1);
1249   memset(read_buf, 0, sizeof(read_buf));
1250   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1251       old_style_transfer_all);
1252   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1253   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1254
1255   s.reset(read_data, sizeof(read_data));
1256   s.next_read_length(1);
1257   memset(read_buf, 0, sizeof(read_buf));
1258   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1259       old_style_transfer_all);
1260   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1261   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1262
1263   s.reset(read_data, sizeof(read_data));
1264   s.next_read_length(10);
1265   memset(read_buf, 0, sizeof(read_buf));
1266   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1267       old_style_transfer_all);
1268   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1269   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1270
1271   s.reset(read_data, sizeof(read_data));
1272   s.next_read_length(10);
1273   memset(read_buf, 0, sizeof(read_buf));
1274   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1275       old_style_transfer_all);
1276   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1277   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1278
1279   s.reset(read_data, sizeof(read_data));
1280   memset(read_buf, 0, sizeof(read_buf));
1281   bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
1282   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1283   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1284
1285   s.reset(read_data, sizeof(read_data));
1286   memset(read_buf, 0, sizeof(read_buf));
1287   bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
1288   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1289   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1290
1291   s.reset(read_data, sizeof(read_data));
1292   s.next_read_length(1);
1293   memset(read_buf, 0, sizeof(read_buf));
1294   bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
1295   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1296   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1297
1298   s.reset(read_data, sizeof(read_data));
1299   s.next_read_length(1);
1300   memset(read_buf, 0, sizeof(read_buf));
1301   bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
1302   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1303   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1304
1305   s.reset(read_data, sizeof(read_data));
1306   s.next_read_length(10);
1307   memset(read_buf, 0, sizeof(read_buf));
1308   bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
1309   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1310   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1311
1312   s.reset(read_data, sizeof(read_data));
1313   s.next_read_length(10);
1314   memset(read_buf, 0, sizeof(read_buf));
1315   bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
1316   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1317   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1318 }
1319
1320 void test_4_arg_streambuf_read_at()
1321 {
1322   boost::asio::io_context ioc;
1323   test_random_access_device s(ioc);
1324   boost::asio::streambuf sb(sizeof(read_data));
1325
1326   s.reset(read_data, sizeof(read_data));
1327   sb.consume(sb.size());
1328   size_t bytes_transferred = boost::asio::read_at(s, 0, sb,
1329       boost::asio::transfer_all());
1330   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1331   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1332   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1333
1334   s.reset(read_data, sizeof(read_data));
1335   sb.consume(sb.size());
1336   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1337       boost::asio::transfer_all());
1338   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1339   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1340   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1341
1342   s.reset(read_data, sizeof(read_data));
1343   s.next_read_length(1);
1344   sb.consume(sb.size());
1345   bytes_transferred = boost::asio::read_at(s, 0, sb,
1346       boost::asio::transfer_all());
1347   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1348   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1349   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1350
1351   s.reset(read_data, sizeof(read_data));
1352   s.next_read_length(1);
1353   sb.consume(sb.size());
1354   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1355       boost::asio::transfer_all());
1356   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1357   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1358   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1359
1360   s.reset(read_data, sizeof(read_data));
1361   s.next_read_length(10);
1362   sb.consume(sb.size());
1363   bytes_transferred = boost::asio::read_at(s, 0, sb,
1364       boost::asio::transfer_all());
1365   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1366   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1367   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1368
1369   s.reset(read_data, sizeof(read_data));
1370   s.next_read_length(10);
1371   sb.consume(sb.size());
1372   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1373       boost::asio::transfer_all());
1374   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1375   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1376   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1377
1378   s.reset(read_data, sizeof(read_data));
1379   sb.consume(sb.size());
1380   bytes_transferred = boost::asio::read_at(s, 0, sb,
1381       boost::asio::transfer_at_least(1));
1382   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1383   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1384   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1385
1386   s.reset(read_data, sizeof(read_data));
1387   sb.consume(sb.size());
1388   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1389       boost::asio::transfer_at_least(1));
1390   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1391   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1392   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1393
1394   s.reset(read_data, sizeof(read_data));
1395   s.next_read_length(1);
1396   sb.consume(sb.size());
1397   bytes_transferred = boost::asio::read_at(s, 0, sb,
1398       boost::asio::transfer_at_least(1));
1399   BOOST_ASIO_CHECK(bytes_transferred == 1);
1400   BOOST_ASIO_CHECK(sb.size() == 1);
1401   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1402
1403   s.reset(read_data, sizeof(read_data));
1404   s.next_read_length(1);
1405   sb.consume(sb.size());
1406   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1407       boost::asio::transfer_at_least(1));
1408   BOOST_ASIO_CHECK(bytes_transferred == 1);
1409   BOOST_ASIO_CHECK(sb.size() == 1);
1410   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1411
1412   s.reset(read_data, sizeof(read_data));
1413   s.next_read_length(10);
1414   sb.consume(sb.size());
1415   bytes_transferred = boost::asio::read_at(s, 0, sb,
1416       boost::asio::transfer_at_least(1));
1417   BOOST_ASIO_CHECK(bytes_transferred == 10);
1418   BOOST_ASIO_CHECK(sb.size() == 10);
1419   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1420
1421   s.reset(read_data, sizeof(read_data));
1422   s.next_read_length(10);
1423   sb.consume(sb.size());
1424   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1425       boost::asio::transfer_at_least(1));
1426   BOOST_ASIO_CHECK(bytes_transferred == 10);
1427   BOOST_ASIO_CHECK(sb.size() == 10);
1428   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1429
1430   s.reset(read_data, sizeof(read_data));
1431   sb.consume(sb.size());
1432   bytes_transferred = boost::asio::read_at(s, 0, sb,
1433       boost::asio::transfer_at_least(10));
1434   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1435   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1436   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1437
1438   s.reset(read_data, sizeof(read_data));
1439   sb.consume(sb.size());
1440   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1441       boost::asio::transfer_at_least(10));
1442   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1443   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1444   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1445
1446   s.reset(read_data, sizeof(read_data));
1447   s.next_read_length(1);
1448   sb.consume(sb.size());
1449   bytes_transferred = boost::asio::read_at(s, 0, sb,
1450       boost::asio::transfer_at_least(10));
1451   BOOST_ASIO_CHECK(bytes_transferred == 10);
1452   BOOST_ASIO_CHECK(sb.size() == 10);
1453   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1454
1455   s.reset(read_data, sizeof(read_data));
1456   s.next_read_length(1);
1457   sb.consume(sb.size());
1458   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1459       boost::asio::transfer_at_least(10));
1460   BOOST_ASIO_CHECK(bytes_transferred == 10);
1461   BOOST_ASIO_CHECK(sb.size() == 10);
1462   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1463
1464   s.reset(read_data, sizeof(read_data));
1465   s.next_read_length(10);
1466   sb.consume(sb.size());
1467   bytes_transferred = boost::asio::read_at(s, 0, sb,
1468       boost::asio::transfer_at_least(10));
1469   BOOST_ASIO_CHECK(bytes_transferred == 10);
1470   BOOST_ASIO_CHECK(sb.size() == 10);
1471   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1472
1473   s.reset(read_data, sizeof(read_data));
1474   s.next_read_length(10);
1475   sb.consume(sb.size());
1476   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1477       boost::asio::transfer_at_least(10));
1478   BOOST_ASIO_CHECK(bytes_transferred == 10);
1479   BOOST_ASIO_CHECK(sb.size() == 10);
1480   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1481
1482   s.reset(read_data, sizeof(read_data));
1483   sb.consume(sb.size());
1484   bytes_transferred = boost::asio::read_at(s, 0, sb,
1485       boost::asio::transfer_at_least(42));
1486   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1487   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1488   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1489
1490   s.reset(read_data, sizeof(read_data));
1491   sb.consume(sb.size());
1492   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1493       boost::asio::transfer_at_least(42));
1494   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1495   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1496   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1497
1498   s.reset(read_data, sizeof(read_data));
1499   s.next_read_length(1);
1500   sb.consume(sb.size());
1501   bytes_transferred = boost::asio::read_at(s, 0, sb,
1502       boost::asio::transfer_at_least(42));
1503   BOOST_ASIO_CHECK(bytes_transferred == 42);
1504   BOOST_ASIO_CHECK(sb.size() == 42);
1505   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1506
1507   s.reset(read_data, sizeof(read_data));
1508   s.next_read_length(1);
1509   sb.consume(sb.size());
1510   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1511       boost::asio::transfer_at_least(42));
1512   BOOST_ASIO_CHECK(bytes_transferred == 42);
1513   BOOST_ASIO_CHECK(sb.size() == 42);
1514   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1515
1516   s.reset(read_data, sizeof(read_data));
1517   s.next_read_length(10);
1518   sb.consume(sb.size());
1519   bytes_transferred = boost::asio::read_at(s, 0, sb,
1520       boost::asio::transfer_at_least(42));
1521   BOOST_ASIO_CHECK(bytes_transferred == 50);
1522   BOOST_ASIO_CHECK(sb.size() == 50);
1523   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
1524
1525   s.reset(read_data, sizeof(read_data));
1526   s.next_read_length(10);
1527   sb.consume(sb.size());
1528   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1529       boost::asio::transfer_at_least(42));
1530   BOOST_ASIO_CHECK(bytes_transferred == 50);
1531   BOOST_ASIO_CHECK(sb.size() == 50);
1532   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
1533
1534   s.reset(read_data, sizeof(read_data));
1535   sb.consume(sb.size());
1536   bytes_transferred = boost::asio::read_at(s, 0, sb,
1537       boost::asio::transfer_exactly(1));
1538   BOOST_ASIO_CHECK(bytes_transferred == 1);
1539   BOOST_ASIO_CHECK(sb.size() == 1);
1540   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1541
1542   s.reset(read_data, sizeof(read_data));
1543   sb.consume(sb.size());
1544   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1545       boost::asio::transfer_exactly(1));
1546   BOOST_ASIO_CHECK(bytes_transferred == 1);
1547   BOOST_ASIO_CHECK(sb.size() == 1);
1548   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1549
1550   s.reset(read_data, sizeof(read_data));
1551   s.next_read_length(1);
1552   sb.consume(sb.size());
1553   bytes_transferred = boost::asio::read_at(s, 0, sb,
1554       boost::asio::transfer_exactly(1));
1555   BOOST_ASIO_CHECK(bytes_transferred == 1);
1556   BOOST_ASIO_CHECK(sb.size() == 1);
1557   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1558
1559   s.reset(read_data, sizeof(read_data));
1560   s.next_read_length(1);
1561   sb.consume(sb.size());
1562   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1563       boost::asio::transfer_exactly(1));
1564   BOOST_ASIO_CHECK(bytes_transferred == 1);
1565   BOOST_ASIO_CHECK(sb.size() == 1);
1566   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1567
1568   s.reset(read_data, sizeof(read_data));
1569   s.next_read_length(10);
1570   sb.consume(sb.size());
1571   bytes_transferred = boost::asio::read_at(s, 0, sb,
1572       boost::asio::transfer_exactly(1));
1573   BOOST_ASIO_CHECK(bytes_transferred == 1);
1574   BOOST_ASIO_CHECK(sb.size() == 1);
1575   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1576
1577   s.reset(read_data, sizeof(read_data));
1578   s.next_read_length(10);
1579   sb.consume(sb.size());
1580   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1581       boost::asio::transfer_exactly(1));
1582   BOOST_ASIO_CHECK(bytes_transferred == 1);
1583   BOOST_ASIO_CHECK(sb.size() == 1);
1584   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1585
1586   s.reset(read_data, sizeof(read_data));
1587   sb.consume(sb.size());
1588   bytes_transferred = boost::asio::read_at(s, 0, sb,
1589       boost::asio::transfer_exactly(10));
1590   BOOST_ASIO_CHECK(bytes_transferred == 10);
1591   BOOST_ASIO_CHECK(sb.size() == 10);
1592   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1593
1594   s.reset(read_data, sizeof(read_data));
1595   sb.consume(sb.size());
1596   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1597       boost::asio::transfer_exactly(10));
1598   BOOST_ASIO_CHECK(bytes_transferred == 10);
1599   BOOST_ASIO_CHECK(sb.size() == 10);
1600   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1601
1602   s.reset(read_data, sizeof(read_data));
1603   s.next_read_length(1);
1604   sb.consume(sb.size());
1605   bytes_transferred = boost::asio::read_at(s, 0, sb,
1606       boost::asio::transfer_exactly(10));
1607   BOOST_ASIO_CHECK(bytes_transferred == 10);
1608   BOOST_ASIO_CHECK(sb.size() == 10);
1609   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1610
1611   s.reset(read_data, sizeof(read_data));
1612   s.next_read_length(1);
1613   sb.consume(sb.size());
1614   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1615       boost::asio::transfer_exactly(10));
1616   BOOST_ASIO_CHECK(bytes_transferred == 10);
1617   BOOST_ASIO_CHECK(sb.size() == 10);
1618   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1619
1620   s.reset(read_data, sizeof(read_data));
1621   s.next_read_length(10);
1622   sb.consume(sb.size());
1623   bytes_transferred = boost::asio::read_at(s, 0, sb,
1624       boost::asio::transfer_exactly(10));
1625   BOOST_ASIO_CHECK(bytes_transferred == 10);
1626   BOOST_ASIO_CHECK(sb.size() == 10);
1627   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1628
1629   s.reset(read_data, sizeof(read_data));
1630   s.next_read_length(10);
1631   sb.consume(sb.size());
1632   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1633       boost::asio::transfer_exactly(10));
1634   BOOST_ASIO_CHECK(bytes_transferred == 10);
1635   BOOST_ASIO_CHECK(sb.size() == 10);
1636   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1637
1638   s.reset(read_data, sizeof(read_data));
1639   sb.consume(sb.size());
1640   bytes_transferred = boost::asio::read_at(s, 0, sb,
1641       boost::asio::transfer_exactly(42));
1642   BOOST_ASIO_CHECK(bytes_transferred == 42);
1643   BOOST_ASIO_CHECK(sb.size() == 42);
1644   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1645
1646   s.reset(read_data, sizeof(read_data));
1647   sb.consume(sb.size());
1648   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1649       boost::asio::transfer_exactly(42));
1650   BOOST_ASIO_CHECK(bytes_transferred == 42);
1651   BOOST_ASIO_CHECK(sb.size() == 42);
1652   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1653
1654   s.reset(read_data, sizeof(read_data));
1655   s.next_read_length(1);
1656   sb.consume(sb.size());
1657   bytes_transferred = boost::asio::read_at(s, 0, sb,
1658       boost::asio::transfer_exactly(42));
1659   BOOST_ASIO_CHECK(bytes_transferred == 42);
1660   BOOST_ASIO_CHECK(sb.size() == 42);
1661   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1662
1663   s.reset(read_data, sizeof(read_data));
1664   s.next_read_length(1);
1665   sb.consume(sb.size());
1666   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1667       boost::asio::transfer_exactly(42));
1668   BOOST_ASIO_CHECK(bytes_transferred == 42);
1669   BOOST_ASIO_CHECK(sb.size() == 42);
1670   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1671
1672   s.reset(read_data, sizeof(read_data));
1673   s.next_read_length(10);
1674   sb.consume(sb.size());
1675   bytes_transferred = boost::asio::read_at(s, 0, sb,
1676       boost::asio::transfer_exactly(42));
1677   BOOST_ASIO_CHECK(bytes_transferred == 42);
1678   BOOST_ASIO_CHECK(sb.size() == 42);
1679   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1680
1681   s.reset(read_data, sizeof(read_data));
1682   s.next_read_length(10);
1683   sb.consume(sb.size());
1684   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1685       boost::asio::transfer_exactly(42));
1686   BOOST_ASIO_CHECK(bytes_transferred == 42);
1687   BOOST_ASIO_CHECK(sb.size() == 42);
1688   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1689
1690   s.reset(read_data, sizeof(read_data));
1691   sb.consume(sb.size());
1692   bytes_transferred = boost::asio::read_at(s, 0, sb,
1693       old_style_transfer_all);
1694   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1695   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1696   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1697
1698   s.reset(read_data, sizeof(read_data));
1699   sb.consume(sb.size());
1700   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1701       old_style_transfer_all);
1702   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1703   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1704   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1705
1706   s.reset(read_data, sizeof(read_data));
1707   s.next_read_length(1);
1708   sb.consume(sb.size());
1709   bytes_transferred = boost::asio::read_at(s, 0, sb,
1710       old_style_transfer_all);
1711   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1712   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1713   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1714
1715   s.reset(read_data, sizeof(read_data));
1716   s.next_read_length(1);
1717   sb.consume(sb.size());
1718   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1719       old_style_transfer_all);
1720   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1721   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1722   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1723
1724   s.reset(read_data, sizeof(read_data));
1725   s.next_read_length(10);
1726   sb.consume(sb.size());
1727   bytes_transferred = boost::asio::read_at(s, 0, sb,
1728       old_style_transfer_all);
1729   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1730   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1731   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1732
1733   s.reset(read_data, sizeof(read_data));
1734   s.next_read_length(10);
1735   sb.consume(sb.size());
1736   bytes_transferred = boost::asio::read_at(s, 1234, sb,
1737       old_style_transfer_all);
1738   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1739   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1740   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1741
1742   s.reset(read_data, sizeof(read_data));
1743   sb.consume(sb.size());
1744   bytes_transferred = boost::asio::read_at(s, 0, sb, short_transfer);
1745   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1746   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1747   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1748
1749   s.reset(read_data, sizeof(read_data));
1750   sb.consume(sb.size());
1751   bytes_transferred = boost::asio::read_at(s, 1234, sb, short_transfer);
1752   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1753   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1754   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1755
1756   s.reset(read_data, sizeof(read_data));
1757   s.next_read_length(1);
1758   sb.consume(sb.size());
1759   bytes_transferred = boost::asio::read_at(s, 0, sb, short_transfer);
1760   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1761   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1762   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1763
1764   s.reset(read_data, sizeof(read_data));
1765   s.next_read_length(1);
1766   sb.consume(sb.size());
1767   bytes_transferred = boost::asio::read_at(s, 1234, sb, short_transfer);
1768   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1769   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1770   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1771
1772   s.reset(read_data, sizeof(read_data));
1773   s.next_read_length(10);
1774   sb.consume(sb.size());
1775   bytes_transferred = boost::asio::read_at(s, 0, sb, short_transfer);
1776   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1777   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1778   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1779
1780   s.reset(read_data, sizeof(read_data));
1781   s.next_read_length(10);
1782   sb.consume(sb.size());
1783   bytes_transferred = boost::asio::read_at(s, 1234, sb, short_transfer);
1784   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1785   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1786   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1787 }
1788
1789 void test_5_arg_mutable_buffer_read_at()
1790 {
1791   boost::asio::io_context ioc;
1792   test_random_access_device s(ioc);
1793   char read_buf[sizeof(read_data)];
1794   boost::asio::mutable_buffer buffers
1795     = boost::asio::buffer(read_buf, sizeof(read_buf));
1796
1797   s.reset(read_data, sizeof(read_data));
1798   memset(read_buf, 0, sizeof(read_buf));
1799   boost::system::error_code error;
1800   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers,
1801       boost::asio::transfer_all(), error);
1802   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1803   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1804   BOOST_ASIO_CHECK(!error);
1805
1806   s.reset(read_data, sizeof(read_data));
1807   memset(read_buf, 0, sizeof(read_buf));
1808   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1809       boost::asio::transfer_all(), error);
1810   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1811   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1812   BOOST_ASIO_CHECK(!error);
1813
1814   s.reset(read_data, sizeof(read_data));
1815   s.next_read_length(1);
1816   memset(read_buf, 0, sizeof(read_buf));
1817   error = boost::system::error_code();
1818   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1819       boost::asio::transfer_all(), error);
1820   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1821   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1822   BOOST_ASIO_CHECK(!error);
1823
1824   s.reset(read_data, sizeof(read_data));
1825   s.next_read_length(1);
1826   memset(read_buf, 0, sizeof(read_buf));
1827   error = boost::system::error_code();
1828   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1829       boost::asio::transfer_all(), error);
1830   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1831   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1832   BOOST_ASIO_CHECK(!error);
1833
1834   s.reset(read_data, sizeof(read_data));
1835   s.next_read_length(10);
1836   memset(read_buf, 0, sizeof(read_buf));
1837   error = boost::system::error_code();
1838   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1839       boost::asio::transfer_all(), error);
1840   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1841   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1842   BOOST_ASIO_CHECK(!error);
1843
1844   s.reset(read_data, sizeof(read_data));
1845   s.next_read_length(10);
1846   memset(read_buf, 0, sizeof(read_buf));
1847   error = boost::system::error_code();
1848   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1849       boost::asio::transfer_all(), error);
1850   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1851   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1852   BOOST_ASIO_CHECK(!error);
1853
1854   s.reset(read_data, sizeof(read_data));
1855   memset(read_buf, 0, sizeof(read_buf));
1856   error = boost::system::error_code();
1857   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1858       boost::asio::transfer_at_least(1), error);
1859   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1860   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1861   BOOST_ASIO_CHECK(!error);
1862
1863   s.reset(read_data, sizeof(read_data));
1864   memset(read_buf, 0, sizeof(read_buf));
1865   error = boost::system::error_code();
1866   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1867       boost::asio::transfer_at_least(1), error);
1868   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1869   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1870   BOOST_ASIO_CHECK(!error);
1871
1872   s.reset(read_data, sizeof(read_data));
1873   s.next_read_length(1);
1874   memset(read_buf, 0, sizeof(read_buf));
1875   error = boost::system::error_code();
1876   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1877       boost::asio::transfer_at_least(1), error);
1878   BOOST_ASIO_CHECK(bytes_transferred == 1);
1879   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
1880   BOOST_ASIO_CHECK(!error);
1881
1882   s.reset(read_data, sizeof(read_data));
1883   s.next_read_length(1);
1884   memset(read_buf, 0, sizeof(read_buf));
1885   error = boost::system::error_code();
1886   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1887       boost::asio::transfer_at_least(1), error);
1888   BOOST_ASIO_CHECK(bytes_transferred == 1);
1889   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1890   BOOST_ASIO_CHECK(!error);
1891
1892   s.reset(read_data, sizeof(read_data));
1893   s.next_read_length(10);
1894   memset(read_buf, 0, sizeof(read_buf));
1895   error = boost::system::error_code();
1896   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1897       boost::asio::transfer_at_least(1), error);
1898   BOOST_ASIO_CHECK(bytes_transferred == 10);
1899   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1900   BOOST_ASIO_CHECK(!error);
1901
1902   s.reset(read_data, sizeof(read_data));
1903   s.next_read_length(10);
1904   memset(read_buf, 0, sizeof(read_buf));
1905   error = boost::system::error_code();
1906   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1907       boost::asio::transfer_at_least(1), error);
1908   BOOST_ASIO_CHECK(bytes_transferred == 10);
1909   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1910   BOOST_ASIO_CHECK(!error);
1911
1912   s.reset(read_data, sizeof(read_data));
1913   memset(read_buf, 0, sizeof(read_buf));
1914   error = boost::system::error_code();
1915   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1916       boost::asio::transfer_at_least(10), error);
1917   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1918   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1919   BOOST_ASIO_CHECK(!error);
1920
1921   s.reset(read_data, sizeof(read_data));
1922   memset(read_buf, 0, sizeof(read_buf));
1923   error = boost::system::error_code();
1924   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1925       boost::asio::transfer_at_least(10), error);
1926   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1927   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1928   BOOST_ASIO_CHECK(!error);
1929
1930   s.reset(read_data, sizeof(read_data));
1931   s.next_read_length(1);
1932   memset(read_buf, 0, sizeof(read_buf));
1933   error = boost::system::error_code();
1934   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1935       boost::asio::transfer_at_least(10), error);
1936   BOOST_ASIO_CHECK(bytes_transferred == 10);
1937   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1938   BOOST_ASIO_CHECK(!error);
1939
1940   s.reset(read_data, sizeof(read_data));
1941   s.next_read_length(1);
1942   memset(read_buf, 0, sizeof(read_buf));
1943   error = boost::system::error_code();
1944   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1945       boost::asio::transfer_at_least(10), error);
1946   BOOST_ASIO_CHECK(bytes_transferred == 10);
1947   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1948   BOOST_ASIO_CHECK(!error);
1949
1950   s.reset(read_data, sizeof(read_data));
1951   s.next_read_length(10);
1952   memset(read_buf, 0, sizeof(read_buf));
1953   error = boost::system::error_code();
1954   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1955       boost::asio::transfer_at_least(10), error);
1956   BOOST_ASIO_CHECK(bytes_transferred == 10);
1957   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
1958   BOOST_ASIO_CHECK(!error);
1959
1960   s.reset(read_data, sizeof(read_data));
1961   s.next_read_length(10);
1962   memset(read_buf, 0, sizeof(read_buf));
1963   error = boost::system::error_code();
1964   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1965       boost::asio::transfer_at_least(10), error);
1966   BOOST_ASIO_CHECK(bytes_transferred == 10);
1967   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1968   BOOST_ASIO_CHECK(!error);
1969
1970   s.reset(read_data, sizeof(read_data));
1971   memset(read_buf, 0, sizeof(read_buf));
1972   error = boost::system::error_code();
1973   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1974       boost::asio::transfer_at_least(42), error);
1975   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1976   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1977   BOOST_ASIO_CHECK(!error);
1978
1979   s.reset(read_data, sizeof(read_data));
1980   memset(read_buf, 0, sizeof(read_buf));
1981   error = boost::system::error_code();
1982   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
1983       boost::asio::transfer_at_least(42), error);
1984   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1985   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1986   BOOST_ASIO_CHECK(!error);
1987
1988   s.reset(read_data, sizeof(read_data));
1989   s.next_read_length(1);
1990   memset(read_buf, 0, sizeof(read_buf));
1991   error = boost::system::error_code();
1992   bytes_transferred = boost::asio::read_at(s, 0, buffers,
1993       boost::asio::transfer_at_least(42), error);
1994   BOOST_ASIO_CHECK(bytes_transferred == 42);
1995   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
1996   BOOST_ASIO_CHECK(!error);
1997
1998   s.reset(read_data, sizeof(read_data));
1999   s.next_read_length(1);
2000   memset(read_buf, 0, sizeof(read_buf));
2001   error = boost::system::error_code();
2002   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2003       boost::asio::transfer_at_least(42), error);
2004   BOOST_ASIO_CHECK(bytes_transferred == 42);
2005   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2006   BOOST_ASIO_CHECK(!error);
2007
2008   s.reset(read_data, sizeof(read_data));
2009   s.next_read_length(10);
2010   memset(read_buf, 0, sizeof(read_buf));
2011   error = boost::system::error_code();
2012   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2013       boost::asio::transfer_at_least(42), error);
2014   BOOST_ASIO_CHECK(bytes_transferred == 50);
2015   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
2016   BOOST_ASIO_CHECK(!error);
2017
2018   s.reset(read_data, sizeof(read_data));
2019   s.next_read_length(10);
2020   memset(read_buf, 0, sizeof(read_buf));
2021   error = boost::system::error_code();
2022   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2023       boost::asio::transfer_at_least(42), error);
2024   BOOST_ASIO_CHECK(bytes_transferred == 50);
2025   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
2026   BOOST_ASIO_CHECK(!error);
2027
2028   s.reset(read_data, sizeof(read_data));
2029   memset(read_buf, 0, sizeof(read_buf));
2030   error = boost::system::error_code();
2031   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2032       boost::asio::transfer_exactly(1), error);
2033   BOOST_ASIO_CHECK(bytes_transferred == 1);
2034   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2035   BOOST_ASIO_CHECK(!error);
2036
2037   s.reset(read_data, sizeof(read_data));
2038   memset(read_buf, 0, sizeof(read_buf));
2039   error = boost::system::error_code();
2040   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2041       boost::asio::transfer_exactly(1), error);
2042   BOOST_ASIO_CHECK(bytes_transferred == 1);
2043   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2044   BOOST_ASIO_CHECK(!error);
2045
2046   s.reset(read_data, sizeof(read_data));
2047   s.next_read_length(1);
2048   memset(read_buf, 0, sizeof(read_buf));
2049   error = boost::system::error_code();
2050   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2051       boost::asio::transfer_exactly(1), error);
2052   BOOST_ASIO_CHECK(bytes_transferred == 1);
2053   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2054   BOOST_ASIO_CHECK(!error);
2055
2056   s.reset(read_data, sizeof(read_data));
2057   s.next_read_length(1);
2058   memset(read_buf, 0, sizeof(read_buf));
2059   error = boost::system::error_code();
2060   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2061       boost::asio::transfer_exactly(1), error);
2062   BOOST_ASIO_CHECK(bytes_transferred == 1);
2063   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2064   BOOST_ASIO_CHECK(!error);
2065
2066   s.reset(read_data, sizeof(read_data));
2067   s.next_read_length(10);
2068   memset(read_buf, 0, sizeof(read_buf));
2069   error = boost::system::error_code();
2070   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2071       boost::asio::transfer_exactly(1), error);
2072   BOOST_ASIO_CHECK(bytes_transferred == 1);
2073   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2074   BOOST_ASIO_CHECK(!error);
2075
2076   s.reset(read_data, sizeof(read_data));
2077   s.next_read_length(10);
2078   memset(read_buf, 0, sizeof(read_buf));
2079   error = boost::system::error_code();
2080   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2081       boost::asio::transfer_exactly(1), error);
2082   BOOST_ASIO_CHECK(bytes_transferred == 1);
2083   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2084   BOOST_ASIO_CHECK(!error);
2085
2086   s.reset(read_data, sizeof(read_data));
2087   memset(read_buf, 0, sizeof(read_buf));
2088   error = boost::system::error_code();
2089   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2090       boost::asio::transfer_exactly(10), error);
2091   BOOST_ASIO_CHECK(bytes_transferred == 10);
2092   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2093   BOOST_ASIO_CHECK(!error);
2094
2095   s.reset(read_data, sizeof(read_data));
2096   memset(read_buf, 0, sizeof(read_buf));
2097   error = boost::system::error_code();
2098   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2099       boost::asio::transfer_exactly(10), error);
2100   BOOST_ASIO_CHECK(bytes_transferred == 10);
2101   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2102   BOOST_ASIO_CHECK(!error);
2103
2104   s.reset(read_data, sizeof(read_data));
2105   s.next_read_length(1);
2106   memset(read_buf, 0, sizeof(read_buf));
2107   error = boost::system::error_code();
2108   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2109       boost::asio::transfer_exactly(10), error);
2110   BOOST_ASIO_CHECK(bytes_transferred == 10);
2111   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2112   BOOST_ASIO_CHECK(!error);
2113
2114   s.reset(read_data, sizeof(read_data));
2115   s.next_read_length(1);
2116   memset(read_buf, 0, sizeof(read_buf));
2117   error = boost::system::error_code();
2118   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2119       boost::asio::transfer_exactly(10), error);
2120   BOOST_ASIO_CHECK(bytes_transferred == 10);
2121   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2122   BOOST_ASIO_CHECK(!error);
2123
2124   s.reset(read_data, sizeof(read_data));
2125   s.next_read_length(10);
2126   memset(read_buf, 0, sizeof(read_buf));
2127   error = boost::system::error_code();
2128   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2129       boost::asio::transfer_exactly(10), error);
2130   BOOST_ASIO_CHECK(bytes_transferred == 10);
2131   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2132   BOOST_ASIO_CHECK(!error);
2133
2134   s.reset(read_data, sizeof(read_data));
2135   s.next_read_length(10);
2136   memset(read_buf, 0, sizeof(read_buf));
2137   error = boost::system::error_code();
2138   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2139       boost::asio::transfer_exactly(10), error);
2140   BOOST_ASIO_CHECK(bytes_transferred == 10);
2141   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2142   BOOST_ASIO_CHECK(!error);
2143
2144   s.reset(read_data, sizeof(read_data));
2145   memset(read_buf, 0, sizeof(read_buf));
2146   error = boost::system::error_code();
2147   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2148       boost::asio::transfer_exactly(42), error);
2149   BOOST_ASIO_CHECK(bytes_transferred == 42);
2150   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2151   BOOST_ASIO_CHECK(!error);
2152
2153   s.reset(read_data, sizeof(read_data));
2154   memset(read_buf, 0, sizeof(read_buf));
2155   error = boost::system::error_code();
2156   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2157       boost::asio::transfer_exactly(42), error);
2158   BOOST_ASIO_CHECK(bytes_transferred == 42);
2159   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2160   BOOST_ASIO_CHECK(!error);
2161
2162   s.reset(read_data, sizeof(read_data));
2163   s.next_read_length(1);
2164   memset(read_buf, 0, sizeof(read_buf));
2165   error = boost::system::error_code();
2166   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2167       boost::asio::transfer_exactly(42), error);
2168   BOOST_ASIO_CHECK(bytes_transferred == 42);
2169   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2170   BOOST_ASIO_CHECK(!error);
2171
2172   s.reset(read_data, sizeof(read_data));
2173   s.next_read_length(1);
2174   memset(read_buf, 0, sizeof(read_buf));
2175   error = boost::system::error_code();
2176   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2177       boost::asio::transfer_exactly(42), error);
2178   BOOST_ASIO_CHECK(bytes_transferred == 42);
2179   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2180   BOOST_ASIO_CHECK(!error);
2181
2182   s.reset(read_data, sizeof(read_data));
2183   s.next_read_length(10);
2184   memset(read_buf, 0, sizeof(read_buf));
2185   error = boost::system::error_code();
2186   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2187       boost::asio::transfer_exactly(42), error);
2188   BOOST_ASIO_CHECK(bytes_transferred == 42);
2189   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2190   BOOST_ASIO_CHECK(!error);
2191
2192   s.reset(read_data, sizeof(read_data));
2193   s.next_read_length(10);
2194   memset(read_buf, 0, sizeof(read_buf));
2195   error = boost::system::error_code();
2196   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2197       boost::asio::transfer_exactly(42), error);
2198   BOOST_ASIO_CHECK(bytes_transferred == 42);
2199   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2200   BOOST_ASIO_CHECK(!error);
2201
2202   s.reset(read_data, sizeof(read_data));
2203   memset(read_buf, 0, sizeof(read_buf));
2204   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2205       old_style_transfer_all, error);
2206   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2207   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2208   BOOST_ASIO_CHECK(!error);
2209
2210   s.reset(read_data, sizeof(read_data));
2211   memset(read_buf, 0, sizeof(read_buf));
2212   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2213       old_style_transfer_all, error);
2214   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2215   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2216   BOOST_ASIO_CHECK(!error);
2217
2218   s.reset(read_data, sizeof(read_data));
2219   s.next_read_length(1);
2220   memset(read_buf, 0, sizeof(read_buf));
2221   error = boost::system::error_code();
2222   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2223       old_style_transfer_all, error);
2224   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2225   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2226   BOOST_ASIO_CHECK(!error);
2227
2228   s.reset(read_data, sizeof(read_data));
2229   s.next_read_length(1);
2230   memset(read_buf, 0, sizeof(read_buf));
2231   error = boost::system::error_code();
2232   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2233       old_style_transfer_all, error);
2234   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2235   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2236   BOOST_ASIO_CHECK(!error);
2237
2238   s.reset(read_data, sizeof(read_data));
2239   s.next_read_length(10);
2240   memset(read_buf, 0, sizeof(read_buf));
2241   error = boost::system::error_code();
2242   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2243       old_style_transfer_all, error);
2244   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2245   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2246   BOOST_ASIO_CHECK(!error);
2247
2248   s.reset(read_data, sizeof(read_data));
2249   s.next_read_length(10);
2250   memset(read_buf, 0, sizeof(read_buf));
2251   error = boost::system::error_code();
2252   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2253       old_style_transfer_all, error);
2254   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2255   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2256   BOOST_ASIO_CHECK(!error);
2257
2258   s.reset(read_data, sizeof(read_data));
2259   memset(read_buf, 0, sizeof(read_buf));
2260   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2261       short_transfer, error);
2262   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2263   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2264   BOOST_ASIO_CHECK(!error);
2265
2266   s.reset(read_data, sizeof(read_data));
2267   memset(read_buf, 0, sizeof(read_buf));
2268   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2269       short_transfer, error);
2270   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2271   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2272   BOOST_ASIO_CHECK(!error);
2273
2274   s.reset(read_data, sizeof(read_data));
2275   s.next_read_length(1);
2276   memset(read_buf, 0, sizeof(read_buf));
2277   error = boost::system::error_code();
2278   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2279       short_transfer, error);
2280   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2281   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2282   BOOST_ASIO_CHECK(!error);
2283
2284   s.reset(read_data, sizeof(read_data));
2285   s.next_read_length(1);
2286   memset(read_buf, 0, sizeof(read_buf));
2287   error = boost::system::error_code();
2288   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2289       short_transfer, error);
2290   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2291   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2292   BOOST_ASIO_CHECK(!error);
2293
2294   s.reset(read_data, sizeof(read_data));
2295   s.next_read_length(10);
2296   memset(read_buf, 0, sizeof(read_buf));
2297   error = boost::system::error_code();
2298   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2299       short_transfer, error);
2300   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2301   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2302   BOOST_ASIO_CHECK(!error);
2303
2304   s.reset(read_data, sizeof(read_data));
2305   s.next_read_length(10);
2306   memset(read_buf, 0, sizeof(read_buf));
2307   error = boost::system::error_code();
2308   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2309       short_transfer, error);
2310   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2311   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2312   BOOST_ASIO_CHECK(!error);
2313 }
2314
2315 void test_5_arg_vector_buffers_read_at()
2316 {
2317   boost::asio::io_context ioc;
2318   test_random_access_device s(ioc);
2319   char read_buf[sizeof(read_data)];
2320   std::vector<boost::asio::mutable_buffer> buffers;
2321   buffers.push_back(boost::asio::buffer(read_buf, 32));
2322   buffers.push_back(boost::asio::buffer(read_buf) + 32);
2323
2324   s.reset(read_data, sizeof(read_data));
2325   memset(read_buf, 0, sizeof(read_buf));
2326   boost::system::error_code error;
2327   size_t bytes_transferred = boost::asio::read_at(s, 0, buffers,
2328       boost::asio::transfer_all(), error);
2329   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2330   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2331   BOOST_ASIO_CHECK(!error);
2332
2333   s.reset(read_data, sizeof(read_data));
2334   memset(read_buf, 0, sizeof(read_buf));
2335   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2336       boost::asio::transfer_all(), error);
2337   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2338   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2339   BOOST_ASIO_CHECK(!error);
2340
2341   s.reset(read_data, sizeof(read_data));
2342   s.next_read_length(1);
2343   memset(read_buf, 0, sizeof(read_buf));
2344   error = boost::system::error_code();
2345   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2346       boost::asio::transfer_all(), error);
2347   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2348   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2349   BOOST_ASIO_CHECK(!error);
2350
2351   s.reset(read_data, sizeof(read_data));
2352   s.next_read_length(1);
2353   memset(read_buf, 0, sizeof(read_buf));
2354   error = boost::system::error_code();
2355   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2356       boost::asio::transfer_all(), error);
2357   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2358   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2359   BOOST_ASIO_CHECK(!error);
2360
2361   s.reset(read_data, sizeof(read_data));
2362   s.next_read_length(10);
2363   memset(read_buf, 0, sizeof(read_buf));
2364   error = boost::system::error_code();
2365   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2366       boost::asio::transfer_all(), error);
2367   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2368   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2369   BOOST_ASIO_CHECK(!error);
2370
2371   s.reset(read_data, sizeof(read_data));
2372   s.next_read_length(10);
2373   memset(read_buf, 0, sizeof(read_buf));
2374   error = boost::system::error_code();
2375   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2376       boost::asio::transfer_all(), error);
2377   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2378   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2379   BOOST_ASIO_CHECK(!error);
2380
2381   s.reset(read_data, sizeof(read_data));
2382   memset(read_buf, 0, sizeof(read_buf));
2383   error = boost::system::error_code();
2384   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2385       boost::asio::transfer_at_least(1), error);
2386   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2387   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2388   BOOST_ASIO_CHECK(!error);
2389
2390   s.reset(read_data, sizeof(read_data));
2391   memset(read_buf, 0, sizeof(read_buf));
2392   error = boost::system::error_code();
2393   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2394       boost::asio::transfer_at_least(1), error);
2395   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2396   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2397   BOOST_ASIO_CHECK(!error);
2398
2399   s.reset(read_data, sizeof(read_data));
2400   s.next_read_length(1);
2401   memset(read_buf, 0, sizeof(read_buf));
2402   error = boost::system::error_code();
2403   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2404       boost::asio::transfer_at_least(1), error);
2405   BOOST_ASIO_CHECK(bytes_transferred == 1);
2406   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2407   BOOST_ASIO_CHECK(!error);
2408
2409   s.reset(read_data, sizeof(read_data));
2410   s.next_read_length(1);
2411   memset(read_buf, 0, sizeof(read_buf));
2412   error = boost::system::error_code();
2413   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2414       boost::asio::transfer_at_least(1), error);
2415   BOOST_ASIO_CHECK(bytes_transferred == 1);
2416   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2417   BOOST_ASIO_CHECK(!error);
2418
2419   s.reset(read_data, sizeof(read_data));
2420   s.next_read_length(10);
2421   memset(read_buf, 0, sizeof(read_buf));
2422   error = boost::system::error_code();
2423   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2424       boost::asio::transfer_at_least(1), error);
2425   BOOST_ASIO_CHECK(bytes_transferred == 10);
2426   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2427   BOOST_ASIO_CHECK(!error);
2428
2429   s.reset(read_data, sizeof(read_data));
2430   s.next_read_length(10);
2431   memset(read_buf, 0, sizeof(read_buf));
2432   error = boost::system::error_code();
2433   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2434       boost::asio::transfer_at_least(1), error);
2435   BOOST_ASIO_CHECK(bytes_transferred == 10);
2436   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2437   BOOST_ASIO_CHECK(!error);
2438
2439   s.reset(read_data, sizeof(read_data));
2440   memset(read_buf, 0, sizeof(read_buf));
2441   error = boost::system::error_code();
2442   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2443       boost::asio::transfer_at_least(10), error);
2444   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2445   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2446   BOOST_ASIO_CHECK(!error);
2447
2448   s.reset(read_data, sizeof(read_data));
2449   memset(read_buf, 0, sizeof(read_buf));
2450   error = boost::system::error_code();
2451   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2452       boost::asio::transfer_at_least(10), error);
2453   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2454   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2455   BOOST_ASIO_CHECK(!error);
2456
2457   s.reset(read_data, sizeof(read_data));
2458   s.next_read_length(1);
2459   memset(read_buf, 0, sizeof(read_buf));
2460   error = boost::system::error_code();
2461   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2462       boost::asio::transfer_at_least(10), error);
2463   BOOST_ASIO_CHECK(bytes_transferred == 10);
2464   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2465   BOOST_ASIO_CHECK(!error);
2466
2467   s.reset(read_data, sizeof(read_data));
2468   s.next_read_length(1);
2469   memset(read_buf, 0, sizeof(read_buf));
2470   error = boost::system::error_code();
2471   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2472       boost::asio::transfer_at_least(10), error);
2473   BOOST_ASIO_CHECK(bytes_transferred == 10);
2474   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2475   BOOST_ASIO_CHECK(!error);
2476
2477   s.reset(read_data, sizeof(read_data));
2478   s.next_read_length(10);
2479   memset(read_buf, 0, sizeof(read_buf));
2480   error = boost::system::error_code();
2481   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2482       boost::asio::transfer_at_least(10), error);
2483   BOOST_ASIO_CHECK(bytes_transferred == 10);
2484   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2485   BOOST_ASIO_CHECK(!error);
2486
2487   s.reset(read_data, sizeof(read_data));
2488   s.next_read_length(10);
2489   memset(read_buf, 0, sizeof(read_buf));
2490   error = boost::system::error_code();
2491   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2492       boost::asio::transfer_at_least(10), error);
2493   BOOST_ASIO_CHECK(bytes_transferred == 10);
2494   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2495   BOOST_ASIO_CHECK(!error);
2496
2497   s.reset(read_data, sizeof(read_data));
2498   memset(read_buf, 0, sizeof(read_buf));
2499   error = boost::system::error_code();
2500   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2501       boost::asio::transfer_at_least(42), error);
2502   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2503   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2504   BOOST_ASIO_CHECK(!error);
2505
2506   s.reset(read_data, sizeof(read_data));
2507   memset(read_buf, 0, sizeof(read_buf));
2508   error = boost::system::error_code();
2509   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2510       boost::asio::transfer_at_least(42), error);
2511   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2512   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2513   BOOST_ASIO_CHECK(!error);
2514
2515   s.reset(read_data, sizeof(read_data));
2516   s.next_read_length(1);
2517   memset(read_buf, 0, sizeof(read_buf));
2518   error = boost::system::error_code();
2519   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2520       boost::asio::transfer_at_least(42), error);
2521   BOOST_ASIO_CHECK(bytes_transferred == 42);
2522   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2523   BOOST_ASIO_CHECK(!error);
2524
2525   s.reset(read_data, sizeof(read_data));
2526   s.next_read_length(1);
2527   memset(read_buf, 0, sizeof(read_buf));
2528   error = boost::system::error_code();
2529   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2530       boost::asio::transfer_at_least(42), error);
2531   BOOST_ASIO_CHECK(bytes_transferred == 42);
2532   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2533   BOOST_ASIO_CHECK(!error);
2534
2535   s.reset(read_data, sizeof(read_data));
2536   s.next_read_length(10);
2537   memset(read_buf, 0, sizeof(read_buf));
2538   error = boost::system::error_code();
2539   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2540       boost::asio::transfer_at_least(42), error);
2541   BOOST_ASIO_CHECK(bytes_transferred == 50);
2542   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
2543   BOOST_ASIO_CHECK(!error);
2544
2545   s.reset(read_data, sizeof(read_data));
2546   s.next_read_length(10);
2547   memset(read_buf, 0, sizeof(read_buf));
2548   error = boost::system::error_code();
2549   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2550       boost::asio::transfer_at_least(42), error);
2551   BOOST_ASIO_CHECK(bytes_transferred == 50);
2552   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
2553   BOOST_ASIO_CHECK(!error);
2554
2555   s.reset(read_data, sizeof(read_data));
2556   memset(read_buf, 0, sizeof(read_buf));
2557   error = boost::system::error_code();
2558   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2559       boost::asio::transfer_exactly(1), error);
2560   BOOST_ASIO_CHECK(bytes_transferred == 1);
2561   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2562   BOOST_ASIO_CHECK(!error);
2563
2564   s.reset(read_data, sizeof(read_data));
2565   memset(read_buf, 0, sizeof(read_buf));
2566   error = boost::system::error_code();
2567   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2568       boost::asio::transfer_exactly(1), error);
2569   BOOST_ASIO_CHECK(bytes_transferred == 1);
2570   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2571   BOOST_ASIO_CHECK(!error);
2572
2573   s.reset(read_data, sizeof(read_data));
2574   s.next_read_length(1);
2575   memset(read_buf, 0, sizeof(read_buf));
2576   error = boost::system::error_code();
2577   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2578       boost::asio::transfer_exactly(1), error);
2579   BOOST_ASIO_CHECK(bytes_transferred == 1);
2580   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2581   BOOST_ASIO_CHECK(!error);
2582
2583   s.reset(read_data, sizeof(read_data));
2584   s.next_read_length(1);
2585   memset(read_buf, 0, sizeof(read_buf));
2586   error = boost::system::error_code();
2587   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2588       boost::asio::transfer_exactly(1), error);
2589   BOOST_ASIO_CHECK(bytes_transferred == 1);
2590   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2591   BOOST_ASIO_CHECK(!error);
2592
2593   s.reset(read_data, sizeof(read_data));
2594   s.next_read_length(10);
2595   memset(read_buf, 0, sizeof(read_buf));
2596   error = boost::system::error_code();
2597   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2598       boost::asio::transfer_exactly(1), error);
2599   BOOST_ASIO_CHECK(bytes_transferred == 1);
2600   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
2601   BOOST_ASIO_CHECK(!error);
2602
2603   s.reset(read_data, sizeof(read_data));
2604   s.next_read_length(10);
2605   memset(read_buf, 0, sizeof(read_buf));
2606   error = boost::system::error_code();
2607   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2608       boost::asio::transfer_exactly(1), error);
2609   BOOST_ASIO_CHECK(bytes_transferred == 1);
2610   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2611   BOOST_ASIO_CHECK(!error);
2612
2613   s.reset(read_data, sizeof(read_data));
2614   memset(read_buf, 0, sizeof(read_buf));
2615   error = boost::system::error_code();
2616   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2617       boost::asio::transfer_exactly(10), error);
2618   BOOST_ASIO_CHECK(bytes_transferred == 10);
2619   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2620   BOOST_ASIO_CHECK(!error);
2621
2622   s.reset(read_data, sizeof(read_data));
2623   memset(read_buf, 0, sizeof(read_buf));
2624   error = boost::system::error_code();
2625   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2626       boost::asio::transfer_exactly(10), error);
2627   BOOST_ASIO_CHECK(bytes_transferred == 10);
2628   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2629   BOOST_ASIO_CHECK(!error);
2630
2631   s.reset(read_data, sizeof(read_data));
2632   s.next_read_length(1);
2633   memset(read_buf, 0, sizeof(read_buf));
2634   error = boost::system::error_code();
2635   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2636       boost::asio::transfer_exactly(10), error);
2637   BOOST_ASIO_CHECK(bytes_transferred == 10);
2638   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2639   BOOST_ASIO_CHECK(!error);
2640
2641   s.reset(read_data, sizeof(read_data));
2642   s.next_read_length(1);
2643   memset(read_buf, 0, sizeof(read_buf));
2644   error = boost::system::error_code();
2645   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2646       boost::asio::transfer_exactly(10), error);
2647   BOOST_ASIO_CHECK(bytes_transferred == 10);
2648   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2649   BOOST_ASIO_CHECK(!error);
2650
2651   s.reset(read_data, sizeof(read_data));
2652   s.next_read_length(10);
2653   memset(read_buf, 0, sizeof(read_buf));
2654   error = boost::system::error_code();
2655   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2656       boost::asio::transfer_exactly(10), error);
2657   BOOST_ASIO_CHECK(bytes_transferred == 10);
2658   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
2659   BOOST_ASIO_CHECK(!error);
2660
2661   s.reset(read_data, sizeof(read_data));
2662   s.next_read_length(10);
2663   memset(read_buf, 0, sizeof(read_buf));
2664   error = boost::system::error_code();
2665   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2666       boost::asio::transfer_exactly(10), error);
2667   BOOST_ASIO_CHECK(bytes_transferred == 10);
2668   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2669   BOOST_ASIO_CHECK(!error);
2670
2671   s.reset(read_data, sizeof(read_data));
2672   memset(read_buf, 0, sizeof(read_buf));
2673   error = boost::system::error_code();
2674   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2675       boost::asio::transfer_exactly(42), error);
2676   BOOST_ASIO_CHECK(bytes_transferred == 42);
2677   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2678   BOOST_ASIO_CHECK(!error);
2679
2680   s.reset(read_data, sizeof(read_data));
2681   memset(read_buf, 0, sizeof(read_buf));
2682   error = boost::system::error_code();
2683   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2684       boost::asio::transfer_exactly(42), error);
2685   BOOST_ASIO_CHECK(bytes_transferred == 42);
2686   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2687   BOOST_ASIO_CHECK(!error);
2688
2689   s.reset(read_data, sizeof(read_data));
2690   s.next_read_length(1);
2691   memset(read_buf, 0, sizeof(read_buf));
2692   error = boost::system::error_code();
2693   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2694       boost::asio::transfer_exactly(42), error);
2695   BOOST_ASIO_CHECK(bytes_transferred == 42);
2696   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2697   BOOST_ASIO_CHECK(!error);
2698
2699   s.reset(read_data, sizeof(read_data));
2700   s.next_read_length(1);
2701   memset(read_buf, 0, sizeof(read_buf));
2702   error = boost::system::error_code();
2703   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2704       boost::asio::transfer_exactly(42), error);
2705   BOOST_ASIO_CHECK(bytes_transferred == 42);
2706   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2707   BOOST_ASIO_CHECK(!error);
2708
2709   s.reset(read_data, sizeof(read_data));
2710   s.next_read_length(10);
2711   memset(read_buf, 0, sizeof(read_buf));
2712   error = boost::system::error_code();
2713   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2714       boost::asio::transfer_exactly(42), error);
2715   BOOST_ASIO_CHECK(bytes_transferred == 42);
2716   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
2717   BOOST_ASIO_CHECK(!error);
2718
2719   s.reset(read_data, sizeof(read_data));
2720   s.next_read_length(10);
2721   memset(read_buf, 0, sizeof(read_buf));
2722   error = boost::system::error_code();
2723   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2724       boost::asio::transfer_exactly(42), error);
2725   BOOST_ASIO_CHECK(bytes_transferred == 42);
2726   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2727   BOOST_ASIO_CHECK(!error);
2728
2729   s.reset(read_data, sizeof(read_data));
2730   memset(read_buf, 0, sizeof(read_buf));
2731   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2732       old_style_transfer_all, error);
2733   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2734   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2735   BOOST_ASIO_CHECK(!error);
2736
2737   s.reset(read_data, sizeof(read_data));
2738   memset(read_buf, 0, sizeof(read_buf));
2739   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2740       old_style_transfer_all, error);
2741   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2742   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2743   BOOST_ASIO_CHECK(!error);
2744
2745   s.reset(read_data, sizeof(read_data));
2746   s.next_read_length(1);
2747   memset(read_buf, 0, sizeof(read_buf));
2748   error = boost::system::error_code();
2749   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2750       old_style_transfer_all, error);
2751   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2752   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2753   BOOST_ASIO_CHECK(!error);
2754
2755   s.reset(read_data, sizeof(read_data));
2756   s.next_read_length(1);
2757   memset(read_buf, 0, sizeof(read_buf));
2758   error = boost::system::error_code();
2759   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2760       old_style_transfer_all, error);
2761   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2762   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2763   BOOST_ASIO_CHECK(!error);
2764
2765   s.reset(read_data, sizeof(read_data));
2766   s.next_read_length(10);
2767   memset(read_buf, 0, sizeof(read_buf));
2768   error = boost::system::error_code();
2769   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2770       old_style_transfer_all, error);
2771   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2772   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2773   BOOST_ASIO_CHECK(!error);
2774
2775   s.reset(read_data, sizeof(read_data));
2776   s.next_read_length(10);
2777   memset(read_buf, 0, sizeof(read_buf));
2778   error = boost::system::error_code();
2779   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2780       old_style_transfer_all, error);
2781   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2782   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2783   BOOST_ASIO_CHECK(!error);
2784
2785   s.reset(read_data, sizeof(read_data));
2786   memset(read_buf, 0, sizeof(read_buf));
2787   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2788       short_transfer, error);
2789   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2790   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2791   BOOST_ASIO_CHECK(!error);
2792
2793   s.reset(read_data, sizeof(read_data));
2794   memset(read_buf, 0, sizeof(read_buf));
2795   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2796       short_transfer, error);
2797   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2798   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2799   BOOST_ASIO_CHECK(!error);
2800
2801   s.reset(read_data, sizeof(read_data));
2802   s.next_read_length(1);
2803   memset(read_buf, 0, sizeof(read_buf));
2804   error = boost::system::error_code();
2805   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2806       short_transfer, error);
2807   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2808   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2809   BOOST_ASIO_CHECK(!error);
2810
2811   s.reset(read_data, sizeof(read_data));
2812   s.next_read_length(1);
2813   memset(read_buf, 0, sizeof(read_buf));
2814   error = boost::system::error_code();
2815   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2816       short_transfer, error);
2817   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2818   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2819   BOOST_ASIO_CHECK(!error);
2820
2821   s.reset(read_data, sizeof(read_data));
2822   s.next_read_length(10);
2823   memset(read_buf, 0, sizeof(read_buf));
2824   error = boost::system::error_code();
2825   bytes_transferred = boost::asio::read_at(s, 0, buffers,
2826       short_transfer, error);
2827   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2828   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2829   BOOST_ASIO_CHECK(!error);
2830
2831   s.reset(read_data, sizeof(read_data));
2832   s.next_read_length(10);
2833   memset(read_buf, 0, sizeof(read_buf));
2834   error = boost::system::error_code();
2835   bytes_transferred = boost::asio::read_at(s, 1234, buffers,
2836       short_transfer, error);
2837   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2838   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2839   BOOST_ASIO_CHECK(!error);
2840 }
2841
2842 void test_5_arg_streambuf_read_at()
2843 {
2844   boost::asio::io_context ioc;
2845   test_random_access_device s(ioc);
2846   boost::asio::streambuf sb(sizeof(read_data));
2847
2848   s.reset(read_data, sizeof(read_data));
2849   sb.consume(sb.size());
2850   boost::system::error_code error;
2851   size_t bytes_transferred = boost::asio::read_at(s, 0, sb,
2852       boost::asio::transfer_all(), error);
2853   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2854   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2855   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2856   BOOST_ASIO_CHECK(!error);
2857
2858   s.reset(read_data, sizeof(read_data));
2859   sb.consume(sb.size());
2860   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2861       boost::asio::transfer_all(), error);
2862   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2863   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2864   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2865   BOOST_ASIO_CHECK(!error);
2866
2867   s.reset(read_data, sizeof(read_data));
2868   s.next_read_length(1);
2869   sb.consume(sb.size());
2870   error = boost::system::error_code();
2871   bytes_transferred = boost::asio::read_at(s, 0, sb,
2872       boost::asio::transfer_all(), error);
2873   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2874   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2875   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2876   BOOST_ASIO_CHECK(!error);
2877
2878   s.reset(read_data, sizeof(read_data));
2879   s.next_read_length(1);
2880   sb.consume(sb.size());
2881   error = boost::system::error_code();
2882   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2883       boost::asio::transfer_all(), error);
2884   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2885   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2886   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2887   BOOST_ASIO_CHECK(!error);
2888
2889   s.reset(read_data, sizeof(read_data));
2890   s.next_read_length(10);
2891   sb.consume(sb.size());
2892   error = boost::system::error_code();
2893   bytes_transferred = boost::asio::read_at(s, 0, sb,
2894       boost::asio::transfer_all(), error);
2895   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2896   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2897   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2898   BOOST_ASIO_CHECK(!error);
2899
2900   s.reset(read_data, sizeof(read_data));
2901   s.next_read_length(10);
2902   sb.consume(sb.size());
2903   error = boost::system::error_code();
2904   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2905       boost::asio::transfer_all(), error);
2906   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2907   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2908   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2909   BOOST_ASIO_CHECK(!error);
2910
2911   s.reset(read_data, sizeof(read_data));
2912   sb.consume(sb.size());
2913   error = boost::system::error_code();
2914   bytes_transferred = boost::asio::read_at(s, 0, sb,
2915       boost::asio::transfer_at_least(1), error);
2916   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2917   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2918   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2919   BOOST_ASIO_CHECK(!error);
2920
2921   s.reset(read_data, sizeof(read_data));
2922   sb.consume(sb.size());
2923   error = boost::system::error_code();
2924   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2925       boost::asio::transfer_at_least(1), error);
2926   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2927   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2928   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2929   BOOST_ASIO_CHECK(!error);
2930
2931   s.reset(read_data, sizeof(read_data));
2932   s.next_read_length(1);
2933   sb.consume(sb.size());
2934   error = boost::system::error_code();
2935   bytes_transferred = boost::asio::read_at(s, 0, sb,
2936       boost::asio::transfer_at_least(1), error);
2937   BOOST_ASIO_CHECK(bytes_transferred == 1);
2938   BOOST_ASIO_CHECK(sb.size() == 1);
2939   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
2940   BOOST_ASIO_CHECK(!error);
2941
2942   s.reset(read_data, sizeof(read_data));
2943   s.next_read_length(1);
2944   sb.consume(sb.size());
2945   error = boost::system::error_code();
2946   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2947       boost::asio::transfer_at_least(1), error);
2948   BOOST_ASIO_CHECK(bytes_transferred == 1);
2949   BOOST_ASIO_CHECK(sb.size() == 1);
2950   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
2951   BOOST_ASIO_CHECK(!error);
2952
2953   s.reset(read_data, sizeof(read_data));
2954   s.next_read_length(10);
2955   sb.consume(sb.size());
2956   error = boost::system::error_code();
2957   bytes_transferred = boost::asio::read_at(s, 0, sb,
2958       boost::asio::transfer_at_least(1), error);
2959   BOOST_ASIO_CHECK(bytes_transferred == 10);
2960   BOOST_ASIO_CHECK(sb.size() == 10);
2961   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
2962   BOOST_ASIO_CHECK(!error);
2963
2964   s.reset(read_data, sizeof(read_data));
2965   s.next_read_length(10);
2966   sb.consume(sb.size());
2967   error = boost::system::error_code();
2968   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2969       boost::asio::transfer_at_least(1), error);
2970   BOOST_ASIO_CHECK(bytes_transferred == 10);
2971   BOOST_ASIO_CHECK(sb.size() == 10);
2972   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
2973   BOOST_ASIO_CHECK(!error);
2974
2975   s.reset(read_data, sizeof(read_data));
2976   sb.consume(sb.size());
2977   error = boost::system::error_code();
2978   bytes_transferred = boost::asio::read_at(s, 0, sb,
2979       boost::asio::transfer_at_least(10), error);
2980   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2981   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2982   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2983   BOOST_ASIO_CHECK(!error);
2984
2985   s.reset(read_data, sizeof(read_data));
2986   sb.consume(sb.size());
2987   error = boost::system::error_code();
2988   bytes_transferred = boost::asio::read_at(s, 1234, sb,
2989       boost::asio::transfer_at_least(10), error);
2990   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2991   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2992   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2993   BOOST_ASIO_CHECK(!error);
2994
2995   s.reset(read_data, sizeof(read_data));
2996   s.next_read_length(1);
2997   sb.consume(sb.size());
2998   error = boost::system::error_code();
2999   bytes_transferred = boost::asio::read_at(s, 0, sb,
3000       boost::asio::transfer_at_least(10), error);
3001   BOOST_ASIO_CHECK(bytes_transferred == 10);
3002   BOOST_ASIO_CHECK(sb.size() == 10);
3003   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3004   BOOST_ASIO_CHECK(!error);
3005
3006   s.reset(read_data, sizeof(read_data));
3007   s.next_read_length(1);
3008   sb.consume(sb.size());
3009   error = boost::system::error_code();
3010   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3011       boost::asio::transfer_at_least(10), error);
3012   BOOST_ASIO_CHECK(bytes_transferred == 10);
3013   BOOST_ASIO_CHECK(sb.size() == 10);
3014   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3015   BOOST_ASIO_CHECK(!error);
3016
3017   s.reset(read_data, sizeof(read_data));
3018   s.next_read_length(10);
3019   sb.consume(sb.size());
3020   error = boost::system::error_code();
3021   bytes_transferred = boost::asio::read_at(s, 0, sb,
3022       boost::asio::transfer_at_least(10), error);
3023   BOOST_ASIO_CHECK(bytes_transferred == 10);
3024   BOOST_ASIO_CHECK(sb.size() == 10);
3025   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3026   BOOST_ASIO_CHECK(!error);
3027
3028   s.reset(read_data, sizeof(read_data));
3029   s.next_read_length(10);
3030   sb.consume(sb.size());
3031   error = boost::system::error_code();
3032   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3033       boost::asio::transfer_at_least(10), error);
3034   BOOST_ASIO_CHECK(bytes_transferred == 10);
3035   BOOST_ASIO_CHECK(sb.size() == 10);
3036   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3037   BOOST_ASIO_CHECK(!error);
3038
3039   s.reset(read_data, sizeof(read_data));
3040   sb.consume(sb.size());
3041   error = boost::system::error_code();
3042   bytes_transferred = boost::asio::read_at(s, 0, sb,
3043       boost::asio::transfer_at_least(42), error);
3044   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3045   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3046   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3047   BOOST_ASIO_CHECK(!error);
3048
3049   s.reset(read_data, sizeof(read_data));
3050   sb.consume(sb.size());
3051   error = boost::system::error_code();
3052   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3053       boost::asio::transfer_at_least(42), error);
3054   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3055   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3056   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3057   BOOST_ASIO_CHECK(!error);
3058
3059   s.reset(read_data, sizeof(read_data));
3060   s.next_read_length(1);
3061   sb.consume(sb.size());
3062   error = boost::system::error_code();
3063   bytes_transferred = boost::asio::read_at(s, 0, sb,
3064       boost::asio::transfer_at_least(42), error);
3065   BOOST_ASIO_CHECK(bytes_transferred == 42);
3066   BOOST_ASIO_CHECK(sb.size() == 42);
3067   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3068   BOOST_ASIO_CHECK(!error);
3069
3070   s.reset(read_data, sizeof(read_data));
3071   s.next_read_length(1);
3072   sb.consume(sb.size());
3073   error = boost::system::error_code();
3074   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3075       boost::asio::transfer_at_least(42), error);
3076   BOOST_ASIO_CHECK(bytes_transferred == 42);
3077   BOOST_ASIO_CHECK(sb.size() == 42);
3078   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3079   BOOST_ASIO_CHECK(!error);
3080
3081   s.reset(read_data, sizeof(read_data));
3082   s.next_read_length(10);
3083   sb.consume(sb.size());
3084   error = boost::system::error_code();
3085   bytes_transferred = boost::asio::read_at(s, 0, sb,
3086       boost::asio::transfer_at_least(42), error);
3087   BOOST_ASIO_CHECK(bytes_transferred == 50);
3088   BOOST_ASIO_CHECK(sb.size() == 50);
3089   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
3090   BOOST_ASIO_CHECK(!error);
3091
3092   s.reset(read_data, sizeof(read_data));
3093   s.next_read_length(10);
3094   sb.consume(sb.size());
3095   error = boost::system::error_code();
3096   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3097       boost::asio::transfer_at_least(42), error);
3098   BOOST_ASIO_CHECK(bytes_transferred == 50);
3099   BOOST_ASIO_CHECK(sb.size() == 50);
3100   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
3101   BOOST_ASIO_CHECK(!error);
3102
3103   s.reset(read_data, sizeof(read_data));
3104   sb.consume(sb.size());
3105   error = boost::system::error_code();
3106   bytes_transferred = boost::asio::read_at(s, 0, sb,
3107       boost::asio::transfer_exactly(1), error);
3108   BOOST_ASIO_CHECK(bytes_transferred == 1);
3109   BOOST_ASIO_CHECK(sb.size() == 1);
3110   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
3111   BOOST_ASIO_CHECK(!error);
3112
3113   s.reset(read_data, sizeof(read_data));
3114   sb.consume(sb.size());
3115   error = boost::system::error_code();
3116   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3117       boost::asio::transfer_exactly(1), error);
3118   BOOST_ASIO_CHECK(bytes_transferred == 1);
3119   BOOST_ASIO_CHECK(sb.size() == 1);
3120   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
3121   BOOST_ASIO_CHECK(!error);
3122
3123   s.reset(read_data, sizeof(read_data));
3124   s.next_read_length(1);
3125   sb.consume(sb.size());
3126   error = boost::system::error_code();
3127   bytes_transferred = boost::asio::read_at(s, 0, sb,
3128       boost::asio::transfer_exactly(1), error);
3129   BOOST_ASIO_CHECK(bytes_transferred == 1);
3130   BOOST_ASIO_CHECK(sb.size() == 1);
3131   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
3132   BOOST_ASIO_CHECK(!error);
3133
3134   s.reset(read_data, sizeof(read_data));
3135   s.next_read_length(1);
3136   sb.consume(sb.size());
3137   error = boost::system::error_code();
3138   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3139       boost::asio::transfer_exactly(1), error);
3140   BOOST_ASIO_CHECK(bytes_transferred == 1);
3141   BOOST_ASIO_CHECK(sb.size() == 1);
3142   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
3143   BOOST_ASIO_CHECK(!error);
3144
3145   s.reset(read_data, sizeof(read_data));
3146   s.next_read_length(10);
3147   sb.consume(sb.size());
3148   error = boost::system::error_code();
3149   bytes_transferred = boost::asio::read_at(s, 0, sb,
3150       boost::asio::transfer_exactly(1), error);
3151   BOOST_ASIO_CHECK(bytes_transferred == 1);
3152   BOOST_ASIO_CHECK(sb.size() == 1);
3153   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
3154   BOOST_ASIO_CHECK(!error);
3155
3156   s.reset(read_data, sizeof(read_data));
3157   s.next_read_length(10);
3158   sb.consume(sb.size());
3159   error = boost::system::error_code();
3160   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3161       boost::asio::transfer_exactly(1), error);
3162   BOOST_ASIO_CHECK(bytes_transferred == 1);
3163   BOOST_ASIO_CHECK(sb.size() == 1);
3164   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
3165   BOOST_ASIO_CHECK(!error);
3166
3167   s.reset(read_data, sizeof(read_data));
3168   sb.consume(sb.size());
3169   error = boost::system::error_code();
3170   bytes_transferred = boost::asio::read_at(s, 0, sb,
3171       boost::asio::transfer_exactly(10), error);
3172   BOOST_ASIO_CHECK(bytes_transferred == 10);
3173   BOOST_ASIO_CHECK(sb.size() == 10);
3174   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3175   BOOST_ASIO_CHECK(!error);
3176
3177   s.reset(read_data, sizeof(read_data));
3178   sb.consume(sb.size());
3179   error = boost::system::error_code();
3180   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3181       boost::asio::transfer_exactly(10), error);
3182   BOOST_ASIO_CHECK(bytes_transferred == 10);
3183   BOOST_ASIO_CHECK(sb.size() == 10);
3184   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3185   BOOST_ASIO_CHECK(!error);
3186
3187   s.reset(read_data, sizeof(read_data));
3188   s.next_read_length(1);
3189   sb.consume(sb.size());
3190   error = boost::system::error_code();
3191   bytes_transferred = boost::asio::read_at(s, 0, sb,
3192       boost::asio::transfer_exactly(10), error);
3193   BOOST_ASIO_CHECK(bytes_transferred == 10);
3194   BOOST_ASIO_CHECK(sb.size() == 10);
3195   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3196   BOOST_ASIO_CHECK(!error);
3197
3198   s.reset(read_data, sizeof(read_data));
3199   s.next_read_length(1);
3200   sb.consume(sb.size());
3201   error = boost::system::error_code();
3202   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3203       boost::asio::transfer_exactly(10), error);
3204   BOOST_ASIO_CHECK(bytes_transferred == 10);
3205   BOOST_ASIO_CHECK(sb.size() == 10);
3206   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3207   BOOST_ASIO_CHECK(!error);
3208
3209   s.reset(read_data, sizeof(read_data));
3210   s.next_read_length(10);
3211   sb.consume(sb.size());
3212   error = boost::system::error_code();
3213   bytes_transferred = boost::asio::read_at(s, 0, sb,
3214       boost::asio::transfer_exactly(10), error);
3215   BOOST_ASIO_CHECK(bytes_transferred == 10);
3216   BOOST_ASIO_CHECK(sb.size() == 10);
3217   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3218   BOOST_ASIO_CHECK(!error);
3219
3220   s.reset(read_data, sizeof(read_data));
3221   s.next_read_length(10);
3222   sb.consume(sb.size());
3223   error = boost::system::error_code();
3224   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3225       boost::asio::transfer_exactly(10), error);
3226   BOOST_ASIO_CHECK(bytes_transferred == 10);
3227   BOOST_ASIO_CHECK(sb.size() == 10);
3228   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3229   BOOST_ASIO_CHECK(!error);
3230
3231   s.reset(read_data, sizeof(read_data));
3232   sb.consume(sb.size());
3233   error = boost::system::error_code();
3234   bytes_transferred = boost::asio::read_at(s, 0, sb,
3235       boost::asio::transfer_exactly(42), error);
3236   BOOST_ASIO_CHECK(bytes_transferred == 42);
3237   BOOST_ASIO_CHECK(sb.size() == 42);
3238   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3239   BOOST_ASIO_CHECK(!error);
3240
3241   s.reset(read_data, sizeof(read_data));
3242   sb.consume(sb.size());
3243   error = boost::system::error_code();
3244   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3245       boost::asio::transfer_exactly(42), error);
3246   BOOST_ASIO_CHECK(bytes_transferred == 42);
3247   BOOST_ASIO_CHECK(sb.size() == 42);
3248   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3249   BOOST_ASIO_CHECK(!error);
3250
3251   s.reset(read_data, sizeof(read_data));
3252   s.next_read_length(1);
3253   sb.consume(sb.size());
3254   error = boost::system::error_code();
3255   bytes_transferred = boost::asio::read_at(s, 0, sb,
3256       boost::asio::transfer_exactly(42), error);
3257   BOOST_ASIO_CHECK(bytes_transferred == 42);
3258   BOOST_ASIO_CHECK(sb.size() == 42);
3259   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3260   BOOST_ASIO_CHECK(!error);
3261
3262   s.reset(read_data, sizeof(read_data));
3263   s.next_read_length(1);
3264   sb.consume(sb.size());
3265   error = boost::system::error_code();
3266   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3267       boost::asio::transfer_exactly(42), error);
3268   BOOST_ASIO_CHECK(bytes_transferred == 42);
3269   BOOST_ASIO_CHECK(sb.size() == 42);
3270   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3271   BOOST_ASIO_CHECK(!error);
3272
3273   s.reset(read_data, sizeof(read_data));
3274   s.next_read_length(10);
3275   sb.consume(sb.size());
3276   error = boost::system::error_code();
3277   bytes_transferred = boost::asio::read_at(s, 0, sb,
3278       boost::asio::transfer_exactly(42), error);
3279   BOOST_ASIO_CHECK(bytes_transferred == 42);
3280   BOOST_ASIO_CHECK(sb.size() == 42);
3281   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3282   BOOST_ASIO_CHECK(!error);
3283
3284   s.reset(read_data, sizeof(read_data));
3285   s.next_read_length(10);
3286   sb.consume(sb.size());
3287   error = boost::system::error_code();
3288   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3289       boost::asio::transfer_exactly(42), error);
3290   BOOST_ASIO_CHECK(bytes_transferred == 42);
3291   BOOST_ASIO_CHECK(sb.size() == 42);
3292   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3293   BOOST_ASIO_CHECK(!error);
3294
3295   s.reset(read_data, sizeof(read_data));
3296   sb.consume(sb.size());
3297   bytes_transferred = boost::asio::read_at(s, 0, sb,
3298       old_style_transfer_all, error);
3299   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3300   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3301   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3302   BOOST_ASIO_CHECK(!error);
3303
3304   s.reset(read_data, sizeof(read_data));
3305   sb.consume(sb.size());
3306   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3307       old_style_transfer_all, error);
3308   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3309   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3310   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3311   BOOST_ASIO_CHECK(!error);
3312
3313   s.reset(read_data, sizeof(read_data));
3314   s.next_read_length(1);
3315   sb.consume(sb.size());
3316   error = boost::system::error_code();
3317   bytes_transferred = boost::asio::read_at(s, 0, sb,
3318       old_style_transfer_all, error);
3319   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3320   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3321   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3322   BOOST_ASIO_CHECK(!error);
3323
3324   s.reset(read_data, sizeof(read_data));
3325   s.next_read_length(1);
3326   sb.consume(sb.size());
3327   error = boost::system::error_code();
3328   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3329       old_style_transfer_all, error);
3330   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3331   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3332   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3333   BOOST_ASIO_CHECK(!error);
3334
3335   s.reset(read_data, sizeof(read_data));
3336   s.next_read_length(10);
3337   sb.consume(sb.size());
3338   error = boost::system::error_code();
3339   bytes_transferred = boost::asio::read_at(s, 0, sb,
3340       old_style_transfer_all, error);
3341   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3342   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3343   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3344   BOOST_ASIO_CHECK(!error);
3345
3346   s.reset(read_data, sizeof(read_data));
3347   s.next_read_length(10);
3348   sb.consume(sb.size());
3349   error = boost::system::error_code();
3350   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3351       old_style_transfer_all, error);
3352   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3353   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3354   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3355   BOOST_ASIO_CHECK(!error);
3356
3357   s.reset(read_data, sizeof(read_data));
3358   sb.consume(sb.size());
3359   bytes_transferred = boost::asio::read_at(s, 0, sb,
3360       short_transfer, error);
3361   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3362   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3363   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3364   BOOST_ASIO_CHECK(!error);
3365
3366   s.reset(read_data, sizeof(read_data));
3367   sb.consume(sb.size());
3368   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3369       short_transfer, error);
3370   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3371   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3372   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3373   BOOST_ASIO_CHECK(!error);
3374
3375   s.reset(read_data, sizeof(read_data));
3376   s.next_read_length(1);
3377   sb.consume(sb.size());
3378   error = boost::system::error_code();
3379   bytes_transferred = boost::asio::read_at(s, 0, sb,
3380       short_transfer, error);
3381   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3382   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3383   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3384   BOOST_ASIO_CHECK(!error);
3385
3386   s.reset(read_data, sizeof(read_data));
3387   s.next_read_length(1);
3388   sb.consume(sb.size());
3389   error = boost::system::error_code();
3390   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3391       short_transfer, error);
3392   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3393   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3394   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3395   BOOST_ASIO_CHECK(!error);
3396
3397   s.reset(read_data, sizeof(read_data));
3398   s.next_read_length(10);
3399   sb.consume(sb.size());
3400   error = boost::system::error_code();
3401   bytes_transferred = boost::asio::read_at(s, 0, sb,
3402       short_transfer, error);
3403   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3404   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3405   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3406   BOOST_ASIO_CHECK(!error);
3407
3408   s.reset(read_data, sizeof(read_data));
3409   s.next_read_length(10);
3410   sb.consume(sb.size());
3411   error = boost::system::error_code();
3412   bytes_transferred = boost::asio::read_at(s, 1234, sb,
3413       short_transfer, error);
3414   BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
3415   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3416   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3417   BOOST_ASIO_CHECK(!error);
3418 }
3419
3420 void async_read_handler(const boost::system::error_code& e,
3421     size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
3422 {
3423   *called = true;
3424   BOOST_ASIO_CHECK(!e);
3425   BOOST_ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
3426 }
3427
3428 void test_4_arg_mutable_buffer_async_read_at()
3429 {
3430 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3431   namespace bindns = boost;
3432 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3433   namespace bindns = std;
3434   using std::placeholders::_1;
3435   using std::placeholders::_2;
3436 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3437
3438   boost::asio::io_context ioc;
3439   test_random_access_device s(ioc);
3440   char read_buf[sizeof(read_data)];
3441   boost::asio::mutable_buffer buffers
3442     = boost::asio::buffer(read_buf, sizeof(read_buf));
3443
3444   s.reset(read_data, sizeof(read_data));
3445   memset(read_buf, 0, sizeof(read_buf));
3446   bool called = false;
3447   boost::asio::async_read_at(s, 0, buffers,
3448       bindns::bind(async_read_handler,
3449         _1, _2, sizeof(read_data), &called));
3450   ioc.restart();
3451   ioc.run();
3452   BOOST_ASIO_CHECK(called);
3453   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3454
3455   s.reset(read_data, sizeof(read_data));
3456   memset(read_buf, 0, sizeof(read_buf));
3457   called = false;
3458   boost::asio::async_read_at(s, 1234, buffers,
3459       bindns::bind(async_read_handler,
3460         _1, _2, sizeof(read_data), &called));
3461   ioc.restart();
3462   ioc.run();
3463   BOOST_ASIO_CHECK(called);
3464   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3465
3466   s.reset(read_data, sizeof(read_data));
3467   s.next_read_length(1);
3468   memset(read_buf, 0, sizeof(read_buf));
3469   called = false;
3470   boost::asio::async_read_at(s, 0, buffers,
3471       bindns::bind(async_read_handler,
3472         _1, _2, sizeof(read_data), &called));
3473   ioc.restart();
3474   ioc.run();
3475   BOOST_ASIO_CHECK(called);
3476   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3477
3478   s.reset(read_data, sizeof(read_data));
3479   s.next_read_length(1);
3480   memset(read_buf, 0, sizeof(read_buf));
3481   called = false;
3482   boost::asio::async_read_at(s, 1234, buffers,
3483       bindns::bind(async_read_handler,
3484         _1, _2, sizeof(read_data), &called));
3485   ioc.restart();
3486   ioc.run();
3487   BOOST_ASIO_CHECK(called);
3488   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3489
3490   s.reset(read_data, sizeof(read_data));
3491   s.next_read_length(10);
3492   memset(read_buf, 0, sizeof(read_buf));
3493   called = false;
3494   boost::asio::async_read_at(s, 0, buffers,
3495       bindns::bind(async_read_handler,
3496         _1, _2, sizeof(read_data), &called));
3497   ioc.restart();
3498   ioc.run();
3499   BOOST_ASIO_CHECK(called);
3500   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3501
3502   s.reset(read_data, sizeof(read_data));
3503   s.next_read_length(10);
3504   memset(read_buf, 0, sizeof(read_buf));
3505   called = false;
3506   boost::asio::async_read_at(s, 1234, buffers,
3507       bindns::bind(async_read_handler,
3508         _1, _2, sizeof(read_data), &called));
3509   ioc.restart();
3510   ioc.run();
3511   BOOST_ASIO_CHECK(called);
3512   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3513
3514   s.reset(read_data, sizeof(read_data));
3515   memset(read_buf, 0, sizeof(read_buf));
3516   int i = boost::asio::async_read_at(s, 1234, buffers,
3517       archetypes::lazy_handler());
3518   BOOST_ASIO_CHECK(i == 42);
3519   ioc.restart();
3520   ioc.run();
3521   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3522 }
3523
3524 void test_4_arg_boost_array_buffers_async_read_at()
3525 {
3526 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3527   namespace bindns = boost;
3528 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3529   namespace bindns = std;
3530   using std::placeholders::_1;
3531   using std::placeholders::_2;
3532 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3533
3534 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
3535   boost::asio::io_context ioc;
3536   test_random_access_device s(ioc);
3537   char read_buf[sizeof(read_data)];
3538   boost::array<boost::asio::mutable_buffer, 2> buffers = { {
3539     boost::asio::buffer(read_buf, 32),
3540     boost::asio::buffer(read_buf) + 32 } };
3541
3542   s.reset(read_data, sizeof(read_data));
3543   memset(read_buf, 0, sizeof(read_buf));
3544   bool called = false;
3545   boost::asio::async_read_at(s, 0, buffers,
3546       bindns::bind(async_read_handler,
3547         _1, _2, sizeof(read_data), &called));
3548   ioc.restart();
3549   ioc.run();
3550   BOOST_ASIO_CHECK(called);
3551   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3552
3553   s.reset(read_data, sizeof(read_data));
3554   memset(read_buf, 0, sizeof(read_buf));
3555   called = false;
3556   boost::asio::async_read_at(s, 1234, buffers,
3557       bindns::bind(async_read_handler,
3558         _1, _2, sizeof(read_data), &called));
3559   ioc.restart();
3560   ioc.run();
3561   BOOST_ASIO_CHECK(called);
3562   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3563
3564   s.reset(read_data, sizeof(read_data));
3565   s.next_read_length(1);
3566   memset(read_buf, 0, sizeof(read_buf));
3567   called = false;
3568   boost::asio::async_read_at(s, 0, buffers,
3569       bindns::bind(async_read_handler,
3570         _1, _2, sizeof(read_data), &called));
3571   ioc.restart();
3572   ioc.run();
3573   BOOST_ASIO_CHECK(called);
3574   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3575
3576   s.reset(read_data, sizeof(read_data));
3577   s.next_read_length(1);
3578   memset(read_buf, 0, sizeof(read_buf));
3579   called = false;
3580   boost::asio::async_read_at(s, 1234, buffers,
3581       bindns::bind(async_read_handler,
3582         _1, _2, sizeof(read_data), &called));
3583   ioc.restart();
3584   ioc.run();
3585   BOOST_ASIO_CHECK(called);
3586   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3587
3588   s.reset(read_data, sizeof(read_data));
3589   s.next_read_length(10);
3590   memset(read_buf, 0, sizeof(read_buf));
3591   called = false;
3592   boost::asio::async_read_at(s, 0, buffers,
3593       bindns::bind(async_read_handler,
3594         _1, _2, sizeof(read_data), &called));
3595   ioc.restart();
3596   ioc.run();
3597   BOOST_ASIO_CHECK(called);
3598   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3599
3600   s.reset(read_data, sizeof(read_data));
3601   s.next_read_length(10);
3602   memset(read_buf, 0, sizeof(read_buf));
3603   called = false;
3604   boost::asio::async_read_at(s, 1234, buffers,
3605       bindns::bind(async_read_handler,
3606         _1, _2, sizeof(read_data), &called));
3607   ioc.restart();
3608   ioc.run();
3609   BOOST_ASIO_CHECK(called);
3610   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3611
3612   s.reset(read_data, sizeof(read_data));
3613   memset(read_buf, 0, sizeof(read_buf));
3614   int i = boost::asio::async_read_at(s, 1234, buffers,
3615       archetypes::lazy_handler());
3616   BOOST_ASIO_CHECK(i == 42);
3617   ioc.restart();
3618   ioc.run();
3619   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3620 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
3621 }
3622
3623 void test_4_arg_std_array_buffers_async_read_at()
3624 {
3625 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3626   namespace bindns = boost;
3627 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3628   namespace bindns = std;
3629   using std::placeholders::_1;
3630   using std::placeholders::_2;
3631 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3632
3633 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
3634   boost::asio::io_context ioc;
3635   test_random_access_device s(ioc);
3636   char read_buf[sizeof(read_data)];
3637   std::array<boost::asio::mutable_buffer, 2> buffers = { {
3638     boost::asio::buffer(read_buf, 32),
3639     boost::asio::buffer(read_buf) + 32 } };
3640
3641   s.reset(read_data, sizeof(read_data));
3642   memset(read_buf, 0, sizeof(read_buf));
3643   bool called = false;
3644   boost::asio::async_read_at(s, 0, buffers,
3645       bindns::bind(async_read_handler,
3646         _1, _2, sizeof(read_data), &called));
3647   ioc.restart();
3648   ioc.run();
3649   BOOST_ASIO_CHECK(called);
3650   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3651
3652   s.reset(read_data, sizeof(read_data));
3653   memset(read_buf, 0, sizeof(read_buf));
3654   called = false;
3655   boost::asio::async_read_at(s, 1234, buffers,
3656       bindns::bind(async_read_handler,
3657         _1, _2, sizeof(read_data), &called));
3658   ioc.restart();
3659   ioc.run();
3660   BOOST_ASIO_CHECK(called);
3661   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3662
3663   s.reset(read_data, sizeof(read_data));
3664   s.next_read_length(1);
3665   memset(read_buf, 0, sizeof(read_buf));
3666   called = false;
3667   boost::asio::async_read_at(s, 0, buffers,
3668       bindns::bind(async_read_handler,
3669         _1, _2, sizeof(read_data), &called));
3670   ioc.restart();
3671   ioc.run();
3672   BOOST_ASIO_CHECK(called);
3673   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3674
3675   s.reset(read_data, sizeof(read_data));
3676   s.next_read_length(1);
3677   memset(read_buf, 0, sizeof(read_buf));
3678   called = false;
3679   boost::asio::async_read_at(s, 1234, buffers,
3680       bindns::bind(async_read_handler,
3681         _1, _2, sizeof(read_data), &called));
3682   ioc.restart();
3683   ioc.run();
3684   BOOST_ASIO_CHECK(called);
3685   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3686
3687   s.reset(read_data, sizeof(read_data));
3688   s.next_read_length(10);
3689   memset(read_buf, 0, sizeof(read_buf));
3690   called = false;
3691   boost::asio::async_read_at(s, 0, buffers,
3692       bindns::bind(async_read_handler,
3693         _1, _2, sizeof(read_data), &called));
3694   ioc.restart();
3695   ioc.run();
3696   BOOST_ASIO_CHECK(called);
3697   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3698
3699   s.reset(read_data, sizeof(read_data));
3700   s.next_read_length(10);
3701   memset(read_buf, 0, sizeof(read_buf));
3702   called = false;
3703   boost::asio::async_read_at(s, 1234, buffers,
3704       bindns::bind(async_read_handler,
3705         _1, _2, sizeof(read_data), &called));
3706   ioc.restart();
3707   ioc.run();
3708   BOOST_ASIO_CHECK(called);
3709   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3710
3711   s.reset(read_data, sizeof(read_data));
3712   memset(read_buf, 0, sizeof(read_buf));
3713   int i = boost::asio::async_read_at(s, 1234, buffers,
3714       archetypes::lazy_handler());
3715   BOOST_ASIO_CHECK(i == 42);
3716   ioc.restart();
3717   ioc.run();
3718   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3719 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
3720 }
3721
3722 void test_4_arg_vector_buffers_async_read_at()
3723 {
3724 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3725   namespace bindns = boost;
3726 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3727   namespace bindns = std;
3728   using std::placeholders::_1;
3729   using std::placeholders::_2;
3730 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3731
3732   boost::asio::io_context ioc;
3733   test_random_access_device s(ioc);
3734   char read_buf[sizeof(read_data)];
3735   std::vector<boost::asio::mutable_buffer> buffers;
3736   buffers.push_back(boost::asio::buffer(read_buf, 32));
3737   buffers.push_back(boost::asio::buffer(read_buf) + 32);
3738
3739   s.reset(read_data, sizeof(read_data));
3740   memset(read_buf, 0, sizeof(read_buf));
3741   bool called = false;
3742   boost::asio::async_read_at(s, 0, buffers,
3743       bindns::bind(async_read_handler,
3744         _1, _2, sizeof(read_data), &called));
3745   ioc.restart();
3746   ioc.run();
3747   BOOST_ASIO_CHECK(called);
3748   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3749
3750   s.reset(read_data, sizeof(read_data));
3751   memset(read_buf, 0, sizeof(read_buf));
3752   called = false;
3753   boost::asio::async_read_at(s, 1234, buffers,
3754       bindns::bind(async_read_handler,
3755         _1, _2, sizeof(read_data), &called));
3756   ioc.restart();
3757   ioc.run();
3758   BOOST_ASIO_CHECK(called);
3759   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3760
3761   s.reset(read_data, sizeof(read_data));
3762   s.next_read_length(1);
3763   memset(read_buf, 0, sizeof(read_buf));
3764   called = false;
3765   boost::asio::async_read_at(s, 0, buffers,
3766       bindns::bind(async_read_handler,
3767         _1, _2, sizeof(read_data), &called));
3768   ioc.restart();
3769   ioc.run();
3770   BOOST_ASIO_CHECK(called);
3771   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3772
3773   s.reset(read_data, sizeof(read_data));
3774   s.next_read_length(1);
3775   memset(read_buf, 0, sizeof(read_buf));
3776   called = false;
3777   boost::asio::async_read_at(s, 1234, buffers,
3778       bindns::bind(async_read_handler,
3779         _1, _2, sizeof(read_data), &called));
3780   ioc.restart();
3781   ioc.run();
3782   BOOST_ASIO_CHECK(called);
3783   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3784
3785   s.reset(read_data, sizeof(read_data));
3786   s.next_read_length(10);
3787   memset(read_buf, 0, sizeof(read_buf));
3788   called = false;
3789   boost::asio::async_read_at(s, 0, buffers,
3790       bindns::bind(async_read_handler,
3791         _1, _2, sizeof(read_data), &called));
3792   ioc.restart();
3793   ioc.run();
3794   BOOST_ASIO_CHECK(called);
3795   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3796
3797   s.reset(read_data, sizeof(read_data));
3798   s.next_read_length(10);
3799   memset(read_buf, 0, sizeof(read_buf));
3800   called = false;
3801   boost::asio::async_read_at(s, 1234, buffers,
3802       bindns::bind(async_read_handler,
3803         _1, _2, sizeof(read_data), &called));
3804   ioc.restart();
3805   ioc.run();
3806   BOOST_ASIO_CHECK(called);
3807   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3808
3809   s.reset(read_data, sizeof(read_data));
3810   memset(read_buf, 0, sizeof(read_buf));
3811   int i = boost::asio::async_read_at(s, 1234, buffers,
3812       archetypes::lazy_handler());
3813   BOOST_ASIO_CHECK(i == 42);
3814   ioc.restart();
3815   ioc.run();
3816   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3817 }
3818
3819 void test_4_arg_streambuf_async_read_at()
3820 {
3821 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3822   namespace bindns = boost;
3823 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3824   namespace bindns = std;
3825   using std::placeholders::_1;
3826   using std::placeholders::_2;
3827 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3828
3829   boost::asio::io_context ioc;
3830   test_random_access_device s(ioc);
3831   boost::asio::streambuf sb(sizeof(read_data));
3832
3833   s.reset(read_data, sizeof(read_data));
3834   sb.consume(sb.size());
3835   bool called = false;
3836   boost::asio::async_read_at(s, 0, sb,
3837       bindns::bind(async_read_handler,
3838         _1, _2, sizeof(read_data), &called));
3839   ioc.restart();
3840   ioc.run();
3841   BOOST_ASIO_CHECK(called);
3842   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3843   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3844
3845   s.reset(read_data, sizeof(read_data));
3846   sb.consume(sb.size());
3847   called = false;
3848   boost::asio::async_read_at(s, 1234, sb,
3849       bindns::bind(async_read_handler,
3850         _1, _2, sizeof(read_data), &called));
3851   ioc.restart();
3852   ioc.run();
3853   BOOST_ASIO_CHECK(called);
3854   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3855   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3856
3857   s.reset(read_data, sizeof(read_data));
3858   s.next_read_length(1);
3859   sb.consume(sb.size());
3860   called = false;
3861   boost::asio::async_read_at(s, 0, sb,
3862       bindns::bind(async_read_handler,
3863         _1, _2, sizeof(read_data), &called));
3864   ioc.restart();
3865   ioc.run();
3866   BOOST_ASIO_CHECK(called);
3867   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3868   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3869
3870   s.reset(read_data, sizeof(read_data));
3871   s.next_read_length(1);
3872   sb.consume(sb.size());
3873   called = false;
3874   boost::asio::async_read_at(s, 1234, sb,
3875       bindns::bind(async_read_handler,
3876         _1, _2, sizeof(read_data), &called));
3877   ioc.restart();
3878   ioc.run();
3879   BOOST_ASIO_CHECK(called);
3880   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3881   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3882
3883   s.reset(read_data, sizeof(read_data));
3884   s.next_read_length(10);
3885   sb.consume(sb.size());
3886   called = false;
3887   boost::asio::async_read_at(s, 0, sb,
3888       bindns::bind(async_read_handler,
3889         _1, _2, sizeof(read_data), &called));
3890   ioc.restart();
3891   ioc.run();
3892   BOOST_ASIO_CHECK(called);
3893   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3894   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3895
3896   s.reset(read_data, sizeof(read_data));
3897   s.next_read_length(10);
3898   sb.consume(sb.size());
3899   called = false;
3900   boost::asio::async_read_at(s, 1234, sb,
3901       bindns::bind(async_read_handler,
3902         _1, _2, sizeof(read_data), &called));
3903   ioc.restart();
3904   ioc.run();
3905   BOOST_ASIO_CHECK(called);
3906   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
3907   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3908
3909   s.reset(read_data, sizeof(read_data));
3910   sb.consume(sb.size());
3911   int i = boost::asio::async_read_at(s, 1234, sb,
3912       archetypes::lazy_handler());
3913   BOOST_ASIO_CHECK(i == 42);
3914   ioc.restart();
3915   ioc.run();
3916   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3917 }
3918
3919 void test_5_arg_mutable_buffer_async_read_at()
3920 {
3921 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
3922   namespace bindns = boost;
3923 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3924   namespace bindns = std;
3925   using std::placeholders::_1;
3926   using std::placeholders::_2;
3927 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3928
3929   boost::asio::io_context ioc;
3930   test_random_access_device s(ioc);
3931   char read_buf[sizeof(read_data)];
3932   boost::asio::mutable_buffer buffers
3933     = boost::asio::buffer(read_buf, sizeof(read_buf));
3934
3935   s.reset(read_data, sizeof(read_data));
3936   memset(read_buf, 0, sizeof(read_buf));
3937   bool called = false;
3938   boost::asio::async_read_at(s, 0, buffers,
3939       boost::asio::transfer_all(),
3940       bindns::bind(async_read_handler,
3941         _1, _2, sizeof(read_data), &called));
3942   ioc.restart();
3943   ioc.run();
3944   BOOST_ASIO_CHECK(called);
3945   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3946
3947   s.reset(read_data, sizeof(read_data));
3948   memset(read_buf, 0, sizeof(read_buf));
3949   called = false;
3950   boost::asio::async_read_at(s, 1234, buffers,
3951       boost::asio::transfer_all(),
3952       bindns::bind(async_read_handler,
3953         _1, _2, sizeof(read_data), &called));
3954   ioc.restart();
3955   ioc.run();
3956   BOOST_ASIO_CHECK(called);
3957   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3958
3959   s.reset(read_data, sizeof(read_data));
3960   s.next_read_length(1);
3961   memset(read_buf, 0, sizeof(read_buf));
3962   called = false;
3963   boost::asio::async_read_at(s, 0, buffers,
3964       boost::asio::transfer_all(),
3965       bindns::bind(async_read_handler,
3966         _1, _2, sizeof(read_data), &called));
3967   ioc.restart();
3968   ioc.run();
3969   BOOST_ASIO_CHECK(called);
3970   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3971
3972   s.reset(read_data, sizeof(read_data));
3973   s.next_read_length(1);
3974   memset(read_buf, 0, sizeof(read_buf));
3975   called = false;
3976   boost::asio::async_read_at(s, 1234, buffers,
3977       boost::asio::transfer_all(),
3978       bindns::bind(async_read_handler,
3979         _1, _2, sizeof(read_data), &called));
3980   ioc.restart();
3981   ioc.run();
3982   BOOST_ASIO_CHECK(called);
3983   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3984
3985   s.reset(read_data, sizeof(read_data));
3986   s.next_read_length(10);
3987   memset(read_buf, 0, sizeof(read_buf));
3988   called = false;
3989   boost::asio::async_read_at(s, 0, buffers,
3990       boost::asio::transfer_all(),
3991       bindns::bind(async_read_handler,
3992         _1, _2, sizeof(read_data), &called));
3993   ioc.restart();
3994   ioc.run();
3995   BOOST_ASIO_CHECK(called);
3996   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3997
3998   s.reset(read_data, sizeof(read_data));
3999   s.next_read_length(10);
4000   memset(read_buf, 0, sizeof(read_buf));
4001   called = false;
4002   boost::asio::async_read_at(s, 1234, buffers,
4003       boost::asio::transfer_all(),
4004       bindns::bind(async_read_handler,
4005         _1, _2, sizeof(read_data), &called));
4006   ioc.restart();
4007   ioc.run();
4008   BOOST_ASIO_CHECK(called);
4009   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4010
4011   s.reset(read_data, sizeof(read_data));
4012   memset(read_buf, 0, sizeof(read_buf));
4013   called = false;
4014   boost::asio::async_read_at(s, 0, buffers,
4015       boost::asio::transfer_at_least(1),
4016       bindns::bind(async_read_handler,
4017         _1, _2, sizeof(read_data), &called));
4018   ioc.restart();
4019   ioc.run();
4020   BOOST_ASIO_CHECK(called);
4021   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4022
4023   s.reset(read_data, sizeof(read_data));
4024   memset(read_buf, 0, sizeof(read_buf));
4025   called = false;
4026   boost::asio::async_read_at(s, 1234, buffers,
4027       boost::asio::transfer_at_least(1),
4028       bindns::bind(async_read_handler,
4029         _1, _2, sizeof(read_data), &called));
4030   ioc.restart();
4031   ioc.run();
4032   BOOST_ASIO_CHECK(called);
4033   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4034
4035   s.reset(read_data, sizeof(read_data));
4036   s.next_read_length(1);
4037   memset(read_buf, 0, sizeof(read_buf));
4038   called = false;
4039   boost::asio::async_read_at(s, 0, buffers,
4040       boost::asio::transfer_at_least(1),
4041       bindns::bind(async_read_handler,
4042         _1, _2, 1, &called));
4043   ioc.restart();
4044   ioc.run();
4045   BOOST_ASIO_CHECK(called);
4046   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4047
4048   s.reset(read_data, sizeof(read_data));
4049   s.next_read_length(1);
4050   memset(read_buf, 0, sizeof(read_buf));
4051   called = false;
4052   boost::asio::async_read_at(s, 1234, buffers,
4053       boost::asio::transfer_at_least(1),
4054       bindns::bind(async_read_handler,
4055         _1, _2, 1, &called));
4056   ioc.restart();
4057   ioc.run();
4058   BOOST_ASIO_CHECK(called);
4059   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4060
4061   s.reset(read_data, sizeof(read_data));
4062   s.next_read_length(10);
4063   memset(read_buf, 0, sizeof(read_buf));
4064   called = false;
4065   boost::asio::async_read_at(s, 0, buffers,
4066       boost::asio::transfer_at_least(1),
4067       bindns::bind(async_read_handler,
4068         _1, _2, 10, &called));
4069   ioc.restart();
4070   ioc.run();
4071   BOOST_ASIO_CHECK(called);
4072   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4073
4074   s.reset(read_data, sizeof(read_data));
4075   s.next_read_length(10);
4076   memset(read_buf, 0, sizeof(read_buf));
4077   called = false;
4078   boost::asio::async_read_at(s, 1234, buffers,
4079       boost::asio::transfer_at_least(1),
4080       bindns::bind(async_read_handler,
4081         _1, _2, 10, &called));
4082   ioc.restart();
4083   ioc.run();
4084   BOOST_ASIO_CHECK(called);
4085   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4086
4087   s.reset(read_data, sizeof(read_data));
4088   memset(read_buf, 0, sizeof(read_buf));
4089   called = false;
4090   boost::asio::async_read_at(s, 0, buffers,
4091       boost::asio::transfer_at_least(10),
4092       bindns::bind(async_read_handler,
4093         _1, _2, sizeof(read_data), &called));
4094   ioc.restart();
4095   ioc.run();
4096   BOOST_ASIO_CHECK(called);
4097   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4098
4099   s.reset(read_data, sizeof(read_data));
4100   memset(read_buf, 0, sizeof(read_buf));
4101   called = false;
4102   boost::asio::async_read_at(s, 1234, buffers,
4103       boost::asio::transfer_at_least(10),
4104       bindns::bind(async_read_handler,
4105         _1, _2, sizeof(read_data), &called));
4106   ioc.restart();
4107   ioc.run();
4108   BOOST_ASIO_CHECK(called);
4109   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4110
4111   s.reset(read_data, sizeof(read_data));
4112   s.next_read_length(1);
4113   memset(read_buf, 0, sizeof(read_buf));
4114   called = false;
4115   boost::asio::async_read_at(s, 0, buffers,
4116       boost::asio::transfer_at_least(10),
4117       bindns::bind(async_read_handler,
4118         _1, _2, 10, &called));
4119   ioc.restart();
4120   ioc.run();
4121   BOOST_ASIO_CHECK(called);
4122   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4123
4124   s.reset(read_data, sizeof(read_data));
4125   s.next_read_length(1);
4126   memset(read_buf, 0, sizeof(read_buf));
4127   called = false;
4128   boost::asio::async_read_at(s, 1234, buffers,
4129       boost::asio::transfer_at_least(10),
4130       bindns::bind(async_read_handler,
4131         _1, _2, 10, &called));
4132   ioc.restart();
4133   ioc.run();
4134   BOOST_ASIO_CHECK(called);
4135   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4136
4137   s.reset(read_data, sizeof(read_data));
4138   s.next_read_length(10);
4139   memset(read_buf, 0, sizeof(read_buf));
4140   called = false;
4141   boost::asio::async_read_at(s, 0, buffers,
4142       boost::asio::transfer_at_least(10),
4143       bindns::bind(async_read_handler,
4144         _1, _2, 10, &called));
4145   ioc.restart();
4146   ioc.run();
4147   BOOST_ASIO_CHECK(called);
4148   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4149
4150   s.reset(read_data, sizeof(read_data));
4151   s.next_read_length(10);
4152   memset(read_buf, 0, sizeof(read_buf));
4153   called = false;
4154   boost::asio::async_read_at(s, 1234, buffers,
4155       boost::asio::transfer_at_least(10),
4156       bindns::bind(async_read_handler,
4157         _1, _2, 10, &called));
4158   ioc.restart();
4159   ioc.run();
4160   BOOST_ASIO_CHECK(called);
4161   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4162
4163   s.reset(read_data, sizeof(read_data));
4164   memset(read_buf, 0, sizeof(read_buf));
4165   called = false;
4166   boost::asio::async_read_at(s, 0, buffers,
4167       boost::asio::transfer_at_least(42),
4168       bindns::bind(async_read_handler,
4169         _1, _2, sizeof(read_data), &called));
4170   ioc.restart();
4171   ioc.run();
4172   BOOST_ASIO_CHECK(called);
4173   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4174
4175   s.reset(read_data, sizeof(read_data));
4176   memset(read_buf, 0, sizeof(read_buf));
4177   called = false;
4178   boost::asio::async_read_at(s, 1234, buffers,
4179       boost::asio::transfer_at_least(42),
4180       bindns::bind(async_read_handler,
4181         _1, _2, sizeof(read_data), &called));
4182   ioc.restart();
4183   ioc.run();
4184   BOOST_ASIO_CHECK(called);
4185   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4186
4187   s.reset(read_data, sizeof(read_data));
4188   s.next_read_length(1);
4189   memset(read_buf, 0, sizeof(read_buf));
4190   called = false;
4191   boost::asio::async_read_at(s, 0, buffers,
4192       boost::asio::transfer_at_least(42),
4193       bindns::bind(async_read_handler,
4194         _1, _2, 42, &called));
4195   ioc.restart();
4196   ioc.run();
4197   BOOST_ASIO_CHECK(called);
4198   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
4199
4200   s.reset(read_data, sizeof(read_data));
4201   s.next_read_length(1);
4202   memset(read_buf, 0, sizeof(read_buf));
4203   called = false;
4204   boost::asio::async_read_at(s, 1234, buffers,
4205       boost::asio::transfer_at_least(42),
4206       bindns::bind(async_read_handler,
4207         _1, _2, 42, &called));
4208   ioc.restart();
4209   ioc.run();
4210   BOOST_ASIO_CHECK(called);
4211   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4212
4213   s.reset(read_data, sizeof(read_data));
4214   s.next_read_length(10);
4215   memset(read_buf, 0, sizeof(read_buf));
4216   called = false;
4217   boost::asio::async_read_at(s, 0, buffers,
4218       boost::asio::transfer_at_least(42),
4219       bindns::bind(async_read_handler,
4220         _1, _2, 50, &called));
4221   ioc.restart();
4222   ioc.run();
4223   BOOST_ASIO_CHECK(called);
4224   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
4225
4226   s.reset(read_data, sizeof(read_data));
4227   s.next_read_length(10);
4228   memset(read_buf, 0, sizeof(read_buf));
4229   called = false;
4230   boost::asio::async_read_at(s, 1234, buffers,
4231       boost::asio::transfer_at_least(42),
4232       bindns::bind(async_read_handler,
4233         _1, _2, 50, &called));
4234   ioc.restart();
4235   ioc.run();
4236   BOOST_ASIO_CHECK(called);
4237   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
4238
4239   s.reset(read_data, sizeof(read_data));
4240   memset(read_buf, 0, sizeof(read_buf));
4241   called = false;
4242   boost::asio::async_read_at(s, 0, buffers,
4243       boost::asio::transfer_exactly(1),
4244       bindns::bind(async_read_handler,
4245         _1, _2, 1, &called));
4246   ioc.restart();
4247   ioc.run();
4248   BOOST_ASIO_CHECK(called);
4249   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4250
4251   s.reset(read_data, sizeof(read_data));
4252   memset(read_buf, 0, sizeof(read_buf));
4253   called = false;
4254   boost::asio::async_read_at(s, 1234, buffers,
4255       boost::asio::transfer_exactly(1),
4256       bindns::bind(async_read_handler,
4257         _1, _2, 1, &called));
4258   ioc.restart();
4259   ioc.run();
4260   BOOST_ASIO_CHECK(called);
4261   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4262
4263   s.reset(read_data, sizeof(read_data));
4264   s.next_read_length(1);
4265   memset(read_buf, 0, sizeof(read_buf));
4266   called = false;
4267   boost::asio::async_read_at(s, 0, buffers,
4268       boost::asio::transfer_exactly(1),
4269       bindns::bind(async_read_handler,
4270         _1, _2, 1, &called));
4271   ioc.restart();
4272   ioc.run();
4273   BOOST_ASIO_CHECK(called);
4274   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4275
4276   s.reset(read_data, sizeof(read_data));
4277   s.next_read_length(1);
4278   memset(read_buf, 0, sizeof(read_buf));
4279   called = false;
4280   boost::asio::async_read_at(s, 1234, buffers,
4281       boost::asio::transfer_exactly(1),
4282       bindns::bind(async_read_handler,
4283         _1, _2, 1, &called));
4284   ioc.restart();
4285   ioc.run();
4286   BOOST_ASIO_CHECK(called);
4287   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4288
4289   s.reset(read_data, sizeof(read_data));
4290   s.next_read_length(10);
4291   memset(read_buf, 0, sizeof(read_buf));
4292   called = false;
4293   boost::asio::async_read_at(s, 0, buffers,
4294       boost::asio::transfer_exactly(1),
4295       bindns::bind(async_read_handler,
4296         _1, _2, 1, &called));
4297   ioc.restart();
4298   ioc.run();
4299   BOOST_ASIO_CHECK(called);
4300   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4301
4302   s.reset(read_data, sizeof(read_data));
4303   s.next_read_length(10);
4304   memset(read_buf, 0, sizeof(read_buf));
4305   called = false;
4306   boost::asio::async_read_at(s, 1234, buffers,
4307       boost::asio::transfer_exactly(1),
4308       bindns::bind(async_read_handler,
4309         _1, _2, 1, &called));
4310   ioc.restart();
4311   ioc.run();
4312   BOOST_ASIO_CHECK(called);
4313   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4314
4315   s.reset(read_data, sizeof(read_data));
4316   memset(read_buf, 0, sizeof(read_buf));
4317   called = false;
4318   boost::asio::async_read_at(s, 0, buffers,
4319       boost::asio::transfer_exactly(10),
4320       bindns::bind(async_read_handler,
4321         _1, _2, 10, &called));
4322   ioc.restart();
4323   ioc.run();
4324   BOOST_ASIO_CHECK(called);
4325   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4326
4327   s.reset(read_data, sizeof(read_data));
4328   memset(read_buf, 0, sizeof(read_buf));
4329   called = false;
4330   boost::asio::async_read_at(s, 1234, buffers,
4331       boost::asio::transfer_exactly(10),
4332       bindns::bind(async_read_handler,
4333         _1, _2, 10, &called));
4334   ioc.restart();
4335   ioc.run();
4336   BOOST_ASIO_CHECK(called);
4337   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4338
4339   s.reset(read_data, sizeof(read_data));
4340   s.next_read_length(1);
4341   memset(read_buf, 0, sizeof(read_buf));
4342   called = false;
4343   boost::asio::async_read_at(s, 0, buffers,
4344       boost::asio::transfer_exactly(10),
4345       bindns::bind(async_read_handler,
4346         _1, _2, 10, &called));
4347   ioc.restart();
4348   ioc.run();
4349   BOOST_ASIO_CHECK(called);
4350   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4351
4352   s.reset(read_data, sizeof(read_data));
4353   s.next_read_length(1);
4354   memset(read_buf, 0, sizeof(read_buf));
4355   called = false;
4356   boost::asio::async_read_at(s, 1234, buffers,
4357       boost::asio::transfer_exactly(10),
4358       bindns::bind(async_read_handler,
4359         _1, _2, 10, &called));
4360   ioc.restart();
4361   ioc.run();
4362   BOOST_ASIO_CHECK(called);
4363   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4364
4365   s.reset(read_data, sizeof(read_data));
4366   s.next_read_length(10);
4367   memset(read_buf, 0, sizeof(read_buf));
4368   called = false;
4369   boost::asio::async_read_at(s, 0, buffers,
4370       boost::asio::transfer_exactly(10),
4371       bindns::bind(async_read_handler,
4372         _1, _2, 10, &called));
4373   ioc.restart();
4374   ioc.run();
4375   BOOST_ASIO_CHECK(called);
4376   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4377
4378   s.reset(read_data, sizeof(read_data));
4379   s.next_read_length(10);
4380   memset(read_buf, 0, sizeof(read_buf));
4381   called = false;
4382   boost::asio::async_read_at(s, 1234, buffers,
4383       boost::asio::transfer_exactly(10),
4384       bindns::bind(async_read_handler,
4385         _1, _2, 10, &called));
4386   ioc.restart();
4387   ioc.run();
4388   BOOST_ASIO_CHECK(called);
4389   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4390
4391   s.reset(read_data, sizeof(read_data));
4392   memset(read_buf, 0, sizeof(read_buf));
4393   called = false;
4394   boost::asio::async_read_at(s, 0, buffers,
4395       boost::asio::transfer_exactly(42),
4396       bindns::bind(async_read_handler,
4397         _1, _2, 42, &called));
4398   ioc.restart();
4399   ioc.run();
4400   BOOST_ASIO_CHECK(called);
4401   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
4402
4403   s.reset(read_data, sizeof(read_data));
4404   memset(read_buf, 0, sizeof(read_buf));
4405   called = false;
4406   boost::asio::async_read_at(s, 1234, buffers,
4407       boost::asio::transfer_exactly(42),
4408       bindns::bind(async_read_handler,
4409         _1, _2, 42, &called));
4410   ioc.restart();
4411   ioc.run();
4412   BOOST_ASIO_CHECK(called);
4413   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4414
4415   s.reset(read_data, sizeof(read_data));
4416   s.next_read_length(1);
4417   memset(read_buf, 0, sizeof(read_buf));
4418   called = false;
4419   boost::asio::async_read_at(s, 0, buffers,
4420       boost::asio::transfer_exactly(42),
4421       bindns::bind(async_read_handler,
4422         _1, _2, 42, &called));
4423   ioc.restart();
4424   ioc.run();
4425   BOOST_ASIO_CHECK(called);
4426   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
4427
4428   s.reset(read_data, sizeof(read_data));
4429   s.next_read_length(1);
4430   memset(read_buf, 0, sizeof(read_buf));
4431   called = false;
4432   boost::asio::async_read_at(s, 1234, buffers,
4433       boost::asio::transfer_exactly(42),
4434       bindns::bind(async_read_handler,
4435         _1, _2, 42, &called));
4436   ioc.restart();
4437   ioc.run();
4438   BOOST_ASIO_CHECK(called);
4439   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4440
4441   s.reset(read_data, sizeof(read_data));
4442   s.next_read_length(10);
4443   memset(read_buf, 0, sizeof(read_buf));
4444   called = false;
4445   boost::asio::async_read_at(s, 0, buffers,
4446       boost::asio::transfer_exactly(42),
4447       bindns::bind(async_read_handler,
4448         _1, _2, 42, &called));
4449   ioc.restart();
4450   ioc.run();
4451   BOOST_ASIO_CHECK(called);
4452   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
4453
4454   s.reset(read_data, sizeof(read_data));
4455   s.next_read_length(10);
4456   memset(read_buf, 0, sizeof(read_buf));
4457   called = false;
4458   boost::asio::async_read_at(s, 1234, buffers,
4459       boost::asio::transfer_exactly(42),
4460       bindns::bind(async_read_handler,
4461         _1, _2, 42, &called));
4462   ioc.restart();
4463   ioc.run();
4464   BOOST_ASIO_CHECK(called);
4465   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4466
4467   s.reset(read_data, sizeof(read_data));
4468   memset(read_buf, 0, sizeof(read_buf));
4469   called = false;
4470   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
4471       bindns::bind(async_read_handler,
4472         _1, _2, sizeof(read_data), &called));
4473   ioc.restart();
4474   ioc.run();
4475   BOOST_ASIO_CHECK(called);
4476   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4477
4478   s.reset(read_data, sizeof(read_data));
4479   memset(read_buf, 0, sizeof(read_buf));
4480   called = false;
4481   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
4482       bindns::bind(async_read_handler,
4483         _1, _2, sizeof(read_data), &called));
4484   ioc.restart();
4485   ioc.run();
4486   BOOST_ASIO_CHECK(called);
4487   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4488
4489   s.reset(read_data, sizeof(read_data));
4490   s.next_read_length(1);
4491   memset(read_buf, 0, sizeof(read_buf));
4492   called = false;
4493   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
4494       bindns::bind(async_read_handler,
4495         _1, _2, sizeof(read_data), &called));
4496   ioc.restart();
4497   ioc.run();
4498   BOOST_ASIO_CHECK(called);
4499   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4500
4501   s.reset(read_data, sizeof(read_data));
4502   s.next_read_length(1);
4503   memset(read_buf, 0, sizeof(read_buf));
4504   called = false;
4505   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
4506       bindns::bind(async_read_handler,
4507         _1, _2, sizeof(read_data), &called));
4508   ioc.restart();
4509   ioc.run();
4510   BOOST_ASIO_CHECK(called);
4511   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4512
4513   s.reset(read_data, sizeof(read_data));
4514   s.next_read_length(10);
4515   memset(read_buf, 0, sizeof(read_buf));
4516   called = false;
4517   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
4518       bindns::bind(async_read_handler,
4519         _1, _2, sizeof(read_data), &called));
4520   ioc.restart();
4521   ioc.run();
4522   BOOST_ASIO_CHECK(called);
4523   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4524
4525   s.reset(read_data, sizeof(read_data));
4526   s.next_read_length(10);
4527   memset(read_buf, 0, sizeof(read_buf));
4528   called = false;
4529   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
4530       bindns::bind(async_read_handler,
4531         _1, _2, sizeof(read_data), &called));
4532   ioc.restart();
4533   ioc.run();
4534   BOOST_ASIO_CHECK(called);
4535   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4536
4537   s.reset(read_data, sizeof(read_data));
4538   memset(read_buf, 0, sizeof(read_buf));
4539   called = false;
4540   boost::asio::async_read_at(s, 0, buffers, short_transfer,
4541       bindns::bind(async_read_handler,
4542         _1, _2, sizeof(read_data), &called));
4543   ioc.restart();
4544   ioc.run();
4545   BOOST_ASIO_CHECK(called);
4546   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4547
4548   s.reset(read_data, sizeof(read_data));
4549   memset(read_buf, 0, sizeof(read_buf));
4550   called = false;
4551   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
4552       bindns::bind(async_read_handler,
4553         _1, _2, sizeof(read_data), &called));
4554   ioc.restart();
4555   ioc.run();
4556   BOOST_ASIO_CHECK(called);
4557   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4558
4559   s.reset(read_data, sizeof(read_data));
4560   s.next_read_length(1);
4561   memset(read_buf, 0, sizeof(read_buf));
4562   called = false;
4563   boost::asio::async_read_at(s, 0, buffers, short_transfer,
4564       bindns::bind(async_read_handler,
4565         _1, _2, sizeof(read_data), &called));
4566   ioc.restart();
4567   ioc.run();
4568   BOOST_ASIO_CHECK(called);
4569   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4570
4571   s.reset(read_data, sizeof(read_data));
4572   s.next_read_length(1);
4573   memset(read_buf, 0, sizeof(read_buf));
4574   called = false;
4575   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
4576       bindns::bind(async_read_handler,
4577         _1, _2, sizeof(read_data), &called));
4578   ioc.restart();
4579   ioc.run();
4580   BOOST_ASIO_CHECK(called);
4581   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4582
4583   s.reset(read_data, sizeof(read_data));
4584   s.next_read_length(10);
4585   memset(read_buf, 0, sizeof(read_buf));
4586   called = false;
4587   boost::asio::async_read_at(s, 0, buffers, short_transfer,
4588       bindns::bind(async_read_handler,
4589         _1, _2, sizeof(read_data), &called));
4590   ioc.restart();
4591   ioc.run();
4592   BOOST_ASIO_CHECK(called);
4593   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4594
4595   s.reset(read_data, sizeof(read_data));
4596   s.next_read_length(10);
4597   memset(read_buf, 0, sizeof(read_buf));
4598   called = false;
4599   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
4600       bindns::bind(async_read_handler,
4601         _1, _2, sizeof(read_data), &called));
4602   ioc.restart();
4603   ioc.run();
4604   BOOST_ASIO_CHECK(called);
4605   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4606
4607   s.reset(read_data, sizeof(read_data));
4608   memset(read_buf, 0, sizeof(read_buf));
4609   int i = boost::asio::async_read_at(s, 1234, buffers,
4610       short_transfer, archetypes::lazy_handler());
4611   BOOST_ASIO_CHECK(i == 42);
4612   ioc.restart();
4613   ioc.run();
4614   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4615 }
4616
4617 void test_5_arg_boost_array_buffers_async_read_at()
4618 {
4619 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
4620   namespace bindns = boost;
4621 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
4622   namespace bindns = std;
4623   using std::placeholders::_1;
4624   using std::placeholders::_2;
4625 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
4626
4627 #if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
4628   boost::asio::io_context ioc;
4629   test_random_access_device s(ioc);
4630   char read_buf[sizeof(read_data)];
4631   boost::array<boost::asio::mutable_buffer, 2> buffers = { {
4632     boost::asio::buffer(read_buf, 32),
4633     boost::asio::buffer(read_buf) + 32 } };
4634
4635   s.reset(read_data, sizeof(read_data));
4636   memset(read_buf, 0, sizeof(read_buf));
4637   bool called = false;
4638   boost::asio::async_read_at(s, 0, buffers,
4639       boost::asio::transfer_all(),
4640       bindns::bind(async_read_handler,
4641         _1, _2, sizeof(read_data), &called));
4642   ioc.restart();
4643   ioc.run();
4644   BOOST_ASIO_CHECK(called);
4645   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4646
4647   s.reset(read_data, sizeof(read_data));
4648   memset(read_buf, 0, sizeof(read_buf));
4649   called = false;
4650   boost::asio::async_read_at(s, 1234, buffers,
4651       boost::asio::transfer_all(),
4652       bindns::bind(async_read_handler,
4653         _1, _2, sizeof(read_data), &called));
4654   ioc.restart();
4655   ioc.run();
4656   BOOST_ASIO_CHECK(called);
4657   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4658
4659   s.reset(read_data, sizeof(read_data));
4660   s.next_read_length(1);
4661   memset(read_buf, 0, sizeof(read_buf));
4662   called = false;
4663   boost::asio::async_read_at(s, 0, buffers,
4664       boost::asio::transfer_all(),
4665       bindns::bind(async_read_handler,
4666         _1, _2, sizeof(read_data), &called));
4667   ioc.restart();
4668   ioc.run();
4669   BOOST_ASIO_CHECK(called);
4670   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4671
4672   s.reset(read_data, sizeof(read_data));
4673   s.next_read_length(1);
4674   memset(read_buf, 0, sizeof(read_buf));
4675   called = false;
4676   boost::asio::async_read_at(s, 1234, buffers,
4677       boost::asio::transfer_all(),
4678       bindns::bind(async_read_handler,
4679         _1, _2, sizeof(read_data), &called));
4680   ioc.restart();
4681   ioc.run();
4682   BOOST_ASIO_CHECK(called);
4683   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4684
4685   s.reset(read_data, sizeof(read_data));
4686   s.next_read_length(10);
4687   memset(read_buf, 0, sizeof(read_buf));
4688   called = false;
4689   boost::asio::async_read_at(s, 0, buffers,
4690       boost::asio::transfer_all(),
4691       bindns::bind(async_read_handler,
4692         _1, _2, sizeof(read_data), &called));
4693   ioc.restart();
4694   ioc.run();
4695   BOOST_ASIO_CHECK(called);
4696   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4697
4698   s.reset(read_data, sizeof(read_data));
4699   s.next_read_length(10);
4700   memset(read_buf, 0, sizeof(read_buf));
4701   called = false;
4702   boost::asio::async_read_at(s, 1234, buffers,
4703       boost::asio::transfer_all(),
4704       bindns::bind(async_read_handler,
4705         _1, _2, sizeof(read_data), &called));
4706   ioc.restart();
4707   ioc.run();
4708   BOOST_ASIO_CHECK(called);
4709   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4710
4711   s.reset(read_data, sizeof(read_data));
4712   memset(read_buf, 0, sizeof(read_buf));
4713   called = false;
4714   boost::asio::async_read_at(s, 0, buffers,
4715       boost::asio::transfer_at_least(1),
4716       bindns::bind(async_read_handler,
4717         _1, _2, sizeof(read_data), &called));
4718   ioc.restart();
4719   ioc.run();
4720   BOOST_ASIO_CHECK(called);
4721   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4722
4723   s.reset(read_data, sizeof(read_data));
4724   memset(read_buf, 0, sizeof(read_buf));
4725   called = false;
4726   boost::asio::async_read_at(s, 1234, buffers,
4727       boost::asio::transfer_at_least(1),
4728       bindns::bind(async_read_handler,
4729         _1, _2, sizeof(read_data), &called));
4730   ioc.restart();
4731   ioc.run();
4732   BOOST_ASIO_CHECK(called);
4733   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4734
4735   s.reset(read_data, sizeof(read_data));
4736   s.next_read_length(1);
4737   memset(read_buf, 0, sizeof(read_buf));
4738   called = false;
4739   boost::asio::async_read_at(s, 0, buffers,
4740       boost::asio::transfer_at_least(1),
4741       bindns::bind(async_read_handler,
4742         _1, _2, 1, &called));
4743   ioc.restart();
4744   ioc.run();
4745   BOOST_ASIO_CHECK(called);
4746   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4747
4748   s.reset(read_data, sizeof(read_data));
4749   s.next_read_length(1);
4750   memset(read_buf, 0, sizeof(read_buf));
4751   called = false;
4752   boost::asio::async_read_at(s, 1234, buffers,
4753       boost::asio::transfer_at_least(1),
4754       bindns::bind(async_read_handler,
4755         _1, _2, 1, &called));
4756   ioc.restart();
4757   ioc.run();
4758   BOOST_ASIO_CHECK(called);
4759   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4760
4761   s.reset(read_data, sizeof(read_data));
4762   s.next_read_length(10);
4763   memset(read_buf, 0, sizeof(read_buf));
4764   called = false;
4765   boost::asio::async_read_at(s, 0, buffers,
4766       boost::asio::transfer_at_least(1),
4767       bindns::bind(async_read_handler,
4768         _1, _2, 10, &called));
4769   ioc.restart();
4770   ioc.run();
4771   BOOST_ASIO_CHECK(called);
4772   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4773
4774   s.reset(read_data, sizeof(read_data));
4775   s.next_read_length(10);
4776   memset(read_buf, 0, sizeof(read_buf));
4777   called = false;
4778   boost::asio::async_read_at(s, 1234, buffers,
4779       boost::asio::transfer_at_least(1),
4780       bindns::bind(async_read_handler,
4781         _1, _2, 10, &called));
4782   ioc.restart();
4783   ioc.run();
4784   BOOST_ASIO_CHECK(called);
4785   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4786
4787   s.reset(read_data, sizeof(read_data));
4788   memset(read_buf, 0, sizeof(read_buf));
4789   called = false;
4790   boost::asio::async_read_at(s, 0, buffers,
4791       boost::asio::transfer_at_least(10),
4792       bindns::bind(async_read_handler,
4793         _1, _2, sizeof(read_data), &called));
4794   ioc.restart();
4795   ioc.run();
4796   BOOST_ASIO_CHECK(called);
4797   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4798
4799   s.reset(read_data, sizeof(read_data));
4800   memset(read_buf, 0, sizeof(read_buf));
4801   called = false;
4802   boost::asio::async_read_at(s, 1234, buffers,
4803       boost::asio::transfer_at_least(10),
4804       bindns::bind(async_read_handler,
4805         _1, _2, sizeof(read_data), &called));
4806   ioc.restart();
4807   ioc.run();
4808   BOOST_ASIO_CHECK(called);
4809   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4810
4811   s.reset(read_data, sizeof(read_data));
4812   s.next_read_length(1);
4813   memset(read_buf, 0, sizeof(read_buf));
4814   called = false;
4815   boost::asio::async_read_at(s, 0, buffers,
4816       boost::asio::transfer_at_least(10),
4817       bindns::bind(async_read_handler,
4818         _1, _2, 10, &called));
4819   ioc.restart();
4820   ioc.run();
4821   BOOST_ASIO_CHECK(called);
4822   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4823
4824   s.reset(read_data, sizeof(read_data));
4825   s.next_read_length(1);
4826   memset(read_buf, 0, sizeof(read_buf));
4827   called = false;
4828   boost::asio::async_read_at(s, 1234, buffers,
4829       boost::asio::transfer_at_least(10),
4830       bindns::bind(async_read_handler,
4831         _1, _2, 10, &called));
4832   ioc.restart();
4833   ioc.run();
4834   BOOST_ASIO_CHECK(called);
4835   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4836
4837   s.reset(read_data, sizeof(read_data));
4838   s.next_read_length(10);
4839   memset(read_buf, 0, sizeof(read_buf));
4840   called = false;
4841   boost::asio::async_read_at(s, 0, buffers,
4842       boost::asio::transfer_at_least(10),
4843       bindns::bind(async_read_handler,
4844         _1, _2, 10, &called));
4845   ioc.restart();
4846   ioc.run();
4847   BOOST_ASIO_CHECK(called);
4848   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
4849
4850   s.reset(read_data, sizeof(read_data));
4851   s.next_read_length(10);
4852   memset(read_buf, 0, sizeof(read_buf));
4853   called = false;
4854   boost::asio::async_read_at(s, 1234, buffers,
4855       boost::asio::transfer_at_least(10),
4856       bindns::bind(async_read_handler,
4857         _1, _2, 10, &called));
4858   ioc.restart();
4859   ioc.run();
4860   BOOST_ASIO_CHECK(called);
4861   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4862
4863   s.reset(read_data, sizeof(read_data));
4864   memset(read_buf, 0, sizeof(read_buf));
4865   called = false;
4866   boost::asio::async_read_at(s, 0, buffers,
4867       boost::asio::transfer_at_least(42),
4868       bindns::bind(async_read_handler,
4869         _1, _2, sizeof(read_data), &called));
4870   ioc.restart();
4871   ioc.run();
4872   BOOST_ASIO_CHECK(called);
4873   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4874
4875   s.reset(read_data, sizeof(read_data));
4876   memset(read_buf, 0, sizeof(read_buf));
4877   called = false;
4878   boost::asio::async_read_at(s, 1234, buffers,
4879       boost::asio::transfer_at_least(42),
4880       bindns::bind(async_read_handler,
4881         _1, _2, sizeof(read_data), &called));
4882   ioc.restart();
4883   ioc.run();
4884   BOOST_ASIO_CHECK(called);
4885   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4886
4887   s.reset(read_data, sizeof(read_data));
4888   s.next_read_length(1);
4889   memset(read_buf, 0, sizeof(read_buf));
4890   called = false;
4891   boost::asio::async_read_at(s, 0, buffers,
4892       boost::asio::transfer_at_least(42),
4893       bindns::bind(async_read_handler,
4894         _1, _2, 42, &called));
4895   ioc.restart();
4896   ioc.run();
4897   BOOST_ASIO_CHECK(called);
4898   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
4899
4900   s.reset(read_data, sizeof(read_data));
4901   s.next_read_length(1);
4902   memset(read_buf, 0, sizeof(read_buf));
4903   called = false;
4904   boost::asio::async_read_at(s, 1234, buffers,
4905       boost::asio::transfer_at_least(42),
4906       bindns::bind(async_read_handler,
4907         _1, _2, 42, &called));
4908   ioc.restart();
4909   ioc.run();
4910   BOOST_ASIO_CHECK(called);
4911   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4912
4913   s.reset(read_data, sizeof(read_data));
4914   s.next_read_length(10);
4915   memset(read_buf, 0, sizeof(read_buf));
4916   called = false;
4917   boost::asio::async_read_at(s, 0, buffers,
4918       boost::asio::transfer_at_least(42),
4919       bindns::bind(async_read_handler,
4920         _1, _2, 50, &called));
4921   ioc.restart();
4922   ioc.run();
4923   BOOST_ASIO_CHECK(called);
4924   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
4925
4926   s.reset(read_data, sizeof(read_data));
4927   s.next_read_length(10);
4928   memset(read_buf, 0, sizeof(read_buf));
4929   called = false;
4930   boost::asio::async_read_at(s, 1234, buffers,
4931       boost::asio::transfer_at_least(42),
4932       bindns::bind(async_read_handler,
4933         _1, _2, 50, &called));
4934   ioc.restart();
4935   ioc.run();
4936   BOOST_ASIO_CHECK(called);
4937   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
4938
4939   s.reset(read_data, sizeof(read_data));
4940   memset(read_buf, 0, sizeof(read_buf));
4941   called = false;
4942   boost::asio::async_read_at(s, 0, buffers,
4943       boost::asio::transfer_exactly(1),
4944       bindns::bind(async_read_handler,
4945         _1, _2, 1, &called));
4946   ioc.restart();
4947   ioc.run();
4948   BOOST_ASIO_CHECK(called);
4949   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4950
4951   s.reset(read_data, sizeof(read_data));
4952   memset(read_buf, 0, sizeof(read_buf));
4953   called = false;
4954   boost::asio::async_read_at(s, 1234, buffers,
4955       boost::asio::transfer_exactly(1),
4956       bindns::bind(async_read_handler,
4957         _1, _2, 1, &called));
4958   ioc.restart();
4959   ioc.run();
4960   BOOST_ASIO_CHECK(called);
4961   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4962
4963   s.reset(read_data, sizeof(read_data));
4964   s.next_read_length(1);
4965   memset(read_buf, 0, sizeof(read_buf));
4966   called = false;
4967   boost::asio::async_read_at(s, 0, buffers,
4968       boost::asio::transfer_exactly(1),
4969       bindns::bind(async_read_handler,
4970         _1, _2, 1, &called));
4971   ioc.restart();
4972   ioc.run();
4973   BOOST_ASIO_CHECK(called);
4974   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
4975
4976   s.reset(read_data, sizeof(read_data));
4977   s.next_read_length(1);
4978   memset(read_buf, 0, sizeof(read_buf));
4979   called = false;
4980   boost::asio::async_read_at(s, 1234, buffers,
4981       boost::asio::transfer_exactly(1),
4982       bindns::bind(async_read_handler,
4983         _1, _2, 1, &called));
4984   ioc.restart();
4985   ioc.run();
4986   BOOST_ASIO_CHECK(called);
4987   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4988
4989   s.reset(read_data, sizeof(read_data));
4990   s.next_read_length(10);
4991   memset(read_buf, 0, sizeof(read_buf));
4992   called = false;
4993   boost::asio::async_read_at(s, 0, buffers,
4994       boost::asio::transfer_exactly(1),
4995       bindns::bind(async_read_handler,
4996         _1, _2, 1, &called));
4997   ioc.restart();
4998   ioc.run();
4999   BOOST_ASIO_CHECK(called);
5000   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
5001
5002   s.reset(read_data, sizeof(read_data));
5003   s.next_read_length(10);
5004   memset(read_buf, 0, sizeof(read_buf));
5005   called = false;
5006   boost::asio::async_read_at(s, 1234, buffers,
5007       boost::asio::transfer_exactly(1),
5008       bindns::bind(async_read_handler,
5009         _1, _2, 1, &called));
5010   ioc.restart();
5011   ioc.run();
5012   BOOST_ASIO_CHECK(called);
5013   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5014
5015   s.reset(read_data, sizeof(read_data));
5016   memset(read_buf, 0, sizeof(read_buf));
5017   called = false;
5018   boost::asio::async_read_at(s, 0, buffers,
5019       boost::asio::transfer_exactly(10),
5020       bindns::bind(async_read_handler,
5021         _1, _2, 10, &called));
5022   ioc.restart();
5023   ioc.run();
5024   BOOST_ASIO_CHECK(called);
5025   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5026
5027   s.reset(read_data, sizeof(read_data));
5028   memset(read_buf, 0, sizeof(read_buf));
5029   called = false;
5030   boost::asio::async_read_at(s, 1234, buffers,
5031       boost::asio::transfer_exactly(10),
5032       bindns::bind(async_read_handler,
5033         _1, _2, 10, &called));
5034   ioc.restart();
5035   ioc.run();
5036   BOOST_ASIO_CHECK(called);
5037   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5038
5039   s.reset(read_data, sizeof(read_data));
5040   s.next_read_length(1);
5041   memset(read_buf, 0, sizeof(read_buf));
5042   called = false;
5043   boost::asio::async_read_at(s, 0, buffers,
5044       boost::asio::transfer_exactly(10),
5045       bindns::bind(async_read_handler,
5046         _1, _2, 10, &called));
5047   ioc.restart();
5048   ioc.run();
5049   BOOST_ASIO_CHECK(called);
5050   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5051
5052   s.reset(read_data, sizeof(read_data));
5053   s.next_read_length(1);
5054   memset(read_buf, 0, sizeof(read_buf));
5055   called = false;
5056   boost::asio::async_read_at(s, 1234, buffers,
5057       boost::asio::transfer_exactly(10),
5058       bindns::bind(async_read_handler,
5059         _1, _2, 10, &called));
5060   ioc.restart();
5061   ioc.run();
5062   BOOST_ASIO_CHECK(called);
5063   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5064
5065   s.reset(read_data, sizeof(read_data));
5066   s.next_read_length(10);
5067   memset(read_buf, 0, sizeof(read_buf));
5068   called = false;
5069   boost::asio::async_read_at(s, 0, buffers,
5070       boost::asio::transfer_exactly(10),
5071       bindns::bind(async_read_handler,
5072         _1, _2, 10, &called));
5073   ioc.restart();
5074   ioc.run();
5075   BOOST_ASIO_CHECK(called);
5076   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5077
5078   s.reset(read_data, sizeof(read_data));
5079   s.next_read_length(10);
5080   memset(read_buf, 0, sizeof(read_buf));
5081   called = false;
5082   boost::asio::async_read_at(s, 1234, buffers,
5083       boost::asio::transfer_exactly(10),
5084       bindns::bind(async_read_handler,
5085         _1, _2, 10, &called));
5086   ioc.restart();
5087   ioc.run();
5088   BOOST_ASIO_CHECK(called);
5089   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5090
5091   s.reset(read_data, sizeof(read_data));
5092   memset(read_buf, 0, sizeof(read_buf));
5093   called = false;
5094   boost::asio::async_read_at(s, 0, buffers,
5095       boost::asio::transfer_exactly(42),
5096       bindns::bind(async_read_handler,
5097         _1, _2, 42, &called));
5098   ioc.restart();
5099   ioc.run();
5100   BOOST_ASIO_CHECK(called);
5101   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5102
5103   s.reset(read_data, sizeof(read_data));
5104   memset(read_buf, 0, sizeof(read_buf));
5105   called = false;
5106   boost::asio::async_read_at(s, 1234, buffers,
5107       boost::asio::transfer_exactly(42),
5108       bindns::bind(async_read_handler,
5109         _1, _2, 42, &called));
5110   ioc.restart();
5111   ioc.run();
5112   BOOST_ASIO_CHECK(called);
5113   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5114
5115   s.reset(read_data, sizeof(read_data));
5116   s.next_read_length(1);
5117   memset(read_buf, 0, sizeof(read_buf));
5118   called = false;
5119   boost::asio::async_read_at(s, 0, buffers,
5120       boost::asio::transfer_exactly(42),
5121       bindns::bind(async_read_handler,
5122         _1, _2, 42, &called));
5123   ioc.restart();
5124   ioc.run();
5125   BOOST_ASIO_CHECK(called);
5126   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5127
5128   s.reset(read_data, sizeof(read_data));
5129   s.next_read_length(1);
5130   memset(read_buf, 0, sizeof(read_buf));
5131   called = false;
5132   boost::asio::async_read_at(s, 1234, buffers,
5133       boost::asio::transfer_exactly(42),
5134       bindns::bind(async_read_handler,
5135         _1, _2, 42, &called));
5136   ioc.restart();
5137   ioc.run();
5138   BOOST_ASIO_CHECK(called);
5139   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5140
5141   s.reset(read_data, sizeof(read_data));
5142   s.next_read_length(10);
5143   memset(read_buf, 0, sizeof(read_buf));
5144   called = false;
5145   boost::asio::async_read_at(s, 0, buffers,
5146       boost::asio::transfer_exactly(42),
5147       bindns::bind(async_read_handler,
5148         _1, _2, 42, &called));
5149   ioc.restart();
5150   ioc.run();
5151   BOOST_ASIO_CHECK(called);
5152   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5153
5154   s.reset(read_data, sizeof(read_data));
5155   s.next_read_length(10);
5156   memset(read_buf, 0, sizeof(read_buf));
5157   called = false;
5158   boost::asio::async_read_at(s, 1234, buffers,
5159       boost::asio::transfer_exactly(42),
5160       bindns::bind(async_read_handler,
5161         _1, _2, 42, &called));
5162   ioc.restart();
5163   ioc.run();
5164   BOOST_ASIO_CHECK(called);
5165   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5166
5167   s.reset(read_data, sizeof(read_data));
5168   memset(read_buf, 0, sizeof(read_buf));
5169   called = false;
5170   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5171       bindns::bind(async_read_handler,
5172         _1, _2, sizeof(read_data), &called));
5173   ioc.restart();
5174   ioc.run();
5175   BOOST_ASIO_CHECK(called);
5176   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5177
5178   s.reset(read_data, sizeof(read_data));
5179   memset(read_buf, 0, sizeof(read_buf));
5180   called = false;
5181   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5182       bindns::bind(async_read_handler,
5183         _1, _2, sizeof(read_data), &called));
5184   ioc.restart();
5185   ioc.run();
5186   BOOST_ASIO_CHECK(called);
5187   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5188
5189   s.reset(read_data, sizeof(read_data));
5190   s.next_read_length(1);
5191   memset(read_buf, 0, sizeof(read_buf));
5192   called = false;
5193   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5194       bindns::bind(async_read_handler,
5195         _1, _2, sizeof(read_data), &called));
5196   ioc.restart();
5197   ioc.run();
5198   BOOST_ASIO_CHECK(called);
5199   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5200
5201   s.reset(read_data, sizeof(read_data));
5202   s.next_read_length(1);
5203   memset(read_buf, 0, sizeof(read_buf));
5204   called = false;
5205   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5206       bindns::bind(async_read_handler,
5207         _1, _2, sizeof(read_data), &called));
5208   ioc.restart();
5209   ioc.run();
5210   BOOST_ASIO_CHECK(called);
5211   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5212
5213   s.reset(read_data, sizeof(read_data));
5214   s.next_read_length(10);
5215   memset(read_buf, 0, sizeof(read_buf));
5216   called = false;
5217   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5218       bindns::bind(async_read_handler,
5219         _1, _2, sizeof(read_data), &called));
5220   ioc.restart();
5221   ioc.run();
5222   BOOST_ASIO_CHECK(called);
5223   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5224
5225   s.reset(read_data, sizeof(read_data));
5226   s.next_read_length(10);
5227   memset(read_buf, 0, sizeof(read_buf));
5228   called = false;
5229   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5230       bindns::bind(async_read_handler,
5231         _1, _2, sizeof(read_data), &called));
5232   ioc.restart();
5233   ioc.run();
5234   BOOST_ASIO_CHECK(called);
5235   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5236
5237   s.reset(read_data, sizeof(read_data));
5238   memset(read_buf, 0, sizeof(read_buf));
5239   called = false;
5240   boost::asio::async_read_at(s, 0, buffers, short_transfer,
5241       bindns::bind(async_read_handler,
5242         _1, _2, sizeof(read_data), &called));
5243   ioc.restart();
5244   ioc.run();
5245   BOOST_ASIO_CHECK(called);
5246   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5247
5248   s.reset(read_data, sizeof(read_data));
5249   memset(read_buf, 0, sizeof(read_buf));
5250   called = false;
5251   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
5252       bindns::bind(async_read_handler,
5253         _1, _2, sizeof(read_data), &called));
5254   ioc.restart();
5255   ioc.run();
5256   BOOST_ASIO_CHECK(called);
5257   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5258
5259   s.reset(read_data, sizeof(read_data));
5260   s.next_read_length(1);
5261   memset(read_buf, 0, sizeof(read_buf));
5262   called = false;
5263   boost::asio::async_read_at(s, 0, buffers, short_transfer,
5264       bindns::bind(async_read_handler,
5265         _1, _2, sizeof(read_data), &called));
5266   ioc.restart();
5267   ioc.run();
5268   BOOST_ASIO_CHECK(called);
5269   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5270
5271   s.reset(read_data, sizeof(read_data));
5272   s.next_read_length(1);
5273   memset(read_buf, 0, sizeof(read_buf));
5274   called = false;
5275   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
5276       bindns::bind(async_read_handler,
5277         _1, _2, sizeof(read_data), &called));
5278   ioc.restart();
5279   ioc.run();
5280   BOOST_ASIO_CHECK(called);
5281   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5282
5283   s.reset(read_data, sizeof(read_data));
5284   s.next_read_length(10);
5285   memset(read_buf, 0, sizeof(read_buf));
5286   called = false;
5287   boost::asio::async_read_at(s, 0, buffers, short_transfer,
5288       bindns::bind(async_read_handler,
5289         _1, _2, sizeof(read_data), &called));
5290   ioc.restart();
5291   ioc.run();
5292   BOOST_ASIO_CHECK(called);
5293   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5294
5295   s.reset(read_data, sizeof(read_data));
5296   s.next_read_length(10);
5297   memset(read_buf, 0, sizeof(read_buf));
5298   called = false;
5299   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
5300       bindns::bind(async_read_handler,
5301         _1, _2, sizeof(read_data), &called));
5302   ioc.restart();
5303   ioc.run();
5304   BOOST_ASIO_CHECK(called);
5305   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5306
5307   s.reset(read_data, sizeof(read_data));
5308   memset(read_buf, 0, sizeof(read_buf));
5309   int i = boost::asio::async_read_at(s, 1234, buffers,
5310       short_transfer, archetypes::lazy_handler());
5311   BOOST_ASIO_CHECK(i == 42);
5312   ioc.restart();
5313   ioc.run();
5314   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5315 #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
5316 }
5317
5318 void test_5_arg_std_array_buffers_async_read_at()
5319 {
5320 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
5321   namespace bindns = boost;
5322 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
5323   namespace bindns = std;
5324   using std::placeholders::_1;
5325   using std::placeholders::_2;
5326 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
5327
5328 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
5329   boost::asio::io_context ioc;
5330   test_random_access_device s(ioc);
5331   char read_buf[sizeof(read_data)];
5332   std::array<boost::asio::mutable_buffer, 2> buffers = { {
5333     boost::asio::buffer(read_buf, 32),
5334     boost::asio::buffer(read_buf) + 32 } };
5335
5336   s.reset(read_data, sizeof(read_data));
5337   memset(read_buf, 0, sizeof(read_buf));
5338   bool called = false;
5339   boost::asio::async_read_at(s, 0, buffers,
5340       boost::asio::transfer_all(),
5341       bindns::bind(async_read_handler,
5342         _1, _2, sizeof(read_data), &called));
5343   ioc.restart();
5344   ioc.run();
5345   BOOST_ASIO_CHECK(called);
5346   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5347
5348   s.reset(read_data, sizeof(read_data));
5349   memset(read_buf, 0, sizeof(read_buf));
5350   called = false;
5351   boost::asio::async_read_at(s, 1234, buffers,
5352       boost::asio::transfer_all(),
5353       bindns::bind(async_read_handler,
5354         _1, _2, sizeof(read_data), &called));
5355   ioc.restart();
5356   ioc.run();
5357   BOOST_ASIO_CHECK(called);
5358   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5359
5360   s.reset(read_data, sizeof(read_data));
5361   s.next_read_length(1);
5362   memset(read_buf, 0, sizeof(read_buf));
5363   called = false;
5364   boost::asio::async_read_at(s, 0, buffers,
5365       boost::asio::transfer_all(),
5366       bindns::bind(async_read_handler,
5367         _1, _2, sizeof(read_data), &called));
5368   ioc.restart();
5369   ioc.run();
5370   BOOST_ASIO_CHECK(called);
5371   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5372
5373   s.reset(read_data, sizeof(read_data));
5374   s.next_read_length(1);
5375   memset(read_buf, 0, sizeof(read_buf));
5376   called = false;
5377   boost::asio::async_read_at(s, 1234, buffers,
5378       boost::asio::transfer_all(),
5379       bindns::bind(async_read_handler,
5380         _1, _2, sizeof(read_data), &called));
5381   ioc.restart();
5382   ioc.run();
5383   BOOST_ASIO_CHECK(called);
5384   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5385
5386   s.reset(read_data, sizeof(read_data));
5387   s.next_read_length(10);
5388   memset(read_buf, 0, sizeof(read_buf));
5389   called = false;
5390   boost::asio::async_read_at(s, 0, buffers,
5391       boost::asio::transfer_all(),
5392       bindns::bind(async_read_handler,
5393         _1, _2, sizeof(read_data), &called));
5394   ioc.restart();
5395   ioc.run();
5396   BOOST_ASIO_CHECK(called);
5397   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5398
5399   s.reset(read_data, sizeof(read_data));
5400   s.next_read_length(10);
5401   memset(read_buf, 0, sizeof(read_buf));
5402   called = false;
5403   boost::asio::async_read_at(s, 1234, buffers,
5404       boost::asio::transfer_all(),
5405       bindns::bind(async_read_handler,
5406         _1, _2, sizeof(read_data), &called));
5407   ioc.restart();
5408   ioc.run();
5409   BOOST_ASIO_CHECK(called);
5410   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5411
5412   s.reset(read_data, sizeof(read_data));
5413   memset(read_buf, 0, sizeof(read_buf));
5414   called = false;
5415   boost::asio::async_read_at(s, 0, buffers,
5416       boost::asio::transfer_at_least(1),
5417       bindns::bind(async_read_handler,
5418         _1, _2, sizeof(read_data), &called));
5419   ioc.restart();
5420   ioc.run();
5421   BOOST_ASIO_CHECK(called);
5422   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5423
5424   s.reset(read_data, sizeof(read_data));
5425   memset(read_buf, 0, sizeof(read_buf));
5426   called = false;
5427   boost::asio::async_read_at(s, 1234, buffers,
5428       boost::asio::transfer_at_least(1),
5429       bindns::bind(async_read_handler,
5430         _1, _2, sizeof(read_data), &called));
5431   ioc.restart();
5432   ioc.run();
5433   BOOST_ASIO_CHECK(called);
5434   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5435
5436   s.reset(read_data, sizeof(read_data));
5437   s.next_read_length(1);
5438   memset(read_buf, 0, sizeof(read_buf));
5439   called = false;
5440   boost::asio::async_read_at(s, 0, buffers,
5441       boost::asio::transfer_at_least(1),
5442       bindns::bind(async_read_handler,
5443         _1, _2, 1, &called));
5444   ioc.restart();
5445   ioc.run();
5446   BOOST_ASIO_CHECK(called);
5447   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
5448
5449   s.reset(read_data, sizeof(read_data));
5450   s.next_read_length(1);
5451   memset(read_buf, 0, sizeof(read_buf));
5452   called = false;
5453   boost::asio::async_read_at(s, 1234, buffers,
5454       boost::asio::transfer_at_least(1),
5455       bindns::bind(async_read_handler,
5456         _1, _2, 1, &called));
5457   ioc.restart();
5458   ioc.run();
5459   BOOST_ASIO_CHECK(called);
5460   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5461
5462   s.reset(read_data, sizeof(read_data));
5463   s.next_read_length(10);
5464   memset(read_buf, 0, sizeof(read_buf));
5465   called = false;
5466   boost::asio::async_read_at(s, 0, buffers,
5467       boost::asio::transfer_at_least(1),
5468       bindns::bind(async_read_handler,
5469         _1, _2, 10, &called));
5470   ioc.restart();
5471   ioc.run();
5472   BOOST_ASIO_CHECK(called);
5473   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5474
5475   s.reset(read_data, sizeof(read_data));
5476   s.next_read_length(10);
5477   memset(read_buf, 0, sizeof(read_buf));
5478   called = false;
5479   boost::asio::async_read_at(s, 1234, buffers,
5480       boost::asio::transfer_at_least(1),
5481       bindns::bind(async_read_handler,
5482         _1, _2, 10, &called));
5483   ioc.restart();
5484   ioc.run();
5485   BOOST_ASIO_CHECK(called);
5486   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5487
5488   s.reset(read_data, sizeof(read_data));
5489   memset(read_buf, 0, sizeof(read_buf));
5490   called = false;
5491   boost::asio::async_read_at(s, 0, buffers,
5492       boost::asio::transfer_at_least(10),
5493       bindns::bind(async_read_handler,
5494         _1, _2, sizeof(read_data), &called));
5495   ioc.restart();
5496   ioc.run();
5497   BOOST_ASIO_CHECK(called);
5498   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5499
5500   s.reset(read_data, sizeof(read_data));
5501   memset(read_buf, 0, sizeof(read_buf));
5502   called = false;
5503   boost::asio::async_read_at(s, 1234, buffers,
5504       boost::asio::transfer_at_least(10),
5505       bindns::bind(async_read_handler,
5506         _1, _2, sizeof(read_data), &called));
5507   ioc.restart();
5508   ioc.run();
5509   BOOST_ASIO_CHECK(called);
5510   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5511
5512   s.reset(read_data, sizeof(read_data));
5513   s.next_read_length(1);
5514   memset(read_buf, 0, sizeof(read_buf));
5515   called = false;
5516   boost::asio::async_read_at(s, 0, buffers,
5517       boost::asio::transfer_at_least(10),
5518       bindns::bind(async_read_handler,
5519         _1, _2, 10, &called));
5520   ioc.restart();
5521   ioc.run();
5522   BOOST_ASIO_CHECK(called);
5523   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5524
5525   s.reset(read_data, sizeof(read_data));
5526   s.next_read_length(1);
5527   memset(read_buf, 0, sizeof(read_buf));
5528   called = false;
5529   boost::asio::async_read_at(s, 1234, buffers,
5530       boost::asio::transfer_at_least(10),
5531       bindns::bind(async_read_handler,
5532         _1, _2, 10, &called));
5533   ioc.restart();
5534   ioc.run();
5535   BOOST_ASIO_CHECK(called);
5536   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5537
5538   s.reset(read_data, sizeof(read_data));
5539   s.next_read_length(10);
5540   memset(read_buf, 0, sizeof(read_buf));
5541   called = false;
5542   boost::asio::async_read_at(s, 0, buffers,
5543       boost::asio::transfer_at_least(10),
5544       bindns::bind(async_read_handler,
5545         _1, _2, 10, &called));
5546   ioc.restart();
5547   ioc.run();
5548   BOOST_ASIO_CHECK(called);
5549   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5550
5551   s.reset(read_data, sizeof(read_data));
5552   s.next_read_length(10);
5553   memset(read_buf, 0, sizeof(read_buf));
5554   called = false;
5555   boost::asio::async_read_at(s, 1234, buffers,
5556       boost::asio::transfer_at_least(10),
5557       bindns::bind(async_read_handler,
5558         _1, _2, 10, &called));
5559   ioc.restart();
5560   ioc.run();
5561   BOOST_ASIO_CHECK(called);
5562   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5563
5564   s.reset(read_data, sizeof(read_data));
5565   memset(read_buf, 0, sizeof(read_buf));
5566   called = false;
5567   boost::asio::async_read_at(s, 0, buffers,
5568       boost::asio::transfer_at_least(42),
5569       bindns::bind(async_read_handler,
5570         _1, _2, sizeof(read_data), &called));
5571   ioc.restart();
5572   ioc.run();
5573   BOOST_ASIO_CHECK(called);
5574   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5575
5576   s.reset(read_data, sizeof(read_data));
5577   memset(read_buf, 0, sizeof(read_buf));
5578   called = false;
5579   boost::asio::async_read_at(s, 1234, buffers,
5580       boost::asio::transfer_at_least(42),
5581       bindns::bind(async_read_handler,
5582         _1, _2, sizeof(read_data), &called));
5583   ioc.restart();
5584   ioc.run();
5585   BOOST_ASIO_CHECK(called);
5586   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5587
5588   s.reset(read_data, sizeof(read_data));
5589   s.next_read_length(1);
5590   memset(read_buf, 0, sizeof(read_buf));
5591   called = false;
5592   boost::asio::async_read_at(s, 0, buffers,
5593       boost::asio::transfer_at_least(42),
5594       bindns::bind(async_read_handler,
5595         _1, _2, 42, &called));
5596   ioc.restart();
5597   ioc.run();
5598   BOOST_ASIO_CHECK(called);
5599   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5600
5601   s.reset(read_data, sizeof(read_data));
5602   s.next_read_length(1);
5603   memset(read_buf, 0, sizeof(read_buf));
5604   called = false;
5605   boost::asio::async_read_at(s, 1234, buffers,
5606       boost::asio::transfer_at_least(42),
5607       bindns::bind(async_read_handler,
5608         _1, _2, 42, &called));
5609   ioc.restart();
5610   ioc.run();
5611   BOOST_ASIO_CHECK(called);
5612   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5613
5614   s.reset(read_data, sizeof(read_data));
5615   s.next_read_length(10);
5616   memset(read_buf, 0, sizeof(read_buf));
5617   called = false;
5618   boost::asio::async_read_at(s, 0, buffers,
5619       boost::asio::transfer_at_least(42),
5620       bindns::bind(async_read_handler,
5621         _1, _2, 50, &called));
5622   ioc.restart();
5623   ioc.run();
5624   BOOST_ASIO_CHECK(called);
5625   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
5626
5627   s.reset(read_data, sizeof(read_data));
5628   s.next_read_length(10);
5629   memset(read_buf, 0, sizeof(read_buf));
5630   called = false;
5631   boost::asio::async_read_at(s, 1234, buffers,
5632       boost::asio::transfer_at_least(42),
5633       bindns::bind(async_read_handler,
5634         _1, _2, 50, &called));
5635   ioc.restart();
5636   ioc.run();
5637   BOOST_ASIO_CHECK(called);
5638   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
5639
5640   s.reset(read_data, sizeof(read_data));
5641   memset(read_buf, 0, sizeof(read_buf));
5642   called = false;
5643   boost::asio::async_read_at(s, 0, buffers,
5644       boost::asio::transfer_exactly(1),
5645       bindns::bind(async_read_handler,
5646         _1, _2, 1, &called));
5647   ioc.restart();
5648   ioc.run();
5649   BOOST_ASIO_CHECK(called);
5650   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
5651
5652   s.reset(read_data, sizeof(read_data));
5653   memset(read_buf, 0, sizeof(read_buf));
5654   called = false;
5655   boost::asio::async_read_at(s, 1234, buffers,
5656       boost::asio::transfer_exactly(1),
5657       bindns::bind(async_read_handler,
5658         _1, _2, 1, &called));
5659   ioc.restart();
5660   ioc.run();
5661   BOOST_ASIO_CHECK(called);
5662   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5663
5664   s.reset(read_data, sizeof(read_data));
5665   s.next_read_length(1);
5666   memset(read_buf, 0, sizeof(read_buf));
5667   called = false;
5668   boost::asio::async_read_at(s, 0, buffers,
5669       boost::asio::transfer_exactly(1),
5670       bindns::bind(async_read_handler,
5671         _1, _2, 1, &called));
5672   ioc.restart();
5673   ioc.run();
5674   BOOST_ASIO_CHECK(called);
5675   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
5676
5677   s.reset(read_data, sizeof(read_data));
5678   s.next_read_length(1);
5679   memset(read_buf, 0, sizeof(read_buf));
5680   called = false;
5681   boost::asio::async_read_at(s, 1234, buffers,
5682       boost::asio::transfer_exactly(1),
5683       bindns::bind(async_read_handler,
5684         _1, _2, 1, &called));
5685   ioc.restart();
5686   ioc.run();
5687   BOOST_ASIO_CHECK(called);
5688   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5689
5690   s.reset(read_data, sizeof(read_data));
5691   s.next_read_length(10);
5692   memset(read_buf, 0, sizeof(read_buf));
5693   called = false;
5694   boost::asio::async_read_at(s, 0, buffers,
5695       boost::asio::transfer_exactly(1),
5696       bindns::bind(async_read_handler,
5697         _1, _2, 1, &called));
5698   ioc.restart();
5699   ioc.run();
5700   BOOST_ASIO_CHECK(called);
5701   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
5702
5703   s.reset(read_data, sizeof(read_data));
5704   s.next_read_length(10);
5705   memset(read_buf, 0, sizeof(read_buf));
5706   called = false;
5707   boost::asio::async_read_at(s, 1234, buffers,
5708       boost::asio::transfer_exactly(1),
5709       bindns::bind(async_read_handler,
5710         _1, _2, 1, &called));
5711   ioc.restart();
5712   ioc.run();
5713   BOOST_ASIO_CHECK(called);
5714   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5715
5716   s.reset(read_data, sizeof(read_data));
5717   memset(read_buf, 0, sizeof(read_buf));
5718   called = false;
5719   boost::asio::async_read_at(s, 0, buffers,
5720       boost::asio::transfer_exactly(10),
5721       bindns::bind(async_read_handler,
5722         _1, _2, 10, &called));
5723   ioc.restart();
5724   ioc.run();
5725   BOOST_ASIO_CHECK(called);
5726   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5727
5728   s.reset(read_data, sizeof(read_data));
5729   memset(read_buf, 0, sizeof(read_buf));
5730   called = false;
5731   boost::asio::async_read_at(s, 1234, buffers,
5732       boost::asio::transfer_exactly(10),
5733       bindns::bind(async_read_handler,
5734         _1, _2, 10, &called));
5735   ioc.restart();
5736   ioc.run();
5737   BOOST_ASIO_CHECK(called);
5738   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5739
5740   s.reset(read_data, sizeof(read_data));
5741   s.next_read_length(1);
5742   memset(read_buf, 0, sizeof(read_buf));
5743   called = false;
5744   boost::asio::async_read_at(s, 0, buffers,
5745       boost::asio::transfer_exactly(10),
5746       bindns::bind(async_read_handler,
5747         _1, _2, 10, &called));
5748   ioc.restart();
5749   ioc.run();
5750   BOOST_ASIO_CHECK(called);
5751   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5752
5753   s.reset(read_data, sizeof(read_data));
5754   s.next_read_length(1);
5755   memset(read_buf, 0, sizeof(read_buf));
5756   called = false;
5757   boost::asio::async_read_at(s, 1234, buffers,
5758       boost::asio::transfer_exactly(10),
5759       bindns::bind(async_read_handler,
5760         _1, _2, 10, &called));
5761   ioc.restart();
5762   ioc.run();
5763   BOOST_ASIO_CHECK(called);
5764   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5765
5766   s.reset(read_data, sizeof(read_data));
5767   s.next_read_length(10);
5768   memset(read_buf, 0, sizeof(read_buf));
5769   called = false;
5770   boost::asio::async_read_at(s, 0, buffers,
5771       boost::asio::transfer_exactly(10),
5772       bindns::bind(async_read_handler,
5773         _1, _2, 10, &called));
5774   ioc.restart();
5775   ioc.run();
5776   BOOST_ASIO_CHECK(called);
5777   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
5778
5779   s.reset(read_data, sizeof(read_data));
5780   s.next_read_length(10);
5781   memset(read_buf, 0, sizeof(read_buf));
5782   called = false;
5783   boost::asio::async_read_at(s, 1234, buffers,
5784       boost::asio::transfer_exactly(10),
5785       bindns::bind(async_read_handler,
5786         _1, _2, 10, &called));
5787   ioc.restart();
5788   ioc.run();
5789   BOOST_ASIO_CHECK(called);
5790   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5791
5792   s.reset(read_data, sizeof(read_data));
5793   memset(read_buf, 0, sizeof(read_buf));
5794   called = false;
5795   boost::asio::async_read_at(s, 0, buffers,
5796       boost::asio::transfer_exactly(42),
5797       bindns::bind(async_read_handler,
5798         _1, _2, 42, &called));
5799   ioc.restart();
5800   ioc.run();
5801   BOOST_ASIO_CHECK(called);
5802   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5803
5804   s.reset(read_data, sizeof(read_data));
5805   memset(read_buf, 0, sizeof(read_buf));
5806   called = false;
5807   boost::asio::async_read_at(s, 1234, buffers,
5808       boost::asio::transfer_exactly(42),
5809       bindns::bind(async_read_handler,
5810         _1, _2, 42, &called));
5811   ioc.restart();
5812   ioc.run();
5813   BOOST_ASIO_CHECK(called);
5814   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5815
5816   s.reset(read_data, sizeof(read_data));
5817   s.next_read_length(1);
5818   memset(read_buf, 0, sizeof(read_buf));
5819   called = false;
5820   boost::asio::async_read_at(s, 0, buffers,
5821       boost::asio::transfer_exactly(42),
5822       bindns::bind(async_read_handler,
5823         _1, _2, 42, &called));
5824   ioc.restart();
5825   ioc.run();
5826   BOOST_ASIO_CHECK(called);
5827   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5828
5829   s.reset(read_data, sizeof(read_data));
5830   s.next_read_length(1);
5831   memset(read_buf, 0, sizeof(read_buf));
5832   called = false;
5833   boost::asio::async_read_at(s, 1234, buffers,
5834       boost::asio::transfer_exactly(42),
5835       bindns::bind(async_read_handler,
5836         _1, _2, 42, &called));
5837   ioc.restart();
5838   ioc.run();
5839   BOOST_ASIO_CHECK(called);
5840   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5841
5842   s.reset(read_data, sizeof(read_data));
5843   s.next_read_length(10);
5844   memset(read_buf, 0, sizeof(read_buf));
5845   called = false;
5846   boost::asio::async_read_at(s, 0, buffers,
5847       boost::asio::transfer_exactly(42),
5848       bindns::bind(async_read_handler,
5849         _1, _2, 42, &called));
5850   ioc.restart();
5851   ioc.run();
5852   BOOST_ASIO_CHECK(called);
5853   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
5854
5855   s.reset(read_data, sizeof(read_data));
5856   s.next_read_length(10);
5857   memset(read_buf, 0, sizeof(read_buf));
5858   called = false;
5859   boost::asio::async_read_at(s, 1234, buffers,
5860       boost::asio::transfer_exactly(42),
5861       bindns::bind(async_read_handler,
5862         _1, _2, 42, &called));
5863   ioc.restart();
5864   ioc.run();
5865   BOOST_ASIO_CHECK(called);
5866   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5867
5868   s.reset(read_data, sizeof(read_data));
5869   memset(read_buf, 0, sizeof(read_buf));
5870   called = false;
5871   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5872       bindns::bind(async_read_handler,
5873         _1, _2, sizeof(read_data), &called));
5874   ioc.restart();
5875   ioc.run();
5876   BOOST_ASIO_CHECK(called);
5877   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5878
5879   s.reset(read_data, sizeof(read_data));
5880   memset(read_buf, 0, sizeof(read_buf));
5881   called = false;
5882   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5883       bindns::bind(async_read_handler,
5884         _1, _2, sizeof(read_data), &called));
5885   ioc.restart();
5886   ioc.run();
5887   BOOST_ASIO_CHECK(called);
5888   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5889
5890   s.reset(read_data, sizeof(read_data));
5891   s.next_read_length(1);
5892   memset(read_buf, 0, sizeof(read_buf));
5893   called = false;
5894   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5895       bindns::bind(async_read_handler,
5896         _1, _2, sizeof(read_data), &called));
5897   ioc.restart();
5898   ioc.run();
5899   BOOST_ASIO_CHECK(called);
5900   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5901
5902   s.reset(read_data, sizeof(read_data));
5903   s.next_read_length(1);
5904   memset(read_buf, 0, sizeof(read_buf));
5905   called = false;
5906   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5907       bindns::bind(async_read_handler,
5908         _1, _2, sizeof(read_data), &called));
5909   ioc.restart();
5910   ioc.run();
5911   BOOST_ASIO_CHECK(called);
5912   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5913
5914   s.reset(read_data, sizeof(read_data));
5915   s.next_read_length(10);
5916   memset(read_buf, 0, sizeof(read_buf));
5917   called = false;
5918   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5919       bindns::bind(async_read_handler,
5920         _1, _2, sizeof(read_data), &called));
5921   ioc.restart();
5922   ioc.run();
5923   BOOST_ASIO_CHECK(called);
5924   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5925
5926   s.reset(read_data, sizeof(read_data));
5927   s.next_read_length(10);
5928   memset(read_buf, 0, sizeof(read_buf));
5929   called = false;
5930   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5931       bindns::bind(async_read_handler,
5932         _1, _2, sizeof(read_data), &called));
5933   ioc.restart();
5934   ioc.run();
5935   BOOST_ASIO_CHECK(called);
5936   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5937
5938   s.reset(read_data, sizeof(read_data));
5939   memset(read_buf, 0, sizeof(read_buf));
5940   called = false;
5941   boost::asio::async_read_at(s, 0, buffers, short_transfer,
5942       bindns::bind(async_read_handler,
5943         _1, _2, sizeof(read_data), &called));
5944   ioc.restart();
5945   ioc.run();
5946   BOOST_ASIO_CHECK(called);
5947   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5948
5949   s.reset(read_data, sizeof(read_data));
5950   memset(read_buf, 0, sizeof(read_buf));
5951   called = false;
5952   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
5953       bindns::bind(async_read_handler,
5954         _1, _2, sizeof(read_data), &called));
5955   ioc.restart();
5956   ioc.run();
5957   BOOST_ASIO_CHECK(called);
5958   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5959
5960   s.reset(read_data, sizeof(read_data));
5961   s.next_read_length(1);
5962   memset(read_buf, 0, sizeof(read_buf));
5963   called = false;
5964   boost::asio::async_read_at(s, 0, buffers, short_transfer,
5965       bindns::bind(async_read_handler,
5966         _1, _2, sizeof(read_data), &called));
5967   ioc.restart();
5968   ioc.run();
5969   BOOST_ASIO_CHECK(called);
5970   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5971
5972   s.reset(read_data, sizeof(read_data));
5973   s.next_read_length(1);
5974   memset(read_buf, 0, sizeof(read_buf));
5975   called = false;
5976   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
5977       bindns::bind(async_read_handler,
5978         _1, _2, sizeof(read_data), &called));
5979   ioc.restart();
5980   ioc.run();
5981   BOOST_ASIO_CHECK(called);
5982   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5983
5984   s.reset(read_data, sizeof(read_data));
5985   s.next_read_length(10);
5986   memset(read_buf, 0, sizeof(read_buf));
5987   called = false;
5988   boost::asio::async_read_at(s, 0, buffers, short_transfer,
5989       bindns::bind(async_read_handler,
5990         _1, _2, sizeof(read_data), &called));
5991   ioc.restart();
5992   ioc.run();
5993   BOOST_ASIO_CHECK(called);
5994   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5995
5996   s.reset(read_data, sizeof(read_data));
5997   s.next_read_length(10);
5998   memset(read_buf, 0, sizeof(read_buf));
5999   called = false;
6000   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
6001       bindns::bind(async_read_handler,
6002         _1, _2, sizeof(read_data), &called));
6003   ioc.restart();
6004   ioc.run();
6005   BOOST_ASIO_CHECK(called);
6006   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6007
6008   s.reset(read_data, sizeof(read_data));
6009   memset(read_buf, 0, sizeof(read_buf));
6010   int i = boost::asio::async_read_at(s, 1234, buffers,
6011       short_transfer, archetypes::lazy_handler());
6012   BOOST_ASIO_CHECK(i == 42);
6013   ioc.restart();
6014   ioc.run();
6015   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6016 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
6017 }
6018
6019 void test_5_arg_vector_buffers_async_read_at()
6020 {
6021 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
6022   namespace bindns = boost;
6023 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
6024   namespace bindns = std;
6025   using std::placeholders::_1;
6026   using std::placeholders::_2;
6027 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
6028
6029   boost::asio::io_context ioc;
6030   test_random_access_device s(ioc);
6031   char read_buf[sizeof(read_data)];
6032   std::vector<boost::asio::mutable_buffer> buffers;
6033   buffers.push_back(boost::asio::buffer(read_buf, 32));
6034   buffers.push_back(boost::asio::buffer(read_buf) + 32);
6035
6036   s.reset(read_data, sizeof(read_data));
6037   memset(read_buf, 0, sizeof(read_buf));
6038   bool called = false;
6039   boost::asio::async_read_at(s, 0, buffers,
6040       boost::asio::transfer_all(),
6041       bindns::bind(async_read_handler,
6042         _1, _2, sizeof(read_data), &called));
6043   ioc.restart();
6044   ioc.run();
6045   BOOST_ASIO_CHECK(called);
6046   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6047
6048   s.reset(read_data, sizeof(read_data));
6049   memset(read_buf, 0, sizeof(read_buf));
6050   called = false;
6051   boost::asio::async_read_at(s, 1234, buffers,
6052       boost::asio::transfer_all(),
6053       bindns::bind(async_read_handler,
6054         _1, _2, sizeof(read_data), &called));
6055   ioc.restart();
6056   ioc.run();
6057   BOOST_ASIO_CHECK(called);
6058   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6059
6060   s.reset(read_data, sizeof(read_data));
6061   s.next_read_length(1);
6062   memset(read_buf, 0, sizeof(read_buf));
6063   called = false;
6064   boost::asio::async_read_at(s, 0, buffers,
6065       boost::asio::transfer_all(),
6066       bindns::bind(async_read_handler,
6067         _1, _2, sizeof(read_data), &called));
6068   ioc.restart();
6069   ioc.run();
6070   BOOST_ASIO_CHECK(called);
6071   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6072
6073   s.reset(read_data, sizeof(read_data));
6074   s.next_read_length(1);
6075   memset(read_buf, 0, sizeof(read_buf));
6076   called = false;
6077   boost::asio::async_read_at(s, 1234, buffers,
6078       boost::asio::transfer_all(),
6079       bindns::bind(async_read_handler,
6080         _1, _2, sizeof(read_data), &called));
6081   ioc.restart();
6082   ioc.run();
6083   BOOST_ASIO_CHECK(called);
6084   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6085
6086   s.reset(read_data, sizeof(read_data));
6087   s.next_read_length(10);
6088   memset(read_buf, 0, sizeof(read_buf));
6089   called = false;
6090   boost::asio::async_read_at(s, 0, buffers,
6091       boost::asio::transfer_all(),
6092       bindns::bind(async_read_handler,
6093         _1, _2, sizeof(read_data), &called));
6094   ioc.restart();
6095   ioc.run();
6096   BOOST_ASIO_CHECK(called);
6097   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6098
6099   s.reset(read_data, sizeof(read_data));
6100   s.next_read_length(10);
6101   memset(read_buf, 0, sizeof(read_buf));
6102   called = false;
6103   boost::asio::async_read_at(s, 1234, buffers,
6104       boost::asio::transfer_all(),
6105       bindns::bind(async_read_handler,
6106         _1, _2, sizeof(read_data), &called));
6107   ioc.restart();
6108   ioc.run();
6109   BOOST_ASIO_CHECK(called);
6110   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6111
6112   s.reset(read_data, sizeof(read_data));
6113   memset(read_buf, 0, sizeof(read_buf));
6114   called = false;
6115   boost::asio::async_read_at(s, 0, buffers,
6116       boost::asio::transfer_at_least(1),
6117       bindns::bind(async_read_handler,
6118         _1, _2, sizeof(read_data), &called));
6119   ioc.restart();
6120   ioc.run();
6121   BOOST_ASIO_CHECK(called);
6122   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6123
6124   s.reset(read_data, sizeof(read_data));
6125   memset(read_buf, 0, sizeof(read_buf));
6126   called = false;
6127   boost::asio::async_read_at(s, 1234, buffers,
6128       boost::asio::transfer_at_least(1),
6129       bindns::bind(async_read_handler,
6130         _1, _2, sizeof(read_data), &called));
6131   ioc.restart();
6132   ioc.run();
6133   BOOST_ASIO_CHECK(called);
6134   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6135
6136   s.reset(read_data, sizeof(read_data));
6137   s.next_read_length(1);
6138   memset(read_buf, 0, sizeof(read_buf));
6139   called = false;
6140   boost::asio::async_read_at(s, 0, buffers,
6141       boost::asio::transfer_at_least(1),
6142       bindns::bind(async_read_handler,
6143         _1, _2, 1, &called));
6144   ioc.restart();
6145   ioc.run();
6146   BOOST_ASIO_CHECK(called);
6147   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
6148
6149   s.reset(read_data, sizeof(read_data));
6150   s.next_read_length(1);
6151   memset(read_buf, 0, sizeof(read_buf));
6152   called = false;
6153   boost::asio::async_read_at(s, 1234, buffers,
6154       boost::asio::transfer_at_least(1),
6155       bindns::bind(async_read_handler,
6156         _1, _2, 1, &called));
6157   ioc.restart();
6158   ioc.run();
6159   BOOST_ASIO_CHECK(called);
6160   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6161
6162   s.reset(read_data, sizeof(read_data));
6163   s.next_read_length(10);
6164   memset(read_buf, 0, sizeof(read_buf));
6165   called = false;
6166   boost::asio::async_read_at(s, 0, buffers,
6167       boost::asio::transfer_at_least(1),
6168       bindns::bind(async_read_handler,
6169         _1, _2, 10, &called));
6170   ioc.restart();
6171   ioc.run();
6172   BOOST_ASIO_CHECK(called);
6173   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
6174
6175   s.reset(read_data, sizeof(read_data));
6176   s.next_read_length(10);
6177   memset(read_buf, 0, sizeof(read_buf));
6178   called = false;
6179   boost::asio::async_read_at(s, 1234, buffers,
6180       boost::asio::transfer_at_least(1),
6181       bindns::bind(async_read_handler,
6182         _1, _2, 10, &called));
6183   ioc.restart();
6184   ioc.run();
6185   BOOST_ASIO_CHECK(called);
6186   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6187
6188   s.reset(read_data, sizeof(read_data));
6189   memset(read_buf, 0, sizeof(read_buf));
6190   called = false;
6191   boost::asio::async_read_at(s, 0, buffers,
6192       boost::asio::transfer_at_least(10),
6193       bindns::bind(async_read_handler,
6194         _1, _2, sizeof(read_data), &called));
6195   ioc.restart();
6196   ioc.run();
6197   BOOST_ASIO_CHECK(called);
6198   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6199
6200   s.reset(read_data, sizeof(read_data));
6201   memset(read_buf, 0, sizeof(read_buf));
6202   called = false;
6203   boost::asio::async_read_at(s, 1234, buffers,
6204       boost::asio::transfer_at_least(10),
6205       bindns::bind(async_read_handler,
6206         _1, _2, sizeof(read_data), &called));
6207   ioc.restart();
6208   ioc.run();
6209   BOOST_ASIO_CHECK(called);
6210   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6211
6212   s.reset(read_data, sizeof(read_data));
6213   s.next_read_length(1);
6214   memset(read_buf, 0, sizeof(read_buf));
6215   called = false;
6216   boost::asio::async_read_at(s, 0, buffers,
6217       boost::asio::transfer_at_least(10),
6218       bindns::bind(async_read_handler,
6219         _1, _2, 10, &called));
6220   ioc.restart();
6221   ioc.run();
6222   BOOST_ASIO_CHECK(called);
6223   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
6224
6225   s.reset(read_data, sizeof(read_data));
6226   s.next_read_length(1);
6227   memset(read_buf, 0, sizeof(read_buf));
6228   called = false;
6229   boost::asio::async_read_at(s, 1234, buffers,
6230       boost::asio::transfer_at_least(10),
6231       bindns::bind(async_read_handler,
6232         _1, _2, 10, &called));
6233   ioc.restart();
6234   ioc.run();
6235   BOOST_ASIO_CHECK(called);
6236   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6237
6238   s.reset(read_data, sizeof(read_data));
6239   s.next_read_length(10);
6240   memset(read_buf, 0, sizeof(read_buf));
6241   called = false;
6242   boost::asio::async_read_at(s, 0, buffers,
6243       boost::asio::transfer_at_least(10),
6244       bindns::bind(async_read_handler,
6245         _1, _2, 10, &called));
6246   ioc.restart();
6247   ioc.run();
6248   BOOST_ASIO_CHECK(called);
6249   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
6250
6251   s.reset(read_data, sizeof(read_data));
6252   s.next_read_length(10);
6253   memset(read_buf, 0, sizeof(read_buf));
6254   called = false;
6255   boost::asio::async_read_at(s, 1234, buffers,
6256       boost::asio::transfer_at_least(10),
6257       bindns::bind(async_read_handler,
6258         _1, _2, 10, &called));
6259   ioc.restart();
6260   ioc.run();
6261   BOOST_ASIO_CHECK(called);
6262   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6263
6264   s.reset(read_data, sizeof(read_data));
6265   memset(read_buf, 0, sizeof(read_buf));
6266   called = false;
6267   boost::asio::async_read_at(s, 0, buffers,
6268       boost::asio::transfer_at_least(42),
6269       bindns::bind(async_read_handler,
6270         _1, _2, sizeof(read_data), &called));
6271   ioc.restart();
6272   ioc.run();
6273   BOOST_ASIO_CHECK(called);
6274   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6275
6276   s.reset(read_data, sizeof(read_data));
6277   memset(read_buf, 0, sizeof(read_buf));
6278   called = false;
6279   boost::asio::async_read_at(s, 1234, buffers,
6280       boost::asio::transfer_at_least(42),
6281       bindns::bind(async_read_handler,
6282         _1, _2, sizeof(read_data), &called));
6283   ioc.restart();
6284   ioc.run();
6285   BOOST_ASIO_CHECK(called);
6286   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6287
6288   s.reset(read_data, sizeof(read_data));
6289   s.next_read_length(1);
6290   memset(read_buf, 0, sizeof(read_buf));
6291   called = false;
6292   boost::asio::async_read_at(s, 0, buffers,
6293       boost::asio::transfer_at_least(42),
6294       bindns::bind(async_read_handler,
6295         _1, _2, 42, &called));
6296   ioc.restart();
6297   ioc.run();
6298   BOOST_ASIO_CHECK(called);
6299   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
6300
6301   s.reset(read_data, sizeof(read_data));
6302   s.next_read_length(1);
6303   memset(read_buf, 0, sizeof(read_buf));
6304   called = false;
6305   boost::asio::async_read_at(s, 1234, buffers,
6306       boost::asio::transfer_at_least(42),
6307       bindns::bind(async_read_handler,
6308         _1, _2, 42, &called));
6309   ioc.restart();
6310   ioc.run();
6311   BOOST_ASIO_CHECK(called);
6312   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6313
6314   s.reset(read_data, sizeof(read_data));
6315   s.next_read_length(10);
6316   memset(read_buf, 0, sizeof(read_buf));
6317   called = false;
6318   boost::asio::async_read_at(s, 0, buffers,
6319       boost::asio::transfer_at_least(42),
6320       bindns::bind(async_read_handler,
6321         _1, _2, 50, &called));
6322   ioc.restart();
6323   ioc.run();
6324   BOOST_ASIO_CHECK(called);
6325   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
6326
6327   s.reset(read_data, sizeof(read_data));
6328   s.next_read_length(10);
6329   memset(read_buf, 0, sizeof(read_buf));
6330   called = false;
6331   boost::asio::async_read_at(s, 1234, buffers,
6332       boost::asio::transfer_at_least(42),
6333       bindns::bind(async_read_handler,
6334         _1, _2, 50, &called));
6335   ioc.restart();
6336   ioc.run();
6337   BOOST_ASIO_CHECK(called);
6338   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
6339
6340   s.reset(read_data, sizeof(read_data));
6341   memset(read_buf, 0, sizeof(read_buf));
6342   called = false;
6343   boost::asio::async_read_at(s, 0, buffers,
6344       boost::asio::transfer_exactly(1),
6345       bindns::bind(async_read_handler,
6346         _1, _2, 1, &called));
6347   ioc.restart();
6348   ioc.run();
6349   BOOST_ASIO_CHECK(called);
6350   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
6351
6352   s.reset(read_data, sizeof(read_data));
6353   memset(read_buf, 0, sizeof(read_buf));
6354   called = false;
6355   boost::asio::async_read_at(s, 1234, buffers,
6356       boost::asio::transfer_exactly(1),
6357       bindns::bind(async_read_handler,
6358         _1, _2, 1, &called));
6359   ioc.restart();
6360   ioc.run();
6361   BOOST_ASIO_CHECK(called);
6362   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6363
6364   s.reset(read_data, sizeof(read_data));
6365   s.next_read_length(1);
6366   memset(read_buf, 0, sizeof(read_buf));
6367   called = false;
6368   boost::asio::async_read_at(s, 0, buffers,
6369       boost::asio::transfer_exactly(1),
6370       bindns::bind(async_read_handler,
6371         _1, _2, 1, &called));
6372   ioc.restart();
6373   ioc.run();
6374   BOOST_ASIO_CHECK(called);
6375   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
6376
6377   s.reset(read_data, sizeof(read_data));
6378   s.next_read_length(1);
6379   memset(read_buf, 0, sizeof(read_buf));
6380   called = false;
6381   boost::asio::async_read_at(s, 1234, buffers,
6382       boost::asio::transfer_exactly(1),
6383       bindns::bind(async_read_handler,
6384         _1, _2, 1, &called));
6385   ioc.restart();
6386   ioc.run();
6387   BOOST_ASIO_CHECK(called);
6388   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6389
6390   s.reset(read_data, sizeof(read_data));
6391   s.next_read_length(10);
6392   memset(read_buf, 0, sizeof(read_buf));
6393   called = false;
6394   boost::asio::async_read_at(s, 0, buffers,
6395       boost::asio::transfer_exactly(1),
6396       bindns::bind(async_read_handler,
6397         _1, _2, 1, &called));
6398   ioc.restart();
6399   ioc.run();
6400   BOOST_ASIO_CHECK(called);
6401   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
6402
6403   s.reset(read_data, sizeof(read_data));
6404   s.next_read_length(10);
6405   memset(read_buf, 0, sizeof(read_buf));
6406   called = false;
6407   boost::asio::async_read_at(s, 1234, buffers,
6408       boost::asio::transfer_exactly(1),
6409       bindns::bind(async_read_handler,
6410         _1, _2, 1, &called));
6411   ioc.restart();
6412   ioc.run();
6413   BOOST_ASIO_CHECK(called);
6414   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6415
6416   s.reset(read_data, sizeof(read_data));
6417   memset(read_buf, 0, sizeof(read_buf));
6418   called = false;
6419   boost::asio::async_read_at(s, 0, buffers,
6420       boost::asio::transfer_exactly(10),
6421       bindns::bind(async_read_handler,
6422         _1, _2, 10, &called));
6423   ioc.restart();
6424   ioc.run();
6425   BOOST_ASIO_CHECK(called);
6426   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
6427
6428   s.reset(read_data, sizeof(read_data));
6429   memset(read_buf, 0, sizeof(read_buf));
6430   called = false;
6431   boost::asio::async_read_at(s, 1234, buffers,
6432       boost::asio::transfer_exactly(10),
6433       bindns::bind(async_read_handler,
6434         _1, _2, 10, &called));
6435   ioc.restart();
6436   ioc.run();
6437   BOOST_ASIO_CHECK(called);
6438   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6439
6440   s.reset(read_data, sizeof(read_data));
6441   s.next_read_length(1);
6442   memset(read_buf, 0, sizeof(read_buf));
6443   called = false;
6444   boost::asio::async_read_at(s, 0, buffers,
6445       boost::asio::transfer_exactly(10),
6446       bindns::bind(async_read_handler,
6447         _1, _2, 10, &called));
6448   ioc.restart();
6449   ioc.run();
6450   BOOST_ASIO_CHECK(called);
6451   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
6452
6453   s.reset(read_data, sizeof(read_data));
6454   s.next_read_length(1);
6455   memset(read_buf, 0, sizeof(read_buf));
6456   called = false;
6457   boost::asio::async_read_at(s, 1234, buffers,
6458       boost::asio::transfer_exactly(10),
6459       bindns::bind(async_read_handler,
6460         _1, _2, 10, &called));
6461   ioc.restart();
6462   ioc.run();
6463   BOOST_ASIO_CHECK(called);
6464   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6465
6466   s.reset(read_data, sizeof(read_data));
6467   s.next_read_length(10);
6468   memset(read_buf, 0, sizeof(read_buf));
6469   called = false;
6470   boost::asio::async_read_at(s, 0, buffers,
6471       boost::asio::transfer_exactly(10),
6472       bindns::bind(async_read_handler,
6473         _1, _2, 10, &called));
6474   ioc.restart();
6475   ioc.run();
6476   BOOST_ASIO_CHECK(called);
6477   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
6478
6479   s.reset(read_data, sizeof(read_data));
6480   s.next_read_length(10);
6481   memset(read_buf, 0, sizeof(read_buf));
6482   called = false;
6483   boost::asio::async_read_at(s, 1234, buffers,
6484       boost::asio::transfer_exactly(10),
6485       bindns::bind(async_read_handler,
6486         _1, _2, 10, &called));
6487   ioc.restart();
6488   ioc.run();
6489   BOOST_ASIO_CHECK(called);
6490   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6491
6492   s.reset(read_data, sizeof(read_data));
6493   memset(read_buf, 0, sizeof(read_buf));
6494   called = false;
6495   boost::asio::async_read_at(s, 0, buffers,
6496       boost::asio::transfer_exactly(42),
6497       bindns::bind(async_read_handler,
6498         _1, _2, 42, &called));
6499   ioc.restart();
6500   ioc.run();
6501   BOOST_ASIO_CHECK(called);
6502   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
6503
6504   s.reset(read_data, sizeof(read_data));
6505   memset(read_buf, 0, sizeof(read_buf));
6506   called = false;
6507   boost::asio::async_read_at(s, 1234, buffers,
6508       boost::asio::transfer_exactly(42),
6509       bindns::bind(async_read_handler,
6510         _1, _2, 42, &called));
6511   ioc.restart();
6512   ioc.run();
6513   BOOST_ASIO_CHECK(called);
6514   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6515
6516   s.reset(read_data, sizeof(read_data));
6517   s.next_read_length(1);
6518   memset(read_buf, 0, sizeof(read_buf));
6519   called = false;
6520   boost::asio::async_read_at(s, 0, buffers,
6521       boost::asio::transfer_exactly(42),
6522       bindns::bind(async_read_handler,
6523         _1, _2, 42, &called));
6524   ioc.restart();
6525   ioc.run();
6526   BOOST_ASIO_CHECK(called);
6527   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
6528
6529   s.reset(read_data, sizeof(read_data));
6530   s.next_read_length(1);
6531   memset(read_buf, 0, sizeof(read_buf));
6532   called = false;
6533   boost::asio::async_read_at(s, 1234, buffers,
6534       boost::asio::transfer_exactly(42),
6535       bindns::bind(async_read_handler,
6536         _1, _2, 42, &called));
6537   ioc.restart();
6538   ioc.run();
6539   BOOST_ASIO_CHECK(called);
6540   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6541
6542   s.reset(read_data, sizeof(read_data));
6543   s.next_read_length(10);
6544   memset(read_buf, 0, sizeof(read_buf));
6545   called = false;
6546   boost::asio::async_read_at(s, 0, buffers,
6547       boost::asio::transfer_exactly(42),
6548       bindns::bind(async_read_handler,
6549         _1, _2, 42, &called));
6550   ioc.restart();
6551   ioc.run();
6552   BOOST_ASIO_CHECK(called);
6553   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
6554
6555   s.reset(read_data, sizeof(read_data));
6556   s.next_read_length(10);
6557   memset(read_buf, 0, sizeof(read_buf));
6558   called = false;
6559   boost::asio::async_read_at(s, 1234, buffers,
6560       boost::asio::transfer_exactly(42),
6561       bindns::bind(async_read_handler,
6562         _1, _2, 42, &called));
6563   ioc.restart();
6564   ioc.run();
6565   BOOST_ASIO_CHECK(called);
6566   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6567
6568   s.reset(read_data, sizeof(read_data));
6569   memset(read_buf, 0, sizeof(read_buf));
6570   called = false;
6571   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
6572       bindns::bind(async_read_handler,
6573         _1, _2, sizeof(read_data), &called));
6574   ioc.restart();
6575   ioc.run();
6576   BOOST_ASIO_CHECK(called);
6577   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6578
6579   s.reset(read_data, sizeof(read_data));
6580   memset(read_buf, 0, sizeof(read_buf));
6581   called = false;
6582   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
6583       bindns::bind(async_read_handler,
6584         _1, _2, sizeof(read_data), &called));
6585   ioc.restart();
6586   ioc.run();
6587   BOOST_ASIO_CHECK(called);
6588   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6589
6590   s.reset(read_data, sizeof(read_data));
6591   s.next_read_length(1);
6592   memset(read_buf, 0, sizeof(read_buf));
6593   called = false;
6594   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
6595       bindns::bind(async_read_handler,
6596         _1, _2, sizeof(read_data), &called));
6597   ioc.restart();
6598   ioc.run();
6599   BOOST_ASIO_CHECK(called);
6600   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6601
6602   s.reset(read_data, sizeof(read_data));
6603   s.next_read_length(1);
6604   memset(read_buf, 0, sizeof(read_buf));
6605   called = false;
6606   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
6607       bindns::bind(async_read_handler,
6608         _1, _2, sizeof(read_data), &called));
6609   ioc.restart();
6610   ioc.run();
6611   BOOST_ASIO_CHECK(called);
6612   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6613
6614   s.reset(read_data, sizeof(read_data));
6615   s.next_read_length(10);
6616   memset(read_buf, 0, sizeof(read_buf));
6617   called = false;
6618   boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
6619       bindns::bind(async_read_handler,
6620         _1, _2, sizeof(read_data), &called));
6621   ioc.restart();
6622   ioc.run();
6623   BOOST_ASIO_CHECK(called);
6624   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6625
6626   s.reset(read_data, sizeof(read_data));
6627   s.next_read_length(10);
6628   memset(read_buf, 0, sizeof(read_buf));
6629   called = false;
6630   boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
6631       bindns::bind(async_read_handler,
6632         _1, _2, sizeof(read_data), &called));
6633   ioc.restart();
6634   ioc.run();
6635   BOOST_ASIO_CHECK(called);
6636   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6637
6638   s.reset(read_data, sizeof(read_data));
6639   memset(read_buf, 0, sizeof(read_buf));
6640   called = false;
6641   boost::asio::async_read_at(s, 0, buffers, short_transfer,
6642       bindns::bind(async_read_handler,
6643         _1, _2, sizeof(read_data), &called));
6644   ioc.restart();
6645   ioc.run();
6646   BOOST_ASIO_CHECK(called);
6647   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6648
6649   s.reset(read_data, sizeof(read_data));
6650   memset(read_buf, 0, sizeof(read_buf));
6651   called = false;
6652   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
6653       bindns::bind(async_read_handler,
6654         _1, _2, sizeof(read_data), &called));
6655   ioc.restart();
6656   ioc.run();
6657   BOOST_ASIO_CHECK(called);
6658   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6659
6660   s.reset(read_data, sizeof(read_data));
6661   s.next_read_length(1);
6662   memset(read_buf, 0, sizeof(read_buf));
6663   called = false;
6664   boost::asio::async_read_at(s, 0, buffers, short_transfer,
6665       bindns::bind(async_read_handler,
6666         _1, _2, sizeof(read_data), &called));
6667   ioc.restart();
6668   ioc.run();
6669   BOOST_ASIO_CHECK(called);
6670   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6671
6672   s.reset(read_data, sizeof(read_data));
6673   s.next_read_length(1);
6674   memset(read_buf, 0, sizeof(read_buf));
6675   called = false;
6676   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
6677       bindns::bind(async_read_handler,
6678         _1, _2, sizeof(read_data), &called));
6679   ioc.restart();
6680   ioc.run();
6681   BOOST_ASIO_CHECK(called);
6682   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6683
6684   s.reset(read_data, sizeof(read_data));
6685   s.next_read_length(10);
6686   memset(read_buf, 0, sizeof(read_buf));
6687   called = false;
6688   boost::asio::async_read_at(s, 0, buffers, short_transfer,
6689       bindns::bind(async_read_handler,
6690         _1, _2, sizeof(read_data), &called));
6691   ioc.restart();
6692   ioc.run();
6693   BOOST_ASIO_CHECK(called);
6694   BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6695
6696   s.reset(read_data, sizeof(read_data));
6697   s.next_read_length(10);
6698   memset(read_buf, 0, sizeof(read_buf));
6699   called = false;
6700   boost::asio::async_read_at(s, 1234, buffers, short_transfer,
6701       bindns::bind(async_read_handler,
6702         _1, _2, sizeof(read_data), &called));
6703   ioc.restart();
6704   ioc.run();
6705   BOOST_ASIO_CHECK(called);
6706   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6707
6708   s.reset(read_data, sizeof(read_data));
6709   memset(read_buf, 0, sizeof(read_buf));
6710   int i = boost::asio::async_read_at(s, 1234, buffers,
6711       short_transfer, archetypes::lazy_handler());
6712   BOOST_ASIO_CHECK(i == 42);
6713   ioc.restart();
6714   ioc.run();
6715   BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6716 }
6717
6718 void test_5_arg_streambuf_async_read_at()
6719 {
6720 #if defined(BOOST_ASIO_HAS_BOOST_BIND)
6721   namespace bindns = boost;
6722 #else // defined(BOOST_ASIO_HAS_BOOST_BIND)
6723   namespace bindns = std;
6724   using std::placeholders::_1;
6725   using std::placeholders::_2;
6726 #endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
6727
6728   boost::asio::io_context ioc;
6729   test_random_access_device s(ioc);
6730   boost::asio::streambuf sb(sizeof(read_data));
6731
6732   s.reset(read_data, sizeof(read_data));
6733   sb.consume(sb.size());
6734   bool called = false;
6735   boost::asio::async_read_at(s, 0, sb,
6736       boost::asio::transfer_all(),
6737       bindns::bind(async_read_handler,
6738         _1, _2, sizeof(read_data), &called));
6739   ioc.restart();
6740   ioc.run();
6741   BOOST_ASIO_CHECK(called);
6742   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6743   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6744
6745   s.reset(read_data, sizeof(read_data));
6746   sb.consume(sb.size());
6747   called = false;
6748   boost::asio::async_read_at(s, 1234, sb,
6749       boost::asio::transfer_all(),
6750       bindns::bind(async_read_handler,
6751         _1, _2, sizeof(read_data), &called));
6752   ioc.restart();
6753   ioc.run();
6754   BOOST_ASIO_CHECK(called);
6755   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6756   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6757
6758   s.reset(read_data, sizeof(read_data));
6759   s.next_read_length(1);
6760   sb.consume(sb.size());
6761   called = false;
6762   boost::asio::async_read_at(s, 0, sb,
6763       boost::asio::transfer_all(),
6764       bindns::bind(async_read_handler,
6765         _1, _2, sizeof(read_data), &called));
6766   ioc.restart();
6767   ioc.run();
6768   BOOST_ASIO_CHECK(called);
6769   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6770   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6771
6772   s.reset(read_data, sizeof(read_data));
6773   s.next_read_length(1);
6774   sb.consume(sb.size());
6775   called = false;
6776   boost::asio::async_read_at(s, 1234, sb,
6777       boost::asio::transfer_all(),
6778       bindns::bind(async_read_handler,
6779         _1, _2, sizeof(read_data), &called));
6780   ioc.restart();
6781   ioc.run();
6782   BOOST_ASIO_CHECK(called);
6783   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6784   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6785
6786   s.reset(read_data, sizeof(read_data));
6787   s.next_read_length(10);
6788   sb.consume(sb.size());
6789   called = false;
6790   boost::asio::async_read_at(s, 0, sb,
6791       boost::asio::transfer_all(),
6792       bindns::bind(async_read_handler,
6793         _1, _2, sizeof(read_data), &called));
6794   ioc.restart();
6795   ioc.run();
6796   BOOST_ASIO_CHECK(called);
6797   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6798   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6799
6800   s.reset(read_data, sizeof(read_data));
6801   s.next_read_length(10);
6802   sb.consume(sb.size());
6803   called = false;
6804   boost::asio::async_read_at(s, 1234, sb,
6805       boost::asio::transfer_all(),
6806       bindns::bind(async_read_handler,
6807         _1, _2, sizeof(read_data), &called));
6808   ioc.restart();
6809   ioc.run();
6810   BOOST_ASIO_CHECK(called);
6811   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6812   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6813
6814   s.reset(read_data, sizeof(read_data));
6815   sb.consume(sb.size());
6816   called = false;
6817   boost::asio::async_read_at(s, 0, sb,
6818       boost::asio::transfer_at_least(1),
6819       bindns::bind(async_read_handler,
6820         _1, _2, sizeof(read_data), &called));
6821   ioc.restart();
6822   ioc.run();
6823   BOOST_ASIO_CHECK(called);
6824   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6825   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6826
6827   s.reset(read_data, sizeof(read_data));
6828   sb.consume(sb.size());
6829   called = false;
6830   boost::asio::async_read_at(s, 1234, sb,
6831       boost::asio::transfer_at_least(1),
6832       bindns::bind(async_read_handler,
6833         _1, _2, sizeof(read_data), &called));
6834   ioc.restart();
6835   ioc.run();
6836   BOOST_ASIO_CHECK(called);
6837   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6838   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6839
6840   s.reset(read_data, sizeof(read_data));
6841   s.next_read_length(1);
6842   sb.consume(sb.size());
6843   called = false;
6844   boost::asio::async_read_at(s, 0, sb,
6845       boost::asio::transfer_at_least(1),
6846       bindns::bind(async_read_handler,
6847         _1, _2, 1, &called));
6848   ioc.restart();
6849   ioc.run();
6850   BOOST_ASIO_CHECK(called);
6851   BOOST_ASIO_CHECK(sb.size() == 1);
6852   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
6853
6854   s.reset(read_data, sizeof(read_data));
6855   s.next_read_length(1);
6856   sb.consume(sb.size());
6857   called = false;
6858   boost::asio::async_read_at(s, 1234, sb,
6859       boost::asio::transfer_at_least(1),
6860       bindns::bind(async_read_handler,
6861         _1, _2, 1, &called));
6862   ioc.restart();
6863   ioc.run();
6864   BOOST_ASIO_CHECK(called);
6865   BOOST_ASIO_CHECK(sb.size() == 1);
6866   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
6867
6868   s.reset(read_data, sizeof(read_data));
6869   s.next_read_length(10);
6870   sb.consume(sb.size());
6871   called = false;
6872   boost::asio::async_read_at(s, 0, sb,
6873       boost::asio::transfer_at_least(1),
6874       bindns::bind(async_read_handler,
6875         _1, _2, 10, &called));
6876   ioc.restart();
6877   ioc.run();
6878   BOOST_ASIO_CHECK(called);
6879   BOOST_ASIO_CHECK(sb.size() == 10);
6880   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
6881
6882   s.reset(read_data, sizeof(read_data));
6883   s.next_read_length(10);
6884   sb.consume(sb.size());
6885   called = false;
6886   boost::asio::async_read_at(s, 1234, sb,
6887       boost::asio::transfer_at_least(1),
6888       bindns::bind(async_read_handler,
6889         _1, _2, 10, &called));
6890   ioc.restart();
6891   ioc.run();
6892   BOOST_ASIO_CHECK(called);
6893   BOOST_ASIO_CHECK(sb.size() == 10);
6894   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
6895
6896   s.reset(read_data, sizeof(read_data));
6897   sb.consume(sb.size());
6898   called = false;
6899   boost::asio::async_read_at(s, 0, sb,
6900       boost::asio::transfer_at_least(10),
6901       bindns::bind(async_read_handler,
6902         _1, _2, sizeof(read_data), &called));
6903   ioc.restart();
6904   ioc.run();
6905   BOOST_ASIO_CHECK(called);
6906   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6907   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6908
6909   s.reset(read_data, sizeof(read_data));
6910   sb.consume(sb.size());
6911   called = false;
6912   boost::asio::async_read_at(s, 1234, sb,
6913       boost::asio::transfer_at_least(10),
6914       bindns::bind(async_read_handler,
6915         _1, _2, sizeof(read_data), &called));
6916   ioc.restart();
6917   ioc.run();
6918   BOOST_ASIO_CHECK(called);
6919   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6920   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6921
6922   s.reset(read_data, sizeof(read_data));
6923   s.next_read_length(1);
6924   sb.consume(sb.size());
6925   called = false;
6926   boost::asio::async_read_at(s, 0, sb,
6927       boost::asio::transfer_at_least(10),
6928       bindns::bind(async_read_handler,
6929         _1, _2, 10, &called));
6930   ioc.restart();
6931   ioc.run();
6932   BOOST_ASIO_CHECK(called);
6933   BOOST_ASIO_CHECK(sb.size() == 10);
6934   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
6935
6936   s.reset(read_data, sizeof(read_data));
6937   s.next_read_length(1);
6938   sb.consume(sb.size());
6939   called = false;
6940   boost::asio::async_read_at(s, 1234, sb,
6941       boost::asio::transfer_at_least(10),
6942       bindns::bind(async_read_handler,
6943         _1, _2, 10, &called));
6944   ioc.restart();
6945   ioc.run();
6946   BOOST_ASIO_CHECK(called);
6947   BOOST_ASIO_CHECK(sb.size() == 10);
6948   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
6949
6950   s.reset(read_data, sizeof(read_data));
6951   s.next_read_length(10);
6952   sb.consume(sb.size());
6953   called = false;
6954   boost::asio::async_read_at(s, 0, sb,
6955       boost::asio::transfer_at_least(10),
6956       bindns::bind(async_read_handler,
6957         _1, _2, 10, &called));
6958   ioc.restart();
6959   ioc.run();
6960   BOOST_ASIO_CHECK(called);
6961   BOOST_ASIO_CHECK(sb.size() == 10);
6962   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
6963
6964   s.reset(read_data, sizeof(read_data));
6965   s.next_read_length(10);
6966   sb.consume(sb.size());
6967   called = false;
6968   boost::asio::async_read_at(s, 1234, sb,
6969       boost::asio::transfer_at_least(10),
6970       bindns::bind(async_read_handler,
6971         _1, _2, 10, &called));
6972   ioc.restart();
6973   ioc.run();
6974   BOOST_ASIO_CHECK(called);
6975   BOOST_ASIO_CHECK(sb.size() == 10);
6976   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
6977
6978   s.reset(read_data, sizeof(read_data));
6979   sb.consume(sb.size());
6980   called = false;
6981   boost::asio::async_read_at(s, 0, sb,
6982       boost::asio::transfer_at_least(42),
6983       bindns::bind(async_read_handler,
6984         _1, _2, sizeof(read_data), &called));
6985   ioc.restart();
6986   ioc.run();
6987   BOOST_ASIO_CHECK(called);
6988   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
6989   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6990
6991   s.reset(read_data, sizeof(read_data));
6992   sb.consume(sb.size());
6993   called = false;
6994   boost::asio::async_read_at(s, 1234, sb,
6995       boost::asio::transfer_at_least(42),
6996       bindns::bind(async_read_handler,
6997         _1, _2, sizeof(read_data), &called));
6998   ioc.restart();
6999   ioc.run();
7000   BOOST_ASIO_CHECK(called);
7001   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7002   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7003
7004   s.reset(read_data, sizeof(read_data));
7005   s.next_read_length(1);
7006   sb.consume(sb.size());
7007   called = false;
7008   boost::asio::async_read_at(s, 0, sb,
7009       boost::asio::transfer_at_least(42),
7010       bindns::bind(async_read_handler,
7011         _1, _2, 42, &called));
7012   ioc.restart();
7013   ioc.run();
7014   BOOST_ASIO_CHECK(called);
7015   BOOST_ASIO_CHECK(sb.size() == 42);
7016   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7017
7018   s.reset(read_data, sizeof(read_data));
7019   s.next_read_length(1);
7020   sb.consume(sb.size());
7021   called = false;
7022   boost::asio::async_read_at(s, 1234, sb,
7023       boost::asio::transfer_at_least(42),
7024       bindns::bind(async_read_handler,
7025         _1, _2, 42, &called));
7026   ioc.restart();
7027   ioc.run();
7028   BOOST_ASIO_CHECK(called);
7029   BOOST_ASIO_CHECK(sb.size() == 42);
7030   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7031
7032   s.reset(read_data, sizeof(read_data));
7033   s.next_read_length(10);
7034   sb.consume(sb.size());
7035   called = false;
7036   boost::asio::async_read_at(s, 0, sb,
7037       boost::asio::transfer_at_least(42),
7038       bindns::bind(async_read_handler,
7039         _1, _2, 50, &called));
7040   ioc.restart();
7041   ioc.run();
7042   BOOST_ASIO_CHECK(called);
7043   BOOST_ASIO_CHECK(sb.size() == 50);
7044   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
7045
7046   s.reset(read_data, sizeof(read_data));
7047   s.next_read_length(10);
7048   sb.consume(sb.size());
7049   called = false;
7050   boost::asio::async_read_at(s, 1234, sb,
7051       boost::asio::transfer_at_least(42),
7052       bindns::bind(async_read_handler,
7053         _1, _2, 50, &called));
7054   ioc.restart();
7055   ioc.run();
7056   BOOST_ASIO_CHECK(called);
7057   BOOST_ASIO_CHECK(sb.size() == 50);
7058   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
7059
7060   s.reset(read_data, sizeof(read_data));
7061   sb.consume(sb.size());
7062   called = false;
7063   boost::asio::async_read_at(s, 0, sb,
7064       boost::asio::transfer_exactly(1),
7065       bindns::bind(async_read_handler,
7066         _1, _2, 1, &called));
7067   ioc.restart();
7068   ioc.run();
7069   BOOST_ASIO_CHECK(called);
7070   BOOST_ASIO_CHECK(sb.size() == 1);
7071   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
7072
7073   s.reset(read_data, sizeof(read_data));
7074   sb.consume(sb.size());
7075   called = false;
7076   boost::asio::async_read_at(s, 1234, sb,
7077       boost::asio::transfer_exactly(1),
7078       bindns::bind(async_read_handler,
7079         _1, _2, 1, &called));
7080   ioc.restart();
7081   ioc.run();
7082   BOOST_ASIO_CHECK(called);
7083   BOOST_ASIO_CHECK(sb.size() == 1);
7084   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
7085
7086   s.reset(read_data, sizeof(read_data));
7087   s.next_read_length(1);
7088   sb.consume(sb.size());
7089   called = false;
7090   boost::asio::async_read_at(s, 0, sb,
7091       boost::asio::transfer_exactly(1),
7092       bindns::bind(async_read_handler,
7093         _1, _2, 1, &called));
7094   ioc.restart();
7095   ioc.run();
7096   BOOST_ASIO_CHECK(called);
7097   BOOST_ASIO_CHECK(sb.size() == 1);
7098   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
7099
7100   s.reset(read_data, sizeof(read_data));
7101   s.next_read_length(1);
7102   sb.consume(sb.size());
7103   called = false;
7104   boost::asio::async_read_at(s, 1234, sb,
7105       boost::asio::transfer_exactly(1),
7106       bindns::bind(async_read_handler,
7107         _1, _2, 1, &called));
7108   ioc.restart();
7109   ioc.run();
7110   BOOST_ASIO_CHECK(called);
7111   BOOST_ASIO_CHECK(sb.size() == 1);
7112   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
7113
7114   s.reset(read_data, sizeof(read_data));
7115   s.next_read_length(10);
7116   sb.consume(sb.size());
7117   called = false;
7118   boost::asio::async_read_at(s, 0, sb,
7119       boost::asio::transfer_exactly(1),
7120       bindns::bind(async_read_handler,
7121         _1, _2, 1, &called));
7122   ioc.restart();
7123   ioc.run();
7124   BOOST_ASIO_CHECK(called);
7125   BOOST_ASIO_CHECK(sb.size() == 1);
7126   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
7127
7128   s.reset(read_data, sizeof(read_data));
7129   s.next_read_length(10);
7130   sb.consume(sb.size());
7131   called = false;
7132   boost::asio::async_read_at(s, 1234, sb,
7133       boost::asio::transfer_exactly(1),
7134       bindns::bind(async_read_handler,
7135         _1, _2, 1, &called));
7136   ioc.restart();
7137   ioc.run();
7138   BOOST_ASIO_CHECK(called);
7139   BOOST_ASIO_CHECK(sb.size() == 1);
7140   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
7141
7142   s.reset(read_data, sizeof(read_data));
7143   sb.consume(sb.size());
7144   called = false;
7145   boost::asio::async_read_at(s, 0, sb,
7146       boost::asio::transfer_exactly(10),
7147       bindns::bind(async_read_handler,
7148         _1, _2, 10, &called));
7149   ioc.restart();
7150   ioc.run();
7151   BOOST_ASIO_CHECK(called);
7152   BOOST_ASIO_CHECK(sb.size() == 10);
7153   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
7154
7155   s.reset(read_data, sizeof(read_data));
7156   sb.consume(sb.size());
7157   called = false;
7158   boost::asio::async_read_at(s, 1234, sb,
7159       boost::asio::transfer_exactly(10),
7160       bindns::bind(async_read_handler,
7161         _1, _2, 10, &called));
7162   ioc.restart();
7163   ioc.run();
7164   BOOST_ASIO_CHECK(called);
7165   BOOST_ASIO_CHECK(sb.size() == 10);
7166   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
7167
7168   s.reset(read_data, sizeof(read_data));
7169   s.next_read_length(1);
7170   sb.consume(sb.size());
7171   called = false;
7172   boost::asio::async_read_at(s, 0, sb,
7173       boost::asio::transfer_exactly(10),
7174       bindns::bind(async_read_handler,
7175         _1, _2, 10, &called));
7176   ioc.restart();
7177   ioc.run();
7178   BOOST_ASIO_CHECK(called);
7179   BOOST_ASIO_CHECK(sb.size() == 10);
7180   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
7181
7182   s.reset(read_data, sizeof(read_data));
7183   s.next_read_length(1);
7184   sb.consume(sb.size());
7185   called = false;
7186   boost::asio::async_read_at(s, 1234, sb,
7187       boost::asio::transfer_exactly(10),
7188       bindns::bind(async_read_handler,
7189         _1, _2, 10, &called));
7190   ioc.restart();
7191   ioc.run();
7192   BOOST_ASIO_CHECK(called);
7193   BOOST_ASIO_CHECK(sb.size() == 10);
7194   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
7195
7196   s.reset(read_data, sizeof(read_data));
7197   s.next_read_length(10);
7198   sb.consume(sb.size());
7199   called = false;
7200   boost::asio::async_read_at(s, 0, sb,
7201       boost::asio::transfer_exactly(10),
7202       bindns::bind(async_read_handler,
7203         _1, _2, 10, &called));
7204   ioc.restart();
7205   ioc.run();
7206   BOOST_ASIO_CHECK(called);
7207   BOOST_ASIO_CHECK(sb.size() == 10);
7208   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
7209
7210   s.reset(read_data, sizeof(read_data));
7211   s.next_read_length(10);
7212   sb.consume(sb.size());
7213   called = false;
7214   boost::asio::async_read_at(s, 1234, sb,
7215       boost::asio::transfer_exactly(10),
7216       bindns::bind(async_read_handler,
7217         _1, _2, 10, &called));
7218   ioc.restart();
7219   ioc.run();
7220   BOOST_ASIO_CHECK(called);
7221   BOOST_ASIO_CHECK(sb.size() == 10);
7222   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
7223
7224   s.reset(read_data, sizeof(read_data));
7225   sb.consume(sb.size());
7226   called = false;
7227   boost::asio::async_read_at(s, 0, sb,
7228       boost::asio::transfer_exactly(42),
7229       bindns::bind(async_read_handler,
7230         _1, _2, 42, &called));
7231   ioc.restart();
7232   ioc.run();
7233   BOOST_ASIO_CHECK(called);
7234   BOOST_ASIO_CHECK(sb.size() == 42);
7235   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7236
7237   s.reset(read_data, sizeof(read_data));
7238   sb.consume(sb.size());
7239   called = false;
7240   boost::asio::async_read_at(s, 1234, sb,
7241       boost::asio::transfer_exactly(42),
7242       bindns::bind(async_read_handler,
7243         _1, _2, 42, &called));
7244   ioc.restart();
7245   ioc.run();
7246   BOOST_ASIO_CHECK(called);
7247   BOOST_ASIO_CHECK(sb.size() == 42);
7248   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7249
7250   s.reset(read_data, sizeof(read_data));
7251   s.next_read_length(1);
7252   sb.consume(sb.size());
7253   called = false;
7254   boost::asio::async_read_at(s, 0, sb,
7255       boost::asio::transfer_exactly(42),
7256       bindns::bind(async_read_handler,
7257         _1, _2, 42, &called));
7258   ioc.restart();
7259   ioc.run();
7260   BOOST_ASIO_CHECK(called);
7261   BOOST_ASIO_CHECK(sb.size() == 42);
7262   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7263
7264   s.reset(read_data, sizeof(read_data));
7265   s.next_read_length(1);
7266   sb.consume(sb.size());
7267   called = false;
7268   boost::asio::async_read_at(s, 1234, sb,
7269       boost::asio::transfer_exactly(42),
7270       bindns::bind(async_read_handler,
7271         _1, _2, 42, &called));
7272   ioc.restart();
7273   ioc.run();
7274   BOOST_ASIO_CHECK(called);
7275   BOOST_ASIO_CHECK(sb.size() == 42);
7276   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7277
7278   s.reset(read_data, sizeof(read_data));
7279   s.next_read_length(10);
7280   sb.consume(sb.size());
7281   called = false;
7282   boost::asio::async_read_at(s, 0, sb,
7283       boost::asio::transfer_exactly(42),
7284       bindns::bind(async_read_handler,
7285         _1, _2, 42, &called));
7286   ioc.restart();
7287   ioc.run();
7288   BOOST_ASIO_CHECK(called);
7289   BOOST_ASIO_CHECK(sb.size() == 42);
7290   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7291
7292   s.reset(read_data, sizeof(read_data));
7293   s.next_read_length(10);
7294   sb.consume(sb.size());
7295   called = false;
7296   boost::asio::async_read_at(s, 1234, sb,
7297       boost::asio::transfer_exactly(42),
7298       bindns::bind(async_read_handler,
7299         _1, _2, 42, &called));
7300   ioc.restart();
7301   ioc.run();
7302   BOOST_ASIO_CHECK(called);
7303   BOOST_ASIO_CHECK(sb.size() == 42);
7304   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7305
7306   s.reset(read_data, sizeof(read_data));
7307   sb.consume(sb.size());
7308   called = false;
7309   boost::asio::async_read_at(s, 0, sb, old_style_transfer_all,
7310       bindns::bind(async_read_handler,
7311         _1, _2, sizeof(read_data), &called));
7312   ioc.restart();
7313   ioc.run();
7314   BOOST_ASIO_CHECK(called);
7315   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7316   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7317
7318   s.reset(read_data, sizeof(read_data));
7319   sb.consume(sb.size());
7320   called = false;
7321   boost::asio::async_read_at(s, 1234, sb, old_style_transfer_all,
7322       bindns::bind(async_read_handler,
7323         _1, _2, sizeof(read_data), &called));
7324   ioc.restart();
7325   ioc.run();
7326   BOOST_ASIO_CHECK(called);
7327   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7328   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7329
7330   s.reset(read_data, sizeof(read_data));
7331   s.next_read_length(1);
7332   sb.consume(sb.size());
7333   called = false;
7334   boost::asio::async_read_at(s, 0, sb, old_style_transfer_all,
7335       bindns::bind(async_read_handler,
7336         _1, _2, sizeof(read_data), &called));
7337   ioc.restart();
7338   ioc.run();
7339   BOOST_ASIO_CHECK(called);
7340   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7341   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7342
7343   s.reset(read_data, sizeof(read_data));
7344   s.next_read_length(1);
7345   sb.consume(sb.size());
7346   called = false;
7347   boost::asio::async_read_at(s, 1234, sb, old_style_transfer_all,
7348       bindns::bind(async_read_handler,
7349         _1, _2, sizeof(read_data), &called));
7350   ioc.restart();
7351   ioc.run();
7352   BOOST_ASIO_CHECK(called);
7353   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7354   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7355
7356   s.reset(read_data, sizeof(read_data));
7357   s.next_read_length(10);
7358   sb.consume(sb.size());
7359   called = false;
7360   boost::asio::async_read_at(s, 0, sb, old_style_transfer_all,
7361       bindns::bind(async_read_handler,
7362         _1, _2, sizeof(read_data), &called));
7363   ioc.restart();
7364   ioc.run();
7365   BOOST_ASIO_CHECK(called);
7366   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7367   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7368
7369   s.reset(read_data, sizeof(read_data));
7370   s.next_read_length(10);
7371   sb.consume(sb.size());
7372   called = false;
7373   boost::asio::async_read_at(s, 1234, sb, old_style_transfer_all,
7374       bindns::bind(async_read_handler,
7375         _1, _2, sizeof(read_data), &called));
7376   ioc.restart();
7377   ioc.run();
7378   BOOST_ASIO_CHECK(called);
7379   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7380   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7381
7382   s.reset(read_data, sizeof(read_data));
7383   sb.consume(sb.size());
7384   called = false;
7385   boost::asio::async_read_at(s, 0, sb, short_transfer,
7386       bindns::bind(async_read_handler,
7387         _1, _2, sizeof(read_data), &called));
7388   ioc.restart();
7389   ioc.run();
7390   BOOST_ASIO_CHECK(called);
7391   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7392   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7393
7394   s.reset(read_data, sizeof(read_data));
7395   sb.consume(sb.size());
7396   called = false;
7397   boost::asio::async_read_at(s, 1234, sb, short_transfer,
7398       bindns::bind(async_read_handler,
7399         _1, _2, sizeof(read_data), &called));
7400   ioc.restart();
7401   ioc.run();
7402   BOOST_ASIO_CHECK(called);
7403   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7404   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7405
7406   s.reset(read_data, sizeof(read_data));
7407   s.next_read_length(1);
7408   sb.consume(sb.size());
7409   called = false;
7410   boost::asio::async_read_at(s, 0, sb, short_transfer,
7411       bindns::bind(async_read_handler,
7412         _1, _2, sizeof(read_data), &called));
7413   ioc.restart();
7414   ioc.run();
7415   BOOST_ASIO_CHECK(called);
7416   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7417   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7418
7419   s.reset(read_data, sizeof(read_data));
7420   s.next_read_length(1);
7421   sb.consume(sb.size());
7422   called = false;
7423   boost::asio::async_read_at(s, 1234, sb, short_transfer,
7424       bindns::bind(async_read_handler,
7425         _1, _2, sizeof(read_data), &called));
7426   ioc.restart();
7427   ioc.run();
7428   BOOST_ASIO_CHECK(called);
7429   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7430   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7431
7432   s.reset(read_data, sizeof(read_data));
7433   s.next_read_length(10);
7434   sb.consume(sb.size());
7435   called = false;
7436   boost::asio::async_read_at(s, 0, sb, short_transfer,
7437       bindns::bind(async_read_handler,
7438         _1, _2, sizeof(read_data), &called));
7439   ioc.restart();
7440   ioc.run();
7441   BOOST_ASIO_CHECK(called);
7442   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7443   BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7444
7445   s.reset(read_data, sizeof(read_data));
7446   s.next_read_length(10);
7447   sb.consume(sb.size());
7448   called = false;
7449   boost::asio::async_read_at(s, 1234, sb, short_transfer,
7450       bindns::bind(async_read_handler,
7451         _1, _2, sizeof(read_data), &called));
7452   ioc.restart();
7453   ioc.run();
7454   BOOST_ASIO_CHECK(called);
7455   BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
7456   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7457
7458   s.reset(read_data, sizeof(read_data));
7459   sb.consume(sb.size());
7460   int i = boost::asio::async_read_at(s, 1234, sb,
7461       short_transfer, archetypes::lazy_handler());
7462   BOOST_ASIO_CHECK(i == 42);
7463   ioc.restart();
7464   ioc.run();
7465   BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7466 }
7467
7468 BOOST_ASIO_TEST_SUITE
7469 (
7470   "read_at",
7471   BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_read_at)
7472   BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_read_at)
7473   BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_read_at)
7474   BOOST_ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffer_read_at)
7475   BOOST_ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_read_at)
7476   BOOST_ASIO_TEST_CASE(test_4_arg_nothrow_streambuf_read_at)
7477   BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_read_at)
7478   BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_read_at)
7479   BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_read_at)
7480   BOOST_ASIO_TEST_CASE(test_5_arg_mutable_buffer_read_at)
7481   BOOST_ASIO_TEST_CASE(test_5_arg_vector_buffers_read_at)
7482   BOOST_ASIO_TEST_CASE(test_5_arg_streambuf_read_at)
7483   BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read_at)
7484   BOOST_ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read_at)
7485   BOOST_ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read_at)
7486   BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read_at)
7487   BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_async_read_at)
7488   BOOST_ASIO_TEST_CASE(test_5_arg_mutable_buffer_async_read_at)
7489   BOOST_ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_read_at)
7490   BOOST_ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_read_at)
7491   BOOST_ASIO_TEST_CASE(test_5_arg_vector_buffers_async_read_at)
7492   BOOST_ASIO_TEST_CASE(test_5_arg_streambuf_async_read_at)
7493 )