[Boost-commit] svn:boost r60717 - trunk/libs/asio/test

Subject: [Boost-commit] svn:boost r60717 - trunk/libs/asio/test
From: chris_at_[hidden]
Date: 2010-03-19 19:23:29

Author: chris_kohlhoff
Date: 2010-03-19 19:23:28 EDT (Fri, 19 Mar 2010)
New Revision: 60717
URL: http://svn.boost.org/trac/boost/changeset/60717

Log:
More extensive read and write tests.

Text files modified: 
   trunk/libs/asio/test/read.cpp  |  1748 +++++++++++++++++++++++++++++++++++---- 
   trunk/libs/asio/test/write.cpp |  1242 +++++++++++++++++++++++++++             
   2 files changed, 2778 insertions(+), 212 deletions(-)

Modified: trunk/libs/asio/test/read.cpp
==============================================================================
--- trunk/libs/asio/test/read.cpp	(original)
+++ trunk/libs/asio/test/read.cpp	2010-03-19 19:23:28 EDT (Fri, 19 Mar 2010)
@@ -21,6 +21,7 @@
 #include <cstring>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/placeholders.hpp>
+#include <boost/asio/streambuf.hpp>
 #include "unit_test.hpp"
 
 using namespace std; // For memcmp, memcpy and memset.
@@ -134,7 +135,7 @@
 static const char read_data[]
   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
-void test_2_arg_read()
+void test_2_arg_mutable_buffers_1_read()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
@@ -163,6 +164,66 @@
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
 }
 
+void test_2_arg_multi_buffers_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::array<boost::asio::mutable_buffer, 2> buffers = { {
+    boost::asio::buffer(read_buf, 32),
+    boost::asio::buffer(read_buf) + 32 } };
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  size_t bytes_transferred = boost::asio::read(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+}
+
+void test_2_arg_streambuf_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::streambuf sb(sizeof(read_data));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  size_t bytes_transferred = boost::asio::read(s, sb);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+}
+
 bool old_style_transfer_all(const boost::system::error_code& ec,
     size_t /*bytes_transferred*/)
 {
@@ -175,7 +236,7 @@
   return !!ec ? 0 : 3;
 }
 
-void test_3_arg_read()
+void test_3_arg_mutable_buffers_1_read()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
@@ -316,336 +377,1366 @@
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
 }
 
-void test_4_arg_read()
+void test_3_arg_multi_buffers_read()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
   char read_buf[sizeof(read_data)];
-  boost::asio::mutable_buffers_1 buffers
-    = boost::asio::buffer(read_buf, sizeof(read_buf));
+  boost::array<boost::asio::mutable_buffer, 2> buffers = { {
+    boost::asio::buffer(read_buf, 32),
+    boost::asio::buffer(read_buf) + 32 } };
 
   s.reset(read_data, sizeof(read_data));
   memset(read_buf, 0, sizeof(read_buf));
-  boost::system::error_code error;
   size_t bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_all(), error);
+      boost::asio::transfer_all());
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_all(), error);
+      boost::asio::transfer_all());
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_all(), error);
+      boost::asio::transfer_all());
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(1), error);
+      boost::asio::transfer_at_least(1));
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(1), error);
+      boost::asio::transfer_at_least(1));
   BOOST_CHECK(bytes_transferred == 1);
   BOOST_CHECK(s.check(buffers, 1));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(1), error);
+      boost::asio::transfer_at_least(1));
   BOOST_CHECK(bytes_transferred == 10);
   BOOST_CHECK(s.check(buffers, 10));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(10), error);
+      boost::asio::transfer_at_least(10));
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(10), error);
+      boost::asio::transfer_at_least(10));
   BOOST_CHECK(bytes_transferred == 10);
   BOOST_CHECK(s.check(buffers, 10));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(10), error);
+      boost::asio::transfer_at_least(10));
   BOOST_CHECK(bytes_transferred == 10);
   BOOST_CHECK(s.check(buffers, 10));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(42), error);
+      boost::asio::transfer_at_least(42));
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(42), error);
+      boost::asio::transfer_at_least(42));
   BOOST_CHECK(bytes_transferred == 42);
   BOOST_CHECK(s.check(buffers, 42));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
   bytes_transferred = boost::asio::read(s, buffers,
-      boost::asio::transfer_at_least(42), error);
+      boost::asio::transfer_at_least(42));
   BOOST_CHECK(bytes_transferred == 50);
   BOOST_CHECK(s.check(buffers, 50));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = boost::asio::read(s, buffers,
-      old_style_transfer_all, error);
+  bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
-  bytes_transferred = boost::asio::read(s, buffers,
-      old_style_transfer_all, error);
+  bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
-  bytes_transferred = boost::asio::read(s, buffers,
-      old_style_transfer_all, error);
+  bytes_transferred = boost::asio::read(s, buffers, old_style_transfer_all);
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer);
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
-  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer);
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
   memset(read_buf, 0, sizeof(read_buf));
-  error = boost::system::error_code();
-  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer);
   BOOST_CHECK(bytes_transferred == sizeof(read_data));
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-  BOOST_CHECK(!error);
-}
-
-void async_read_handler(const boost::system::error_code& e,
-    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
-{
-  *called = true;
-  BOOST_CHECK(!e);
-  BOOST_CHECK(bytes_transferred == expected_bytes_transferred);
 }
 
-void test_3_arg_async_read()
+void test_3_arg_streambuf_read()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
-  char read_buf[sizeof(read_data)];
-  boost::asio::mutable_buffers_1 buffers
-    = boost::asio::buffer(read_buf, sizeof(read_buf));
+  boost::asio::streambuf sb(sizeof(read_data));
 
   s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  boost::asio::async_read(s, buffers,
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  sb.consume(sb.size());
+  size_t bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers,
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers,
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
-}
-
-void test_4_arg_async_read()
-{
-  boost::asio::io_service ios;
-  test_stream s(ios);
-  char read_buf[sizeof(read_data)];
-  boost::asio::mutable_buffers_1 buffers
-    = boost::asio::buffer(read_buf, sizeof(read_buf));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
 
   s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(sb.size() == 1);
+  BOOST_CHECK(s.check(sb.data(), 1));
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
 
   s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        sizeof(read_data), &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        1, &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, 1));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
 
   s.reset(read_data, sizeof(read_data));
   s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
-      boost::bind(async_read_handler,
-        boost::asio::placeholders::error,
-        boost::asio::placeholders::bytes_transferred,
-        10, &called));
-  ios.reset();
-  ios.run();
-  BOOST_CHECK(called);
-  BOOST_CHECK(s.check(buffers, 10));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
 
   s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(sb.size() == 42);
+  BOOST_CHECK(s.check(sb.data(), 42));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(sb.size() == 50);
+  BOOST_CHECK(s.check(sb.data(), 50));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+}
+
+void test_4_arg_mutable_buffers_1_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  boost::system::error_code error;
+  size_t bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+}
+
+void test_4_arg_multi_buffers_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::array<boost::asio::mutable_buffer, 2> buffers = { {
+    boost::asio::buffer(read_buf, 32),
+    boost::asio::buffer(read_buf) + 32 } };
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  boost::system::error_code error;
+  size_t bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+}
+
+void test_4_arg_streambuf_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::streambuf sb(sizeof(read_data));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  boost::system::error_code error;
+  size_t bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(sb.size() == 1);
+  BOOST_CHECK(s.check(sb.data(), 1));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(sb.size() == 42);
+  BOOST_CHECK(s.check(sb.data(), 42));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(sb.size() == 50);
+  BOOST_CHECK(s.check(sb.data(), 50));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  bytes_transferred = boost::asio::read(s, sb, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::read(s, sb, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+  BOOST_CHECK(!error);
+}
+
+void async_read_handler(const boost::system::error_code& e,
+    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
+{
+  *called = true;
+  BOOST_CHECK(!e);
+  BOOST_CHECK(bytes_transferred == expected_bytes_transferred);
+}
+
+void test_3_arg_mutable_buffers_1_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bool called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+}
+
+void test_3_arg_multi_buffers_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::array<boost::asio::mutable_buffer, 2> buffers = { {
+    boost::asio::buffer(read_buf, 32),
+    boost::asio::buffer(read_buf) + 32 } };
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bool called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+}
+
+void test_3_arg_streambuf_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::streambuf sb(sizeof(read_data));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  bool called = false;
+  boost::asio::async_read(s, sb,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+}
+
+void test_4_arg_mutable_buffers_1_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bool called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        42, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        50, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 50));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, old_style_transfer_all,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, old_style_transfer_all,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, old_style_transfer_all,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, short_transfer,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, short_transfer,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, short_transfer,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+}
+
+void test_4_arg_multi_buffers_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::array<boost::asio::mutable_buffer, 2> buffers = { {
+    boost::asio::buffer(read_buf, 32),
+    boost::asio::buffer(read_buf) + 32 } };
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bool called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
       boost::bind(async_read_handler,
         boost::asio::placeholders::error,
         boost::asio::placeholders::bytes_transferred,
@@ -807,13 +1898,294 @@
   BOOST_CHECK(s.check(buffers, sizeof(read_data)));
 }
 
+void test_4_arg_streambuf_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::streambuf sb(sizeof(read_data));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  bool called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == 1);
+  BOOST_CHECK(s.check(sb.data(), 1));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == 10);
+  BOOST_CHECK(s.check(sb.data(), 10));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        42, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == 42);
+  BOOST_CHECK(s.check(sb.data(), 42));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        50, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == 50);
+  BOOST_CHECK(s.check(sb.data(), 50));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, old_style_transfer_all,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, old_style_transfer_all,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, old_style_transfer_all,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, short_transfer,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, short_transfer,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  sb.consume(sb.size());
+  called = false;
+  boost::asio::async_read(s, sb, short_transfer,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(sb.size() == sizeof(read_data));
+  BOOST_CHECK(s.check(sb.data(), sizeof(read_data)));
+}
+
 test_suite* init_unit_test_suite(int, char*[])
 {
   test_suite* test = BOOST_TEST_SUITE("read");
-  test->add(BOOST_TEST_CASE(&test_2_arg_read));
-  test->add(BOOST_TEST_CASE(&test_3_arg_read));
-  test->add(BOOST_TEST_CASE(&test_4_arg_read));
-  test->add(BOOST_TEST_CASE(&test_3_arg_async_read));
-  test->add(BOOST_TEST_CASE(&test_4_arg_async_read));
+  test->add(BOOST_TEST_CASE(&test_2_arg_mutable_buffers_1_read));
+  test->add(BOOST_TEST_CASE(&test_2_arg_multi_buffers_read));
+  test->add(BOOST_TEST_CASE(&test_2_arg_streambuf_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_mutable_buffers_1_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_multi_buffers_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_streambuf_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_mutable_buffers_1_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_multi_buffers_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_streambuf_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_mutable_buffers_1_async_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_multi_buffers_async_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_streambuf_async_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_mutable_buffers_1_async_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_multi_buffers_async_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_streambuf_async_read));
   return test;
 }

Modified: trunk/libs/asio/test/write.cpp
==============================================================================
--- trunk/libs/asio/test/write.cpp	(original)
+++ trunk/libs/asio/test/write.cpp	2010-03-19 19:23:28 EDT (Fri, 19 Mar 2010)
@@ -16,6 +16,7 @@
 // Test that header file is self-contained.
 #include <boost/asio/write.hpp>
 
+#include <boost/array.hpp>
 #include <boost/bind.hpp>
 #include <boost/noncopyable.hpp>
 #include <cstring>
@@ -134,8 +135,10 @@
 
 static const char write_data[]
   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+static char mutable_write_data[]
+  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
-void test_2_arg_write()
+void test_2_arg_const_buffers_1_write()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
@@ -160,6 +163,57 @@
   BOOST_CHECK(s.check(buffers, sizeof(write_data)));
 }
 
+void test_2_arg_mutable_buffers_1_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(mutable_write_data, sizeof(mutable_write_data));
+
+  s.reset();
+  size_t bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+}
+
+void test_2_arg_multi_buffers_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::array<boost::asio::const_buffer, 2> buffers = { {
+    boost::asio::buffer(write_data, 32),
+    boost::asio::buffer(write_data) + 32 } };
+
+  s.reset();
+  size_t bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+}
+
 bool old_style_transfer_all(const boost::system::error_code& ec,
     size_t /*bytes_transferred*/)
 {
@@ -172,7 +226,7 @@
   return !!ec ? 0 : 3;
 }
 
-void test_3_arg_write()
+void test_3_arg_const_buffers_1_write()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
@@ -294,7 +348,252 @@
   BOOST_CHECK(s.check(buffers, sizeof(write_data)));
 }
 
-void test_4_arg_write()
+void test_3_arg_mutable_buffers_1_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(mutable_write_data, sizeof(mutable_write_data));
+
+  s.reset();
+  size_t bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+}
+
+void test_3_arg_multi_buffers_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::array<boost::asio::const_buffer, 2> buffers = { {
+    boost::asio::buffer(write_data, 32),
+    boost::asio::buffer(write_data) + 32 } };
+
+  s.reset();
+  size_t bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers, old_style_transfer_all);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+}
+
+void test_4_arg_const_buffers_1_write()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
@@ -453,24 +752,672 @@
   BOOST_CHECK(!error);
 }
 
-void async_write_handler(const boost::system::error_code& e,
-    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
+void test_4_arg_mutable_buffers_1_write()
 {
-  *called = true;
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(mutable_write_data, sizeof(mutable_write_data));
+
+  s.reset();
+  boost::system::error_code error;
+  size_t bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(mutable_write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+  BOOST_CHECK(!error);
+}
+
+void test_4_arg_multi_buffers_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::array<boost::asio::const_buffer, 2> buffers = { {
+    boost::asio::buffer(write_data, 32),
+    boost::asio::buffer(write_data) + 32 } };
+
+  s.reset();
+  boost::system::error_code error;
+  size_t bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), error);
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), error);
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers,
+      old_style_transfer_all, error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::system::error_code();
+  bytes_transferred = boost::asio::write(s, buffers, short_transfer, error);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+}
+
+void async_write_handler(const boost::system::error_code& e,
+    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
+{
+  *called = true;
   BOOST_CHECK(!e);
   BOOST_CHECK(bytes_transferred == expected_bytes_transferred);
 }
 
-void test_3_arg_async_write()
-{
-  boost::asio::io_service ios;
-  test_stream s(ios);
-  boost::asio::const_buffers_1 buffers
-    = boost::asio::buffer(write_data, sizeof(write_data));
+void test_3_arg_const_buffers_1_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffers_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+}
+
+void test_3_arg_mutable_buffers_1_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(mutable_write_data, sizeof(mutable_write_data));
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+}
+
+void test_3_arg_multi_buffers_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::array<boost::asio::const_buffer, 2> buffers = { {
+    boost::asio::buffer(write_data, 32),
+    boost::asio::buffer(write_data) + 32 } };
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+}
+
+void test_4_arg_const_buffers_1_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffers_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        42, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        50, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 50));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, old_style_transfer_all,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, old_style_transfer_all,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
 
   s.reset();
-  bool called = false;
-  boost::asio::async_write(s, buffers,
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, old_style_transfer_all,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, short_transfer,
       boost::bind(async_write_handler,
         boost::asio::placeholders::error,
         boost::asio::placeholders::bytes_transferred,
@@ -483,7 +1430,7 @@
   s.reset();
   s.next_write_length(1);
   called = false;
-  boost::asio::async_write(s, buffers,
+  boost::asio::async_write(s, buffers, short_transfer,
       boost::bind(async_write_handler,
         boost::asio::placeholders::error,
         boost::asio::placeholders::bytes_transferred,
@@ -496,7 +1443,7 @@
   s.reset();
   s.next_write_length(10);
   called = false;
-  boost::asio::async_write(s, buffers,
+  boost::asio::async_write(s, buffers, short_transfer,
       boost::bind(async_write_handler,
         boost::asio::placeholders::error,
         boost::asio::placeholders::bytes_transferred,
@@ -507,12 +1454,249 @@
   BOOST_CHECK(s.check(buffers, sizeof(write_data)));
 }
 
-void test_4_arg_async_write()
+void test_4_arg_mutable_buffers_1_async_write()
 {
   boost::asio::io_service ios;
   test_stream s(ios);
-  boost::asio::const_buffers_1 buffers
-    = boost::asio::buffer(write_data, sizeof(write_data));
+  boost::asio::mutable_buffers_1 buffers
+    = boost::asio::buffer(mutable_write_data, sizeof(mutable_write_data));
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        42, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        50, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 50));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, old_style_transfer_all,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, old_style_transfer_all,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, old_style_transfer_all,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, short_transfer,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, short_transfer,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, short_transfer,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(mutable_write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(mutable_write_data)));
+}
+
+void test_4_arg_multi_buffers_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::array<boost::asio::const_buffer, 2> buffers = { {
+    boost::asio::buffer(write_data, 32),
+    boost::asio::buffer(write_data) + 32 } };
 
   s.reset();
   bool called = false;
@@ -746,10 +1930,20 @@
 test_suite* init_unit_test_suite(int, char*[])
 {
   test_suite* test = BOOST_TEST_SUITE("write");
-  test->add(BOOST_TEST_CASE(&test_2_arg_write));
-  test->add(BOOST_TEST_CASE(&test_3_arg_write));
-  test->add(BOOST_TEST_CASE(&test_4_arg_write));
-  test->add(BOOST_TEST_CASE(&test_3_arg_async_write));
-  test->add(BOOST_TEST_CASE(&test_4_arg_async_write));
+  test->add(BOOST_TEST_CASE(&test_2_arg_const_buffers_1_write));
+  test->add(BOOST_TEST_CASE(&test_2_arg_mutable_buffers_1_write));
+  test->add(BOOST_TEST_CASE(&test_2_arg_multi_buffers_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_const_buffers_1_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_mutable_buffers_1_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_multi_buffers_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_const_buffers_1_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_mutable_buffers_1_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_multi_buffers_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_const_buffers_1_async_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_mutable_buffers_1_async_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_multi_buffers_async_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_const_buffers_1_async_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_mutable_buffers_1_async_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_multi_buffers_async_write));
   return test;
 }