1	//
2	// read.cpp
3	// ~~~~~~~~
4	//
5	// Copyright (c) 2003-2024 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.hpp>
18
19	#include <array>
20	#include <cstring>
21	#include <functional>
22	#include <vector>
23	#include "archetypes/async_result.hpp"
24	#include <boost/asio/io_context.hpp>
25	#include <boost/asio/post.hpp>
26	#include <boost/asio/streambuf.hpp>
27	#include "unit_test.hpp"
28
29	#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
30	#include <boost/array.hpp>
31	#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
32
33	using namespace std; // For memcmp, memcpy and memset.
34
35	class test_stream
36	{
37	public:
38	typedef boost::asio::io_context::executor_type executor_type;
39
40	test_stream(boost::asio::io_context& io_context)
41	: io_context_(io_context),
42	length_(0),
43	position_(0),
44	next_read_length_(0)
45	{
46	}
47
48	executor_type get_executor() noexcept
49	{
50	return io_context_.get_executor();
51	}
52
53	void reset(const void* data, size_t length)
54	{
55	BOOST_ASIO_CHECK(length <= max_length);
56
57	memcpy(dest: data_, src: data, n: length);
58	length_ = length;
59	position_ = 0;
60	next_read_length_ = length;
61	}
62
63	void next_read_length(size_t length)
64	{
65	next_read_length_ = length;
66	}
67
68	template <typename Iterator>
69	bool check_buffers(Iterator begin, Iterator end, size_t length)
70	{
71	if (length != position_)
72	return false;
73
74	Iterator iter = begin;
75	size_t checked_length = 0;
76	for (; iter != end && checked_length < length; ++iter)
77	{
78	size_t buffer_length = boost::asio::buffer_size(*iter);
79	if (buffer_length > length - checked_length)
80	buffer_length = length - checked_length;
81	if (memcmp(data_ + checked_length, iter->data(), buffer_length) != 0)
82	return false;
83	checked_length += buffer_length;
84	}
85
86	return true;
87	}
88
89	template <typename Const_Buffers>
90	bool check_buffers(const Const_Buffers& buffers, size_t length)
91	{
92	return check_buffers(boost::asio::buffer_sequence_begin(buffers),
93	boost::asio::buffer_sequence_end(buffers), length);
94	}
95
96	template <typename Mutable_Buffers>
97	size_t read_some(const Mutable_Buffers& buffers)
98	{
99	size_t n = boost::asio::buffer_copy(buffers,
100	boost::asio::buffer(data&: data_, max_size_in_bytes: length_) + position_,
101	next_read_length_);
102	position_ += n;
103	return n;
104	}
105
106	template <typename Mutable_Buffers>
107	size_t read_some(const Mutable_Buffers& buffers,
108	boost::system::error_code& ec)
109	{
110	ec = boost::system::error_code();
111	return read_some(buffers);
112	}
113
114	template <typename Mutable_Buffers, typename Handler>
115	void async_read_some(const Mutable_Buffers& buffers,
116	Handler&& handler)
117	{
118	size_t bytes_transferred = read_some(buffers);
119	boost::asio::post(get_executor(),
120	boost::asio::detail::bind_handler(
121	static_cast<Handler&&>(handler),
122	boost::system::error_code(), bytes_transferred));
123	}
124
125	private:
126	boost::asio::io_context& io_context_;
127	enum { max_length = 8192 };
128	char data_[max_length];
129	size_t length_;
130	size_t position_;
131	size_t next_read_length_;
132	};
133
134	static const char read_data[]
135	= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
136
137	void test_2_arg_zero_buffers_read()
138	{
139	boost::asio::io_context ioc;
140	test_stream s(ioc);
141	std::vector<boost::asio::mutable_buffer> buffers;
142
143	size_t bytes_transferred = boost::asio::read(s, buffers);
144	BOOST_ASIO_CHECK(bytes_transferred == 0);
145	}
146
147	void test_2_arg_mutable_buffer_read()
148	{
149	boost::asio::io_context ioc;
150	test_stream s(ioc);
151	char read_buf[sizeof(read_data)];
152	boost::asio::mutable_buffer buffers
153	= boost::asio::buffer(data&: read_buf, max_size_in_bytes: sizeof(read_buf));
154
155	s.reset(data: read_data, length: sizeof(read_data));
156	memset(s: read_buf, c: 0, n: sizeof(read_buf));
157	size_t bytes_transferred = boost::asio::read(s, buffers);
158	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
159	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
160
161	s.reset(data: read_data, length: sizeof(read_data));
162	s.next_read_length(length: 1);
163	memset(s: read_buf, c: 0, n: sizeof(read_buf));
164	bytes_transferred = boost::asio::read(s, buffers);
165	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
166	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
167
168	s.reset(data: read_data, length: sizeof(read_data));
169	s.next_read_length(length: 10);
170	memset(s: read_buf, c: 0, n: sizeof(read_buf));
171	bytes_transferred = boost::asio::read(s, buffers);
172	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
173	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
174	}
175
176	void test_2_arg_vector_buffers_read()
177	{
178	boost::asio::io_context ioc;
179	test_stream s(ioc);
180	char read_buf[sizeof(read_data)];
181	std::vector<boost::asio::mutable_buffer> buffers;
182	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32));
183	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 39) + 32);
184	buffers.push_back(x: boost::asio::buffer(data&: read_buf) + 39);
185
186	s.reset(data: read_data, length: sizeof(read_data));
187	memset(s: read_buf, c: 0, n: sizeof(read_buf));
188	size_t bytes_transferred = boost::asio::read(s, buffers);
189	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
190	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
191
192	s.reset(data: read_data, length: sizeof(read_data));
193	s.next_read_length(length: 1);
194	memset(s: read_buf, c: 0, n: sizeof(read_buf));
195	bytes_transferred = boost::asio::read(s, buffers);
196	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
197	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
198
199	s.reset(data: read_data, length: sizeof(read_data));
200	s.next_read_length(length: 10);
201	memset(s: read_buf, c: 0, n: sizeof(read_buf));
202	bytes_transferred = boost::asio::read(s, buffers);
203	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
204	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
205	}
206
207	void test_2_arg_dynamic_string_read()
208	{
209	boost::asio::io_context ioc;
210	test_stream s(ioc);
211	std::string data;
212	boost::asio::dynamic_string_buffer<char, std::string::traits_type,
213	std::string::allocator_type> sb
214	= boost::asio::dynamic_buffer(data, max_size: sizeof(read_data));
215
216	s.reset(data: read_data, length: sizeof(read_data));
217	sb.consume(n: sb.size());
218	size_t bytes_transferred = boost::asio::read(s, buffers: sb);
219	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
220	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
221	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
222
223	s.reset(data: read_data, length: sizeof(read_data));
224	s.next_read_length(length: 1);
225	sb.consume(n: sb.size());
226	bytes_transferred = boost::asio::read(s, buffers: sb);
227	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
228	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
229	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
230
231	s.reset(data: read_data, length: sizeof(read_data));
232	s.next_read_length(length: 10);
233	sb.consume(n: sb.size());
234	bytes_transferred = boost::asio::read(s, buffers: sb);
235	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
236	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
237	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
238	}
239
240	void test_2_arg_streambuf_read()
241	{
242	#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
243	boost::asio::io_context ioc;
244	test_stream s(ioc);
245	boost::asio::streambuf sb(sizeof(read_data));
246
247	s.reset(data: read_data, length: sizeof(read_data));
248	sb.consume(n: sb.size());
249	size_t bytes_transferred = boost::asio::read(s, b&: sb);
250	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
251	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
252	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
253
254	s.reset(data: read_data, length: sizeof(read_data));
255	s.next_read_length(length: 1);
256	sb.consume(n: sb.size());
257	bytes_transferred = boost::asio::read(s, b&: sb);
258	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
259	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
260	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
261
262	s.reset(data: read_data, length: sizeof(read_data));
263	s.next_read_length(length: 10);
264	sb.consume(n: sb.size());
265	bytes_transferred = boost::asio::read(s, b&: sb);
266	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
267	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
268	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
269	#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
270	}
271
272	void test_3_arg_nothrow_zero_buffers_read()
273	{
274	boost::asio::io_context ioc;
275	test_stream s(ioc);
276	std::vector<boost::asio::mutable_buffer> buffers;
277
278	boost::system::error_code error;
279	size_t bytes_transferred = boost::asio::read(s, buffers, ec&: error);
280	BOOST_ASIO_CHECK(bytes_transferred == 0);
281	BOOST_ASIO_CHECK(!error);
282	}
283
284	void test_3_arg_nothrow_mutable_buffer_read()
285	{
286	boost::asio::io_context ioc;
287	test_stream s(ioc);
288	char read_buf[sizeof(read_data)];
289	boost::asio::mutable_buffer buffers
290	= boost::asio::buffer(data&: read_buf, max_size_in_bytes: sizeof(read_buf));
291
292	s.reset(data: read_data, length: sizeof(read_data));
293	memset(s: read_buf, c: 0, n: sizeof(read_buf));
294	boost::system::error_code error;
295	size_t bytes_transferred = boost::asio::read(s, buffers, ec&: error);
296	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
297	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
298	BOOST_ASIO_CHECK(!error);
299
300	s.reset(data: read_data, length: sizeof(read_data));
301	s.next_read_length(length: 1);
302	memset(s: read_buf, c: 0, n: sizeof(read_buf));
303	bytes_transferred = boost::asio::read(s, buffers, ec&: error);
304	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
305	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
306	BOOST_ASIO_CHECK(!error);
307
308	s.reset(data: read_data, length: sizeof(read_data));
309	s.next_read_length(length: 10);
310	memset(s: read_buf, c: 0, n: sizeof(read_buf));
311	bytes_transferred = boost::asio::read(s, buffers, ec&: error);
312	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
313	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
314	BOOST_ASIO_CHECK(!error);
315	}
316
317	void test_3_arg_nothrow_vector_buffers_read()
318	{
319	boost::asio::io_context ioc;
320	test_stream s(ioc);
321	char read_buf[sizeof(read_data)];
322	std::vector<boost::asio::mutable_buffer> buffers;
323	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32));
324	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 39) + 32);
325	buffers.push_back(x: boost::asio::buffer(data&: read_buf) + 39);
326
327	s.reset(data: read_data, length: sizeof(read_data));
328	memset(s: read_buf, c: 0, n: sizeof(read_buf));
329	boost::system::error_code error;
330	size_t bytes_transferred = boost::asio::read(s, buffers, ec&: error);
331	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
332	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
333	BOOST_ASIO_CHECK(!error);
334
335	s.reset(data: read_data, length: sizeof(read_data));
336	s.next_read_length(length: 1);
337	memset(s: read_buf, c: 0, n: sizeof(read_buf));
338	bytes_transferred = boost::asio::read(s, buffers, ec&: error);
339	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
340	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
341	BOOST_ASIO_CHECK(!error);
342
343	s.reset(data: read_data, length: sizeof(read_data));
344	s.next_read_length(length: 10);
345	memset(s: read_buf, c: 0, n: sizeof(read_buf));
346	bytes_transferred = boost::asio::read(s, buffers, ec&: error);
347	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
348	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
349	BOOST_ASIO_CHECK(!error);
350	}
351
352	void test_3_arg_nothrow_dynamic_string_read()
353	{
354	boost::asio::io_context ioc;
355	test_stream s(ioc);
356	std::string data;
357	boost::asio::dynamic_string_buffer<char, std::string::traits_type,
358	std::string::allocator_type> sb
359	= boost::asio::dynamic_buffer(data, max_size: sizeof(read_data));
360
361	s.reset(data: read_data, length: sizeof(read_data));
362	sb.consume(n: sb.size());
363	boost::system::error_code error;
364	size_t bytes_transferred = boost::asio::read(s, buffers: sb, ec&: error);
365	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
366	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
367	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 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	sb.consume(n: sb.size());
373	bytes_transferred = boost::asio::read(s, buffers: sb, ec&: error);
374	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
375	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
376	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
377	BOOST_ASIO_CHECK(!error);
378
379	s.reset(data: read_data, length: sizeof(read_data));
380	s.next_read_length(length: 10);
381	sb.consume(n: sb.size());
382	bytes_transferred = boost::asio::read(s, buffers: sb, ec&: error);
383	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
384	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
385	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
386	BOOST_ASIO_CHECK(!error);
387	}
388
389	void test_3_arg_nothrow_streambuf_read()
390	{
391	#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
392	boost::asio::io_context ioc;
393	test_stream s(ioc);
394	boost::asio::streambuf sb(sizeof(read_data));
395
396	s.reset(data: read_data, length: sizeof(read_data));
397	sb.consume(n: sb.size());
398	boost::system::error_code error;
399	size_t bytes_transferred = boost::asio::read(s, b&: sb, ec&: error);
400	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
401	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
402	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
403	BOOST_ASIO_CHECK(!error);
404
405	s.reset(data: read_data, length: sizeof(read_data));
406	s.next_read_length(length: 1);
407	sb.consume(n: sb.size());
408	bytes_transferred = boost::asio::read(s, b&: sb, ec&: error);
409	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
410	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
411	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
412	BOOST_ASIO_CHECK(!error);
413
414	s.reset(data: read_data, length: sizeof(read_data));
415	s.next_read_length(length: 10);
416	sb.consume(n: sb.size());
417	bytes_transferred = boost::asio::read(s, b&: sb, ec&: error);
418	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
419	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
420	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
421	BOOST_ASIO_CHECK(!error);
422	#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
423	}
424
425	bool old_style_transfer_all(const boost::system::error_code& ec,
426	size_t /*bytes_transferred*/)
427	{
428	return !!ec;
429	}
430
431	struct short_transfer
432	{
433	short_transfer() {}
434	short_transfer(short_transfer&&) {}
435	size_t operator()(const boost::system::error_code& ec,
436	size_t /*bytes_transferred*/)
437	{
438	return !!ec ? 0 : 3;
439	}
440	};
441
442	void test_3_arg_mutable_buffer_read()
443	{
444	boost::asio::io_context ioc;
445	test_stream s(ioc);
446	char read_buf[sizeof(read_data)];
447	boost::asio::mutable_buffer buffers
448	= boost::asio::buffer(data&: read_buf, max_size_in_bytes: sizeof(read_buf));
449
450	s.reset(data: read_data, length: sizeof(read_data));
451	memset(s: read_buf, c: 0, n: sizeof(read_buf));
452	size_t bytes_transferred = boost::asio::read(s, buffers,
453	completion_condition: boost::asio::transfer_all());
454	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
455	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
456
457	s.reset(data: read_data, length: sizeof(read_data));
458	s.next_read_length(length: 1);
459	memset(s: read_buf, c: 0, n: sizeof(read_buf));
460	bytes_transferred = boost::asio::read(s, buffers,
461	completion_condition: boost::asio::transfer_all());
462	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
463	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
464
465	s.reset(data: read_data, length: sizeof(read_data));
466	s.next_read_length(length: 10);
467	memset(s: read_buf, c: 0, n: sizeof(read_buf));
468	bytes_transferred = boost::asio::read(s, buffers,
469	completion_condition: boost::asio::transfer_all());
470	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
471	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
472
473	s.reset(data: read_data, length: sizeof(read_data));
474	memset(s: read_buf, c: 0, n: sizeof(read_buf));
475	bytes_transferred = boost::asio::read(s, buffers,
476	completion_condition: boost::asio::transfer_at_least(minimum: 1));
477	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
478	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
479
480	s.reset(data: read_data, length: sizeof(read_data));
481	s.next_read_length(length: 1);
482	memset(s: read_buf, c: 0, n: sizeof(read_buf));
483	bytes_transferred = boost::asio::read(s, buffers,
484	completion_condition: boost::asio::transfer_at_least(minimum: 1));
485	BOOST_ASIO_CHECK(bytes_transferred == 1);
486	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
487
488	s.reset(data: read_data, length: sizeof(read_data));
489	s.next_read_length(length: 10);
490	memset(s: read_buf, c: 0, n: sizeof(read_buf));
491	bytes_transferred = boost::asio::read(s, buffers,
492	completion_condition: boost::asio::transfer_at_least(minimum: 1));
493	BOOST_ASIO_CHECK(bytes_transferred == 10);
494	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
495
496	s.reset(data: read_data, length: sizeof(read_data));
497	memset(s: read_buf, c: 0, n: sizeof(read_buf));
498	bytes_transferred = boost::asio::read(s, buffers,
499	completion_condition: boost::asio::transfer_at_least(minimum: 10));
500	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
501	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
502
503	s.reset(data: read_data, length: sizeof(read_data));
504	s.next_read_length(length: 1);
505	memset(s: read_buf, c: 0, n: sizeof(read_buf));
506	bytes_transferred = boost::asio::read(s, buffers,
507	completion_condition: boost::asio::transfer_at_least(minimum: 10));
508	BOOST_ASIO_CHECK(bytes_transferred == 10);
509	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
510
511	s.reset(data: read_data, length: sizeof(read_data));
512	s.next_read_length(length: 10);
513	memset(s: read_buf, c: 0, n: sizeof(read_buf));
514	bytes_transferred = boost::asio::read(s, buffers,
515	completion_condition: boost::asio::transfer_at_least(minimum: 10));
516	BOOST_ASIO_CHECK(bytes_transferred == 10);
517	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
518
519	s.reset(data: read_data, length: sizeof(read_data));
520	memset(s: read_buf, c: 0, n: sizeof(read_buf));
521	bytes_transferred = boost::asio::read(s, buffers,
522	completion_condition: boost::asio::transfer_at_least(minimum: 42));
523	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
524	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
525
526	s.reset(data: read_data, length: sizeof(read_data));
527	s.next_read_length(length: 1);
528	memset(s: read_buf, c: 0, n: sizeof(read_buf));
529	bytes_transferred = boost::asio::read(s, buffers,
530	completion_condition: boost::asio::transfer_at_least(minimum: 42));
531	BOOST_ASIO_CHECK(bytes_transferred == 42);
532	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
533
534	s.reset(data: read_data, length: sizeof(read_data));
535	s.next_read_length(length: 10);
536	memset(s: read_buf, c: 0, n: sizeof(read_buf));
537	bytes_transferred = boost::asio::read(s, buffers,
538	completion_condition: boost::asio::transfer_at_least(minimum: 42));
539	BOOST_ASIO_CHECK(bytes_transferred == 50);
540	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
541
542	s.reset(data: read_data, length: sizeof(read_data));
543	memset(s: read_buf, c: 0, n: sizeof(read_buf));
544	bytes_transferred = boost::asio::read(s, buffers,
545	completion_condition: boost::asio::transfer_exactly(size: 1));
546	BOOST_ASIO_CHECK(bytes_transferred == 1);
547	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
548
549	s.reset(data: read_data, length: sizeof(read_data));
550	s.next_read_length(length: 1);
551	memset(s: read_buf, c: 0, n: sizeof(read_buf));
552	bytes_transferred = boost::asio::read(s, buffers,
553	completion_condition: boost::asio::transfer_exactly(size: 1));
554	BOOST_ASIO_CHECK(bytes_transferred == 1);
555	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
556
557	s.reset(data: read_data, length: sizeof(read_data));
558	s.next_read_length(length: 10);
559	memset(s: read_buf, c: 0, n: sizeof(read_buf));
560	bytes_transferred = boost::asio::read(s, buffers,
561	completion_condition: boost::asio::transfer_exactly(size: 1));
562	BOOST_ASIO_CHECK(bytes_transferred == 1);
563	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
564
565	s.reset(data: read_data, length: sizeof(read_data));
566	memset(s: read_buf, c: 0, n: sizeof(read_buf));
567	bytes_transferred = boost::asio::read(s, buffers,
568	completion_condition: boost::asio::transfer_exactly(size: 10));
569	BOOST_ASIO_CHECK(bytes_transferred == 10);
570	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
571
572	s.reset(data: read_data, length: sizeof(read_data));
573	s.next_read_length(length: 1);
574	memset(s: read_buf, c: 0, n: sizeof(read_buf));
575	bytes_transferred = boost::asio::read(s, buffers,
576	completion_condition: boost::asio::transfer_exactly(size: 10));
577	BOOST_ASIO_CHECK(bytes_transferred == 10);
578	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
579
580	s.reset(data: read_data, length: sizeof(read_data));
581	s.next_read_length(length: 10);
582	memset(s: read_buf, c: 0, n: sizeof(read_buf));
583	bytes_transferred = boost::asio::read(s, buffers,
584	completion_condition: boost::asio::transfer_exactly(size: 10));
585	BOOST_ASIO_CHECK(bytes_transferred == 10);
586	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
587
588	s.reset(data: read_data, length: sizeof(read_data));
589	memset(s: read_buf, c: 0, n: sizeof(read_buf));
590	bytes_transferred = boost::asio::read(s, buffers,
591	completion_condition: boost::asio::transfer_exactly(size: 42));
592	BOOST_ASIO_CHECK(bytes_transferred == 42);
593	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
594
595	s.reset(data: read_data, length: sizeof(read_data));
596	s.next_read_length(length: 1);
597	memset(s: read_buf, c: 0, n: sizeof(read_buf));
598	bytes_transferred = boost::asio::read(s, buffers,
599	completion_condition: boost::asio::transfer_exactly(size: 42));
600	BOOST_ASIO_CHECK(bytes_transferred == 42);
601	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
602
603	s.reset(data: read_data, length: sizeof(read_data));
604	s.next_read_length(length: 10);
605	memset(s: read_buf, c: 0, n: sizeof(read_buf));
606	bytes_transferred = boost::asio::read(s, buffers,
607	completion_condition: boost::asio::transfer_exactly(size: 42));
608	BOOST_ASIO_CHECK(bytes_transferred == 42);
609	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
610
611	s.reset(data: read_data, length: sizeof(read_data));
612	memset(s: read_buf, c: 0, n: sizeof(read_buf));
613	bytes_transferred = boost::asio::read(s, buffers, completion_condition: old_style_transfer_all);
614	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
615	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
616
617	s.reset(data: read_data, length: sizeof(read_data));
618	s.next_read_length(length: 1);
619	memset(s: read_buf, c: 0, n: sizeof(read_buf));
620	bytes_transferred = boost::asio::read(s, buffers, completion_condition: old_style_transfer_all);
621	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
622	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
623
624	s.reset(data: read_data, length: sizeof(read_data));
625	s.next_read_length(length: 10);
626	memset(s: read_buf, c: 0, n: sizeof(read_buf));
627	bytes_transferred = boost::asio::read(s, buffers, completion_condition: old_style_transfer_all);
628	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
629	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
630
631	s.reset(data: read_data, length: sizeof(read_data));
632	memset(s: read_buf, c: 0, n: sizeof(read_buf));
633	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer());
634	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
635	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
636
637	s.reset(data: read_data, length: sizeof(read_data));
638	s.next_read_length(length: 1);
639	memset(s: read_buf, c: 0, n: sizeof(read_buf));
640	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer());
641	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
642	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
643
644	s.reset(data: read_data, length: sizeof(read_data));
645	s.next_read_length(length: 10);
646	memset(s: read_buf, c: 0, n: sizeof(read_buf));
647	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer());
648	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
649	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
650	}
651
652	void test_3_arg_vector_buffers_read()
653	{
654	boost::asio::io_context ioc;
655	test_stream s(ioc);
656	char read_buf[sizeof(read_data)];
657	std::vector<boost::asio::mutable_buffer> buffers;
658	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32));
659	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 39) + 32);
660	buffers.push_back(x: boost::asio::buffer(data&: read_buf) + 39);
661
662	s.reset(data: read_data, length: sizeof(read_data));
663	memset(s: read_buf, c: 0, n: sizeof(read_buf));
664	size_t bytes_transferred = boost::asio::read(s, buffers,
665	completion_condition: boost::asio::transfer_all());
666	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
667	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
668
669	s.reset(data: read_data, length: sizeof(read_data));
670	s.next_read_length(length: 1);
671	memset(s: read_buf, c: 0, n: sizeof(read_buf));
672	bytes_transferred = boost::asio::read(s, buffers,
673	completion_condition: boost::asio::transfer_all());
674	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
675	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
676
677	s.reset(data: read_data, length: sizeof(read_data));
678	s.next_read_length(length: 10);
679	memset(s: read_buf, c: 0, n: sizeof(read_buf));
680	bytes_transferred = boost::asio::read(s, buffers,
681	completion_condition: boost::asio::transfer_all());
682	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
683	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
684
685	s.reset(data: read_data, length: sizeof(read_data));
686	memset(s: read_buf, c: 0, n: sizeof(read_buf));
687	bytes_transferred = boost::asio::read(s, buffers,
688	completion_condition: boost::asio::transfer_at_least(minimum: 1));
689	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
690	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
691
692	s.reset(data: read_data, length: sizeof(read_data));
693	s.next_read_length(length: 1);
694	memset(s: read_buf, c: 0, n: sizeof(read_buf));
695	bytes_transferred = boost::asio::read(s, buffers,
696	completion_condition: boost::asio::transfer_at_least(minimum: 1));
697	BOOST_ASIO_CHECK(bytes_transferred == 1);
698	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
699
700	s.reset(data: read_data, length: sizeof(read_data));
701	s.next_read_length(length: 10);
702	memset(s: read_buf, c: 0, n: sizeof(read_buf));
703	bytes_transferred = boost::asio::read(s, buffers,
704	completion_condition: boost::asio::transfer_at_least(minimum: 1));
705	BOOST_ASIO_CHECK(bytes_transferred == 10);
706	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
707
708	s.reset(data: read_data, length: sizeof(read_data));
709	memset(s: read_buf, c: 0, n: sizeof(read_buf));
710	bytes_transferred = boost::asio::read(s, buffers,
711	completion_condition: boost::asio::transfer_at_least(minimum: 10));
712	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
713	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
714
715	s.reset(data: read_data, length: sizeof(read_data));
716	s.next_read_length(length: 1);
717	memset(s: read_buf, c: 0, n: sizeof(read_buf));
718	bytes_transferred = boost::asio::read(s, buffers,
719	completion_condition: boost::asio::transfer_at_least(minimum: 10));
720	BOOST_ASIO_CHECK(bytes_transferred == 10);
721	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
722
723	s.reset(data: read_data, length: sizeof(read_data));
724	s.next_read_length(length: 10);
725	memset(s: read_buf, c: 0, n: sizeof(read_buf));
726	bytes_transferred = boost::asio::read(s, buffers,
727	completion_condition: boost::asio::transfer_at_least(minimum: 10));
728	BOOST_ASIO_CHECK(bytes_transferred == 10);
729	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
730
731	s.reset(data: read_data, length: sizeof(read_data));
732	memset(s: read_buf, c: 0, n: sizeof(read_buf));
733	bytes_transferred = boost::asio::read(s, buffers,
734	completion_condition: boost::asio::transfer_at_least(minimum: 42));
735	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
736	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
737
738	s.reset(data: read_data, length: sizeof(read_data));
739	s.next_read_length(length: 1);
740	memset(s: read_buf, c: 0, n: sizeof(read_buf));
741	bytes_transferred = boost::asio::read(s, buffers,
742	completion_condition: boost::asio::transfer_at_least(minimum: 42));
743	BOOST_ASIO_CHECK(bytes_transferred == 42);
744	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
745
746	s.reset(data: read_data, length: sizeof(read_data));
747	s.next_read_length(length: 10);
748	memset(s: read_buf, c: 0, n: sizeof(read_buf));
749	bytes_transferred = boost::asio::read(s, buffers,
750	completion_condition: boost::asio::transfer_at_least(minimum: 42));
751	BOOST_ASIO_CHECK(bytes_transferred == 50);
752	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
753
754	s.reset(data: read_data, length: sizeof(read_data));
755	memset(s: read_buf, c: 0, n: sizeof(read_buf));
756	bytes_transferred = boost::asio::read(s, buffers,
757	completion_condition: boost::asio::transfer_exactly(size: 1));
758	BOOST_ASIO_CHECK(bytes_transferred == 1);
759	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
760
761	s.reset(data: read_data, length: sizeof(read_data));
762	s.next_read_length(length: 1);
763	memset(s: read_buf, c: 0, n: sizeof(read_buf));
764	bytes_transferred = boost::asio::read(s, buffers,
765	completion_condition: boost::asio::transfer_exactly(size: 1));
766	BOOST_ASIO_CHECK(bytes_transferred == 1);
767	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
768
769	s.reset(data: read_data, length: sizeof(read_data));
770	s.next_read_length(length: 10);
771	memset(s: read_buf, c: 0, n: sizeof(read_buf));
772	bytes_transferred = boost::asio::read(s, buffers,
773	completion_condition: boost::asio::transfer_exactly(size: 1));
774	BOOST_ASIO_CHECK(bytes_transferred == 1);
775	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
776
777	s.reset(data: read_data, length: sizeof(read_data));
778	memset(s: read_buf, c: 0, n: sizeof(read_buf));
779	bytes_transferred = boost::asio::read(s, buffers,
780	completion_condition: boost::asio::transfer_exactly(size: 10));
781	BOOST_ASIO_CHECK(bytes_transferred == 10);
782	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
783
784	s.reset(data: read_data, length: sizeof(read_data));
785	s.next_read_length(length: 1);
786	memset(s: read_buf, c: 0, n: sizeof(read_buf));
787	bytes_transferred = boost::asio::read(s, buffers,
788	completion_condition: boost::asio::transfer_exactly(size: 10));
789	BOOST_ASIO_CHECK(bytes_transferred == 10);
790	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
791
792	s.reset(data: read_data, length: sizeof(read_data));
793	s.next_read_length(length: 10);
794	memset(s: read_buf, c: 0, n: sizeof(read_buf));
795	bytes_transferred = boost::asio::read(s, buffers,
796	completion_condition: boost::asio::transfer_exactly(size: 10));
797	BOOST_ASIO_CHECK(bytes_transferred == 10);
798	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
799
800	s.reset(data: read_data, length: sizeof(read_data));
801	memset(s: read_buf, c: 0, n: sizeof(read_buf));
802	bytes_transferred = boost::asio::read(s, buffers,
803	completion_condition: boost::asio::transfer_exactly(size: 42));
804	BOOST_ASIO_CHECK(bytes_transferred == 42);
805	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
806
807	s.reset(data: read_data, length: sizeof(read_data));
808	s.next_read_length(length: 1);
809	memset(s: read_buf, c: 0, n: sizeof(read_buf));
810	bytes_transferred = boost::asio::read(s, buffers,
811	completion_condition: boost::asio::transfer_exactly(size: 42));
812	BOOST_ASIO_CHECK(bytes_transferred == 42);
813	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
814
815	s.reset(data: read_data, length: sizeof(read_data));
816	s.next_read_length(length: 10);
817	memset(s: read_buf, c: 0, n: sizeof(read_buf));
818	bytes_transferred = boost::asio::read(s, buffers,
819	completion_condition: boost::asio::transfer_exactly(size: 42));
820	BOOST_ASIO_CHECK(bytes_transferred == 42);
821	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
822
823	s.reset(data: read_data, length: sizeof(read_data));
824	memset(s: read_buf, c: 0, n: sizeof(read_buf));
825	bytes_transferred = boost::asio::read(s, buffers, completion_condition: old_style_transfer_all);
826	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
827	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
828
829	s.reset(data: read_data, length: sizeof(read_data));
830	s.next_read_length(length: 1);
831	memset(s: read_buf, c: 0, n: sizeof(read_buf));
832	bytes_transferred = boost::asio::read(s, buffers, completion_condition: old_style_transfer_all);
833	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
834	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
835
836	s.reset(data: read_data, length: sizeof(read_data));
837	s.next_read_length(length: 10);
838	memset(s: read_buf, c: 0, n: sizeof(read_buf));
839	bytes_transferred = boost::asio::read(s, buffers, completion_condition: old_style_transfer_all);
840	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
841	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
842
843	s.reset(data: read_data, length: sizeof(read_data));
844	memset(s: read_buf, c: 0, n: sizeof(read_buf));
845	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer());
846	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
847	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
848
849	s.reset(data: read_data, length: sizeof(read_data));
850	s.next_read_length(length: 1);
851	memset(s: read_buf, c: 0, n: sizeof(read_buf));
852	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer());
853	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
854	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
855
856	s.reset(data: read_data, length: sizeof(read_data));
857	s.next_read_length(length: 10);
858	memset(s: read_buf, c: 0, n: sizeof(read_buf));
859	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer());
860	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
861	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
862	}
863
864	void test_3_arg_dynamic_string_read()
865	{
866	boost::asio::io_context ioc;
867	test_stream s(ioc);
868	std::string data;
869	boost::asio::dynamic_string_buffer<char, std::string::traits_type,
870	std::string::allocator_type> sb
871	= boost::asio::dynamic_buffer(data, max_size: sizeof(read_data));
872
873	s.reset(data: read_data, length: sizeof(read_data));
874	sb.consume(n: sb.size());
875	size_t bytes_transferred = boost::asio::read(s, buffers: sb,
876	completion_condition: boost::asio::transfer_all());
877	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
878	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
879	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
880
881	s.reset(data: read_data, length: sizeof(read_data));
882	s.next_read_length(length: 1);
883	sb.consume(n: sb.size());
884	bytes_transferred = boost::asio::read(s, buffers: sb,
885	completion_condition: boost::asio::transfer_all());
886	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
887	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
888	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
889
890	s.reset(data: read_data, length: sizeof(read_data));
891	s.next_read_length(length: 10);
892	sb.consume(n: sb.size());
893	bytes_transferred = boost::asio::read(s, buffers: sb,
894	completion_condition: boost::asio::transfer_all());
895	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
896	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
897	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
898
899	s.reset(data: read_data, length: sizeof(read_data));
900	sb.consume(n: sb.size());
901	bytes_transferred = boost::asio::read(s, buffers: sb,
902	completion_condition: boost::asio::transfer_at_least(minimum: 1));
903	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
904	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
905	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
906
907	s.reset(data: read_data, length: sizeof(read_data));
908	s.next_read_length(length: 1);
909	sb.consume(n: sb.size());
910	bytes_transferred = boost::asio::read(s, buffers: sb,
911	completion_condition: boost::asio::transfer_at_least(minimum: 1));
912	BOOST_ASIO_CHECK(bytes_transferred == 1);
913	BOOST_ASIO_CHECK(sb.size() == 1);
914	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
915
916	s.reset(data: read_data, length: sizeof(read_data));
917	s.next_read_length(length: 10);
918	sb.consume(n: sb.size());
919	bytes_transferred = boost::asio::read(s, buffers: sb,
920	completion_condition: boost::asio::transfer_at_least(minimum: 1));
921	BOOST_ASIO_CHECK(bytes_transferred == 10);
922	BOOST_ASIO_CHECK(sb.size() == 10);
923	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
924
925	s.reset(data: read_data, length: sizeof(read_data));
926	sb.consume(n: sb.size());
927	bytes_transferred = boost::asio::read(s, buffers: sb,
928	completion_condition: boost::asio::transfer_at_least(minimum: 10));
929	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
930	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
931	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
932
933	s.reset(data: read_data, length: sizeof(read_data));
934	s.next_read_length(length: 1);
935	sb.consume(n: sb.size());
936	bytes_transferred = boost::asio::read(s, buffers: sb,
937	completion_condition: boost::asio::transfer_at_least(minimum: 10));
938	BOOST_ASIO_CHECK(bytes_transferred == 10);
939	BOOST_ASIO_CHECK(sb.size() == 10);
940	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
941
942	s.reset(data: read_data, length: sizeof(read_data));
943	s.next_read_length(length: 10);
944	sb.consume(n: sb.size());
945	bytes_transferred = boost::asio::read(s, buffers: sb,
946	completion_condition: boost::asio::transfer_at_least(minimum: 10));
947	BOOST_ASIO_CHECK(bytes_transferred == 10);
948	BOOST_ASIO_CHECK(sb.size() == 10);
949	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
950
951	s.reset(data: read_data, length: sizeof(read_data));
952	sb.consume(n: sb.size());
953	bytes_transferred = boost::asio::read(s, buffers: sb,
954	completion_condition: boost::asio::transfer_at_least(minimum: 42));
955	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
956	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
957	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
958
959	s.reset(data: read_data, length: sizeof(read_data));
960	s.next_read_length(length: 1);
961	sb.consume(n: sb.size());
962	bytes_transferred = boost::asio::read(s, buffers: sb,
963	completion_condition: boost::asio::transfer_at_least(minimum: 42));
964	BOOST_ASIO_CHECK(bytes_transferred == 42);
965	BOOST_ASIO_CHECK(sb.size() == 42);
966	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
967
968	s.reset(data: read_data, length: sizeof(read_data));
969	s.next_read_length(length: 10);
970	sb.consume(n: sb.size());
971	bytes_transferred = boost::asio::read(s, buffers: sb,
972	completion_condition: boost::asio::transfer_at_least(minimum: 42));
973	BOOST_ASIO_CHECK(bytes_transferred == 50);
974	BOOST_ASIO_CHECK(sb.size() == 50);
975	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
976
977	s.reset(data: read_data, length: sizeof(read_data));
978	sb.consume(n: sb.size());
979	bytes_transferred = boost::asio::read(s, buffers: sb,
980	completion_condition: boost::asio::transfer_exactly(size: 1));
981	BOOST_ASIO_CHECK(bytes_transferred == 1);
982	BOOST_ASIO_CHECK(sb.size() == 1);
983	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
984
985	s.reset(data: read_data, length: sizeof(read_data));
986	s.next_read_length(length: 1);
987	sb.consume(n: sb.size());
988	bytes_transferred = boost::asio::read(s, buffers: sb,
989	completion_condition: boost::asio::transfer_exactly(size: 1));
990	BOOST_ASIO_CHECK(bytes_transferred == 1);
991	BOOST_ASIO_CHECK(sb.size() == 1);
992	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
993
994	s.reset(data: read_data, length: sizeof(read_data));
995	s.next_read_length(length: 10);
996	sb.consume(n: sb.size());
997	bytes_transferred = boost::asio::read(s, buffers: sb,
998	completion_condition: boost::asio::transfer_exactly(size: 1));
999	BOOST_ASIO_CHECK(bytes_transferred == 1);
1000	BOOST_ASIO_CHECK(sb.size() == 1);
1001	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
1002
1003	s.reset(data: read_data, length: sizeof(read_data));
1004	sb.consume(n: sb.size());
1005	bytes_transferred = boost::asio::read(s, buffers: sb,
1006	completion_condition: boost::asio::transfer_exactly(size: 10));
1007	BOOST_ASIO_CHECK(bytes_transferred == 10);
1008	BOOST_ASIO_CHECK(sb.size() == 10);
1009	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1010
1011	s.reset(data: read_data, length: sizeof(read_data));
1012	s.next_read_length(length: 1);
1013	sb.consume(n: sb.size());
1014	bytes_transferred = boost::asio::read(s, buffers: sb,
1015	completion_condition: boost::asio::transfer_exactly(size: 10));
1016	BOOST_ASIO_CHECK(bytes_transferred == 10);
1017	BOOST_ASIO_CHECK(sb.size() == 10);
1018	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1019
1020	s.reset(data: read_data, length: sizeof(read_data));
1021	s.next_read_length(length: 10);
1022	sb.consume(n: sb.size());
1023	bytes_transferred = boost::asio::read(s, buffers: sb,
1024	completion_condition: boost::asio::transfer_exactly(size: 10));
1025	BOOST_ASIO_CHECK(bytes_transferred == 10);
1026	BOOST_ASIO_CHECK(sb.size() == 10);
1027	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1028
1029	s.reset(data: read_data, length: sizeof(read_data));
1030	sb.consume(n: sb.size());
1031	bytes_transferred = boost::asio::read(s, buffers: sb,
1032	completion_condition: boost::asio::transfer_exactly(size: 42));
1033	BOOST_ASIO_CHECK(bytes_transferred == 42);
1034	BOOST_ASIO_CHECK(sb.size() == 42);
1035	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1036
1037	s.reset(data: read_data, length: sizeof(read_data));
1038	s.next_read_length(length: 1);
1039	sb.consume(n: sb.size());
1040	bytes_transferred = boost::asio::read(s, buffers: sb,
1041	completion_condition: boost::asio::transfer_exactly(size: 42));
1042	BOOST_ASIO_CHECK(bytes_transferred == 42);
1043	BOOST_ASIO_CHECK(sb.size() == 42);
1044	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1045
1046	s.reset(data: read_data, length: sizeof(read_data));
1047	s.next_read_length(length: 10);
1048	sb.consume(n: sb.size());
1049	bytes_transferred = boost::asio::read(s, buffers: sb,
1050	completion_condition: boost::asio::transfer_exactly(size: 42));
1051	BOOST_ASIO_CHECK(bytes_transferred == 42);
1052	BOOST_ASIO_CHECK(sb.size() == 42);
1053	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1054
1055	s.reset(data: read_data, length: sizeof(read_data));
1056	sb.consume(n: sb.size());
1057	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: old_style_transfer_all);
1058	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1059	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1060	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1061
1062	s.reset(data: read_data, length: sizeof(read_data));
1063	s.next_read_length(length: 1);
1064	sb.consume(n: sb.size());
1065	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: old_style_transfer_all);
1066	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1067	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1068	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1069
1070	s.reset(data: read_data, length: sizeof(read_data));
1071	s.next_read_length(length: 10);
1072	sb.consume(n: sb.size());
1073	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: old_style_transfer_all);
1074	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1075	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1076	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1077
1078	s.reset(data: read_data, length: sizeof(read_data));
1079	sb.consume(n: sb.size());
1080	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: short_transfer());
1081	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1082	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1083	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1084
1085	s.reset(data: read_data, length: sizeof(read_data));
1086	s.next_read_length(length: 1);
1087	sb.consume(n: sb.size());
1088	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: short_transfer());
1089	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1090	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1091	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1092
1093	s.reset(data: read_data, length: sizeof(read_data));
1094	s.next_read_length(length: 10);
1095	sb.consume(n: sb.size());
1096	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: short_transfer());
1097	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1098	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1099	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1100	}
1101
1102	void test_3_arg_streambuf_read()
1103	{
1104	#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
1105	boost::asio::io_context ioc;
1106	test_stream s(ioc);
1107	boost::asio::streambuf sb(sizeof(read_data));
1108
1109	s.reset(data: read_data, length: sizeof(read_data));
1110	sb.consume(n: sb.size());
1111	size_t bytes_transferred = boost::asio::read(s, b&: sb,
1112	completion_condition: boost::asio::transfer_all());
1113	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1114	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1115	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1116
1117	s.reset(data: read_data, length: sizeof(read_data));
1118	s.next_read_length(length: 1);
1119	sb.consume(n: sb.size());
1120	bytes_transferred = boost::asio::read(s, b&: sb,
1121	completion_condition: boost::asio::transfer_all());
1122	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1123	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1124	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1125
1126	s.reset(data: read_data, length: sizeof(read_data));
1127	s.next_read_length(length: 10);
1128	sb.consume(n: sb.size());
1129	bytes_transferred = boost::asio::read(s, b&: sb,
1130	completion_condition: boost::asio::transfer_all());
1131	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1132	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1133	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1134
1135	s.reset(data: read_data, length: sizeof(read_data));
1136	sb.consume(n: sb.size());
1137	bytes_transferred = boost::asio::read(s, b&: sb,
1138	completion_condition: boost::asio::transfer_at_least(minimum: 1));
1139	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1140	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1141	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1142
1143	s.reset(data: read_data, length: sizeof(read_data));
1144	s.next_read_length(length: 1);
1145	sb.consume(n: sb.size());
1146	bytes_transferred = boost::asio::read(s, b&: sb,
1147	completion_condition: boost::asio::transfer_at_least(minimum: 1));
1148	BOOST_ASIO_CHECK(bytes_transferred == 1);
1149	BOOST_ASIO_CHECK(sb.size() == 1);
1150	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1151
1152	s.reset(data: read_data, length: sizeof(read_data));
1153	s.next_read_length(length: 10);
1154	sb.consume(n: sb.size());
1155	bytes_transferred = boost::asio::read(s, b&: sb,
1156	completion_condition: boost::asio::transfer_at_least(minimum: 1));
1157	BOOST_ASIO_CHECK(bytes_transferred == 10);
1158	BOOST_ASIO_CHECK(sb.size() == 10);
1159	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1160
1161	s.reset(data: read_data, length: sizeof(read_data));
1162	sb.consume(n: sb.size());
1163	bytes_transferred = boost::asio::read(s, b&: sb,
1164	completion_condition: boost::asio::transfer_at_least(minimum: 10));
1165	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1166	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1167	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1168
1169	s.reset(data: read_data, length: sizeof(read_data));
1170	s.next_read_length(length: 1);
1171	sb.consume(n: sb.size());
1172	bytes_transferred = boost::asio::read(s, b&: sb,
1173	completion_condition: boost::asio::transfer_at_least(minimum: 10));
1174	BOOST_ASIO_CHECK(bytes_transferred == 10);
1175	BOOST_ASIO_CHECK(sb.size() == 10);
1176	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1177
1178	s.reset(data: read_data, length: sizeof(read_data));
1179	s.next_read_length(length: 10);
1180	sb.consume(n: sb.size());
1181	bytes_transferred = boost::asio::read(s, b&: sb,
1182	completion_condition: boost::asio::transfer_at_least(minimum: 10));
1183	BOOST_ASIO_CHECK(bytes_transferred == 10);
1184	BOOST_ASIO_CHECK(sb.size() == 10);
1185	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1186
1187	s.reset(data: read_data, length: sizeof(read_data));
1188	sb.consume(n: sb.size());
1189	bytes_transferred = boost::asio::read(s, b&: sb,
1190	completion_condition: boost::asio::transfer_at_least(minimum: 42));
1191	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1192	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1193	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1194
1195	s.reset(data: read_data, length: sizeof(read_data));
1196	s.next_read_length(length: 1);
1197	sb.consume(n: sb.size());
1198	bytes_transferred = boost::asio::read(s, b&: sb,
1199	completion_condition: boost::asio::transfer_at_least(minimum: 42));
1200	BOOST_ASIO_CHECK(bytes_transferred == 42);
1201	BOOST_ASIO_CHECK(sb.size() == 42);
1202	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1203
1204	s.reset(data: read_data, length: sizeof(read_data));
1205	s.next_read_length(length: 10);
1206	sb.consume(n: sb.size());
1207	bytes_transferred = boost::asio::read(s, b&: sb,
1208	completion_condition: boost::asio::transfer_at_least(minimum: 42));
1209	BOOST_ASIO_CHECK(bytes_transferred == 50);
1210	BOOST_ASIO_CHECK(sb.size() == 50);
1211	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
1212
1213	s.reset(data: read_data, length: sizeof(read_data));
1214	sb.consume(n: sb.size());
1215	bytes_transferred = boost::asio::read(s, b&: sb,
1216	completion_condition: boost::asio::transfer_exactly(size: 1));
1217	BOOST_ASIO_CHECK(bytes_transferred == 1);
1218	BOOST_ASIO_CHECK(sb.size() == 1);
1219	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1220
1221	s.reset(data: read_data, length: sizeof(read_data));
1222	s.next_read_length(length: 1);
1223	sb.consume(n: sb.size());
1224	bytes_transferred = boost::asio::read(s, b&: sb,
1225	completion_condition: boost::asio::transfer_exactly(size: 1));
1226	BOOST_ASIO_CHECK(bytes_transferred == 1);
1227	BOOST_ASIO_CHECK(sb.size() == 1);
1228	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1229
1230	s.reset(data: read_data, length: sizeof(read_data));
1231	s.next_read_length(length: 10);
1232	sb.consume(n: sb.size());
1233	bytes_transferred = boost::asio::read(s, b&: sb,
1234	completion_condition: boost::asio::transfer_exactly(size: 1));
1235	BOOST_ASIO_CHECK(bytes_transferred == 1);
1236	BOOST_ASIO_CHECK(sb.size() == 1);
1237	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
1238
1239	s.reset(data: read_data, length: sizeof(read_data));
1240	sb.consume(n: sb.size());
1241	bytes_transferred = boost::asio::read(s, b&: sb,
1242	completion_condition: boost::asio::transfer_exactly(size: 10));
1243	BOOST_ASIO_CHECK(bytes_transferred == 10);
1244	BOOST_ASIO_CHECK(sb.size() == 10);
1245	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1246
1247	s.reset(data: read_data, length: sizeof(read_data));
1248	s.next_read_length(length: 1);
1249	sb.consume(n: sb.size());
1250	bytes_transferred = boost::asio::read(s, b&: sb,
1251	completion_condition: boost::asio::transfer_exactly(size: 10));
1252	BOOST_ASIO_CHECK(bytes_transferred == 10);
1253	BOOST_ASIO_CHECK(sb.size() == 10);
1254	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1255
1256	s.reset(data: read_data, length: sizeof(read_data));
1257	s.next_read_length(length: 10);
1258	sb.consume(n: sb.size());
1259	bytes_transferred = boost::asio::read(s, b&: sb,
1260	completion_condition: boost::asio::transfer_exactly(size: 10));
1261	BOOST_ASIO_CHECK(bytes_transferred == 10);
1262	BOOST_ASIO_CHECK(sb.size() == 10);
1263	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
1264
1265	s.reset(data: read_data, length: sizeof(read_data));
1266	sb.consume(n: sb.size());
1267	bytes_transferred = boost::asio::read(s, b&: sb,
1268	completion_condition: boost::asio::transfer_exactly(size: 42));
1269	BOOST_ASIO_CHECK(bytes_transferred == 42);
1270	BOOST_ASIO_CHECK(sb.size() == 42);
1271	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1272
1273	s.reset(data: read_data, length: sizeof(read_data));
1274	s.next_read_length(length: 1);
1275	sb.consume(n: sb.size());
1276	bytes_transferred = boost::asio::read(s, b&: sb,
1277	completion_condition: boost::asio::transfer_exactly(size: 42));
1278	BOOST_ASIO_CHECK(bytes_transferred == 42);
1279	BOOST_ASIO_CHECK(sb.size() == 42);
1280	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1281
1282	s.reset(data: read_data, length: sizeof(read_data));
1283	s.next_read_length(length: 10);
1284	sb.consume(n: sb.size());
1285	bytes_transferred = boost::asio::read(s, b&: sb,
1286	completion_condition: boost::asio::transfer_exactly(size: 42));
1287	BOOST_ASIO_CHECK(bytes_transferred == 42);
1288	BOOST_ASIO_CHECK(sb.size() == 42);
1289	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
1290
1291	s.reset(data: read_data, length: sizeof(read_data));
1292	sb.consume(n: sb.size());
1293	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: old_style_transfer_all);
1294	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1295	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1296	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1297
1298	s.reset(data: read_data, length: sizeof(read_data));
1299	s.next_read_length(length: 1);
1300	sb.consume(n: sb.size());
1301	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: old_style_transfer_all);
1302	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1303	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1304	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1305
1306	s.reset(data: read_data, length: sizeof(read_data));
1307	s.next_read_length(length: 10);
1308	sb.consume(n: sb.size());
1309	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: old_style_transfer_all);
1310	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1311	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1312	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1313
1314	s.reset(data: read_data, length: sizeof(read_data));
1315	sb.consume(n: sb.size());
1316	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: short_transfer());
1317	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1318	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1319	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1320
1321	s.reset(data: read_data, length: sizeof(read_data));
1322	s.next_read_length(length: 1);
1323	sb.consume(n: sb.size());
1324	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: short_transfer());
1325	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1326	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1327	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1328
1329	s.reset(data: read_data, length: sizeof(read_data));
1330	s.next_read_length(length: 10);
1331	sb.consume(n: sb.size());
1332	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: short_transfer());
1333	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1334	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1335	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
1336	#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
1337	}
1338
1339	void test_4_arg_mutable_buffer_read()
1340	{
1341	boost::asio::io_context ioc;
1342	test_stream s(ioc);
1343	char read_buf[sizeof(read_data)];
1344	boost::asio::mutable_buffer buffers
1345	= boost::asio::buffer(data&: read_buf, max_size_in_bytes: sizeof(read_buf));
1346
1347	s.reset(data: read_data, length: sizeof(read_data));
1348	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1349	boost::system::error_code error;
1350	size_t bytes_transferred = boost::asio::read(s, buffers,
1351	completion_condition: boost::asio::transfer_all(), ec&: error);
1352	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1353	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1354	BOOST_ASIO_CHECK(!error);
1355
1356	s.reset(data: read_data, length: sizeof(read_data));
1357	s.next_read_length(length: 1);
1358	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1359	error = boost::system::error_code();
1360	bytes_transferred = boost::asio::read(s, buffers,
1361	completion_condition: boost::asio::transfer_all(), ec&: error);
1362	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1363	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1364	BOOST_ASIO_CHECK(!error);
1365
1366	s.reset(data: read_data, length: sizeof(read_data));
1367	s.next_read_length(length: 10);
1368	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1369	error = boost::system::error_code();
1370	bytes_transferred = boost::asio::read(s, buffers,
1371	completion_condition: boost::asio::transfer_all(), ec&: error);
1372	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1373	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1374	BOOST_ASIO_CHECK(!error);
1375
1376	s.reset(data: read_data, length: sizeof(read_data));
1377	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1378	error = boost::system::error_code();
1379	bytes_transferred = boost::asio::read(s, buffers,
1380	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1381	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1382	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1383	BOOST_ASIO_CHECK(!error);
1384
1385	s.reset(data: read_data, length: sizeof(read_data));
1386	s.next_read_length(length: 1);
1387	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1388	error = boost::system::error_code();
1389	bytes_transferred = boost::asio::read(s, buffers,
1390	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1391	BOOST_ASIO_CHECK(bytes_transferred == 1);
1392	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1393	BOOST_ASIO_CHECK(!error);
1394
1395	s.reset(data: read_data, length: sizeof(read_data));
1396	s.next_read_length(length: 10);
1397	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1398	error = boost::system::error_code();
1399	bytes_transferred = boost::asio::read(s, buffers,
1400	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1401	BOOST_ASIO_CHECK(bytes_transferred == 10);
1402	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1403	BOOST_ASIO_CHECK(!error);
1404
1405	s.reset(data: read_data, length: sizeof(read_data));
1406	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1407	error = boost::system::error_code();
1408	bytes_transferred = boost::asio::read(s, buffers,
1409	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1410	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1411	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1412	BOOST_ASIO_CHECK(!error);
1413
1414	s.reset(data: read_data, length: sizeof(read_data));
1415	s.next_read_length(length: 1);
1416	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1417	error = boost::system::error_code();
1418	bytes_transferred = boost::asio::read(s, buffers,
1419	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1420	BOOST_ASIO_CHECK(bytes_transferred == 10);
1421	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1422	BOOST_ASIO_CHECK(!error);
1423
1424	s.reset(data: read_data, length: sizeof(read_data));
1425	s.next_read_length(length: 10);
1426	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1427	error = boost::system::error_code();
1428	bytes_transferred = boost::asio::read(s, buffers,
1429	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1430	BOOST_ASIO_CHECK(bytes_transferred == 10);
1431	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1432	BOOST_ASIO_CHECK(!error);
1433
1434	s.reset(data: read_data, length: sizeof(read_data));
1435	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1436	error = boost::system::error_code();
1437	bytes_transferred = boost::asio::read(s, buffers,
1438	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1439	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1440	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1441	BOOST_ASIO_CHECK(!error);
1442
1443	s.reset(data: read_data, length: sizeof(read_data));
1444	s.next_read_length(length: 1);
1445	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1446	error = boost::system::error_code();
1447	bytes_transferred = boost::asio::read(s, buffers,
1448	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1449	BOOST_ASIO_CHECK(bytes_transferred == 42);
1450	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1451	BOOST_ASIO_CHECK(!error);
1452
1453	s.reset(data: read_data, length: sizeof(read_data));
1454	s.next_read_length(length: 10);
1455	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1456	error = boost::system::error_code();
1457	bytes_transferred = boost::asio::read(s, buffers,
1458	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1459	BOOST_ASIO_CHECK(bytes_transferred == 50);
1460	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1461	BOOST_ASIO_CHECK(!error);
1462
1463	s.reset(data: read_data, length: sizeof(read_data));
1464	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1465	error = boost::system::error_code();
1466	bytes_transferred = boost::asio::read(s, buffers,
1467	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1468	BOOST_ASIO_CHECK(bytes_transferred == 1);
1469	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1470	BOOST_ASIO_CHECK(!error);
1471
1472	s.reset(data: read_data, length: sizeof(read_data));
1473	s.next_read_length(length: 1);
1474	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1475	error = boost::system::error_code();
1476	bytes_transferred = boost::asio::read(s, buffers,
1477	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1478	BOOST_ASIO_CHECK(bytes_transferred == 1);
1479	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1480	BOOST_ASIO_CHECK(!error);
1481
1482	s.reset(data: read_data, length: sizeof(read_data));
1483	s.next_read_length(length: 10);
1484	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1485	error = boost::system::error_code();
1486	bytes_transferred = boost::asio::read(s, buffers,
1487	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1488	BOOST_ASIO_CHECK(bytes_transferred == 1);
1489	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1490	BOOST_ASIO_CHECK(!error);
1491
1492	s.reset(data: read_data, length: sizeof(read_data));
1493	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1494	error = boost::system::error_code();
1495	bytes_transferred = boost::asio::read(s, buffers,
1496	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1497	BOOST_ASIO_CHECK(bytes_transferred == 10);
1498	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1499	BOOST_ASIO_CHECK(!error);
1500
1501	s.reset(data: read_data, length: sizeof(read_data));
1502	s.next_read_length(length: 1);
1503	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1504	error = boost::system::error_code();
1505	bytes_transferred = boost::asio::read(s, buffers,
1506	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1507	BOOST_ASIO_CHECK(bytes_transferred == 10);
1508	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1509	BOOST_ASIO_CHECK(!error);
1510
1511	s.reset(data: read_data, length: sizeof(read_data));
1512	s.next_read_length(length: 10);
1513	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1514	error = boost::system::error_code();
1515	bytes_transferred = boost::asio::read(s, buffers,
1516	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1517	BOOST_ASIO_CHECK(bytes_transferred == 10);
1518	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1519	BOOST_ASIO_CHECK(!error);
1520
1521	s.reset(data: read_data, length: sizeof(read_data));
1522	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1523	error = boost::system::error_code();
1524	bytes_transferred = boost::asio::read(s, buffers,
1525	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1526	BOOST_ASIO_CHECK(bytes_transferred == 42);
1527	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1528	BOOST_ASIO_CHECK(!error);
1529
1530	s.reset(data: read_data, length: sizeof(read_data));
1531	s.next_read_length(length: 1);
1532	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1533	error = boost::system::error_code();
1534	bytes_transferred = boost::asio::read(s, buffers,
1535	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1536	BOOST_ASIO_CHECK(bytes_transferred == 42);
1537	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1538	BOOST_ASIO_CHECK(!error);
1539
1540	s.reset(data: read_data, length: sizeof(read_data));
1541	s.next_read_length(length: 10);
1542	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1543	error = boost::system::error_code();
1544	bytes_transferred = boost::asio::read(s, buffers,
1545	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1546	BOOST_ASIO_CHECK(bytes_transferred == 42);
1547	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1548	BOOST_ASIO_CHECK(!error);
1549
1550	s.reset(data: read_data, length: sizeof(read_data));
1551	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1552	bytes_transferred = boost::asio::read(s, buffers,
1553	completion_condition: old_style_transfer_all, ec&: error);
1554	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1555	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1556	BOOST_ASIO_CHECK(!error);
1557
1558	s.reset(data: read_data, length: sizeof(read_data));
1559	s.next_read_length(length: 1);
1560	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1561	error = boost::system::error_code();
1562	bytes_transferred = boost::asio::read(s, buffers,
1563	completion_condition: old_style_transfer_all, ec&: error);
1564	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1565	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1566	BOOST_ASIO_CHECK(!error);
1567
1568	s.reset(data: read_data, length: sizeof(read_data));
1569	s.next_read_length(length: 10);
1570	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1571	error = boost::system::error_code();
1572	bytes_transferred = boost::asio::read(s, buffers,
1573	completion_condition: old_style_transfer_all, ec&: error);
1574	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1575	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1576	BOOST_ASIO_CHECK(!error);
1577
1578	s.reset(data: read_data, length: sizeof(read_data));
1579	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1580	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer(), ec&: error);
1581	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1582	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1583	BOOST_ASIO_CHECK(!error);
1584
1585	s.reset(data: read_data, length: sizeof(read_data));
1586	s.next_read_length(length: 1);
1587	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1588	error = boost::system::error_code();
1589	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer(), ec&: error);
1590	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1591	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1592	BOOST_ASIO_CHECK(!error);
1593
1594	s.reset(data: read_data, length: sizeof(read_data));
1595	s.next_read_length(length: 10);
1596	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1597	error = boost::system::error_code();
1598	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer(), ec&: error);
1599	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1600	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1601	BOOST_ASIO_CHECK(!error);
1602	}
1603
1604	void test_4_arg_vector_buffers_read()
1605	{
1606	boost::asio::io_context ioc;
1607	test_stream s(ioc);
1608	char read_buf[sizeof(read_data)];
1609	std::vector<boost::asio::mutable_buffer> buffers;
1610	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32));
1611	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 39) + 32);
1612	buffers.push_back(x: boost::asio::buffer(data&: read_buf) + 39);
1613
1614	s.reset(data: read_data, length: sizeof(read_data));
1615	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1616	boost::system::error_code error;
1617	size_t bytes_transferred = boost::asio::read(s, buffers,
1618	completion_condition: boost::asio::transfer_all(), ec&: error);
1619	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1620	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1621	BOOST_ASIO_CHECK(!error);
1622
1623	s.reset(data: read_data, length: sizeof(read_data));
1624	s.next_read_length(length: 1);
1625	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1626	error = boost::system::error_code();
1627	bytes_transferred = boost::asio::read(s, buffers,
1628	completion_condition: boost::asio::transfer_all(), ec&: error);
1629	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1630	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1631	BOOST_ASIO_CHECK(!error);
1632
1633	s.reset(data: read_data, length: sizeof(read_data));
1634	s.next_read_length(length: 10);
1635	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1636	error = boost::system::error_code();
1637	bytes_transferred = boost::asio::read(s, buffers,
1638	completion_condition: boost::asio::transfer_all(), ec&: error);
1639	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1640	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1641	BOOST_ASIO_CHECK(!error);
1642
1643	s.reset(data: read_data, length: sizeof(read_data));
1644	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1645	error = boost::system::error_code();
1646	bytes_transferred = boost::asio::read(s, buffers,
1647	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1648	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1649	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1650	BOOST_ASIO_CHECK(!error);
1651
1652	s.reset(data: read_data, length: sizeof(read_data));
1653	s.next_read_length(length: 1);
1654	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1655	error = boost::system::error_code();
1656	bytes_transferred = boost::asio::read(s, buffers,
1657	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1658	BOOST_ASIO_CHECK(bytes_transferred == 1);
1659	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1660	BOOST_ASIO_CHECK(!error);
1661
1662	s.reset(data: read_data, length: sizeof(read_data));
1663	s.next_read_length(length: 10);
1664	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1665	error = boost::system::error_code();
1666	bytes_transferred = boost::asio::read(s, buffers,
1667	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1668	BOOST_ASIO_CHECK(bytes_transferred == 10);
1669	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1670	BOOST_ASIO_CHECK(!error);
1671
1672	s.reset(data: read_data, length: sizeof(read_data));
1673	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1674	error = boost::system::error_code();
1675	bytes_transferred = boost::asio::read(s, buffers,
1676	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1677	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1678	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1679	BOOST_ASIO_CHECK(!error);
1680
1681	s.reset(data: read_data, length: sizeof(read_data));
1682	s.next_read_length(length: 1);
1683	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1684	error = boost::system::error_code();
1685	bytes_transferred = boost::asio::read(s, buffers,
1686	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1687	BOOST_ASIO_CHECK(bytes_transferred == 10);
1688	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1689	BOOST_ASIO_CHECK(!error);
1690
1691	s.reset(data: read_data, length: sizeof(read_data));
1692	s.next_read_length(length: 10);
1693	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1694	error = boost::system::error_code();
1695	bytes_transferred = boost::asio::read(s, buffers,
1696	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1697	BOOST_ASIO_CHECK(bytes_transferred == 10);
1698	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1699	BOOST_ASIO_CHECK(!error);
1700
1701	s.reset(data: read_data, length: sizeof(read_data));
1702	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1703	error = boost::system::error_code();
1704	bytes_transferred = boost::asio::read(s, buffers,
1705	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1706	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1707	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1708	BOOST_ASIO_CHECK(!error);
1709
1710	s.reset(data: read_data, length: sizeof(read_data));
1711	s.next_read_length(length: 1);
1712	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1713	error = boost::system::error_code();
1714	bytes_transferred = boost::asio::read(s, buffers,
1715	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1716	BOOST_ASIO_CHECK(bytes_transferred == 42);
1717	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1718	BOOST_ASIO_CHECK(!error);
1719
1720	s.reset(data: read_data, length: sizeof(read_data));
1721	s.next_read_length(length: 10);
1722	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1723	error = boost::system::error_code();
1724	bytes_transferred = boost::asio::read(s, buffers,
1725	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1726	BOOST_ASIO_CHECK(bytes_transferred == 50);
1727	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1728	BOOST_ASIO_CHECK(!error);
1729
1730	s.reset(data: read_data, length: sizeof(read_data));
1731	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1732	error = boost::system::error_code();
1733	bytes_transferred = boost::asio::read(s, buffers,
1734	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1735	BOOST_ASIO_CHECK(bytes_transferred == 1);
1736	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1737	BOOST_ASIO_CHECK(!error);
1738
1739	s.reset(data: read_data, length: sizeof(read_data));
1740	s.next_read_length(length: 1);
1741	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1742	error = boost::system::error_code();
1743	bytes_transferred = boost::asio::read(s, buffers,
1744	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1745	BOOST_ASIO_CHECK(bytes_transferred == 1);
1746	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1747	BOOST_ASIO_CHECK(!error);
1748
1749	s.reset(data: read_data, length: sizeof(read_data));
1750	s.next_read_length(length: 10);
1751	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1752	error = boost::system::error_code();
1753	bytes_transferred = boost::asio::read(s, buffers,
1754	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1755	BOOST_ASIO_CHECK(bytes_transferred == 1);
1756	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1757	BOOST_ASIO_CHECK(!error);
1758
1759	s.reset(data: read_data, length: sizeof(read_data));
1760	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1761	error = boost::system::error_code();
1762	bytes_transferred = boost::asio::read(s, buffers,
1763	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1764	BOOST_ASIO_CHECK(bytes_transferred == 10);
1765	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1766	BOOST_ASIO_CHECK(!error);
1767
1768	s.reset(data: read_data, length: sizeof(read_data));
1769	s.next_read_length(length: 1);
1770	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1771	error = boost::system::error_code();
1772	bytes_transferred = boost::asio::read(s, buffers,
1773	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1774	BOOST_ASIO_CHECK(bytes_transferred == 10);
1775	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1776	BOOST_ASIO_CHECK(!error);
1777
1778	s.reset(data: read_data, length: sizeof(read_data));
1779	s.next_read_length(length: 10);
1780	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1781	error = boost::system::error_code();
1782	bytes_transferred = boost::asio::read(s, buffers,
1783	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1784	BOOST_ASIO_CHECK(bytes_transferred == 10);
1785	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1786	BOOST_ASIO_CHECK(!error);
1787
1788	s.reset(data: read_data, length: sizeof(read_data));
1789	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1790	error = boost::system::error_code();
1791	bytes_transferred = boost::asio::read(s, buffers,
1792	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1793	BOOST_ASIO_CHECK(bytes_transferred == 42);
1794	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1795	BOOST_ASIO_CHECK(!error);
1796
1797	s.reset(data: read_data, length: sizeof(read_data));
1798	s.next_read_length(length: 1);
1799	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1800	error = boost::system::error_code();
1801	bytes_transferred = boost::asio::read(s, buffers,
1802	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1803	BOOST_ASIO_CHECK(bytes_transferred == 42);
1804	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1805	BOOST_ASIO_CHECK(!error);
1806
1807	s.reset(data: read_data, length: sizeof(read_data));
1808	s.next_read_length(length: 10);
1809	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1810	error = boost::system::error_code();
1811	bytes_transferred = boost::asio::read(s, buffers,
1812	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1813	BOOST_ASIO_CHECK(bytes_transferred == 42);
1814	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1815	BOOST_ASIO_CHECK(!error);
1816
1817	s.reset(data: read_data, length: sizeof(read_data));
1818	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1819	bytes_transferred = boost::asio::read(s, buffers,
1820	completion_condition: old_style_transfer_all, ec&: error);
1821	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1822	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1823	BOOST_ASIO_CHECK(!error);
1824
1825	s.reset(data: read_data, length: sizeof(read_data));
1826	s.next_read_length(length: 1);
1827	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1828	error = boost::system::error_code();
1829	bytes_transferred = boost::asio::read(s, buffers,
1830	completion_condition: old_style_transfer_all, ec&: error);
1831	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1832	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1833	BOOST_ASIO_CHECK(!error);
1834
1835	s.reset(data: read_data, length: sizeof(read_data));
1836	s.next_read_length(length: 10);
1837	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1838	error = boost::system::error_code();
1839	bytes_transferred = boost::asio::read(s, buffers,
1840	completion_condition: old_style_transfer_all, ec&: error);
1841	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1842	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1843	BOOST_ASIO_CHECK(!error);
1844
1845	s.reset(data: read_data, length: sizeof(read_data));
1846	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1847	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer(), ec&: error);
1848	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1849	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1850	BOOST_ASIO_CHECK(!error);
1851
1852	s.reset(data: read_data, length: sizeof(read_data));
1853	s.next_read_length(length: 1);
1854	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1855	error = boost::system::error_code();
1856	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer(), ec&: error);
1857	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1858	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1859	BOOST_ASIO_CHECK(!error);
1860
1861	s.reset(data: read_data, length: sizeof(read_data));
1862	s.next_read_length(length: 10);
1863	memset(s: read_buf, c: 0, n: sizeof(read_buf));
1864	error = boost::system::error_code();
1865	bytes_transferred = boost::asio::read(s, buffers, completion_condition: short_transfer(), ec&: error);
1866	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1867	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
1868	BOOST_ASIO_CHECK(!error);
1869	}
1870
1871	void test_4_arg_dynamic_string_read()
1872	{
1873	boost::asio::io_context ioc;
1874	test_stream s(ioc);
1875	std::string data;
1876	boost::asio::dynamic_string_buffer<char, std::string::traits_type,
1877	std::string::allocator_type> sb
1878	= boost::asio::dynamic_buffer(data, max_size: sizeof(read_data));
1879
1880	s.reset(data: read_data, length: sizeof(read_data));
1881	sb.consume(n: sb.size());
1882	boost::system::error_code error;
1883	size_t bytes_transferred = boost::asio::read(s, buffers: sb,
1884	completion_condition: boost::asio::transfer_all(), ec&: error);
1885	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1886	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1887	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1888	BOOST_ASIO_CHECK(!error);
1889
1890	s.reset(data: read_data, length: sizeof(read_data));
1891	s.next_read_length(length: 1);
1892	sb.consume(n: sb.size());
1893	error = boost::system::error_code();
1894	bytes_transferred = boost::asio::read(s, buffers: sb,
1895	completion_condition: boost::asio::transfer_all(), ec&: error);
1896	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1897	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1898	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1899	BOOST_ASIO_CHECK(!error);
1900
1901	s.reset(data: read_data, length: sizeof(read_data));
1902	s.next_read_length(length: 10);
1903	sb.consume(n: sb.size());
1904	error = boost::system::error_code();
1905	bytes_transferred = boost::asio::read(s, buffers: sb,
1906	completion_condition: boost::asio::transfer_all(), ec&: error);
1907	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1908	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1909	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1910	BOOST_ASIO_CHECK(!error);
1911
1912	s.reset(data: read_data, length: sizeof(read_data));
1913	sb.consume(n: sb.size());
1914	error = boost::system::error_code();
1915	bytes_transferred = boost::asio::read(s, buffers: sb,
1916	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1917	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1918	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1919	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1920	BOOST_ASIO_CHECK(!error);
1921
1922	s.reset(data: read_data, length: sizeof(read_data));
1923	s.next_read_length(length: 1);
1924	sb.consume(n: sb.size());
1925	error = boost::system::error_code();
1926	bytes_transferred = boost::asio::read(s, buffers: sb,
1927	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1928	BOOST_ASIO_CHECK(bytes_transferred == 1);
1929	BOOST_ASIO_CHECK(sb.size() == 1);
1930	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
1931	BOOST_ASIO_CHECK(!error);
1932
1933	s.reset(data: read_data, length: sizeof(read_data));
1934	s.next_read_length(length: 10);
1935	sb.consume(n: sb.size());
1936	error = boost::system::error_code();
1937	bytes_transferred = boost::asio::read(s, buffers: sb,
1938	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1939	BOOST_ASIO_CHECK(bytes_transferred == 10);
1940	BOOST_ASIO_CHECK(sb.size() == 10);
1941	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1942	BOOST_ASIO_CHECK(!error);
1943
1944	s.reset(data: read_data, length: sizeof(read_data));
1945	sb.consume(n: sb.size());
1946	error = boost::system::error_code();
1947	bytes_transferred = boost::asio::read(s, buffers: sb,
1948	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1949	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1950	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1951	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1952	BOOST_ASIO_CHECK(!error);
1953
1954	s.reset(data: read_data, length: sizeof(read_data));
1955	s.next_read_length(length: 1);
1956	sb.consume(n: sb.size());
1957	error = boost::system::error_code();
1958	bytes_transferred = boost::asio::read(s, buffers: sb,
1959	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1960	BOOST_ASIO_CHECK(bytes_transferred == 10);
1961	BOOST_ASIO_CHECK(sb.size() == 10);
1962	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1963	BOOST_ASIO_CHECK(!error);
1964
1965	s.reset(data: read_data, length: sizeof(read_data));
1966	s.next_read_length(length: 10);
1967	sb.consume(n: sb.size());
1968	error = boost::system::error_code();
1969	bytes_transferred = boost::asio::read(s, buffers: sb,
1970	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1971	BOOST_ASIO_CHECK(bytes_transferred == 10);
1972	BOOST_ASIO_CHECK(sb.size() == 10);
1973	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
1974	BOOST_ASIO_CHECK(!error);
1975
1976	s.reset(data: read_data, length: sizeof(read_data));
1977	sb.consume(n: sb.size());
1978	error = boost::system::error_code();
1979	bytes_transferred = boost::asio::read(s, buffers: sb,
1980	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1981	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
1982	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
1983	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
1984	BOOST_ASIO_CHECK(!error);
1985
1986	s.reset(data: read_data, length: sizeof(read_data));
1987	s.next_read_length(length: 1);
1988	sb.consume(n: sb.size());
1989	error = boost::system::error_code();
1990	bytes_transferred = boost::asio::read(s, buffers: sb,
1991	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1992	BOOST_ASIO_CHECK(bytes_transferred == 42);
1993	BOOST_ASIO_CHECK(sb.size() == 42);
1994	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
1995	BOOST_ASIO_CHECK(!error);
1996
1997	s.reset(data: read_data, length: sizeof(read_data));
1998	s.next_read_length(length: 10);
1999	sb.consume(n: sb.size());
2000	error = boost::system::error_code();
2001	bytes_transferred = boost::asio::read(s, buffers: sb,
2002	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
2003	BOOST_ASIO_CHECK(bytes_transferred == 50);
2004	BOOST_ASIO_CHECK(sb.size() == 50);
2005	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
2006	BOOST_ASIO_CHECK(!error);
2007
2008	s.reset(data: read_data, length: sizeof(read_data));
2009	sb.consume(n: sb.size());
2010	error = boost::system::error_code();
2011	bytes_transferred = boost::asio::read(s, buffers: sb,
2012	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
2013	BOOST_ASIO_CHECK(bytes_transferred == 1);
2014	BOOST_ASIO_CHECK(sb.size() == 1);
2015	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
2016	BOOST_ASIO_CHECK(!error);
2017
2018	s.reset(data: read_data, length: sizeof(read_data));
2019	s.next_read_length(length: 1);
2020	sb.consume(n: sb.size());
2021	error = boost::system::error_code();
2022	bytes_transferred = boost::asio::read(s, buffers: sb,
2023	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
2024	BOOST_ASIO_CHECK(bytes_transferred == 1);
2025	BOOST_ASIO_CHECK(sb.size() == 1);
2026	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
2027	BOOST_ASIO_CHECK(!error);
2028
2029	s.reset(data: read_data, length: sizeof(read_data));
2030	s.next_read_length(length: 10);
2031	sb.consume(n: sb.size());
2032	error = boost::system::error_code();
2033	bytes_transferred = boost::asio::read(s, buffers: sb,
2034	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
2035	BOOST_ASIO_CHECK(bytes_transferred == 1);
2036	BOOST_ASIO_CHECK(sb.size() == 1);
2037	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
2038	BOOST_ASIO_CHECK(!error);
2039
2040	s.reset(data: read_data, length: sizeof(read_data));
2041	sb.consume(n: sb.size());
2042	error = boost::system::error_code();
2043	bytes_transferred = boost::asio::read(s, buffers: sb,
2044	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
2045	BOOST_ASIO_CHECK(bytes_transferred == 10);
2046	BOOST_ASIO_CHECK(sb.size() == 10);
2047	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
2048	BOOST_ASIO_CHECK(!error);
2049
2050	s.reset(data: read_data, length: sizeof(read_data));
2051	s.next_read_length(length: 1);
2052	sb.consume(n: sb.size());
2053	error = boost::system::error_code();
2054	bytes_transferred = boost::asio::read(s, buffers: sb,
2055	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
2056	BOOST_ASIO_CHECK(bytes_transferred == 10);
2057	BOOST_ASIO_CHECK(sb.size() == 10);
2058	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
2059	BOOST_ASIO_CHECK(!error);
2060
2061	s.reset(data: read_data, length: sizeof(read_data));
2062	s.next_read_length(length: 10);
2063	sb.consume(n: sb.size());
2064	error = boost::system::error_code();
2065	bytes_transferred = boost::asio::read(s, buffers: sb,
2066	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
2067	BOOST_ASIO_CHECK(bytes_transferred == 10);
2068	BOOST_ASIO_CHECK(sb.size() == 10);
2069	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
2070	BOOST_ASIO_CHECK(!error);
2071
2072	s.reset(data: read_data, length: sizeof(read_data));
2073	sb.consume(n: sb.size());
2074	error = boost::system::error_code();
2075	bytes_transferred = boost::asio::read(s, buffers: sb,
2076	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
2077	BOOST_ASIO_CHECK(bytes_transferred == 42);
2078	BOOST_ASIO_CHECK(sb.size() == 42);
2079	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2080	BOOST_ASIO_CHECK(!error);
2081
2082	s.reset(data: read_data, length: sizeof(read_data));
2083	s.next_read_length(length: 1);
2084	sb.consume(n: sb.size());
2085	error = boost::system::error_code();
2086	bytes_transferred = boost::asio::read(s, buffers: sb,
2087	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
2088	BOOST_ASIO_CHECK(bytes_transferred == 42);
2089	BOOST_ASIO_CHECK(sb.size() == 42);
2090	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2091	BOOST_ASIO_CHECK(!error);
2092
2093	s.reset(data: read_data, length: sizeof(read_data));
2094	s.next_read_length(length: 10);
2095	sb.consume(n: sb.size());
2096	error = boost::system::error_code();
2097	bytes_transferred = boost::asio::read(s, buffers: sb,
2098	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
2099	BOOST_ASIO_CHECK(bytes_transferred == 42);
2100	BOOST_ASIO_CHECK(sb.size() == 42);
2101	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
2102	BOOST_ASIO_CHECK(!error);
2103
2104	s.reset(data: read_data, length: sizeof(read_data));
2105	sb.consume(n: sb.size());
2106	bytes_transferred = boost::asio::read(s, buffers: sb,
2107	completion_condition: old_style_transfer_all, ec&: error);
2108	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2109	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2110	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2111	BOOST_ASIO_CHECK(!error);
2112
2113	s.reset(data: read_data, length: sizeof(read_data));
2114	s.next_read_length(length: 1);
2115	sb.consume(n: sb.size());
2116	error = boost::system::error_code();
2117	bytes_transferred = boost::asio::read(s, buffers: sb,
2118	completion_condition: old_style_transfer_all, ec&: error);
2119	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2120	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2121	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2122	BOOST_ASIO_CHECK(!error);
2123
2124	s.reset(data: read_data, length: sizeof(read_data));
2125	s.next_read_length(length: 10);
2126	sb.consume(n: sb.size());
2127	error = boost::system::error_code();
2128	bytes_transferred = boost::asio::read(s, buffers: sb,
2129	completion_condition: old_style_transfer_all, ec&: error);
2130	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2131	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2132	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2133	BOOST_ASIO_CHECK(!error);
2134
2135	s.reset(data: read_data, length: sizeof(read_data));
2136	sb.consume(n: sb.size());
2137	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: short_transfer(), ec&: error);
2138	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2139	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2140	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2141	BOOST_ASIO_CHECK(!error);
2142
2143	s.reset(data: read_data, length: sizeof(read_data));
2144	s.next_read_length(length: 1);
2145	sb.consume(n: sb.size());
2146	error = boost::system::error_code();
2147	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: short_transfer(), ec&: error);
2148	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2149	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2150	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2151	BOOST_ASIO_CHECK(!error);
2152
2153	s.reset(data: read_data, length: sizeof(read_data));
2154	s.next_read_length(length: 10);
2155	sb.consume(n: sb.size());
2156	error = boost::system::error_code();
2157	bytes_transferred = boost::asio::read(s, buffers: sb, completion_condition: short_transfer(), ec&: error);
2158	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2159	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2160	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2161	BOOST_ASIO_CHECK(!error);
2162	}
2163
2164	void test_4_arg_streambuf_read()
2165	{
2166	#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2167	boost::asio::io_context ioc;
2168	test_stream s(ioc);
2169	boost::asio::streambuf sb(sizeof(read_data));
2170
2171	s.reset(data: read_data, length: sizeof(read_data));
2172	sb.consume(n: sb.size());
2173	boost::system::error_code error;
2174	size_t bytes_transferred = boost::asio::read(s, b&: sb,
2175	completion_condition: boost::asio::transfer_all(), ec&: error);
2176	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2177	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2178	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2179	BOOST_ASIO_CHECK(!error);
2180
2181	s.reset(data: read_data, length: sizeof(read_data));
2182	s.next_read_length(length: 1);
2183	sb.consume(n: sb.size());
2184	error = boost::system::error_code();
2185	bytes_transferred = boost::asio::read(s, b&: sb,
2186	completion_condition: boost::asio::transfer_all(), ec&: error);
2187	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2188	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2189	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2190	BOOST_ASIO_CHECK(!error);
2191
2192	s.reset(data: read_data, length: sizeof(read_data));
2193	s.next_read_length(length: 10);
2194	sb.consume(n: sb.size());
2195	error = boost::system::error_code();
2196	bytes_transferred = boost::asio::read(s, b&: sb,
2197	completion_condition: boost::asio::transfer_all(), ec&: error);
2198	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2199	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2200	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2201	BOOST_ASIO_CHECK(!error);
2202
2203	s.reset(data: read_data, length: sizeof(read_data));
2204	sb.consume(n: sb.size());
2205	error = boost::system::error_code();
2206	bytes_transferred = boost::asio::read(s, b&: sb,
2207	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
2208	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2209	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2210	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2211	BOOST_ASIO_CHECK(!error);
2212
2213	s.reset(data: read_data, length: sizeof(read_data));
2214	s.next_read_length(length: 1);
2215	sb.consume(n: sb.size());
2216	error = boost::system::error_code();
2217	bytes_transferred = boost::asio::read(s, b&: sb,
2218	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
2219	BOOST_ASIO_CHECK(bytes_transferred == 1);
2220	BOOST_ASIO_CHECK(sb.size() == 1);
2221	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2222	BOOST_ASIO_CHECK(!error);
2223
2224	s.reset(data: read_data, length: sizeof(read_data));
2225	s.next_read_length(length: 10);
2226	sb.consume(n: sb.size());
2227	error = boost::system::error_code();
2228	bytes_transferred = boost::asio::read(s, b&: sb,
2229	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
2230	BOOST_ASIO_CHECK(bytes_transferred == 10);
2231	BOOST_ASIO_CHECK(sb.size() == 10);
2232	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2233	BOOST_ASIO_CHECK(!error);
2234
2235	s.reset(data: read_data, length: sizeof(read_data));
2236	sb.consume(n: sb.size());
2237	error = boost::system::error_code();
2238	bytes_transferred = boost::asio::read(s, b&: sb,
2239	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
2240	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2241	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2242	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2243	BOOST_ASIO_CHECK(!error);
2244
2245	s.reset(data: read_data, length: sizeof(read_data));
2246	s.next_read_length(length: 1);
2247	sb.consume(n: sb.size());
2248	error = boost::system::error_code();
2249	bytes_transferred = boost::asio::read(s, b&: sb,
2250	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
2251	BOOST_ASIO_CHECK(bytes_transferred == 10);
2252	BOOST_ASIO_CHECK(sb.size() == 10);
2253	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2254	BOOST_ASIO_CHECK(!error);
2255
2256	s.reset(data: read_data, length: sizeof(read_data));
2257	s.next_read_length(length: 10);
2258	sb.consume(n: sb.size());
2259	error = boost::system::error_code();
2260	bytes_transferred = boost::asio::read(s, b&: sb,
2261	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
2262	BOOST_ASIO_CHECK(bytes_transferred == 10);
2263	BOOST_ASIO_CHECK(sb.size() == 10);
2264	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2265	BOOST_ASIO_CHECK(!error);
2266
2267	s.reset(data: read_data, length: sizeof(read_data));
2268	sb.consume(n: sb.size());
2269	error = boost::system::error_code();
2270	bytes_transferred = boost::asio::read(s, b&: sb,
2271	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
2272	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2273	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2274	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2275	BOOST_ASIO_CHECK(!error);
2276
2277	s.reset(data: read_data, length: sizeof(read_data));
2278	s.next_read_length(length: 1);
2279	sb.consume(n: sb.size());
2280	error = boost::system::error_code();
2281	bytes_transferred = boost::asio::read(s, b&: sb,
2282	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
2283	BOOST_ASIO_CHECK(bytes_transferred == 42);
2284	BOOST_ASIO_CHECK(sb.size() == 42);
2285	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2286	BOOST_ASIO_CHECK(!error);
2287
2288	s.reset(data: read_data, length: sizeof(read_data));
2289	s.next_read_length(length: 10);
2290	sb.consume(n: sb.size());
2291	error = boost::system::error_code();
2292	bytes_transferred = boost::asio::read(s, b&: sb,
2293	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
2294	BOOST_ASIO_CHECK(bytes_transferred == 50);
2295	BOOST_ASIO_CHECK(sb.size() == 50);
2296	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
2297	BOOST_ASIO_CHECK(!error);
2298
2299	s.reset(data: read_data, length: sizeof(read_data));
2300	sb.consume(n: sb.size());
2301	error = boost::system::error_code();
2302	bytes_transferred = boost::asio::read(s, b&: sb,
2303	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
2304	BOOST_ASIO_CHECK(bytes_transferred == 1);
2305	BOOST_ASIO_CHECK(sb.size() == 1);
2306	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2307	BOOST_ASIO_CHECK(!error);
2308
2309	s.reset(data: read_data, length: sizeof(read_data));
2310	s.next_read_length(length: 1);
2311	sb.consume(n: sb.size());
2312	error = boost::system::error_code();
2313	bytes_transferred = boost::asio::read(s, b&: sb,
2314	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
2315	BOOST_ASIO_CHECK(bytes_transferred == 1);
2316	BOOST_ASIO_CHECK(sb.size() == 1);
2317	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2318	BOOST_ASIO_CHECK(!error);
2319
2320	s.reset(data: read_data, length: sizeof(read_data));
2321	s.next_read_length(length: 10);
2322	sb.consume(n: sb.size());
2323	error = boost::system::error_code();
2324	bytes_transferred = boost::asio::read(s, b&: sb,
2325	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
2326	BOOST_ASIO_CHECK(bytes_transferred == 1);
2327	BOOST_ASIO_CHECK(sb.size() == 1);
2328	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
2329	BOOST_ASIO_CHECK(!error);
2330
2331	s.reset(data: read_data, length: sizeof(read_data));
2332	sb.consume(n: sb.size());
2333	error = boost::system::error_code();
2334	bytes_transferred = boost::asio::read(s, b&: sb,
2335	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
2336	BOOST_ASIO_CHECK(bytes_transferred == 10);
2337	BOOST_ASIO_CHECK(sb.size() == 10);
2338	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2339	BOOST_ASIO_CHECK(!error);
2340
2341	s.reset(data: read_data, length: sizeof(read_data));
2342	s.next_read_length(length: 1);
2343	sb.consume(n: sb.size());
2344	error = boost::system::error_code();
2345	bytes_transferred = boost::asio::read(s, b&: sb,
2346	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
2347	BOOST_ASIO_CHECK(bytes_transferred == 10);
2348	BOOST_ASIO_CHECK(sb.size() == 10);
2349	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2350	BOOST_ASIO_CHECK(!error);
2351
2352	s.reset(data: read_data, length: sizeof(read_data));
2353	s.next_read_length(length: 10);
2354	sb.consume(n: sb.size());
2355	error = boost::system::error_code();
2356	bytes_transferred = boost::asio::read(s, b&: sb,
2357	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
2358	BOOST_ASIO_CHECK(bytes_transferred == 10);
2359	BOOST_ASIO_CHECK(sb.size() == 10);
2360	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
2361	BOOST_ASIO_CHECK(!error);
2362
2363	s.reset(data: read_data, length: sizeof(read_data));
2364	sb.consume(n: sb.size());
2365	error = boost::system::error_code();
2366	bytes_transferred = boost::asio::read(s, b&: sb,
2367	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
2368	BOOST_ASIO_CHECK(bytes_transferred == 42);
2369	BOOST_ASIO_CHECK(sb.size() == 42);
2370	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2371	BOOST_ASIO_CHECK(!error);
2372
2373	s.reset(data: read_data, length: sizeof(read_data));
2374	s.next_read_length(length: 1);
2375	sb.consume(n: sb.size());
2376	error = boost::system::error_code();
2377	bytes_transferred = boost::asio::read(s, b&: sb,
2378	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
2379	BOOST_ASIO_CHECK(bytes_transferred == 42);
2380	BOOST_ASIO_CHECK(sb.size() == 42);
2381	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2382	BOOST_ASIO_CHECK(!error);
2383
2384	s.reset(data: read_data, length: sizeof(read_data));
2385	s.next_read_length(length: 10);
2386	sb.consume(n: sb.size());
2387	error = boost::system::error_code();
2388	bytes_transferred = boost::asio::read(s, b&: sb,
2389	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
2390	BOOST_ASIO_CHECK(bytes_transferred == 42);
2391	BOOST_ASIO_CHECK(sb.size() == 42);
2392	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
2393	BOOST_ASIO_CHECK(!error);
2394
2395	s.reset(data: read_data, length: sizeof(read_data));
2396	sb.consume(n: sb.size());
2397	bytes_transferred = boost::asio::read(s, b&: sb,
2398	completion_condition: old_style_transfer_all, ec&: error);
2399	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2400	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2401	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2402	BOOST_ASIO_CHECK(!error);
2403
2404	s.reset(data: read_data, length: sizeof(read_data));
2405	s.next_read_length(length: 1);
2406	sb.consume(n: sb.size());
2407	error = boost::system::error_code();
2408	bytes_transferred = boost::asio::read(s, b&: sb,
2409	completion_condition: old_style_transfer_all, ec&: error);
2410	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2411	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2412	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2413	BOOST_ASIO_CHECK(!error);
2414
2415	s.reset(data: read_data, length: sizeof(read_data));
2416	s.next_read_length(length: 10);
2417	sb.consume(n: sb.size());
2418	error = boost::system::error_code();
2419	bytes_transferred = boost::asio::read(s, b&: sb,
2420	completion_condition: old_style_transfer_all, ec&: error);
2421	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2422	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2423	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2424	BOOST_ASIO_CHECK(!error);
2425
2426	s.reset(data: read_data, length: sizeof(read_data));
2427	sb.consume(n: sb.size());
2428	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: short_transfer(), ec&: error);
2429	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2430	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2431	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2432	BOOST_ASIO_CHECK(!error);
2433
2434	s.reset(data: read_data, length: sizeof(read_data));
2435	s.next_read_length(length: 1);
2436	sb.consume(n: sb.size());
2437	error = boost::system::error_code();
2438	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: short_transfer(), ec&: error);
2439	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2440	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2441	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2442	BOOST_ASIO_CHECK(!error);
2443
2444	s.reset(data: read_data, length: sizeof(read_data));
2445	s.next_read_length(length: 10);
2446	sb.consume(n: sb.size());
2447	error = boost::system::error_code();
2448	bytes_transferred = boost::asio::read(s, b&: sb, completion_condition: short_transfer(), ec&: error);
2449	BOOST_ASIO_CHECK(bytes_transferred == sizeof(read_data));
2450	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2451	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2452	BOOST_ASIO_CHECK(!error);
2453	#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2454	}
2455
2456	void async_read_handler(const boost::system::error_code& e,
2457	size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
2458	{
2459	*called = true;
2460	BOOST_ASIO_CHECK(!e);
2461	BOOST_ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
2462	}
2463
2464	void test_3_arg_mutable_buffer_async_read()
2465	{
2466	namespace bindns = std;
2467	using bindns::placeholders::_1;
2468	using bindns::placeholders::_2;
2469
2470	boost::asio::io_context ioc;
2471	test_stream s(ioc);
2472	char read_buf[sizeof(read_data)];
2473	boost::asio::mutable_buffer buffers
2474	= boost::asio::buffer(data&: read_buf, max_size_in_bytes: sizeof(read_buf));
2475
2476	s.reset(data: read_data, length: sizeof(read_data));
2477	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2478	bool called = false;
2479	boost::asio::async_read(s, buffers,
2480	token: bindns::bind(f&: async_read_handler,
2481	args: _1, args: _2, args: sizeof(read_data), args: &called));
2482	ioc.restart();
2483	ioc.run();
2484	BOOST_ASIO_CHECK(called);
2485	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2486
2487	s.reset(data: read_data, length: sizeof(read_data));
2488	s.next_read_length(length: 1);
2489	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2490	called = false;
2491	boost::asio::async_read(s, buffers,
2492	token: bindns::bind(f&: async_read_handler,
2493	args: _1, args: _2, args: sizeof(read_data), args: &called));
2494	ioc.restart();
2495	ioc.run();
2496	BOOST_ASIO_CHECK(called);
2497	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2498
2499	s.reset(data: read_data, length: sizeof(read_data));
2500	s.next_read_length(length: 10);
2501	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2502	called = false;
2503	boost::asio::async_read(s, buffers,
2504	token: bindns::bind(f&: async_read_handler,
2505	args: _1, args: _2, args: sizeof(read_data), args: &called));
2506	ioc.restart();
2507	ioc.run();
2508	BOOST_ASIO_CHECK(called);
2509	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2510
2511	s.reset(data: read_data, length: sizeof(read_data));
2512	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2513	int i = boost::asio::async_read(s, buffers, token: archetypes::lazy_handler());
2514	BOOST_ASIO_CHECK(i == 42);
2515	ioc.restart();
2516	ioc.run();
2517	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2518	}
2519
2520	void test_3_arg_boost_array_buffers_async_read()
2521	{
2522	namespace bindns = std;
2523	using bindns::placeholders::_1;
2524	using bindns::placeholders::_2;
2525
2526	#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2527	boost::asio::io_context ioc;
2528	test_stream s(ioc);
2529	char read_buf[sizeof(read_data)];
2530	boost::array<boost::asio::mutable_buffer, 2> buffers = { .elems: {
2531	boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32),
2532	boost::asio::buffer(data&: read_buf) + 32 } };
2533
2534	s.reset(data: read_data, length: sizeof(read_data));
2535	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2536	bool called = false;
2537	boost::asio::async_read(s, buffers,
2538	token: bindns::bind(f&: async_read_handler,
2539	args: _1, args: _2, args: sizeof(read_data), args: &called));
2540	ioc.restart();
2541	ioc.run();
2542	BOOST_ASIO_CHECK(called);
2543	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2544
2545	s.reset(data: read_data, length: sizeof(read_data));
2546	s.next_read_length(length: 1);
2547	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2548	called = false;
2549	boost::asio::async_read(s, buffers,
2550	token: bindns::bind(f&: async_read_handler,
2551	args: _1, args: _2, args: sizeof(read_data), args: &called));
2552	ioc.restart();
2553	ioc.run();
2554	BOOST_ASIO_CHECK(called);
2555	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2556
2557	s.reset(data: read_data, length: sizeof(read_data));
2558	s.next_read_length(length: 10);
2559	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2560	called = false;
2561	boost::asio::async_read(s, buffers,
2562	token: bindns::bind(f&: async_read_handler,
2563	args: _1, args: _2, args: sizeof(read_data), args: &called));
2564	ioc.restart();
2565	ioc.run();
2566	BOOST_ASIO_CHECK(called);
2567	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2568
2569	s.reset(data: read_data, length: sizeof(read_data));
2570	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2571	int i = boost::asio::async_read(s, buffers, token: archetypes::lazy_handler());
2572	BOOST_ASIO_CHECK(i == 42);
2573	ioc.restart();
2574	ioc.run();
2575	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2576	#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2577	}
2578
2579	void test_3_arg_std_array_buffers_async_read()
2580	{
2581	namespace bindns = std;
2582	using bindns::placeholders::_1;
2583	using bindns::placeholders::_2;
2584
2585	boost::asio::io_context ioc;
2586	test_stream s(ioc);
2587	char read_buf[sizeof(read_data)];
2588	std::array<boost::asio::mutable_buffer, 2> buffers = { ._M_elems: {
2589	boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32),
2590	boost::asio::buffer(data&: read_buf) + 32 } };
2591
2592	s.reset(data: read_data, length: sizeof(read_data));
2593	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2594	bool called = false;
2595	boost::asio::async_read(s, buffers,
2596	token: bindns::bind(f&: async_read_handler,
2597	args: _1, args: _2, args: sizeof(read_data), args: &called));
2598	ioc.restart();
2599	ioc.run();
2600	BOOST_ASIO_CHECK(called);
2601	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2602
2603	s.reset(data: read_data, length: sizeof(read_data));
2604	s.next_read_length(length: 1);
2605	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2606	called = false;
2607	boost::asio::async_read(s, buffers,
2608	token: bindns::bind(f&: async_read_handler,
2609	args: _1, args: _2, args: sizeof(read_data), args: &called));
2610	ioc.restart();
2611	ioc.run();
2612	BOOST_ASIO_CHECK(called);
2613	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2614
2615	s.reset(data: read_data, length: sizeof(read_data));
2616	s.next_read_length(length: 10);
2617	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2618	called = false;
2619	boost::asio::async_read(s, buffers,
2620	token: bindns::bind(f&: async_read_handler,
2621	args: _1, args: _2, args: sizeof(read_data), args: &called));
2622	ioc.restart();
2623	ioc.run();
2624	BOOST_ASIO_CHECK(called);
2625	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2626
2627	s.reset(data: read_data, length: sizeof(read_data));
2628	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2629	int i = boost::asio::async_read(s, buffers, token: archetypes::lazy_handler());
2630	BOOST_ASIO_CHECK(i == 42);
2631	ioc.restart();
2632	ioc.run();
2633	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2634	}
2635
2636	void test_3_arg_vector_buffers_async_read()
2637	{
2638	namespace bindns = std;
2639	using bindns::placeholders::_1;
2640	using bindns::placeholders::_2;
2641
2642	boost::asio::io_context ioc;
2643	test_stream s(ioc);
2644	char read_buf[sizeof(read_data)];
2645	std::vector<boost::asio::mutable_buffer> buffers;
2646	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32));
2647	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 39) + 32);
2648	buffers.push_back(x: boost::asio::buffer(data&: read_buf) + 39);
2649
2650	s.reset(data: read_data, length: sizeof(read_data));
2651	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2652	bool called = false;
2653	boost::asio::async_read(s, buffers,
2654	token: bindns::bind(f&: async_read_handler,
2655	args: _1, args: _2, args: sizeof(read_data), args: &called));
2656	ioc.restart();
2657	ioc.run();
2658	BOOST_ASIO_CHECK(called);
2659	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2660
2661	s.reset(data: read_data, length: sizeof(read_data));
2662	s.next_read_length(length: 1);
2663	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2664	called = false;
2665	boost::asio::async_read(s, buffers,
2666	token: bindns::bind(f&: async_read_handler,
2667	args: _1, args: _2, args: sizeof(read_data), args: &called));
2668	ioc.restart();
2669	ioc.run();
2670	BOOST_ASIO_CHECK(called);
2671	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2672
2673	s.reset(data: read_data, length: sizeof(read_data));
2674	s.next_read_length(length: 10);
2675	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2676	called = false;
2677	boost::asio::async_read(s, buffers,
2678	token: bindns::bind(f&: async_read_handler,
2679	args: _1, args: _2, args: sizeof(read_data), args: &called));
2680	ioc.restart();
2681	ioc.run();
2682	BOOST_ASIO_CHECK(called);
2683	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2684
2685	s.reset(data: read_data, length: sizeof(read_data));
2686	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2687	int i = boost::asio::async_read(s, buffers, token: archetypes::lazy_handler());
2688	BOOST_ASIO_CHECK(i == 42);
2689	ioc.restart();
2690	ioc.run();
2691	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2692	}
2693
2694	void test_3_arg_dynamic_string_async_read()
2695	{
2696	namespace bindns = std;
2697	using bindns::placeholders::_1;
2698	using bindns::placeholders::_2;
2699
2700	boost::asio::io_context ioc;
2701	test_stream s(ioc);
2702	std::string data;
2703	boost::asio::dynamic_string_buffer<char, std::string::traits_type,
2704	std::string::allocator_type> sb
2705	= boost::asio::dynamic_buffer(data, max_size: sizeof(read_data));
2706
2707	s.reset(data: read_data, length: sizeof(read_data));
2708	sb.consume(n: sb.size());
2709	bool called = false;
2710	boost::asio::async_read(s, buffers: sb,
2711	token: bindns::bind(f&: async_read_handler,
2712	args: _1, args: _2, args: sizeof(read_data), args: &called));
2713	ioc.restart();
2714	ioc.run();
2715	BOOST_ASIO_CHECK(called);
2716	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2717	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2718
2719	s.reset(data: read_data, length: sizeof(read_data));
2720	s.next_read_length(length: 1);
2721	sb.consume(n: sb.size());
2722	called = false;
2723	boost::asio::async_read(s, buffers: sb,
2724	token: bindns::bind(f&: async_read_handler,
2725	args: _1, args: _2, args: sizeof(read_data), args: &called));
2726	ioc.restart();
2727	ioc.run();
2728	BOOST_ASIO_CHECK(called);
2729	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2730	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2731
2732	s.reset(data: read_data, length: sizeof(read_data));
2733	s.next_read_length(length: 10);
2734	sb.consume(n: sb.size());
2735	called = false;
2736	boost::asio::async_read(s, buffers: sb,
2737	token: bindns::bind(f&: async_read_handler,
2738	args: _1, args: _2, args: sizeof(read_data), args: &called));
2739	ioc.restart();
2740	ioc.run();
2741	BOOST_ASIO_CHECK(called);
2742	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2743	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2744
2745	s.reset(data: read_data, length: sizeof(read_data));
2746	sb.consume(n: sb.size());
2747	int i = boost::asio::async_read(s, buffers: sb, token: archetypes::lazy_handler());
2748	BOOST_ASIO_CHECK(i == 42);
2749	ioc.restart();
2750	ioc.run();
2751	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2752	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
2753	}
2754
2755	void test_3_arg_streambuf_async_read()
2756	{
2757	#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2758	namespace bindns = std;
2759	using bindns::placeholders::_1;
2760	using bindns::placeholders::_2;
2761
2762	boost::asio::io_context ioc;
2763	test_stream s(ioc);
2764	boost::asio::streambuf sb(sizeof(read_data));
2765
2766	s.reset(data: read_data, length: sizeof(read_data));
2767	sb.consume(n: sb.size());
2768	bool called = false;
2769	boost::asio::async_read(s, b&: sb,
2770	token: bindns::bind(f&: async_read_handler,
2771	args: _1, args: _2, args: sizeof(read_data), args: &called));
2772	ioc.restart();
2773	ioc.run();
2774	BOOST_ASIO_CHECK(called);
2775	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2776	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2777
2778	s.reset(data: read_data, length: sizeof(read_data));
2779	s.next_read_length(length: 1);
2780	sb.consume(n: sb.size());
2781	called = false;
2782	boost::asio::async_read(s, b&: sb,
2783	token: bindns::bind(f&: async_read_handler,
2784	args: _1, args: _2, args: sizeof(read_data), args: &called));
2785	ioc.restart();
2786	ioc.run();
2787	BOOST_ASIO_CHECK(called);
2788	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2789	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2790
2791	s.reset(data: read_data, length: sizeof(read_data));
2792	s.next_read_length(length: 10);
2793	sb.consume(n: sb.size());
2794	called = false;
2795	boost::asio::async_read(s, b&: sb,
2796	token: bindns::bind(f&: async_read_handler,
2797	args: _1, args: _2, args: sizeof(read_data), args: &called));
2798	ioc.restart();
2799	ioc.run();
2800	BOOST_ASIO_CHECK(called);
2801	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2802	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2803
2804	s.reset(data: read_data, length: sizeof(read_data));
2805	sb.consume(n: sb.size());
2806	int i = boost::asio::async_read(s, b&: sb, token: archetypes::lazy_handler());
2807	BOOST_ASIO_CHECK(i == 42);
2808	ioc.restart();
2809	ioc.run();
2810	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
2811	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
2812	#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
2813	}
2814
2815	void test_4_arg_mutable_buffer_async_read()
2816	{
2817	namespace bindns = std;
2818	using bindns::placeholders::_1;
2819	using bindns::placeholders::_2;
2820
2821	boost::asio::io_context ioc;
2822	test_stream s(ioc);
2823	char read_buf[sizeof(read_data)];
2824	boost::asio::mutable_buffer buffers
2825	= boost::asio::buffer(data&: read_buf, max_size_in_bytes: sizeof(read_buf));
2826
2827	s.reset(data: read_data, length: sizeof(read_data));
2828	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2829	bool called = false;
2830	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
2831	token: bindns::bind(f&: async_read_handler,
2832	args: _1, args: _2, args: sizeof(read_data), args: &called));
2833	ioc.restart();
2834	ioc.run();
2835	BOOST_ASIO_CHECK(called);
2836	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2837
2838	s.reset(data: read_data, length: sizeof(read_data));
2839	s.next_read_length(length: 1);
2840	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2841	called = false;
2842	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
2843	token: bindns::bind(f&: async_read_handler,
2844	args: _1, args: _2, args: sizeof(read_data), args: &called));
2845	ioc.restart();
2846	ioc.run();
2847	BOOST_ASIO_CHECK(called);
2848	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2849
2850	s.reset(data: read_data, length: sizeof(read_data));
2851	s.next_read_length(length: 10);
2852	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2853	called = false;
2854	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
2855	token: bindns::bind(f&: async_read_handler,
2856	args: _1, args: _2, args: sizeof(read_data), args: &called));
2857	ioc.restart();
2858	ioc.run();
2859	BOOST_ASIO_CHECK(called);
2860	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2861
2862	s.reset(data: read_data, length: sizeof(read_data));
2863	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2864	called = false;
2865	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2866	token: bindns::bind(f&: async_read_handler,
2867	args: _1, args: _2, args: sizeof(read_data), args: &called));
2868	ioc.restart();
2869	ioc.run();
2870	BOOST_ASIO_CHECK(called);
2871	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2872
2873	s.reset(data: read_data, length: sizeof(read_data));
2874	s.next_read_length(length: 1);
2875	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2876	called = false;
2877	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2878	token: bindns::bind(f&: async_read_handler,
2879	args: _1, args: _2, args: 1, args: &called));
2880	ioc.restart();
2881	ioc.run();
2882	BOOST_ASIO_CHECK(called);
2883	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2884
2885	s.reset(data: read_data, length: sizeof(read_data));
2886	s.next_read_length(length: 10);
2887	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2888	called = false;
2889	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2890	token: bindns::bind(f&: async_read_handler,
2891	args: _1, args: _2, args: 10, args: &called));
2892	ioc.restart();
2893	ioc.run();
2894	BOOST_ASIO_CHECK(called);
2895	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2896
2897	s.reset(data: read_data, length: sizeof(read_data));
2898	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2899	called = false;
2900	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2901	token: bindns::bind(f&: async_read_handler,
2902	args: _1, args: _2, args: sizeof(read_data), args: &called));
2903	ioc.restart();
2904	ioc.run();
2905	BOOST_ASIO_CHECK(called);
2906	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2907
2908	s.reset(data: read_data, length: sizeof(read_data));
2909	s.next_read_length(length: 1);
2910	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2911	called = false;
2912	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2913	token: bindns::bind(f&: async_read_handler,
2914	args: _1, args: _2, args: 10, args: &called));
2915	ioc.restart();
2916	ioc.run();
2917	BOOST_ASIO_CHECK(called);
2918	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2919
2920	s.reset(data: read_data, length: sizeof(read_data));
2921	s.next_read_length(length: 10);
2922	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2923	called = false;
2924	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2925	token: bindns::bind(f&: async_read_handler,
2926	args: _1, args: _2, args: 10, args: &called));
2927	ioc.restart();
2928	ioc.run();
2929	BOOST_ASIO_CHECK(called);
2930	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2931
2932	s.reset(data: read_data, length: sizeof(read_data));
2933	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2934	called = false;
2935	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2936	token: bindns::bind(f&: async_read_handler,
2937	args: _1, args: _2, args: sizeof(read_data), args: &called));
2938	ioc.restart();
2939	ioc.run();
2940	BOOST_ASIO_CHECK(called);
2941	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
2942
2943	s.reset(data: read_data, length: sizeof(read_data));
2944	s.next_read_length(length: 1);
2945	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2946	called = false;
2947	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2948	token: bindns::bind(f&: async_read_handler,
2949	args: _1, args: _2, args: 42, args: &called));
2950	ioc.restart();
2951	ioc.run();
2952	BOOST_ASIO_CHECK(called);
2953	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2954
2955	s.reset(data: read_data, length: sizeof(read_data));
2956	s.next_read_length(length: 10);
2957	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2958	called = false;
2959	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2960	token: bindns::bind(f&: async_read_handler,
2961	args: _1, args: _2, args: 50, args: &called));
2962	ioc.restart();
2963	ioc.run();
2964	BOOST_ASIO_CHECK(called);
2965	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
2966
2967	s.reset(data: read_data, length: sizeof(read_data));
2968	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2969	called = false;
2970	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2971	token: bindns::bind(f&: async_read_handler,
2972	args: _1, args: _2, args: 1, args: &called));
2973	ioc.restart();
2974	ioc.run();
2975	BOOST_ASIO_CHECK(called);
2976	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2977
2978	s.reset(data: read_data, length: sizeof(read_data));
2979	s.next_read_length(length: 1);
2980	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2981	called = false;
2982	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2983	token: bindns::bind(f&: async_read_handler,
2984	args: _1, args: _2, args: 1, args: &called));
2985	ioc.restart();
2986	ioc.run();
2987	BOOST_ASIO_CHECK(called);
2988	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2989
2990	s.reset(data: read_data, length: sizeof(read_data));
2991	s.next_read_length(length: 10);
2992	memset(s: read_buf, c: 0, n: sizeof(read_buf));
2993	called = false;
2994	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2995	token: bindns::bind(f&: async_read_handler,
2996	args: _1, args: _2, args: 1, args: &called));
2997	ioc.restart();
2998	ioc.run();
2999	BOOST_ASIO_CHECK(called);
3000	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3001
3002	s.reset(data: read_data, length: sizeof(read_data));
3003	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3004	called = false;
3005	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3006	token: bindns::bind(f&: async_read_handler,
3007	args: _1, args: _2, args: 10, args: &called));
3008	ioc.restart();
3009	ioc.run();
3010	BOOST_ASIO_CHECK(called);
3011	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3012
3013	s.reset(data: read_data, length: sizeof(read_data));
3014	s.next_read_length(length: 1);
3015	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3016	called = false;
3017	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3018	token: bindns::bind(f&: async_read_handler,
3019	args: _1, args: _2, args: 10, args: &called));
3020	ioc.restart();
3021	ioc.run();
3022	BOOST_ASIO_CHECK(called);
3023	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3024
3025	s.reset(data: read_data, length: sizeof(read_data));
3026	s.next_read_length(length: 10);
3027	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3028	called = false;
3029	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3030	token: bindns::bind(f&: async_read_handler,
3031	args: _1, args: _2, args: 10, args: &called));
3032	ioc.restart();
3033	ioc.run();
3034	BOOST_ASIO_CHECK(called);
3035	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3036
3037	s.reset(data: read_data, length: sizeof(read_data));
3038	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3039	called = false;
3040	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3041	token: bindns::bind(f&: async_read_handler,
3042	args: _1, args: _2, args: 42, args: &called));
3043	ioc.restart();
3044	ioc.run();
3045	BOOST_ASIO_CHECK(called);
3046	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3047
3048	s.reset(data: read_data, length: sizeof(read_data));
3049	s.next_read_length(length: 1);
3050	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3051	called = false;
3052	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3053	token: bindns::bind(f&: async_read_handler,
3054	args: _1, args: _2, args: 42, args: &called));
3055	ioc.restart();
3056	ioc.run();
3057	BOOST_ASIO_CHECK(called);
3058	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3059
3060	s.reset(data: read_data, length: sizeof(read_data));
3061	s.next_read_length(length: 10);
3062	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3063	called = false;
3064	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3065	token: bindns::bind(f&: async_read_handler,
3066	args: _1, args: _2, args: 42, args: &called));
3067	ioc.restart();
3068	ioc.run();
3069	BOOST_ASIO_CHECK(called);
3070	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3071
3072	s.reset(data: read_data, length: sizeof(read_data));
3073	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3074	called = false;
3075	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3076	token: bindns::bind(f&: async_read_handler,
3077	args: _1, args: _2, args: sizeof(read_data), args: &called));
3078	ioc.restart();
3079	ioc.run();
3080	BOOST_ASIO_CHECK(called);
3081	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3082
3083	s.reset(data: read_data, length: sizeof(read_data));
3084	s.next_read_length(length: 1);
3085	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3086	called = false;
3087	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3088	token: bindns::bind(f&: async_read_handler,
3089	args: _1, args: _2, args: sizeof(read_data), args: &called));
3090	ioc.restart();
3091	ioc.run();
3092	BOOST_ASIO_CHECK(called);
3093	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3094
3095	s.reset(data: read_data, length: sizeof(read_data));
3096	s.next_read_length(length: 10);
3097	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3098	called = false;
3099	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3100	token: bindns::bind(f&: async_read_handler,
3101	args: _1, args: _2, args: sizeof(read_data), args: &called));
3102	ioc.restart();
3103	ioc.run();
3104	BOOST_ASIO_CHECK(called);
3105	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3106
3107	s.reset(data: read_data, length: sizeof(read_data));
3108	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3109	called = false;
3110	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3111	token: bindns::bind(f&: async_read_handler,
3112	args: _1, args: _2, args: sizeof(read_data), args: &called));
3113	ioc.restart();
3114	ioc.run();
3115	BOOST_ASIO_CHECK(called);
3116	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3117
3118	s.reset(data: read_data, length: sizeof(read_data));
3119	s.next_read_length(length: 1);
3120	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3121	called = false;
3122	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3123	token: bindns::bind(f&: async_read_handler,
3124	args: _1, args: _2, args: sizeof(read_data), args: &called));
3125	ioc.restart();
3126	ioc.run();
3127	BOOST_ASIO_CHECK(called);
3128	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3129
3130	s.reset(data: read_data, length: sizeof(read_data));
3131	s.next_read_length(length: 10);
3132	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3133	called = false;
3134	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3135	token: bindns::bind(f&: async_read_handler,
3136	args: _1, args: _2, args: sizeof(read_data), args: &called));
3137	ioc.restart();
3138	ioc.run();
3139	BOOST_ASIO_CHECK(called);
3140	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3141
3142	s.reset(data: read_data, length: sizeof(read_data));
3143	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3144	int i = boost::asio::async_read(s, buffers,
3145	completion_condition: short_transfer(), token: archetypes::lazy_handler());
3146	BOOST_ASIO_CHECK(i == 42);
3147	ioc.restart();
3148	ioc.run();
3149	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3150	}
3151
3152	void test_4_arg_boost_array_buffers_async_read()
3153	{
3154	namespace bindns = std;
3155	using bindns::placeholders::_1;
3156	using bindns::placeholders::_2;
3157
3158	#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
3159	boost::asio::io_context ioc;
3160	test_stream s(ioc);
3161	char read_buf[sizeof(read_data)];
3162	boost::array<boost::asio::mutable_buffer, 2> buffers = { .elems: {
3163	boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32),
3164	boost::asio::buffer(data&: read_buf) + 32 } };
3165
3166	s.reset(data: read_data, length: sizeof(read_data));
3167	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3168	bool called = false;
3169	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3170	token: bindns::bind(f&: async_read_handler,
3171	args: _1, args: _2, args: sizeof(read_data), args: &called));
3172	ioc.restart();
3173	ioc.run();
3174	BOOST_ASIO_CHECK(called);
3175	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3176
3177	s.reset(data: read_data, length: sizeof(read_data));
3178	s.next_read_length(length: 1);
3179	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3180	called = false;
3181	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3182	token: bindns::bind(f&: async_read_handler,
3183	args: _1, args: _2, args: sizeof(read_data), args: &called));
3184	ioc.restart();
3185	ioc.run();
3186	BOOST_ASIO_CHECK(called);
3187	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3188
3189	s.reset(data: read_data, length: sizeof(read_data));
3190	s.next_read_length(length: 10);
3191	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3192	called = false;
3193	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3194	token: bindns::bind(f&: async_read_handler,
3195	args: _1, args: _2, args: sizeof(read_data), args: &called));
3196	ioc.restart();
3197	ioc.run();
3198	BOOST_ASIO_CHECK(called);
3199	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3200
3201	s.reset(data: read_data, length: sizeof(read_data));
3202	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3203	called = false;
3204	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3205	token: bindns::bind(f&: async_read_handler,
3206	args: _1, args: _2, args: sizeof(read_data), args: &called));
3207	ioc.restart();
3208	ioc.run();
3209	BOOST_ASIO_CHECK(called);
3210	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3211
3212	s.reset(data: read_data, length: sizeof(read_data));
3213	s.next_read_length(length: 1);
3214	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3215	called = false;
3216	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3217	token: bindns::bind(f&: async_read_handler,
3218	args: _1, args: _2, args: 1, args: &called));
3219	ioc.restart();
3220	ioc.run();
3221	BOOST_ASIO_CHECK(called);
3222	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3223
3224	s.reset(data: read_data, length: sizeof(read_data));
3225	s.next_read_length(length: 10);
3226	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3227	called = false;
3228	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3229	token: bindns::bind(f&: async_read_handler,
3230	args: _1, args: _2, args: 10, args: &called));
3231	ioc.restart();
3232	ioc.run();
3233	BOOST_ASIO_CHECK(called);
3234	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3235
3236	s.reset(data: read_data, length: sizeof(read_data));
3237	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3238	called = false;
3239	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3240	token: bindns::bind(f&: async_read_handler,
3241	args: _1, args: _2, args: sizeof(read_data), args: &called));
3242	ioc.restart();
3243	ioc.run();
3244	BOOST_ASIO_CHECK(called);
3245	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3246
3247	s.reset(data: read_data, length: sizeof(read_data));
3248	s.next_read_length(length: 1);
3249	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3250	called = false;
3251	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3252	token: bindns::bind(f&: async_read_handler,
3253	args: _1, args: _2, args: 10, args: &called));
3254	ioc.restart();
3255	ioc.run();
3256	BOOST_ASIO_CHECK(called);
3257	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3258
3259	s.reset(data: read_data, length: sizeof(read_data));
3260	s.next_read_length(length: 10);
3261	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3262	called = false;
3263	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3264	token: bindns::bind(f&: async_read_handler,
3265	args: _1, args: _2, args: 10, args: &called));
3266	ioc.restart();
3267	ioc.run();
3268	BOOST_ASIO_CHECK(called);
3269	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3270
3271	s.reset(data: read_data, length: sizeof(read_data));
3272	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3273	called = false;
3274	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3275	token: bindns::bind(f&: async_read_handler,
3276	args: _1, args: _2, args: sizeof(read_data), args: &called));
3277	ioc.restart();
3278	ioc.run();
3279	BOOST_ASIO_CHECK(called);
3280	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3281
3282	s.reset(data: read_data, length: sizeof(read_data));
3283	s.next_read_length(length: 1);
3284	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3285	called = false;
3286	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3287	token: bindns::bind(f&: async_read_handler,
3288	args: _1, args: _2, args: 42, args: &called));
3289	ioc.restart();
3290	ioc.run();
3291	BOOST_ASIO_CHECK(called);
3292	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3293
3294	s.reset(data: read_data, length: sizeof(read_data));
3295	s.next_read_length(length: 10);
3296	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3297	called = false;
3298	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3299	token: bindns::bind(f&: async_read_handler,
3300	args: _1, args: _2, args: 50, args: &called));
3301	ioc.restart();
3302	ioc.run();
3303	BOOST_ASIO_CHECK(called);
3304	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3305
3306	s.reset(data: read_data, length: sizeof(read_data));
3307	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3308	called = false;
3309	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3310	token: bindns::bind(f&: async_read_handler,
3311	args: _1, args: _2, args: 1, args: &called));
3312	ioc.restart();
3313	ioc.run();
3314	BOOST_ASIO_CHECK(called);
3315	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3316
3317	s.reset(data: read_data, length: sizeof(read_data));
3318	s.next_read_length(length: 1);
3319	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3320	called = false;
3321	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3322	token: bindns::bind(f&: async_read_handler,
3323	args: _1, args: _2, args: 1, args: &called));
3324	ioc.restart();
3325	ioc.run();
3326	BOOST_ASIO_CHECK(called);
3327	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3328
3329	s.reset(data: read_data, length: sizeof(read_data));
3330	s.next_read_length(length: 10);
3331	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3332	called = false;
3333	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3334	token: bindns::bind(f&: async_read_handler,
3335	args: _1, args: _2, args: 1, args: &called));
3336	ioc.restart();
3337	ioc.run();
3338	BOOST_ASIO_CHECK(called);
3339	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3340
3341	s.reset(data: read_data, length: sizeof(read_data));
3342	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3343	called = false;
3344	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3345	token: bindns::bind(f&: async_read_handler,
3346	args: _1, args: _2, args: 10, args: &called));
3347	ioc.restart();
3348	ioc.run();
3349	BOOST_ASIO_CHECK(called);
3350	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3351
3352	s.reset(data: read_data, length: sizeof(read_data));
3353	s.next_read_length(length: 1);
3354	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3355	called = false;
3356	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3357	token: bindns::bind(f&: async_read_handler,
3358	args: _1, args: _2, args: 10, args: &called));
3359	ioc.restart();
3360	ioc.run();
3361	BOOST_ASIO_CHECK(called);
3362	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3363
3364	s.reset(data: read_data, length: sizeof(read_data));
3365	s.next_read_length(length: 10);
3366	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3367	called = false;
3368	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3369	token: bindns::bind(f&: async_read_handler,
3370	args: _1, args: _2, args: 10, args: &called));
3371	ioc.restart();
3372	ioc.run();
3373	BOOST_ASIO_CHECK(called);
3374	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3375
3376	s.reset(data: read_data, length: sizeof(read_data));
3377	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3378	called = false;
3379	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3380	token: bindns::bind(f&: async_read_handler,
3381	args: _1, args: _2, args: 42, args: &called));
3382	ioc.restart();
3383	ioc.run();
3384	BOOST_ASIO_CHECK(called);
3385	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3386
3387	s.reset(data: read_data, length: sizeof(read_data));
3388	s.next_read_length(length: 1);
3389	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3390	called = false;
3391	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3392	token: bindns::bind(f&: async_read_handler,
3393	args: _1, args: _2, args: 42, args: &called));
3394	ioc.restart();
3395	ioc.run();
3396	BOOST_ASIO_CHECK(called);
3397	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3398
3399	s.reset(data: read_data, length: sizeof(read_data));
3400	s.next_read_length(length: 10);
3401	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3402	called = false;
3403	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3404	token: bindns::bind(f&: async_read_handler,
3405	args: _1, args: _2, args: 42, args: &called));
3406	ioc.restart();
3407	ioc.run();
3408	BOOST_ASIO_CHECK(called);
3409	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3410
3411	s.reset(data: read_data, length: sizeof(read_data));
3412	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3413	called = false;
3414	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3415	token: bindns::bind(f&: async_read_handler,
3416	args: _1, args: _2, args: sizeof(read_data), args: &called));
3417	ioc.restart();
3418	ioc.run();
3419	BOOST_ASIO_CHECK(called);
3420	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3421
3422	s.reset(data: read_data, length: sizeof(read_data));
3423	s.next_read_length(length: 1);
3424	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3425	called = false;
3426	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3427	token: bindns::bind(f&: async_read_handler,
3428	args: _1, args: _2, args: sizeof(read_data), args: &called));
3429	ioc.restart();
3430	ioc.run();
3431	BOOST_ASIO_CHECK(called);
3432	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3433
3434	s.reset(data: read_data, length: sizeof(read_data));
3435	s.next_read_length(length: 10);
3436	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3437	called = false;
3438	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3439	token: bindns::bind(f&: async_read_handler,
3440	args: _1, args: _2, args: sizeof(read_data), args: &called));
3441	ioc.restart();
3442	ioc.run();
3443	BOOST_ASIO_CHECK(called);
3444	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3445
3446	s.reset(data: read_data, length: sizeof(read_data));
3447	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3448	called = false;
3449	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3450	token: bindns::bind(f&: async_read_handler,
3451	args: _1, args: _2, args: sizeof(read_data), args: &called));
3452	ioc.restart();
3453	ioc.run();
3454	BOOST_ASIO_CHECK(called);
3455	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3456
3457	s.reset(data: read_data, length: sizeof(read_data));
3458	s.next_read_length(length: 1);
3459	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3460	called = false;
3461	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3462	token: bindns::bind(f&: async_read_handler,
3463	args: _1, args: _2, args: sizeof(read_data), args: &called));
3464	ioc.restart();
3465	ioc.run();
3466	BOOST_ASIO_CHECK(called);
3467	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3468
3469	s.reset(data: read_data, length: sizeof(read_data));
3470	s.next_read_length(length: 10);
3471	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3472	called = false;
3473	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3474	token: bindns::bind(f&: async_read_handler,
3475	args: _1, args: _2, args: sizeof(read_data), args: &called));
3476	ioc.restart();
3477	ioc.run();
3478	BOOST_ASIO_CHECK(called);
3479	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3480
3481	s.reset(data: read_data, length: sizeof(read_data));
3482	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3483	int i = boost::asio::async_read(s, buffers,
3484	completion_condition: short_transfer(), token: archetypes::lazy_handler());
3485	BOOST_ASIO_CHECK(i == 42);
3486	ioc.restart();
3487	ioc.run();
3488	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3489	#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
3490	}
3491
3492	void test_4_arg_std_array_buffers_async_read()
3493	{
3494	namespace bindns = std;
3495	using bindns::placeholders::_1;
3496	using bindns::placeholders::_2;
3497
3498	boost::asio::io_context ioc;
3499	test_stream s(ioc);
3500	char read_buf[sizeof(read_data)];
3501	std::array<boost::asio::mutable_buffer, 2> buffers = { ._M_elems: {
3502	boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32),
3503	boost::asio::buffer(data&: read_buf) + 32 } };
3504
3505	s.reset(data: read_data, length: sizeof(read_data));
3506	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3507	bool called = false;
3508	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3509	token: bindns::bind(f&: async_read_handler,
3510	args: _1, args: _2, args: sizeof(read_data), args: &called));
3511	ioc.restart();
3512	ioc.run();
3513	BOOST_ASIO_CHECK(called);
3514	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3515
3516	s.reset(data: read_data, length: sizeof(read_data));
3517	s.next_read_length(length: 1);
3518	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3519	called = false;
3520	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3521	token: bindns::bind(f&: async_read_handler,
3522	args: _1, args: _2, args: sizeof(read_data), args: &called));
3523	ioc.restart();
3524	ioc.run();
3525	BOOST_ASIO_CHECK(called);
3526	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3527
3528	s.reset(data: read_data, length: sizeof(read_data));
3529	s.next_read_length(length: 10);
3530	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3531	called = false;
3532	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3533	token: bindns::bind(f&: async_read_handler,
3534	args: _1, args: _2, args: sizeof(read_data), args: &called));
3535	ioc.restart();
3536	ioc.run();
3537	BOOST_ASIO_CHECK(called);
3538	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3539
3540	s.reset(data: read_data, length: sizeof(read_data));
3541	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3542	called = false;
3543	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3544	token: bindns::bind(f&: async_read_handler,
3545	args: _1, args: _2, args: sizeof(read_data), args: &called));
3546	ioc.restart();
3547	ioc.run();
3548	BOOST_ASIO_CHECK(called);
3549	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3550
3551	s.reset(data: read_data, length: sizeof(read_data));
3552	s.next_read_length(length: 1);
3553	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3554	called = false;
3555	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3556	token: bindns::bind(f&: async_read_handler,
3557	args: _1, args: _2, args: 1, args: &called));
3558	ioc.restart();
3559	ioc.run();
3560	BOOST_ASIO_CHECK(called);
3561	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3562
3563	s.reset(data: read_data, length: sizeof(read_data));
3564	s.next_read_length(length: 10);
3565	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3566	called = false;
3567	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3568	token: bindns::bind(f&: async_read_handler,
3569	args: _1, args: _2, args: 10, args: &called));
3570	ioc.restart();
3571	ioc.run();
3572	BOOST_ASIO_CHECK(called);
3573	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3574
3575	s.reset(data: read_data, length: sizeof(read_data));
3576	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3577	called = false;
3578	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3579	token: bindns::bind(f&: async_read_handler,
3580	args: _1, args: _2, args: sizeof(read_data), args: &called));
3581	ioc.restart();
3582	ioc.run();
3583	BOOST_ASIO_CHECK(called);
3584	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3585
3586	s.reset(data: read_data, length: sizeof(read_data));
3587	s.next_read_length(length: 1);
3588	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3589	called = false;
3590	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3591	token: bindns::bind(f&: async_read_handler,
3592	args: _1, args: _2, args: 10, args: &called));
3593	ioc.restart();
3594	ioc.run();
3595	BOOST_ASIO_CHECK(called);
3596	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3597
3598	s.reset(data: read_data, length: sizeof(read_data));
3599	s.next_read_length(length: 10);
3600	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3601	called = false;
3602	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3603	token: bindns::bind(f&: async_read_handler,
3604	args: _1, args: _2, args: 10, args: &called));
3605	ioc.restart();
3606	ioc.run();
3607	BOOST_ASIO_CHECK(called);
3608	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3609
3610	s.reset(data: read_data, length: sizeof(read_data));
3611	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3612	called = false;
3613	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3614	token: bindns::bind(f&: async_read_handler,
3615	args: _1, args: _2, args: sizeof(read_data), args: &called));
3616	ioc.restart();
3617	ioc.run();
3618	BOOST_ASIO_CHECK(called);
3619	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3620
3621	s.reset(data: read_data, length: sizeof(read_data));
3622	s.next_read_length(length: 1);
3623	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3624	called = false;
3625	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3626	token: bindns::bind(f&: async_read_handler,
3627	args: _1, args: _2, args: 42, args: &called));
3628	ioc.restart();
3629	ioc.run();
3630	BOOST_ASIO_CHECK(called);
3631	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3632
3633	s.reset(data: read_data, length: sizeof(read_data));
3634	s.next_read_length(length: 10);
3635	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3636	called = false;
3637	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3638	token: bindns::bind(f&: async_read_handler,
3639	args: _1, args: _2, args: 50, args: &called));
3640	ioc.restart();
3641	ioc.run();
3642	BOOST_ASIO_CHECK(called);
3643	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3644
3645	s.reset(data: read_data, length: sizeof(read_data));
3646	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3647	called = false;
3648	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3649	token: bindns::bind(f&: async_read_handler,
3650	args: _1, args: _2, args: 1, args: &called));
3651	ioc.restart();
3652	ioc.run();
3653	BOOST_ASIO_CHECK(called);
3654	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3655
3656	s.reset(data: read_data, length: sizeof(read_data));
3657	s.next_read_length(length: 1);
3658	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3659	called = false;
3660	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3661	token: bindns::bind(f&: async_read_handler,
3662	args: _1, args: _2, args: 1, args: &called));
3663	ioc.restart();
3664	ioc.run();
3665	BOOST_ASIO_CHECK(called);
3666	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3667
3668	s.reset(data: read_data, length: sizeof(read_data));
3669	s.next_read_length(length: 10);
3670	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3671	called = false;
3672	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3673	token: bindns::bind(f&: async_read_handler,
3674	args: _1, args: _2, args: 1, args: &called));
3675	ioc.restart();
3676	ioc.run();
3677	BOOST_ASIO_CHECK(called);
3678	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3679
3680	s.reset(data: read_data, length: sizeof(read_data));
3681	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3682	called = false;
3683	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3684	token: bindns::bind(f&: async_read_handler,
3685	args: _1, args: _2, args: 10, args: &called));
3686	ioc.restart();
3687	ioc.run();
3688	BOOST_ASIO_CHECK(called);
3689	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3690
3691	s.reset(data: read_data, length: sizeof(read_data));
3692	s.next_read_length(length: 1);
3693	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3694	called = false;
3695	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3696	token: bindns::bind(f&: async_read_handler,
3697	args: _1, args: _2, args: 10, args: &called));
3698	ioc.restart();
3699	ioc.run();
3700	BOOST_ASIO_CHECK(called);
3701	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3702
3703	s.reset(data: read_data, length: sizeof(read_data));
3704	s.next_read_length(length: 10);
3705	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3706	called = false;
3707	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3708	token: bindns::bind(f&: async_read_handler,
3709	args: _1, args: _2, args: 10, args: &called));
3710	ioc.restart();
3711	ioc.run();
3712	BOOST_ASIO_CHECK(called);
3713	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3714
3715	s.reset(data: read_data, length: sizeof(read_data));
3716	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3717	called = false;
3718	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3719	token: bindns::bind(f&: async_read_handler,
3720	args: _1, args: _2, args: 42, args: &called));
3721	ioc.restart();
3722	ioc.run();
3723	BOOST_ASIO_CHECK(called);
3724	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3725
3726	s.reset(data: read_data, length: sizeof(read_data));
3727	s.next_read_length(length: 1);
3728	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3729	called = false;
3730	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3731	token: bindns::bind(f&: async_read_handler,
3732	args: _1, args: _2, args: 42, args: &called));
3733	ioc.restart();
3734	ioc.run();
3735	BOOST_ASIO_CHECK(called);
3736	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3737
3738	s.reset(data: read_data, length: sizeof(read_data));
3739	s.next_read_length(length: 10);
3740	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3741	called = false;
3742	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3743	token: bindns::bind(f&: async_read_handler,
3744	args: _1, args: _2, args: 42, args: &called));
3745	ioc.restart();
3746	ioc.run();
3747	BOOST_ASIO_CHECK(called);
3748	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3749
3750	s.reset(data: read_data, length: sizeof(read_data));
3751	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3752	called = false;
3753	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3754	token: bindns::bind(f&: async_read_handler,
3755	args: _1, args: _2, args: sizeof(read_data), args: &called));
3756	ioc.restart();
3757	ioc.run();
3758	BOOST_ASIO_CHECK(called);
3759	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3760
3761	s.reset(data: read_data, length: sizeof(read_data));
3762	s.next_read_length(length: 1);
3763	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3764	called = false;
3765	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3766	token: bindns::bind(f&: async_read_handler,
3767	args: _1, args: _2, args: sizeof(read_data), args: &called));
3768	ioc.restart();
3769	ioc.run();
3770	BOOST_ASIO_CHECK(called);
3771	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3772
3773	s.reset(data: read_data, length: sizeof(read_data));
3774	s.next_read_length(length: 10);
3775	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3776	called = false;
3777	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
3778	token: bindns::bind(f&: async_read_handler,
3779	args: _1, args: _2, args: sizeof(read_data), args: &called));
3780	ioc.restart();
3781	ioc.run();
3782	BOOST_ASIO_CHECK(called);
3783	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3784
3785	s.reset(data: read_data, length: sizeof(read_data));
3786	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3787	called = false;
3788	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3789	token: bindns::bind(f&: async_read_handler,
3790	args: _1, args: _2, args: sizeof(read_data), args: &called));
3791	ioc.restart();
3792	ioc.run();
3793	BOOST_ASIO_CHECK(called);
3794	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3795
3796	s.reset(data: read_data, length: sizeof(read_data));
3797	s.next_read_length(length: 1);
3798	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3799	called = false;
3800	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3801	token: bindns::bind(f&: async_read_handler,
3802	args: _1, args: _2, args: sizeof(read_data), args: &called));
3803	ioc.restart();
3804	ioc.run();
3805	BOOST_ASIO_CHECK(called);
3806	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3807
3808	s.reset(data: read_data, length: sizeof(read_data));
3809	s.next_read_length(length: 10);
3810	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3811	called = false;
3812	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
3813	token: bindns::bind(f&: async_read_handler,
3814	args: _1, args: _2, args: sizeof(read_data), args: &called));
3815	ioc.restart();
3816	ioc.run();
3817	BOOST_ASIO_CHECK(called);
3818	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3819
3820	s.reset(data: read_data, length: sizeof(read_data));
3821	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3822	int i = boost::asio::async_read(s, buffers,
3823	completion_condition: short_transfer(), token: archetypes::lazy_handler());
3824	BOOST_ASIO_CHECK(i == 42);
3825	ioc.restart();
3826	ioc.run();
3827	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3828	}
3829
3830	void test_4_arg_vector_buffers_async_read()
3831	{
3832	namespace bindns = std;
3833	using bindns::placeholders::_1;
3834	using bindns::placeholders::_2;
3835
3836	boost::asio::io_context ioc;
3837	test_stream s(ioc);
3838	char read_buf[sizeof(read_data)];
3839	std::vector<boost::asio::mutable_buffer> buffers;
3840	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 32));
3841	buffers.push_back(x: boost::asio::buffer(data&: read_buf, max_size_in_bytes: 39) + 32);
3842	buffers.push_back(x: boost::asio::buffer(data&: read_buf) + 39);
3843
3844	s.reset(data: read_data, length: sizeof(read_data));
3845	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3846	bool called = false;
3847	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3848	token: bindns::bind(f&: async_read_handler,
3849	args: _1, args: _2, args: sizeof(read_data), args: &called));
3850	ioc.restart();
3851	ioc.run();
3852	BOOST_ASIO_CHECK(called);
3853	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3854
3855	s.reset(data: read_data, length: sizeof(read_data));
3856	s.next_read_length(length: 1);
3857	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3858	called = false;
3859	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3860	token: bindns::bind(f&: async_read_handler,
3861	args: _1, args: _2, args: sizeof(read_data), args: &called));
3862	ioc.restart();
3863	ioc.run();
3864	BOOST_ASIO_CHECK(called);
3865	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3866
3867	s.reset(data: read_data, length: sizeof(read_data));
3868	s.next_read_length(length: 10);
3869	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3870	called = false;
3871	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_all(),
3872	token: bindns::bind(f&: async_read_handler,
3873	args: _1, args: _2, args: sizeof(read_data), args: &called));
3874	ioc.restart();
3875	ioc.run();
3876	BOOST_ASIO_CHECK(called);
3877	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3878
3879	s.reset(data: read_data, length: sizeof(read_data));
3880	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3881	called = false;
3882	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3883	token: bindns::bind(f&: async_read_handler,
3884	args: _1, args: _2, args: sizeof(read_data), args: &called));
3885	ioc.restart();
3886	ioc.run();
3887	BOOST_ASIO_CHECK(called);
3888	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3889
3890	s.reset(data: read_data, length: sizeof(read_data));
3891	s.next_read_length(length: 1);
3892	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3893	called = false;
3894	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3895	token: bindns::bind(f&: async_read_handler,
3896	args: _1, args: _2, args: 1, args: &called));
3897	ioc.restart();
3898	ioc.run();
3899	BOOST_ASIO_CHECK(called);
3900	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3901
3902	s.reset(data: read_data, length: sizeof(read_data));
3903	s.next_read_length(length: 10);
3904	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3905	called = false;
3906	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3907	token: bindns::bind(f&: async_read_handler,
3908	args: _1, args: _2, args: 10, args: &called));
3909	ioc.restart();
3910	ioc.run();
3911	BOOST_ASIO_CHECK(called);
3912	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3913
3914	s.reset(data: read_data, length: sizeof(read_data));
3915	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3916	called = false;
3917	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3918	token: bindns::bind(f&: async_read_handler,
3919	args: _1, args: _2, args: sizeof(read_data), args: &called));
3920	ioc.restart();
3921	ioc.run();
3922	BOOST_ASIO_CHECK(called);
3923	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3924
3925	s.reset(data: read_data, length: sizeof(read_data));
3926	s.next_read_length(length: 1);
3927	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3928	called = false;
3929	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3930	token: bindns::bind(f&: async_read_handler,
3931	args: _1, args: _2, args: 10, args: &called));
3932	ioc.restart();
3933	ioc.run();
3934	BOOST_ASIO_CHECK(called);
3935	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3936
3937	s.reset(data: read_data, length: sizeof(read_data));
3938	s.next_read_length(length: 10);
3939	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3940	called = false;
3941	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3942	token: bindns::bind(f&: async_read_handler,
3943	args: _1, args: _2, args: 10, args: &called));
3944	ioc.restart();
3945	ioc.run();
3946	BOOST_ASIO_CHECK(called);
3947	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3948
3949	s.reset(data: read_data, length: sizeof(read_data));
3950	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3951	called = false;
3952	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3953	token: bindns::bind(f&: async_read_handler,
3954	args: _1, args: _2, args: sizeof(read_data), args: &called));
3955	ioc.restart();
3956	ioc.run();
3957	BOOST_ASIO_CHECK(called);
3958	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
3959
3960	s.reset(data: read_data, length: sizeof(read_data));
3961	s.next_read_length(length: 1);
3962	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3963	called = false;
3964	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3965	token: bindns::bind(f&: async_read_handler,
3966	args: _1, args: _2, args: 42, args: &called));
3967	ioc.restart();
3968	ioc.run();
3969	BOOST_ASIO_CHECK(called);
3970	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3971
3972	s.reset(data: read_data, length: sizeof(read_data));
3973	s.next_read_length(length: 10);
3974	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3975	called = false;
3976	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3977	token: bindns::bind(f&: async_read_handler,
3978	args: _1, args: _2, args: 50, args: &called));
3979	ioc.restart();
3980	ioc.run();
3981	BOOST_ASIO_CHECK(called);
3982	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3983
3984	s.reset(data: read_data, length: sizeof(read_data));
3985	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3986	called = false;
3987	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3988	token: bindns::bind(f&: async_read_handler,
3989	args: _1, args: _2, args: 1, args: &called));
3990	ioc.restart();
3991	ioc.run();
3992	BOOST_ASIO_CHECK(called);
3993	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3994
3995	s.reset(data: read_data, length: sizeof(read_data));
3996	s.next_read_length(length: 1);
3997	memset(s: read_buf, c: 0, n: sizeof(read_buf));
3998	called = false;
3999	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
4000	token: bindns::bind(f&: async_read_handler,
4001	args: _1, args: _2, args: 1, args: &called));
4002	ioc.restart();
4003	ioc.run();
4004	BOOST_ASIO_CHECK(called);
4005	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
4006
4007	s.reset(data: read_data, length: sizeof(read_data));
4008	s.next_read_length(length: 10);
4009	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4010	called = false;
4011	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
4012	token: bindns::bind(f&: async_read_handler,
4013	args: _1, args: _2, args: 1, args: &called));
4014	ioc.restart();
4015	ioc.run();
4016	BOOST_ASIO_CHECK(called);
4017	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
4018
4019	s.reset(data: read_data, length: sizeof(read_data));
4020	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4021	called = false;
4022	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
4023	token: bindns::bind(f&: async_read_handler,
4024	args: _1, args: _2, args: 10, args: &called));
4025	ioc.restart();
4026	ioc.run();
4027	BOOST_ASIO_CHECK(called);
4028	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4029
4030	s.reset(data: read_data, length: sizeof(read_data));
4031	s.next_read_length(length: 1);
4032	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4033	called = false;
4034	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
4035	token: bindns::bind(f&: async_read_handler,
4036	args: _1, args: _2, args: 10, args: &called));
4037	ioc.restart();
4038	ioc.run();
4039	BOOST_ASIO_CHECK(called);
4040	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4041
4042	s.reset(data: read_data, length: sizeof(read_data));
4043	s.next_read_length(length: 10);
4044	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4045	called = false;
4046	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
4047	token: bindns::bind(f&: async_read_handler,
4048	args: _1, args: _2, args: 10, args: &called));
4049	ioc.restart();
4050	ioc.run();
4051	BOOST_ASIO_CHECK(called);
4052	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
4053
4054	s.reset(data: read_data, length: sizeof(read_data));
4055	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4056	called = false;
4057	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
4058	token: bindns::bind(f&: async_read_handler,
4059	args: _1, args: _2, args: 42, args: &called));
4060	ioc.restart();
4061	ioc.run();
4062	BOOST_ASIO_CHECK(called);
4063	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
4064
4065	s.reset(data: read_data, length: sizeof(read_data));
4066	s.next_read_length(length: 1);
4067	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4068	called = false;
4069	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
4070	token: bindns::bind(f&: async_read_handler,
4071	args: _1, args: _2, args: 42, args: &called));
4072	ioc.restart();
4073	ioc.run();
4074	BOOST_ASIO_CHECK(called);
4075	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
4076
4077	s.reset(data: read_data, length: sizeof(read_data));
4078	s.next_read_length(length: 10);
4079	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4080	called = false;
4081	boost::asio::async_read(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
4082	token: bindns::bind(f&: async_read_handler,
4083	args: _1, args: _2, args: 42, args: &called));
4084	ioc.restart();
4085	ioc.run();
4086	BOOST_ASIO_CHECK(called);
4087	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
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(s, buffers, completion_condition: old_style_transfer_all,
4093	token: bindns::bind(f&: async_read_handler,
4094	args: _1, args: _2, args: sizeof(read_data), args: &called));
4095	ioc.restart();
4096	ioc.run();
4097	BOOST_ASIO_CHECK(called);
4098	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4099
4100	s.reset(data: read_data, length: sizeof(read_data));
4101	s.next_read_length(length: 1);
4102	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4103	called = false;
4104	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
4105	token: bindns::bind(f&: async_read_handler,
4106	args: _1, args: _2, args: sizeof(read_data), args: &called));
4107	ioc.restart();
4108	ioc.run();
4109	BOOST_ASIO_CHECK(called);
4110	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4111
4112	s.reset(data: read_data, length: sizeof(read_data));
4113	s.next_read_length(length: 10);
4114	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4115	called = false;
4116	boost::asio::async_read(s, buffers, completion_condition: old_style_transfer_all,
4117	token: bindns::bind(f&: async_read_handler,
4118	args: _1, args: _2, args: sizeof(read_data), args: &called));
4119	ioc.restart();
4120	ioc.run();
4121	BOOST_ASIO_CHECK(called);
4122	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4123
4124	s.reset(data: read_data, length: sizeof(read_data));
4125	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4126	called = false;
4127	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
4128	token: bindns::bind(f&: async_read_handler,
4129	args: _1, args: _2, args: sizeof(read_data), args: &called));
4130	ioc.restart();
4131	ioc.run();
4132	BOOST_ASIO_CHECK(called);
4133	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4134
4135	s.reset(data: read_data, length: sizeof(read_data));
4136	s.next_read_length(length: 1);
4137	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4138	called = false;
4139	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
4140	token: bindns::bind(f&: async_read_handler,
4141	args: _1, args: _2, args: sizeof(read_data), args: &called));
4142	ioc.restart();
4143	ioc.run();
4144	BOOST_ASIO_CHECK(called);
4145	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4146
4147	s.reset(data: read_data, length: sizeof(read_data));
4148	s.next_read_length(length: 10);
4149	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4150	called = false;
4151	boost::asio::async_read(s, buffers, completion_condition: short_transfer(),
4152	token: bindns::bind(f&: async_read_handler,
4153	args: _1, args: _2, args: sizeof(read_data), args: &called));
4154	ioc.restart();
4155	ioc.run();
4156	BOOST_ASIO_CHECK(called);
4157	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4158
4159	s.reset(data: read_data, length: sizeof(read_data));
4160	memset(s: read_buf, c: 0, n: sizeof(read_buf));
4161	int i = boost::asio::async_read(s, buffers,
4162	completion_condition: short_transfer(), token: archetypes::lazy_handler());
4163	BOOST_ASIO_CHECK(i == 42);
4164	ioc.restart();
4165	ioc.run();
4166	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
4167	}
4168
4169	void test_4_arg_dynamic_string_async_read()
4170	{
4171	namespace bindns = std;
4172	using bindns::placeholders::_1;
4173	using bindns::placeholders::_2;
4174
4175	boost::asio::io_context ioc;
4176	test_stream s(ioc);
4177	std::string data;
4178	boost::asio::dynamic_string_buffer<char, std::string::traits_type,
4179	std::string::allocator_type> sb
4180	= boost::asio::dynamic_buffer(data, max_size: sizeof(read_data));
4181
4182	s.reset(data: read_data, length: sizeof(read_data));
4183	sb.consume(n: sb.size());
4184	bool called = false;
4185	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_all(),
4186	token: bindns::bind(f&: async_read_handler,
4187	args: _1, args: _2, args: sizeof(read_data), args: &called));
4188	ioc.restart();
4189	ioc.run();
4190	BOOST_ASIO_CHECK(called);
4191	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4192	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4193
4194	s.reset(data: read_data, length: sizeof(read_data));
4195	s.next_read_length(length: 1);
4196	sb.consume(n: sb.size());
4197	called = false;
4198	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_all(),
4199	token: bindns::bind(f&: async_read_handler,
4200	args: _1, args: _2, args: sizeof(read_data), args: &called));
4201	ioc.restart();
4202	ioc.run();
4203	BOOST_ASIO_CHECK(called);
4204	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4205	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4206
4207	s.reset(data: read_data, length: sizeof(read_data));
4208	s.next_read_length(length: 10);
4209	sb.consume(n: sb.size());
4210	called = false;
4211	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_all(),
4212	token: bindns::bind(f&: async_read_handler,
4213	args: _1, args: _2, args: sizeof(read_data), args: &called));
4214	ioc.restart();
4215	ioc.run();
4216	BOOST_ASIO_CHECK(called);
4217	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4218	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4219
4220	s.reset(data: read_data, length: sizeof(read_data));
4221	sb.consume(n: sb.size());
4222	called = false;
4223	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
4224	token: bindns::bind(f&: async_read_handler,
4225	args: _1, args: _2, args: sizeof(read_data), args: &called));
4226	ioc.restart();
4227	ioc.run();
4228	BOOST_ASIO_CHECK(called);
4229	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4230	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4231
4232	s.reset(data: read_data, length: sizeof(read_data));
4233	s.next_read_length(length: 1);
4234	sb.consume(n: sb.size());
4235	called = false;
4236	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
4237	token: bindns::bind(f&: async_read_handler,
4238	args: _1, args: _2, args: 1, args: &called));
4239	ioc.restart();
4240	ioc.run();
4241	BOOST_ASIO_CHECK(called);
4242	BOOST_ASIO_CHECK(sb.size() == 1);
4243	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4244
4245	s.reset(data: read_data, length: sizeof(read_data));
4246	s.next_read_length(length: 10);
4247	sb.consume(n: sb.size());
4248	called = false;
4249	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
4250	token: bindns::bind(f&: async_read_handler,
4251	args: _1, args: _2, args: 10, args: &called));
4252	ioc.restart();
4253	ioc.run();
4254	BOOST_ASIO_CHECK(called);
4255	BOOST_ASIO_CHECK(sb.size() == 10);
4256	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4257
4258	s.reset(data: read_data, length: sizeof(read_data));
4259	sb.consume(n: sb.size());
4260	called = false;
4261	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
4262	token: bindns::bind(f&: async_read_handler,
4263	args: _1, args: _2, args: sizeof(read_data), args: &called));
4264	ioc.restart();
4265	ioc.run();
4266	BOOST_ASIO_CHECK(called);
4267	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4268	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4269
4270	s.reset(data: read_data, length: sizeof(read_data));
4271	s.next_read_length(length: 1);
4272	sb.consume(n: sb.size());
4273	called = false;
4274	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
4275	token: bindns::bind(f&: async_read_handler,
4276	args: _1, args: _2, args: 10, args: &called));
4277	ioc.restart();
4278	ioc.run();
4279	BOOST_ASIO_CHECK(called);
4280	BOOST_ASIO_CHECK(sb.size() == 10);
4281	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4282
4283	s.reset(data: read_data, length: sizeof(read_data));
4284	s.next_read_length(length: 10);
4285	sb.consume(n: sb.size());
4286	called = false;
4287	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
4288	token: bindns::bind(f&: async_read_handler,
4289	args: _1, args: _2, args: 10, args: &called));
4290	ioc.restart();
4291	ioc.run();
4292	BOOST_ASIO_CHECK(called);
4293	BOOST_ASIO_CHECK(sb.size() == 10);
4294	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4295
4296	s.reset(data: read_data, length: sizeof(read_data));
4297	sb.consume(n: sb.size());
4298	called = false;
4299	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
4300	token: bindns::bind(f&: async_read_handler,
4301	args: _1, args: _2, args: sizeof(read_data), args: &called));
4302	ioc.restart();
4303	ioc.run();
4304	BOOST_ASIO_CHECK(called);
4305	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4306	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4307
4308	s.reset(data: read_data, length: sizeof(read_data));
4309	s.next_read_length(length: 1);
4310	sb.consume(n: sb.size());
4311	called = false;
4312	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
4313	token: bindns::bind(f&: async_read_handler,
4314	args: _1, args: _2, args: 42, args: &called));
4315	ioc.restart();
4316	ioc.run();
4317	BOOST_ASIO_CHECK(called);
4318	BOOST_ASIO_CHECK(sb.size() == 42);
4319	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4320
4321	s.reset(data: read_data, length: sizeof(read_data));
4322	s.next_read_length(length: 10);
4323	sb.consume(n: sb.size());
4324	called = false;
4325	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
4326	token: bindns::bind(f&: async_read_handler,
4327	args: _1, args: _2, args: 50, args: &called));
4328	ioc.restart();
4329	ioc.run();
4330	BOOST_ASIO_CHECK(called);
4331	BOOST_ASIO_CHECK(sb.size() == 50);
4332	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
4333
4334	s.reset(data: read_data, length: sizeof(read_data));
4335	sb.consume(n: sb.size());
4336	called = false;
4337	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
4338	token: bindns::bind(f&: async_read_handler,
4339	args: _1, args: _2, args: 1, args: &called));
4340	ioc.restart();
4341	ioc.run();
4342	BOOST_ASIO_CHECK(called);
4343	BOOST_ASIO_CHECK(sb.size() == 1);
4344	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4345
4346	s.reset(data: read_data, length: sizeof(read_data));
4347	s.next_read_length(length: 1);
4348	sb.consume(n: sb.size());
4349	called = false;
4350	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
4351	token: bindns::bind(f&: async_read_handler,
4352	args: _1, args: _2, args: 1, args: &called));
4353	ioc.restart();
4354	ioc.run();
4355	BOOST_ASIO_CHECK(called);
4356	BOOST_ASIO_CHECK(sb.size() == 1);
4357	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4358
4359	s.reset(data: read_data, length: sizeof(read_data));
4360	s.next_read_length(length: 10);
4361	sb.consume(n: sb.size());
4362	called = false;
4363	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
4364	token: bindns::bind(f&: async_read_handler,
4365	args: _1, args: _2, args: 1, args: &called));
4366	ioc.restart();
4367	ioc.run();
4368	BOOST_ASIO_CHECK(called);
4369	BOOST_ASIO_CHECK(sb.size() == 1);
4370	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
4371
4372	s.reset(data: read_data, length: sizeof(read_data));
4373	sb.consume(n: sb.size());
4374	called = false;
4375	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
4376	token: bindns::bind(f&: async_read_handler,
4377	args: _1, args: _2, args: 10, args: &called));
4378	ioc.restart();
4379	ioc.run();
4380	BOOST_ASIO_CHECK(called);
4381	BOOST_ASIO_CHECK(sb.size() == 10);
4382	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4383
4384	s.reset(data: read_data, length: sizeof(read_data));
4385	s.next_read_length(length: 1);
4386	sb.consume(n: sb.size());
4387	called = false;
4388	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
4389	token: bindns::bind(f&: async_read_handler,
4390	args: _1, args: _2, args: 10, args: &called));
4391	ioc.restart();
4392	ioc.run();
4393	BOOST_ASIO_CHECK(called);
4394	BOOST_ASIO_CHECK(sb.size() == 10);
4395	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4396
4397	s.reset(data: read_data, length: sizeof(read_data));
4398	s.next_read_length(length: 10);
4399	sb.consume(n: sb.size());
4400	called = false;
4401	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
4402	token: bindns::bind(f&: async_read_handler,
4403	args: _1, args: _2, args: 10, args: &called));
4404	ioc.restart();
4405	ioc.run();
4406	BOOST_ASIO_CHECK(called);
4407	BOOST_ASIO_CHECK(sb.size() == 10);
4408	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
4409
4410	s.reset(data: read_data, length: sizeof(read_data));
4411	sb.consume(n: sb.size());
4412	called = false;
4413	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
4414	token: bindns::bind(f&: async_read_handler,
4415	args: _1, args: _2, args: 42, args: &called));
4416	ioc.restart();
4417	ioc.run();
4418	BOOST_ASIO_CHECK(called);
4419	BOOST_ASIO_CHECK(sb.size() == 42);
4420	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4421
4422	s.reset(data: read_data, length: sizeof(read_data));
4423	s.next_read_length(length: 1);
4424	sb.consume(n: sb.size());
4425	called = false;
4426	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
4427	token: bindns::bind(f&: async_read_handler,
4428	args: _1, args: _2, args: 42, args: &called));
4429	ioc.restart();
4430	ioc.run();
4431	BOOST_ASIO_CHECK(called);
4432	BOOST_ASIO_CHECK(sb.size() == 42);
4433	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4434
4435	s.reset(data: read_data, length: sizeof(read_data));
4436	s.next_read_length(length: 10);
4437	sb.consume(n: sb.size());
4438	called = false;
4439	boost::asio::async_read(s, buffers: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
4440	token: bindns::bind(f&: async_read_handler,
4441	args: _1, args: _2, args: 42, args: &called));
4442	ioc.restart();
4443	ioc.run();
4444	BOOST_ASIO_CHECK(called);
4445	BOOST_ASIO_CHECK(sb.size() == 42);
4446	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
4447
4448	s.reset(data: read_data, length: sizeof(read_data));
4449	sb.consume(n: sb.size());
4450	called = false;
4451	boost::asio::async_read(s, buffers: sb, completion_condition: old_style_transfer_all,
4452	token: bindns::bind(f&: async_read_handler,
4453	args: _1, args: _2, args: sizeof(read_data), args: &called));
4454	ioc.restart();
4455	ioc.run();
4456	BOOST_ASIO_CHECK(called);
4457	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4458	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4459
4460	s.reset(data: read_data, length: sizeof(read_data));
4461	s.next_read_length(length: 1);
4462	sb.consume(n: sb.size());
4463	called = false;
4464	boost::asio::async_read(s, buffers: sb, completion_condition: old_style_transfer_all,
4465	token: bindns::bind(f&: async_read_handler,
4466	args: _1, args: _2, args: sizeof(read_data), args: &called));
4467	ioc.restart();
4468	ioc.run();
4469	BOOST_ASIO_CHECK(called);
4470	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4471	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4472
4473	s.reset(data: read_data, length: sizeof(read_data));
4474	s.next_read_length(length: 10);
4475	sb.consume(n: sb.size());
4476	called = false;
4477	boost::asio::async_read(s, buffers: sb, completion_condition: old_style_transfer_all,
4478	token: bindns::bind(f&: async_read_handler,
4479	args: _1, args: _2, args: sizeof(read_data), args: &called));
4480	ioc.restart();
4481	ioc.run();
4482	BOOST_ASIO_CHECK(called);
4483	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4484	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4485
4486	s.reset(data: read_data, length: sizeof(read_data));
4487	sb.consume(n: sb.size());
4488	called = false;
4489	boost::asio::async_read(s, buffers: sb, completion_condition: short_transfer(),
4490	token: bindns::bind(f&: async_read_handler,
4491	args: _1, args: _2, args: sizeof(read_data), args: &called));
4492	ioc.restart();
4493	ioc.run();
4494	BOOST_ASIO_CHECK(called);
4495	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4496	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4497
4498	s.reset(data: read_data, length: sizeof(read_data));
4499	s.next_read_length(length: 1);
4500	sb.consume(n: sb.size());
4501	called = false;
4502	boost::asio::async_read(s, buffers: sb, completion_condition: short_transfer(),
4503	token: bindns::bind(f&: async_read_handler,
4504	args: _1, args: _2, args: sizeof(read_data), args: &called));
4505	ioc.restart();
4506	ioc.run();
4507	BOOST_ASIO_CHECK(called);
4508	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4509	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4510
4511	s.reset(data: read_data, length: sizeof(read_data));
4512	s.next_read_length(length: 10);
4513	sb.consume(n: sb.size());
4514	called = false;
4515	boost::asio::async_read(s, buffers: sb, completion_condition: short_transfer(),
4516	token: bindns::bind(f&: async_read_handler,
4517	args: _1, args: _2, args: sizeof(read_data), args: &called));
4518	ioc.restart();
4519	ioc.run();
4520	BOOST_ASIO_CHECK(called);
4521	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4522	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4523
4524	s.reset(data: read_data, length: sizeof(read_data));
4525	sb.consume(n: sb.size());
4526	int i = boost::asio::async_read(s, buffers: sb,
4527	completion_condition: short_transfer(), token: archetypes::lazy_handler());
4528	BOOST_ASIO_CHECK(i == 42);
4529	ioc.restart();
4530	ioc.run();
4531	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4532	BOOST_ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
4533	}
4534
4535	void test_4_arg_streambuf_async_read()
4536	{
4537	#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
4538	namespace bindns = std;
4539	using bindns::placeholders::_1;
4540	using bindns::placeholders::_2;
4541
4542	boost::asio::io_context ioc;
4543	test_stream s(ioc);
4544	boost::asio::streambuf sb(sizeof(read_data));
4545
4546	s.reset(data: read_data, length: sizeof(read_data));
4547	sb.consume(n: sb.size());
4548	bool called = false;
4549	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_all(),
4550	token: bindns::bind(f&: async_read_handler,
4551	args: _1, args: _2, args: sizeof(read_data), args: &called));
4552	ioc.restart();
4553	ioc.run();
4554	BOOST_ASIO_CHECK(called);
4555	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4556	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4557
4558	s.reset(data: read_data, length: sizeof(read_data));
4559	s.next_read_length(length: 1);
4560	sb.consume(n: sb.size());
4561	called = false;
4562	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_all(),
4563	token: bindns::bind(f&: async_read_handler,
4564	args: _1, args: _2, args: sizeof(read_data), args: &called));
4565	ioc.restart();
4566	ioc.run();
4567	BOOST_ASIO_CHECK(called);
4568	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4569	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4570
4571	s.reset(data: read_data, length: sizeof(read_data));
4572	s.next_read_length(length: 10);
4573	sb.consume(n: sb.size());
4574	called = false;
4575	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_all(),
4576	token: bindns::bind(f&: async_read_handler,
4577	args: _1, args: _2, args: sizeof(read_data), args: &called));
4578	ioc.restart();
4579	ioc.run();
4580	BOOST_ASIO_CHECK(called);
4581	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4582	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4583
4584	s.reset(data: read_data, length: sizeof(read_data));
4585	sb.consume(n: sb.size());
4586	called = false;
4587	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
4588	token: bindns::bind(f&: async_read_handler,
4589	args: _1, args: _2, args: sizeof(read_data), args: &called));
4590	ioc.restart();
4591	ioc.run();
4592	BOOST_ASIO_CHECK(called);
4593	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4594	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4595
4596	s.reset(data: read_data, length: sizeof(read_data));
4597	s.next_read_length(length: 1);
4598	sb.consume(n: sb.size());
4599	called = false;
4600	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
4601	token: bindns::bind(f&: async_read_handler,
4602	args: _1, args: _2, args: 1, args: &called));
4603	ioc.restart();
4604	ioc.run();
4605	BOOST_ASIO_CHECK(called);
4606	BOOST_ASIO_CHECK(sb.size() == 1);
4607	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4608
4609	s.reset(data: read_data, length: sizeof(read_data));
4610	s.next_read_length(length: 10);
4611	sb.consume(n: sb.size());
4612	called = false;
4613	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
4614	token: bindns::bind(f&: async_read_handler,
4615	args: _1, args: _2, args: 10, args: &called));
4616	ioc.restart();
4617	ioc.run();
4618	BOOST_ASIO_CHECK(called);
4619	BOOST_ASIO_CHECK(sb.size() == 10);
4620	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4621
4622	s.reset(data: read_data, length: sizeof(read_data));
4623	sb.consume(n: sb.size());
4624	called = false;
4625	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
4626	token: bindns::bind(f&: async_read_handler,
4627	args: _1, args: _2, args: sizeof(read_data), args: &called));
4628	ioc.restart();
4629	ioc.run();
4630	BOOST_ASIO_CHECK(called);
4631	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4632	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4633
4634	s.reset(data: read_data, length: sizeof(read_data));
4635	s.next_read_length(length: 1);
4636	sb.consume(n: sb.size());
4637	called = false;
4638	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
4639	token: bindns::bind(f&: async_read_handler,
4640	args: _1, args: _2, args: 10, args: &called));
4641	ioc.restart();
4642	ioc.run();
4643	BOOST_ASIO_CHECK(called);
4644	BOOST_ASIO_CHECK(sb.size() == 10);
4645	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4646
4647	s.reset(data: read_data, length: sizeof(read_data));
4648	s.next_read_length(length: 10);
4649	sb.consume(n: sb.size());
4650	called = false;
4651	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
4652	token: bindns::bind(f&: async_read_handler,
4653	args: _1, args: _2, args: 10, args: &called));
4654	ioc.restart();
4655	ioc.run();
4656	BOOST_ASIO_CHECK(called);
4657	BOOST_ASIO_CHECK(sb.size() == 10);
4658	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4659
4660	s.reset(data: read_data, length: sizeof(read_data));
4661	sb.consume(n: sb.size());
4662	called = false;
4663	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
4664	token: bindns::bind(f&: async_read_handler,
4665	args: _1, args: _2, args: sizeof(read_data), args: &called));
4666	ioc.restart();
4667	ioc.run();
4668	BOOST_ASIO_CHECK(called);
4669	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4670	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4671
4672	s.reset(data: read_data, length: sizeof(read_data));
4673	s.next_read_length(length: 1);
4674	sb.consume(n: sb.size());
4675	called = false;
4676	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
4677	token: bindns::bind(f&: async_read_handler,
4678	args: _1, args: _2, args: 42, args: &called));
4679	ioc.restart();
4680	ioc.run();
4681	BOOST_ASIO_CHECK(called);
4682	BOOST_ASIO_CHECK(sb.size() == 42);
4683	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4684
4685	s.reset(data: read_data, length: sizeof(read_data));
4686	s.next_read_length(length: 10);
4687	sb.consume(n: sb.size());
4688	called = false;
4689	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
4690	token: bindns::bind(f&: async_read_handler,
4691	args: _1, args: _2, args: 50, args: &called));
4692	ioc.restart();
4693	ioc.run();
4694	BOOST_ASIO_CHECK(called);
4695	BOOST_ASIO_CHECK(sb.size() == 50);
4696	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 50));
4697
4698	s.reset(data: read_data, length: sizeof(read_data));
4699	sb.consume(n: sb.size());
4700	called = false;
4701	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
4702	token: bindns::bind(f&: async_read_handler,
4703	args: _1, args: _2, args: 1, args: &called));
4704	ioc.restart();
4705	ioc.run();
4706	BOOST_ASIO_CHECK(called);
4707	BOOST_ASIO_CHECK(sb.size() == 1);
4708	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4709
4710	s.reset(data: read_data, length: sizeof(read_data));
4711	s.next_read_length(length: 1);
4712	sb.consume(n: sb.size());
4713	called = false;
4714	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
4715	token: bindns::bind(f&: async_read_handler,
4716	args: _1, args: _2, args: 1, args: &called));
4717	ioc.restart();
4718	ioc.run();
4719	BOOST_ASIO_CHECK(called);
4720	BOOST_ASIO_CHECK(sb.size() == 1);
4721	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4722
4723	s.reset(data: read_data, length: sizeof(read_data));
4724	s.next_read_length(length: 10);
4725	sb.consume(n: sb.size());
4726	called = false;
4727	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
4728	token: bindns::bind(f&: async_read_handler,
4729	args: _1, args: _2, args: 1, args: &called));
4730	ioc.restart();
4731	ioc.run();
4732	BOOST_ASIO_CHECK(called);
4733	BOOST_ASIO_CHECK(sb.size() == 1);
4734	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 1));
4735
4736	s.reset(data: read_data, length: sizeof(read_data));
4737	sb.consume(n: sb.size());
4738	called = false;
4739	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
4740	token: bindns::bind(f&: async_read_handler,
4741	args: _1, args: _2, args: 10, args: &called));
4742	ioc.restart();
4743	ioc.run();
4744	BOOST_ASIO_CHECK(called);
4745	BOOST_ASIO_CHECK(sb.size() == 10);
4746	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4747
4748	s.reset(data: read_data, length: sizeof(read_data));
4749	s.next_read_length(length: 1);
4750	sb.consume(n: sb.size());
4751	called = false;
4752	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
4753	token: bindns::bind(f&: async_read_handler,
4754	args: _1, args: _2, args: 10, args: &called));
4755	ioc.restart();
4756	ioc.run();
4757	BOOST_ASIO_CHECK(called);
4758	BOOST_ASIO_CHECK(sb.size() == 10);
4759	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4760
4761	s.reset(data: read_data, length: sizeof(read_data));
4762	s.next_read_length(length: 10);
4763	sb.consume(n: sb.size());
4764	called = false;
4765	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
4766	token: bindns::bind(f&: async_read_handler,
4767	args: _1, args: _2, args: 10, args: &called));
4768	ioc.restart();
4769	ioc.run();
4770	BOOST_ASIO_CHECK(called);
4771	BOOST_ASIO_CHECK(sb.size() == 10);
4772	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 10));
4773
4774	s.reset(data: read_data, length: sizeof(read_data));
4775	sb.consume(n: sb.size());
4776	called = false;
4777	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
4778	token: bindns::bind(f&: async_read_handler,
4779	args: _1, args: _2, args: 42, args: &called));
4780	ioc.restart();
4781	ioc.run();
4782	BOOST_ASIO_CHECK(called);
4783	BOOST_ASIO_CHECK(sb.size() == 42);
4784	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4785
4786	s.reset(data: read_data, length: sizeof(read_data));
4787	s.next_read_length(length: 1);
4788	sb.consume(n: sb.size());
4789	called = false;
4790	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
4791	token: bindns::bind(f&: async_read_handler,
4792	args: _1, args: _2, args: 42, args: &called));
4793	ioc.restart();
4794	ioc.run();
4795	BOOST_ASIO_CHECK(called);
4796	BOOST_ASIO_CHECK(sb.size() == 42);
4797	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4798
4799	s.reset(data: read_data, length: sizeof(read_data));
4800	s.next_read_length(length: 10);
4801	sb.consume(n: sb.size());
4802	called = false;
4803	boost::asio::async_read(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
4804	token: bindns::bind(f&: async_read_handler,
4805	args: _1, args: _2, args: 42, args: &called));
4806	ioc.restart();
4807	ioc.run();
4808	BOOST_ASIO_CHECK(called);
4809	BOOST_ASIO_CHECK(sb.size() == 42);
4810	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), 42));
4811
4812	s.reset(data: read_data, length: sizeof(read_data));
4813	sb.consume(n: sb.size());
4814	called = false;
4815	boost::asio::async_read(s, b&: sb, completion_condition: old_style_transfer_all,
4816	token: bindns::bind(f&: async_read_handler,
4817	args: _1, args: _2, args: sizeof(read_data), args: &called));
4818	ioc.restart();
4819	ioc.run();
4820	BOOST_ASIO_CHECK(called);
4821	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4822	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4823
4824	s.reset(data: read_data, length: sizeof(read_data));
4825	s.next_read_length(length: 1);
4826	sb.consume(n: sb.size());
4827	called = false;
4828	boost::asio::async_read(s, b&: sb, completion_condition: old_style_transfer_all,
4829	token: bindns::bind(f&: async_read_handler,
4830	args: _1, args: _2, args: sizeof(read_data), args: &called));
4831	ioc.restart();
4832	ioc.run();
4833	BOOST_ASIO_CHECK(called);
4834	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4835	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4836
4837	s.reset(data: read_data, length: sizeof(read_data));
4838	s.next_read_length(length: 10);
4839	sb.consume(n: sb.size());
4840	called = false;
4841	boost::asio::async_read(s, b&: sb, completion_condition: old_style_transfer_all,
4842	token: bindns::bind(f&: async_read_handler,
4843	args: _1, args: _2, args: sizeof(read_data), args: &called));
4844	ioc.restart();
4845	ioc.run();
4846	BOOST_ASIO_CHECK(called);
4847	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4848	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4849
4850	s.reset(data: read_data, length: sizeof(read_data));
4851	sb.consume(n: sb.size());
4852	called = false;
4853	boost::asio::async_read(s, b&: sb, completion_condition: short_transfer(),
4854	token: bindns::bind(f&: async_read_handler,
4855	args: _1, args: _2, args: sizeof(read_data), args: &called));
4856	ioc.restart();
4857	ioc.run();
4858	BOOST_ASIO_CHECK(called);
4859	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4860	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4861
4862	s.reset(data: read_data, length: sizeof(read_data));
4863	s.next_read_length(length: 1);
4864	sb.consume(n: sb.size());
4865	called = false;
4866	boost::asio::async_read(s, b&: sb, completion_condition: short_transfer(),
4867	token: bindns::bind(f&: async_read_handler,
4868	args: _1, args: _2, args: sizeof(read_data), args: &called));
4869	ioc.restart();
4870	ioc.run();
4871	BOOST_ASIO_CHECK(called);
4872	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4873	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4874
4875	s.reset(data: read_data, length: sizeof(read_data));
4876	s.next_read_length(length: 10);
4877	sb.consume(n: sb.size());
4878	called = false;
4879	boost::asio::async_read(s, b&: sb, completion_condition: short_transfer(),
4880	token: bindns::bind(f&: async_read_handler,
4881	args: _1, args: _2, args: sizeof(read_data), args: &called));
4882	ioc.restart();
4883	ioc.run();
4884	BOOST_ASIO_CHECK(called);
4885	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4886	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4887
4888	s.reset(data: read_data, length: sizeof(read_data));
4889	sb.consume(n: sb.size());
4890	int i = boost::asio::async_read(s, b&: sb,
4891	completion_condition: short_transfer(), token: archetypes::lazy_handler());
4892	BOOST_ASIO_CHECK(i == 42);
4893	ioc.restart();
4894	ioc.run();
4895	BOOST_ASIO_CHECK(sb.size() == sizeof(read_data));
4896	BOOST_ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
4897	#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
4898	}
4899
4900	BOOST_ASIO_TEST_SUITE
4901	(
4902	"read",
4903	BOOST_ASIO_TEST_CASE(test_2_arg_zero_buffers_read)
4904	BOOST_ASIO_TEST_CASE(test_2_arg_mutable_buffer_read)
4905	BOOST_ASIO_TEST_CASE(test_2_arg_vector_buffers_read)
4906	BOOST_ASIO_TEST_CASE(test_2_arg_dynamic_string_read)
4907	BOOST_ASIO_TEST_CASE(test_2_arg_streambuf_read)
4908	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_read)
4909	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_read)
4910	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_read)
4911	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_dynamic_string_read)
4912	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_streambuf_read)
4913	BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_read)
4914	BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_read)
4915	BOOST_ASIO_TEST_CASE(test_3_arg_dynamic_string_read)
4916	BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_read)
4917	BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_read)
4918	BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_read)
4919	BOOST_ASIO_TEST_CASE(test_4_arg_dynamic_string_read)
4920	BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_read)
4921	BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_read)
4922	BOOST_ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_read)
4923	BOOST_ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_read)
4924	BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_async_read)
4925	BOOST_ASIO_TEST_CASE(test_3_arg_dynamic_string_async_read)
4926	BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_async_read)
4927	BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read)
4928	BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read)
4929	BOOST_ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read)
4930	BOOST_ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read)
4931	BOOST_ASIO_TEST_CASE(test_4_arg_dynamic_string_async_read)
4932	BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_async_read)
4933	)
4934