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