boost/asio
2
0
Fork 0
mirror of https://github.com/boostorg/asio.git synced 2026-01-24 17:42:08 +00:00
Code Issues Projects Releases Wiki Activity
Files
a2000c8a38b7d626da7ed538c36c9f044ffb01fa
asio/test/read_until.cpp
Christopher Kohlhoff 7139b456d2 Changes for asio version 1.5.0: 
* Added support for timeouts on socket iostreams, such as
  ip::tcp::iostream. A timeout is set by calling expires_at() or
  expires_from_now() to establish a deadline. Any socket operations
  which occur past the deadline will put the iostream into a bad state.

* Added a new error() member function to socket iostreams, for
  retrieving the error code from the most recent system call.

* Added a new basic_deadline_timer::cancel_one() function. This function
  lets you cancel a single waiting handler on a timer. Handlers are
  cancelled in FIFO order.

* Added a new transfer_exactly() completion condition. This can be used
  to send or receive a specified number of bytes even if the total size
  of the buffer (or buffer sequence) is larger.

* Added new free functions connect() and async_connect(). These
  operations try each endpoint in a list until the socket is
  successfully connected.

* Extended the buffer_size() function so that it works for buffer
  sequences in addition to individual buffers.

* Added a new buffer_copy() function that can be used to copy the raw
  bytes between individual buffers and buffer sequences.

* Added new non-throwing overloads of read(), read_at(), write() and
  write_at() that do not require a completion condition.

* Added friendlier compiler errors for when a completion handler does
  not meet the necessary type requirements. When C++0x is available
  (currently supported for g++ 4.5 or later, and MSVC 10), static_assert
  is also used to generate an informative error message. Checking may be
  disabled by defining BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS.

* Made the is_loopback(), is_unspecified() and is_multicast() functions
  consistently available across the ip::address, ip::address_v4 and
  ip::address_v6 classes. Refs #3939.

* Added new non_blocking() functions for managing the non-blocking
  behaviour of a socket or descriptor. The io_control() commands named
  non_blocking_io are now deprecated in favour of these new functions.

* Added new native_non_blocking() functions for managing the
  non-blocking mode of the underlying socket or descriptor. These
  functions are intended to allow the encapsulation of arbitrary
  non-blocking system calls as asynchronous operations, in a way that is
  transparent to the user of the socket object. The functions have no
  effect on the behaviour of the synchronous operations of the socket or
  descriptor. Refs #3307.

* Added the io_control() member function for socket acceptors.
  Refs #3297.

* For consistency with the C++0x standard library, deprecated the
  native_type typedefs in favour of native_handle_type, and the native()
  member functions in favour of native_handle().

* Added a release() member function to posix descriptors. This function
  releases ownership of the underlying native descriptor to the caller.
  Refs #3900.

* Added support for sequenced packet sockets (SOCK_SEQPACKET).

* Added a new io_service::stopped() function that can be used to
  determine whether the io_service has stopped (i.e. a reset() call is
  needed prior to any further calls to run(), run_one(), poll() or
  poll_one()).

* Reduced the copying of handler function objects.

* Added support for C++0x move construction to further reduce copying of
  handler objects. Move support is enabled when compiling in -std=c++0x
  mode on g++ 4.5 or higher, or when using MSVC10.

* Removed the dependency on OS-provided macros for the well-known IPv4
  and IPv6 addresses. This should eliminate the annoying "missing braces
  around initializer" warnings. Refs #3741.

* Reduced the size of ip::basic_endpoint<> objects (such as
  ip::tcp::endpoint and ip::udp::endpoint).

* Changed the reactor backends to assume that any descriptors or sockets
  added using assign() may have been dup()-ed, and so require explicit
  deregistration from the reactor. Refs #4971.

* Changed the SSL error category to return error strings from the
  OpenSSL library.

* Changed the separate compilation support such that, to use Asio's SSL
  capabilities, you should also include 'asio/ssl/impl/src.hpp in one
  source file in your program.

* Removed the deprecated member functions named io_service(). The
  get_io_service() member functions should be used instead.

* Removed the deprecated typedefs resolver_query and resolver_iterator
  from the ip::tcp, ip::udp and ip::icmp classes.

* Fixed a compile error on some versions of g++ due to anonymous enums.
  Refs #4883.

* Added an explicit cast to the FIONBIO constant to int to suppress a
  compiler warning on some platforms. Refs #5128.

* Fixed warnings reported by g++'s -Wshadow compiler option. Refs #3905.


[SVN r69194]
2011-02-23 01:04:16 +00:00

835 lines
24 KiB
C++
Raw Blame History

//
// read_until.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2011 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_until.hpp>
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <cstring>
#include <boost/asio/io_service.hpp>
#include <boost/asio/placeholders.hpp>
#include <boost/asio/streambuf.hpp>
#include "unit_test.hpp"
class test_stream
: private boost::noncopyable
{
public:
typedef boost::asio::io_service io_service_type;
test_stream(boost::asio::io_service& io_service)
: io_service_(io_service),
length_(0),
position_(0),
next_read_length_(0)
{
}
io_service_type& get_io_service()
{
return io_service_;
}
void reset(const void* data, size_t length)
{
using namespace std; // For memcpy.
BOOST_CHECK(length <= max_length);
memcpy(data_, data, length);
length_ = length;
position_ = 0;
next_read_length_ = length;
}
void next_read_length(size_t length)
{
next_read_length_ = length;
}
template <typename Mutable_Buffers>
size_t read_some(const Mutable_Buffers& buffers)
{
size_t n = boost::asio::buffer_copy(buffers,
boost::asio::buffer(data_, length_) + position_,
next_read_length_);
position_ += n;
return n;
}
template <typename Mutable_Buffers>
size_t read_some(const Mutable_Buffers& buffers,
boost::system::error_code& ec)
{
ec = boost::system::error_code();
return read_some(buffers);
}
template <typename Mutable_Buffers, typename Handler>
void async_read_some(const Mutable_Buffers& buffers, Handler handler)
{
size_t bytes_transferred = read_some(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 position_;
size_t next_read_length_;
};
static const char read_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_char_read_until()
{
boost::asio::io_service ios;
test_stream s(ios);
boost::asio::streambuf sb1;
boost::asio::streambuf sb2(25);
boost::system::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = boost::asio::read_until(s, sb1, 'Z');
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, 'Z');
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, 'Z');
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, 'Z', ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, 'Z', ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, 'Z', ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, 'Z', ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, 'Z', ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, 'Z', ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, 'Y', ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, 'Y', ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, 'Y', ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
}
void test_string_read_until()
{
boost::asio::io_service ios;
test_stream s(ios);
boost::asio::streambuf sb1;
boost::asio::streambuf sb2(25);
boost::system::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = boost::asio::read_until(s, sb1, "XYZ");
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, "XYZ");
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, "XYZ");
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, "XYZ", ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, "XYZ", ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, "XYZ", ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, "XYZ", ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, "XYZ", ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, "XYZ", ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, "WXY", ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, "WXY", ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, "WXY", ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
}
class match_char
{
public:
explicit match_char(char c) : c_(c) {}
template <typename Iterator>
std::pair<Iterator, bool> operator()(
Iterator begin, Iterator end) const
{
Iterator i = begin;
while (i != end)
if (c_ == *i++)
return std::make_pair(i, true);
return std::make_pair(i, false);
}
private:
char c_;
};
namespace boost {
namespace asio {
template <> struct is_match_condition<match_char>
: public boost::true_type {};
} // namespace asio
} // namespace boost
void test_match_condition_read_until()
{
boost::asio::io_service ios;
test_stream s(ios);
boost::asio::streambuf sb1;
boost::asio::streambuf sb2(25);
boost::system::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = boost::asio::read_until(s, sb1, match_char('Z'));
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, match_char('Z'));
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, match_char('Z'));
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, match_char('Z'), ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, match_char('Z'), ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = boost::asio::read_until(s, sb1, match_char('Z'), ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, match_char('Z'), ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, match_char('Z'), ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, match_char('Z'), ec);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, match_char('Y'), ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, match_char('Y'), ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = boost::asio::read_until(s, sb2, match_char('Y'), ec);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
}
void async_read_handler(
const boost::system::error_code& err, boost::system::error_code* err_out,
std::size_t bytes_transferred, std::size_t* bytes_out, bool* called)
{
*err_out = err;
*bytes_out = bytes_transferred;
*called = true;
}
void test_char_async_read_until()
{
boost::asio::io_service ios;
test_stream s(ios);
boost::asio::streambuf sb1;
boost::asio::streambuf sb2(25);
boost::system::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, 'Z',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, 'Z',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, 'Z',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, 'Z',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, 'Z',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, 'Z',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, 'Y',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, 'Y',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, 'Y',
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
}
void test_string_async_read_until()
{
boost::asio::io_service ios;
test_stream s(ios);
boost::asio::streambuf sb1;
boost::asio::streambuf sb2(25);
boost::system::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, "XYZ",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, "XYZ",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, "XYZ",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, "XYZ",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, "XYZ",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, "XYZ",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, "WXY",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, "WXY",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, "WXY",
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
}
void test_match_condition_async_read_until()
{
boost::asio::io_service ios;
test_stream s(ios);
boost::asio::streambuf sb1;
boost::asio::streambuf sb2(25);
boost::system::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, match_char('Z'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, match_char('Z'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
boost::asio::async_read_until(s, sb1, match_char('Z'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, match_char('Z'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, match_char('Z'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, match_char('Z'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(ec == boost::asio::error::not_found);
BOOST_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, match_char('Y'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, match_char('Y'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = boost::system::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
boost::asio::async_read_until(s, sb2, match_char('Y'),
boost::bind(async_read_handler, boost::asio::placeholders::error, &ec,
boost::asio::placeholders::bytes_transferred, &length, &called));
ios.reset();
ios.run();
BOOST_CHECK(called);
BOOST_CHECK(!ec);
BOOST_CHECK(length == 25);
}
test_suite* init_unit_test_suite(int, char*[])
{
test_suite* test = BOOST_TEST_SUITE("read_until");
test->add(BOOST_TEST_CASE(&test_char_read_until));
test->add(BOOST_TEST_CASE(&test_string_read_until));
test->add(BOOST_TEST_CASE(&test_match_condition_read_until));
test->add(BOOST_TEST_CASE(&test_char_async_read_until));
test->add(BOOST_TEST_CASE(&test_string_async_read_until));
test->add(BOOST_TEST_CASE(&test_match_condition_async_read_until));
return test;
}
Reference in New Issue View Git Blame Copy Permalink