libs/asio/test/write.cpp

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