boost/asio
2
0
Fork 0
mirror of https://github.com/boostorg/asio.git synced 2026-01-27 06:32:08 +00:00
Code Issues Projects Releases Wiki Activity
Files
boost-1.55.0
asio/test/read_at.cpp
Christopher Kohlhoff 603397befb Merge from trunk. 
------------------------------------------------------------------------
r84301 | chris_kohlhoff | 2013-05-17 07:34:54 +1000 (Fri, 17 May 2013) | 2 lines

Enable handler type requirements static_assert on clang.

------------------------------------------------------------------------
r84308 | chris_kohlhoff | 2013-05-17 09:26:04 +1000 (Fri, 17 May 2013) | 3 lines

Add new traits classes, handler_type and async_result, that allow
the customisation of the return type of an initiating function.

------------------------------------------------------------------------
r84311 | chris_kohlhoff | 2013-05-17 11:38:47 +1000 (Fri, 17 May 2013) | 81 lines

Add the asio::spawn() function, a high-level wrapper for running
stackful coroutines. It is based on the Boost.Coroutine library.

Here is an example of its use:

  asio::spawn(my_strand, do_echo);

  // ...

  void do_echo(asio::yield_context yield)
  {
    try
    {
      char data[128];
      for (;;)
      {
        std::size_t length =
          my_socket.async_read_some(
            asio::buffer(data), yield);

        asio::async_write(my_socket,
            asio::buffer(data, length), yield);
      }
    }
    catch (std::exception& e)
    {
      // ...
    }
  }

The first argument to asio::spawn() may be a strand, io_service or
completion handler. This argument determines the context in which the
coroutine is permitted to execute. For example, a server's per-client
object may consist of multiple coroutines; they should all run on the
same strand so that no explicit synchronisation is required.

The second argument is a function object with signature (**):

  void coroutine(asio::yield_context yield);

that specifies the code to be run as part of the coroutine. The
parameter yield may be passed to an asynchronous operation in place of
the completion handler, as in:

  std::size_t length =
    my_socket.async_read_some(
      asio::buffer(data), yield);

This starts the asynchronous operation and suspends the coroutine. The
coroutine will be resumed automatically when the asynchronous operation
completes.

Where a completion handler signature has the form:

  void handler(error_code ec, result_type result);

the initiating function returns the result_type. In the async_read_some
example above, this is std::size_t. If the asynchronous operation fails,
the error_code is converted into a system_error exception and thrown.

Where a completion handler signature has the form:

  void handler(error_code ec);

the initiating function returns void. As above, an error is passed back
to the coroutine as a system_error exception.

To collect the error_code from an operation, rather than have it throw
an exception, associate the output variable with the yield_context as
follows:

  error_code ec;
  std::size_t length =
    my_socket.async_read_some(
      asio::buffer(data), yield[ec]);

**Note: if asio::spawn() is used with a custom completion handler of
type Handler, the function object signature is actually:
  
  void coroutine(asio::basic_yield_context<Handler> yield);

------------------------------------------------------------------------
r84312 | chris_kohlhoff | 2013-05-17 12:25:10 +1000 (Fri, 17 May 2013) | 4 lines

Move existing examples into a C++03-specific directory, and add a new
directory for C++11-specific examples. A limited subset of the C++03
examples have been converted to their C++11 equivalents.

------------------------------------------------------------------------
r84313 | chris_kohlhoff | 2013-05-17 12:35:08 +1000 (Fri, 17 May 2013) | 26 lines

Add the asio::use_future special value, which adds first-class support
for returning a C++11 std::future from an asynchronous operation's
initiating function.

To use asio::use_future, pass it to an asynchronous operation instead of
a normal completion handler. For example:

  std::future<std::size_t> length =
    my_socket.async_read_some(my_buffer, asio::use_future);

Where a completion handler signature has the form:

  void handler(error_code ec, result_type result);

the initiating function returns a std::future templated on result_type.
In the above example, this is std::size_t. If the asynchronous operation
fails, the error_code is converted into a system_error exception and
passed back to the caller through the future.

Where a completion handler signature has the form:

  void handler(error_code ec);

the initiating function returns std::future<void>. As above, an error
is passed back in the future as a system_error exception.

------------------------------------------------------------------------
r84314 | chris_kohlhoff | 2013-05-17 13:07:51 +1000 (Fri, 17 May 2013) | 27 lines

Add a new handler hook called asio_handler_is_continuation.

Asynchronous operations may represent a continuation of the asynchronous
control flow associated with the current handler. Asio's implementation
can use this knowledge to optimise scheduling of the handler.

The asio_handler_is_continuation hook returns true to indicate whether a
completion handler represents a continuation of the current call
context. The default implementation of the hook returns false, and
applications may customise the hook when necessary. The hook has already
been customised within Asio to return true for the following cases:

- Handlers returned by strand.wrap(), when the corresponding
  asynchronous operation is being initiated from within the strand.

- The internal handlers used to implement the asio::spawn() function's
  stackful coroutines.

- When an intermediate handler of a composed operation (e.g.
  asio::async_read(), asio::async_write(), asio::async_connect(),
  ssl::stream<>, etc.) starts a new asynchronous operation due to the
  composed operation not being complete.

To support this optimisation, a new running_in_this_thread() member
function has been added to the io_service::strand class. This function
returns true when called from within a strand.

------------------------------------------------------------------------
r84315 | chris_kohlhoff | 2013-05-17 20:06:50 +1000 (Fri, 17 May 2013) | 3 lines

Partially decouple Asio from other boost components via an extra level
of indirection.

------------------------------------------------------------------------
r84316 | chris_kohlhoff | 2013-05-17 20:15:21 +1000 (Fri, 17 May 2013) | 2 lines

Minor cleanup.

------------------------------------------------------------------------
r84319 | chris_kohlhoff | 2013-05-17 20:52:08 +1000 (Fri, 17 May 2013) | 9 lines

Support handshake with re-use of data already read from the wire.

Add new overloads of the SSL stream's handshake() and async_handshake()
functions, that accepts a ConstBufferSequence to be used as initial
input to the ssl engine for the handshake procedure.

Thanks go to Nick Jones <nick dot fa dot jones at gmail dot com>, on
whose work this commit is partially based.

------------------------------------------------------------------------
r84320 | chris_kohlhoff | 2013-05-17 20:57:02 +1000 (Fri, 17 May 2013) | 6 lines

Support for creation of TLSv1.1 and TLSv1.2 contexts.

Thanks go to Alvin Cheung <alvin dot cheung at alumni dot ust dot hk>
and Nick Jones <nick dot fa dot jones at gmail dot com>, on whose work
this is based.

------------------------------------------------------------------------
r84322 | chris_kohlhoff | 2013-05-17 21:00:49 +1000 (Fri, 17 May 2013) | 5 lines

Add set_verify_depth function to SSL context and stream.

Thanks go to Nick Jones <nick dot fa dot jones at gmail dot com>, on
whose work this commit is based.

------------------------------------------------------------------------
r84325 | chris_kohlhoff | 2013-05-17 21:04:11 +1000 (Fri, 17 May 2013) | 9 lines

Allow loading of SSL certificate and key data from memory buffers.

Added new buffer-based interfaces:
add_certificate_authority, use_certificate, use_certificate_chain,
use_private_key, use_rsa_private_key, use_tmp_dh.

Thanks go to Nick Jones <nick dot fa dot jones at gmail dot com>, on
whose work this commit is based.

------------------------------------------------------------------------
r84345 | chris_kohlhoff | 2013-05-18 21:24:59 +1000 (Sat, 18 May 2013) | 2 lines

Update copyright notices.

------------------------------------------------------------------------
r84346 | chris_kohlhoff | 2013-05-18 21:54:59 +1000 (Sat, 18 May 2013) | 3 lines

Remove the stackless coroutine class and macros from the HTTP server 4
example, and instead make them a part of Asio's documented interface.

------------------------------------------------------------------------
r84347 | chris_kohlhoff | 2013-05-18 22:01:59 +1000 (Sat, 18 May 2013) | 4 lines

Fix basic_waitable_timer's underlying implementation so that it can
handle any time_point value without overflowing the intermediate
duration objects.

------------------------------------------------------------------------
r84348 | chris_kohlhoff | 2013-05-18 22:07:00 +1000 (Sat, 18 May 2013) | 3 lines

Fix a problem with lost thread wakeups that can occur when making
concurrent calls to run() and poll() on the same io_service object.

------------------------------------------------------------------------
r84349 | chris_kohlhoff | 2013-05-18 22:13:17 +1000 (Sat, 18 May 2013) | 3 lines

Fix implementation of asynchronous connect operation so that it can cope
with spurious readiness notifications from the reactor.

------------------------------------------------------------------------
r84361 | chris_kohlhoff | 2013-05-19 07:56:31 +1000 (Sun, 19 May 2013) | 1 line

Remove some trailing spaces and fix another copyright notice.

------------------------------------------------------------------------
r84363 | chris_kohlhoff | 2013-05-19 14:55:11 +1000 (Sun, 19 May 2013) | 53 lines

Add generic socket protocols and converting move constructors.

Four new protocol classes have been added:

- asio::generic::datagram_protocol
- asio::generic::raw_protocol
- asio::generic::seq_packet_protocol
- asio::generic::stream_protocol

These classes implement the Protocol type requirements, but allow the
user to specify the address family (e.g. AF_INET) and protocol type
(e.g. IPPROTO_TCP) at runtime.

A new endpoint class template, asio::generic::basic_endpoint, has been
added to support these new protocol classes. This endpoint can hold any
other endpoint type, provided its native representation fits into a
sockaddr_storage object.

When using C++11, it is now possible to perform move construction from a
socket (or acceptor) object to convert to the more generic protocol's
socket (or acceptor) type. If the protocol conversion is valid:

  Protocol1 p1 = ...;
  Protocol2 p2(p1);

then the corresponding socket conversion is allowed:

  Protocol1::socket socket1(io_service);
  ...
  Protocol2::socket socket2(std::move(socket1));

For example, one possible conversion is from a TCP socket to a generic
stream-oriented socket:

  asio::ip::tcp::socket socket1(io_service);
  ...
  asio::generic::stream_protocol::socket socket2(std::move(socket1));

The conversion is also available for move-assignment. Note that these
conversions are not limited to the newly added generic protocol classes.
User-defined protocols may take advantage of this feature by similarly
ensuring the conversion from Protocol1 to Protocol2 is valid, as above.

As a convenience, the socket acceptor's accept() and async_accept()
functions have been changed so that they can directly accept into a
different protocol's socket type, provided the protocol conversion is
valid. For example, the following is now possible:

  asio::ip::tcp::acceptor acceptor(io_service);
  ...
  asio::generic::stream_protocol::socket socket1(io_service);
  acceptor.accept(socket1);


[SVN r84388]
2013-05-20 12:32:20 +00:00

7484 lines
256 KiB
C++
Raw Permalink Blame History

//
// read_at.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include <boost/asio/read_at.hpp>
#include <cstring>
#include "archetypes/async_result.hpp"
#include <boost/asio/io_service.hpp>
#include <boost/asio/streambuf.hpp>
#include "unit_test.hpp"
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
# include <boost/bind.hpp>
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
# include <functional>
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
#include <boost/array.hpp>
#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
#if defined(BOOST_ASIO_HAS_STD_ARRAY)
# include <array>
#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
using namespace std; // For memcmp, memcpy and memset.
class test_random_access_device
{
public:
typedef boost::asio::io_service io_service_type;
test_random_access_device(boost::asio::io_service& io_service)
: io_service_(io_service),
length_(0),
next_read_length_(0)
{
}
io_service_type& get_io_service()
{
return io_service_;
}
void reset(const void* data, size_t length)
{
BOOST_ASIO_CHECK(length <= max_length);
length_ = 0;
while (length_ + length < max_length)
{
memcpy(data_ + length_, data, length);
length_ += length;
}
next_read_length_ = length;
}
void next_read_length(size_t length)
{
next_read_length_ = length;
}
template <typename Const_Buffers>
bool check_buffers(boost::asio::uint64_t offset,
const Const_Buffers& buffers, size_t length)
{
if (offset + length > max_length)
return false;
typename Const_Buffers::const_iterator iter = buffers.begin();
typename Const_Buffers::const_iterator end = buffers.end();
size_t checked_length = 0;
for (; iter != end && checked_length < length; ++iter)
{
size_t buffer_length = boost::asio::buffer_size(*iter);
if (buffer_length > length - checked_length)
buffer_length = length - checked_length;
if (memcmp(data_ + offset + checked_length,
boost::asio::buffer_cast<const void*>(*iter), buffer_length) != 0)
return false;
checked_length += buffer_length;
}
return true;
}
template <typename Mutable_Buffers>
size_t read_some_at(boost::asio::uint64_t offset,
const Mutable_Buffers& buffers)
{
return boost::asio::buffer_copy(buffers,
boost::asio::buffer(data_, length_) + offset,
next_read_length_);
}
template <typename Mutable_Buffers>
size_t read_some_at(boost::asio::uint64_t offset,
const Mutable_Buffers& buffers, boost::system::error_code& ec)
{
ec = boost::system::error_code();
return read_some_at(offset, buffers);
}
template <typename Mutable_Buffers, typename Handler>
void async_read_some_at(boost::asio::uint64_t offset,
const Mutable_Buffers& buffers, Handler handler)
{
size_t bytes_transferred = read_some_at(offset, buffers);
io_service_.post(boost::asio::detail::bind_handler(
handler, boost::system::error_code(), bytes_transferred));
}
private:
io_service_type& io_service_;
enum { max_length = 8192 };
char data_[max_length];
size_t length_;
size_t next_read_length_;
};
static const char read_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_3_arg_mutable_buffers_1_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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));
size_t bytes_transferred = boost::asio::read_at(s, 0, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_3_arg_vector_buffers_read_at()
{
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::vector<boost::asio::mutable_buffer> buffers;
buffers.push_back(boost::asio::buffer(read_buf, 32));
buffers.push_back(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_at(s, 0, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_3_arg_streambuf_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, sb);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
void test_4_arg_nothrow_mutable_buffers_1_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
}
void test_4_arg_nothrow_vector_buffers_read_at()
{
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::vector<boost::asio::mutable_buffer> buffers;
buffers.push_back(boost::asio::buffer(read_buf, 32));
buffers.push_back(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_at(s, 0, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
}
void test_4_arg_nothrow_streambuf_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, sb, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
}
bool old_style_transfer_all(const boost::system::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec;
}
size_t short_transfer(const boost::system::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec ? 0 : 3;
}
void test_4_arg_mutable_buffers_1_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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));
size_t bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_vector_buffers_read_at()
{
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::vector<boost::asio::mutable_buffer> buffers;
buffers.push_back(boost::asio::buffer(read_buf, 32));
buffers.push_back(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_at(s, 0, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_streambuf_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, sb,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_all());
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(1));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(sb.size() == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(42));
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(sb.size() == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(1));
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(10));
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(42));
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
old_style_transfer_all);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb, short_transfer);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
void test_5_arg_mutable_buffers_1_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
}
void test_5_arg_vector_buffers_read_at()
{
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::vector<boost::asio::mutable_buffer> buffers;
buffers.push_back(boost::asio::buffer(read_buf, 32));
buffers.push_back(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_at(s, 0, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_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_at(s, 0, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
BOOST_ASIO_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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 0, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = boost::asio::read_at(s, 1234, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, buffers,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
}
void test_5_arg_streambuf_read_at()
{
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, sb,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_all(), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_at_least(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_at_least(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(sb.size() == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_at_least(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 50);
BOOST_ASIO_CHECK(sb.size() == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_exactly(1), error);
BOOST_ASIO_CHECK(bytes_transferred == 1);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_exactly(10), error);
BOOST_ASIO_CHECK(bytes_transferred == 10);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 0, sb,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = boost::system::error_code();
bytes_transferred = boost::asio::read_at(s, 1234, sb,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
BOOST_ASIO_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_at(s, 0, sb,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
BOOST_ASIO_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_at(s, 1234, sb,
boost::asio::transfer_exactly(42), error);
BOOST_ASIO_CHECK(bytes_transferred == 42);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, sb,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, sb,
old_style_transfer_all, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 0, sb,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = boost::asio::read_at(s, 1234, sb,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, sb,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 0, sb,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_at(s, 1234, sb,
short_transfer, error);
BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
BOOST_ASIO_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_ASIO_CHECK(!e);
BOOST_ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
}
void test_4_arg_mutable_buffers_1_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_boost_array_buffers_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
}
void test_4_arg_std_array_buffers_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
#if defined(BOOST_ASIO_HAS_STD_ARRAY)
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
}
void test_4_arg_vector_buffers_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::vector<boost::asio::mutable_buffer> buffers;
buffers.push_back(boost::asio::buffer(read_buf, 32));
buffers.push_back(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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_streambuf_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = boost::asio::async_read_at(s, 1234, sb,
archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
void test_5_arg_mutable_buffers_1_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
short_transfer, archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_5_arg_boost_array_buffers_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
short_transfer, archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
}
void test_5_arg_std_array_buffers_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
#if defined(BOOST_ASIO_HAS_STD_ARRAY)
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
short_transfer, archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
}
void test_5_arg_vector_buffers_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
boost::asio::io_service ios;
test_random_access_device s(ios);
char read_buf[sizeof(read_data)];
std::vector<boost::asio::mutable_buffer> buffers;
buffers.push_back(boost::asio::buffer(read_buf, 32));
buffers.push_back(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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 50));
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_at(s, 1234, buffers,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 1));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 10));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, 42));
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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
boost::asio::async_read_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, buffers, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = boost::asio::async_read_at(s, 1234, buffers,
short_transfer, archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_5_arg_streambuf_async_read_at()
{
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
namespace bindns = std;
using std::placeholders::_1;
using std::placeholders::_2;
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
boost::asio::io_service ios;
test_random_access_device 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_at(s, 0, sb,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 50);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 50);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 1);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 10);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb,
boost::asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == 42);
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 0, sb, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
boost::asio::async_read_at(s, 1234, sb, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, 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_at(s, 0, sb, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(0, 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_at(s, 1234, sb, short_transfer,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ios.reset();
ios.run();
BOOST_ASIO_CHECK(called);
BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = boost::asio::async_read_at(s, 1234, sb,
short_transfer, archetypes::lazy_handler());
BOOST_ASIO_CHECK(i == 42);
ios.reset();
ios.run();
BOOST_ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
BOOST_ASIO_TEST_SUITE
(
"read_at",
BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffers_1_read_at)
BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_read_at)
BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffers_1_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_nothrow_streambuf_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffers_1_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_mutable_buffers_1_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_vector_buffers_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_streambuf_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffers_1_async_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read_at)
BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_async_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_mutable_buffers_1_async_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_vector_buffers_async_read_at)
BOOST_ASIO_TEST_CASE(test_5_arg_streambuf_async_read_at)
)
Reference in New Issue View Git Blame Copy Permalink