1	//
2	// write.cpp
3	// ~~~~~~~~~
4	//
5	// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6	//
7	// Distributed under the Boost Software License, Version 1.0. (See accompanying
8	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9	//
10
11	// Disable autolinking for unit tests.
12	#if !defined(BOOST_ALL_NO_LIB)
13	#define BOOST_ALL_NO_LIB 1
14	#endif // !defined(BOOST_ALL_NO_LIB)
15
16	// Test that header file is self-contained.
17	#include <boost/asio/write.hpp>
18
19	#include <cstring>
20	#include <vector>
21	#include "archetypes/async_result.hpp"
22	#include <boost/asio/io_service.hpp>
23	#include <boost/asio/streambuf.hpp>
24	#include "unit_test.hpp"
25
26	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
27	# include <boost/bind.hpp>
28	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
29	# include <functional>
30	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
31
32	#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
33	#include <boost/array.hpp>
34	#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
35
36	#if defined(BOOST_ASIO_HAS_STD_ARRAY)
37	# include <array>
38	#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
39
40	using namespace std; // For memcmp, memcpy and memset.
41
42	class test_stream
43	{
44	public:
45	typedef boost::asio::io_service io_service_type;
46
47	test_stream(boost::asio::io_service& io_service)
48	: io_service_(io_service),
49	length_(max_length),
50	position_(0),
51	next_write_length_(max_length)
52	{
53	memset(s: data_, c: 0, n: max_length);
54	}
55
56	io_service_type& get_io_service()
57	{
58	return io_service_;
59	}
60
61	void reset(size_t length = max_length)
62	{
63	BOOST_ASIO_CHECK(length <= max_length);
64
65	memset(s: data_, c: 0, n: max_length);
66	length_ = length;
67	position_ = 0;
68	next_write_length_ = length;
69	}
70
71	void next_write_length(size_t length)
72	{
73	next_write_length_ = length;
74	}
75
76	template <typename Const_Buffers>
77	bool check_buffers(const Const_Buffers& buffers, size_t length)
78	{
79	if (length != position_)
80	return false;
81
82	typename Const_Buffers::const_iterator iter = buffers.begin();
83	typename Const_Buffers::const_iterator end = buffers.end();
84	size_t checked_length = 0;
85	for (; iter != end && checked_length < length; ++iter)
86	{
87	size_t buffer_length = boost::asio::buffer_size(*iter);
88	if (buffer_length > length - checked_length)
89	buffer_length = length - checked_length;
90	if (memcmp(data_ + checked_length,
91	boost::asio::buffer_cast<const void*>(*iter), buffer_length) != 0)
92	return false;
93	checked_length += buffer_length;
94	}
95
96	return true;
97	}
98
99	template <typename Const_Buffers>
100	size_t write_some(const Const_Buffers& buffers)
101	{
102	size_t n = boost::asio::buffer_copy(
103	boost::asio::buffer(data&: data_, max_size_in_bytes: length_) + position_,
104	buffers, next_write_length_);
105	position_ += n;
106	return n;
107	}
108
109	template <typename Const_Buffers>
110	size_t write_some(const Const_Buffers& buffers, boost::system::error_code& ec)
111	{
112	ec = boost::system::error_code();
113	return write_some(buffers);
114	}
115
116	template <typename Const_Buffers, typename Handler>
117	void async_write_some(const Const_Buffers& buffers, Handler handler)
118	{
119	size_t bytes_transferred = write_some(buffers);
120	io_service_.post(boost::asio::detail::bind_handler(
121	handler, boost::system::error_code(), bytes_transferred));
122	}
123
124	private:
125	io_service_type& io_service_;
126	enum { max_length = 8192 };
127	char data_[max_length];
128	size_t length_;
129	size_t position_;
130	size_t next_write_length_;
131	};
132
133	static const char write_data[]
134	= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
135	static char mutable_write_data[]
136	= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
137
138	void test_2_arg_zero_buffers_write()
139	{
140	boost::asio::io_service ios;
141	test_stream s(ios);
142	std::vector<boost::asio::const_buffer> buffers;
143
144	size_t bytes_transferred = boost::asio::write(s, buffers);
145	BOOST_ASIO_CHECK(bytes_transferred == 0);
146	}
147
148	void test_2_arg_const_buffers_1_write()
149	{
150	boost::asio::io_service ios;
151	test_stream s(ios);
152	boost::asio::const_buffers_1 buffers
153	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
154
155	s.reset();
156	size_t bytes_transferred = boost::asio::write(s, buffers);
157	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
158	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
159
160	s.reset();
161	s.next_write_length(length: 1);
162	bytes_transferred = boost::asio::write(s, buffers);
163	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
164	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
165
166	s.reset();
167	s.next_write_length(length: 10);
168	bytes_transferred = boost::asio::write(s, buffers);
169	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
170	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
171	}
172
173	void test_2_arg_mutable_buffers_1_write()
174	{
175	boost::asio::io_service ios;
176	test_stream s(ios);
177	boost::asio::mutable_buffers_1 buffers
178	= boost::asio::buffer(data&: mutable_write_data, max_size_in_bytes: sizeof(mutable_write_data));
179
180	s.reset();
181	size_t bytes_transferred = boost::asio::write(s, buffers);
182	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
183	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
184
185	s.reset();
186	s.next_write_length(length: 1);
187	bytes_transferred = boost::asio::write(s, buffers);
188	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
189	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
190
191	s.reset();
192	s.next_write_length(length: 10);
193	bytes_transferred = boost::asio::write(s, buffers);
194	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
195	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
196	}
197
198	void test_2_arg_vector_buffers_write()
199	{
200	boost::asio::io_service ios;
201	test_stream s(ios);
202	std::vector<boost::asio::const_buffer> buffers;
203	buffers.push_back(x: boost::asio::buffer(data: write_data, max_size_in_bytes: 32));
204	buffers.push_back(x: boost::asio::buffer(data: write_data) + 32);
205
206	s.reset();
207	size_t bytes_transferred = boost::asio::write(s, buffers);
208	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
209	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
210
211	s.reset();
212	s.next_write_length(length: 1);
213	bytes_transferred = boost::asio::write(s, buffers);
214	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
215	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
216
217	s.reset();
218	s.next_write_length(length: 10);
219	bytes_transferred = boost::asio::write(s, buffers);
220	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
221	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
222	}
223
224	void test_3_arg_nothrow_zero_buffers_write()
225	{
226	boost::asio::io_service ios;
227	test_stream s(ios);
228	std::vector<boost::asio::const_buffer> buffers;
229
230	boost::system::error_code error;
231	size_t bytes_transferred = boost::asio::write(s, buffers, ec&: error);
232	BOOST_ASIO_CHECK(bytes_transferred == 0);
233	BOOST_ASIO_CHECK(!error);
234	}
235
236	void test_3_arg_nothrow_const_buffers_1_write()
237	{
238	boost::asio::io_service ios;
239	test_stream s(ios);
240	boost::asio::const_buffers_1 buffers
241	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
242
243	s.reset();
244	boost::system::error_code error;
245	size_t bytes_transferred = boost::asio::write(s, buffers, ec&: error);
246	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
247	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
248	BOOST_ASIO_CHECK(!error);
249
250	s.reset();
251	s.next_write_length(length: 1);
252	bytes_transferred = boost::asio::write(s, buffers, ec&: error);
253	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
254	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
255	BOOST_ASIO_CHECK(!error);
256
257	s.reset();
258	s.next_write_length(length: 10);
259	bytes_transferred = boost::asio::write(s, buffers, ec&: error);
260	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
261	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
262	BOOST_ASIO_CHECK(!error);
263	}
264
265	void test_3_arg_nothrow_mutable_buffers_1_write()
266	{
267	boost::asio::io_service ios;
268	test_stream s(ios);
269	boost::asio::mutable_buffers_1 buffers
270	= boost::asio::buffer(data&: mutable_write_data, max_size_in_bytes: sizeof(mutable_write_data));
271
272	s.reset();
273	boost::system::error_code error;
274	size_t bytes_transferred = boost::asio::write(s, buffers, ec&: error);
275	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
276	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
277	BOOST_ASIO_CHECK(!error);
278
279	s.reset();
280	s.next_write_length(length: 1);
281	bytes_transferred = boost::asio::write(s, buffers, ec&: error);
282	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
283	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
284	BOOST_ASIO_CHECK(!error);
285
286	s.reset();
287	s.next_write_length(length: 10);
288	bytes_transferred = boost::asio::write(s, buffers, ec&: error);
289	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
290	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
291	BOOST_ASIO_CHECK(!error);
292	}
293
294	void test_3_arg_nothrow_vector_buffers_write()
295	{
296	boost::asio::io_service ios;
297	test_stream s(ios);
298	std::vector<boost::asio::const_buffer> buffers;
299	buffers.push_back(x: boost::asio::buffer(data: write_data, max_size_in_bytes: 32));
300	buffers.push_back(x: boost::asio::buffer(data: write_data) + 32);
301
302	s.reset();
303	boost::system::error_code error;
304	size_t bytes_transferred = boost::asio::write(s, buffers, ec&: error);
305	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
306	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
307	BOOST_ASIO_CHECK(!error);
308
309	s.reset();
310	s.next_write_length(length: 1);
311	bytes_transferred = boost::asio::write(s, buffers, ec&: error);
312	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
313	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
314	BOOST_ASIO_CHECK(!error);
315
316	s.reset();
317	s.next_write_length(length: 10);
318	bytes_transferred = boost::asio::write(s, buffers, ec&: error);
319	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
320	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
321	BOOST_ASIO_CHECK(!error);
322	}
323
324	bool old_style_transfer_all(const boost::system::error_code& ec,
325	size_t /*bytes_transferred*/)
326	{
327	return !!ec;
328	}
329
330	size_t short_transfer(const boost::system::error_code& ec,
331	size_t /*bytes_transferred*/)
332	{
333	return !!ec ? 0 : 3;
334	}
335
336	void test_3_arg_const_buffers_1_write()
337	{
338	boost::asio::io_service ios;
339	test_stream s(ios);
340	boost::asio::const_buffers_1 buffers
341	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
342
343	s.reset();
344	size_t bytes_transferred = boost::asio::write(s, buffers,
345	completion_condition: boost::asio::transfer_all());
346	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
347	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
348
349	s.reset();
350	s.next_write_length(length: 1);
351	bytes_transferred = boost::asio::write(s, buffers,
352	completion_condition: boost::asio::transfer_all());
353	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
354	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
355
356	s.reset();
357	s.next_write_length(length: 10);
358	bytes_transferred = boost::asio::write(s, buffers,
359	completion_condition: boost::asio::transfer_all());
360	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
361	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
362
363	s.reset();
364	bytes_transferred = boost::asio::write(s, buffers,
365	completion_condition: boost::asio::transfer_at_least(minimum: 1));
366	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
367	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
368
369	s.reset();
370	s.next_write_length(length: 1);
371	bytes_transferred = boost::asio::write(s, buffers,
372	completion_condition: boost::asio::transfer_at_least(minimum: 1));
373	BOOST_ASIO_CHECK(bytes_transferred == 1);
374	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
375
376	s.reset();
377	s.next_write_length(length: 10);
378	bytes_transferred = boost::asio::write(s, buffers,
379	completion_condition: boost::asio::transfer_at_least(minimum: 1));
380	BOOST_ASIO_CHECK(bytes_transferred == 10);
381	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
382
383	s.reset();
384	bytes_transferred = boost::asio::write(s, buffers,
385	completion_condition: boost::asio::transfer_at_least(minimum: 10));
386	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
387	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
388
389	s.reset();
390	s.next_write_length(length: 1);
391	bytes_transferred = boost::asio::write(s, buffers,
392	completion_condition: boost::asio::transfer_at_least(minimum: 10));
393	BOOST_ASIO_CHECK(bytes_transferred == 10);
394	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
395
396	s.reset();
397	s.next_write_length(length: 10);
398	bytes_transferred = boost::asio::write(s, buffers,
399	completion_condition: boost::asio::transfer_at_least(minimum: 10));
400	BOOST_ASIO_CHECK(bytes_transferred == 10);
401	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
402
403	s.reset();
404	bytes_transferred = boost::asio::write(s, buffers,
405	completion_condition: boost::asio::transfer_at_least(minimum: 42));
406	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
407	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
408
409	s.reset();
410	s.next_write_length(length: 1);
411	bytes_transferred = boost::asio::write(s, buffers,
412	completion_condition: boost::asio::transfer_at_least(minimum: 42));
413	BOOST_ASIO_CHECK(bytes_transferred == 42);
414	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
415
416	s.reset();
417	s.next_write_length(length: 10);
418	bytes_transferred = boost::asio::write(s, buffers,
419	completion_condition: boost::asio::transfer_at_least(minimum: 42));
420	BOOST_ASIO_CHECK(bytes_transferred == 50);
421	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
422
423	s.reset();
424	bytes_transferred = boost::asio::write(s, buffers,
425	completion_condition: boost::asio::transfer_exactly(size: 1));
426	BOOST_ASIO_CHECK(bytes_transferred == 1);
427	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
428
429	s.reset();
430	s.next_write_length(length: 1);
431	bytes_transferred = boost::asio::write(s, buffers,
432	completion_condition: boost::asio::transfer_exactly(size: 1));
433	BOOST_ASIO_CHECK(bytes_transferred == 1);
434	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
435
436	s.reset();
437	s.next_write_length(length: 10);
438	bytes_transferred = boost::asio::write(s, buffers,
439	completion_condition: boost::asio::transfer_exactly(size: 1));
440	BOOST_ASIO_CHECK(bytes_transferred == 1);
441	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
442
443	s.reset();
444	bytes_transferred = boost::asio::write(s, buffers,
445	completion_condition: boost::asio::transfer_exactly(size: 10));
446	BOOST_ASIO_CHECK(bytes_transferred == 10);
447	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
448
449	s.reset();
450	s.next_write_length(length: 1);
451	bytes_transferred = boost::asio::write(s, buffers,
452	completion_condition: boost::asio::transfer_exactly(size: 10));
453	BOOST_ASIO_CHECK(bytes_transferred == 10);
454	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
455
456	s.reset();
457	s.next_write_length(length: 10);
458	bytes_transferred = boost::asio::write(s, buffers,
459	completion_condition: boost::asio::transfer_exactly(size: 10));
460	BOOST_ASIO_CHECK(bytes_transferred == 10);
461	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
462
463	s.reset();
464	bytes_transferred = boost::asio::write(s, buffers,
465	completion_condition: boost::asio::transfer_exactly(size: 42));
466	BOOST_ASIO_CHECK(bytes_transferred == 42);
467	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
468
469	s.reset();
470	s.next_write_length(length: 1);
471	bytes_transferred = boost::asio::write(s, buffers,
472	completion_condition: boost::asio::transfer_exactly(size: 42));
473	BOOST_ASIO_CHECK(bytes_transferred == 42);
474	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
475
476	s.reset();
477	s.next_write_length(length: 10);
478	bytes_transferred = boost::asio::write(s, buffers,
479	completion_condition: boost::asio::transfer_exactly(size: 42));
480	BOOST_ASIO_CHECK(bytes_transferred == 42);
481	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
482
483	s.reset();
484	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
485	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
486	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
487
488	s.reset();
489	s.next_write_length(length: 1);
490	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
491	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
492	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
493
494	s.reset();
495	s.next_write_length(length: 10);
496	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
497	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
498	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
499
500	s.reset();
501	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
502	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
503	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
504
505	s.reset();
506	s.next_write_length(length: 1);
507	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
508	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
509	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
510
511	s.reset();
512	s.next_write_length(length: 10);
513	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
514	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
515	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
516	}
517
518	void test_3_arg_mutable_buffers_1_write()
519	{
520	boost::asio::io_service ios;
521	test_stream s(ios);
522	boost::asio::mutable_buffers_1 buffers
523	= boost::asio::buffer(data&: mutable_write_data, max_size_in_bytes: sizeof(mutable_write_data));
524
525	s.reset();
526	size_t bytes_transferred = boost::asio::write(s, buffers,
527	completion_condition: boost::asio::transfer_all());
528	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
529	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
530
531	s.reset();
532	s.next_write_length(length: 1);
533	bytes_transferred = boost::asio::write(s, buffers,
534	completion_condition: boost::asio::transfer_all());
535	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
536	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
537
538	s.reset();
539	s.next_write_length(length: 10);
540	bytes_transferred = boost::asio::write(s, buffers,
541	completion_condition: boost::asio::transfer_all());
542	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
543	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
544
545	s.reset();
546	bytes_transferred = boost::asio::write(s, buffers,
547	completion_condition: boost::asio::transfer_at_least(minimum: 1));
548	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
549	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
550
551	s.reset();
552	s.next_write_length(length: 1);
553	bytes_transferred = boost::asio::write(s, buffers,
554	completion_condition: boost::asio::transfer_at_least(minimum: 1));
555	BOOST_ASIO_CHECK(bytes_transferred == 1);
556	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
557
558	s.reset();
559	s.next_write_length(length: 10);
560	bytes_transferred = boost::asio::write(s, buffers,
561	completion_condition: boost::asio::transfer_at_least(minimum: 1));
562	BOOST_ASIO_CHECK(bytes_transferred == 10);
563	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
564
565	s.reset();
566	bytes_transferred = boost::asio::write(s, buffers,
567	completion_condition: boost::asio::transfer_at_least(minimum: 10));
568	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
569	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
570
571	s.reset();
572	s.next_write_length(length: 1);
573	bytes_transferred = boost::asio::write(s, buffers,
574	completion_condition: boost::asio::transfer_at_least(minimum: 10));
575	BOOST_ASIO_CHECK(bytes_transferred == 10);
576	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
577
578	s.reset();
579	s.next_write_length(length: 10);
580	bytes_transferred = boost::asio::write(s, buffers,
581	completion_condition: boost::asio::transfer_at_least(minimum: 10));
582	BOOST_ASIO_CHECK(bytes_transferred == 10);
583	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
584
585	s.reset();
586	bytes_transferred = boost::asio::write(s, buffers,
587	completion_condition: boost::asio::transfer_at_least(minimum: 42));
588	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
589	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
590
591	s.reset();
592	s.next_write_length(length: 1);
593	bytes_transferred = boost::asio::write(s, buffers,
594	completion_condition: boost::asio::transfer_at_least(minimum: 42));
595	BOOST_ASIO_CHECK(bytes_transferred == 42);
596	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
597
598	s.reset();
599	s.next_write_length(length: 10);
600	bytes_transferred = boost::asio::write(s, buffers,
601	completion_condition: boost::asio::transfer_at_least(minimum: 42));
602	BOOST_ASIO_CHECK(bytes_transferred == 50);
603	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
604
605	s.reset();
606	bytes_transferred = boost::asio::write(s, buffers,
607	completion_condition: boost::asio::transfer_exactly(size: 1));
608	BOOST_ASIO_CHECK(bytes_transferred == 1);
609	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
610
611	s.reset();
612	s.next_write_length(length: 1);
613	bytes_transferred = boost::asio::write(s, buffers,
614	completion_condition: boost::asio::transfer_exactly(size: 1));
615	BOOST_ASIO_CHECK(bytes_transferred == 1);
616	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
617
618	s.reset();
619	s.next_write_length(length: 10);
620	bytes_transferred = boost::asio::write(s, buffers,
621	completion_condition: boost::asio::transfer_exactly(size: 1));
622	BOOST_ASIO_CHECK(bytes_transferred == 1);
623	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
624
625	s.reset();
626	bytes_transferred = boost::asio::write(s, buffers,
627	completion_condition: boost::asio::transfer_exactly(size: 10));
628	BOOST_ASIO_CHECK(bytes_transferred == 10);
629	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
630
631	s.reset();
632	s.next_write_length(length: 1);
633	bytes_transferred = boost::asio::write(s, buffers,
634	completion_condition: boost::asio::transfer_exactly(size: 10));
635	BOOST_ASIO_CHECK(bytes_transferred == 10);
636	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
637
638	s.reset();
639	s.next_write_length(length: 10);
640	bytes_transferred = boost::asio::write(s, buffers,
641	completion_condition: boost::asio::transfer_exactly(size: 10));
642	BOOST_ASIO_CHECK(bytes_transferred == 10);
643	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
644
645	s.reset();
646	bytes_transferred = boost::asio::write(s, buffers,
647	completion_condition: boost::asio::transfer_exactly(size: 42));
648	BOOST_ASIO_CHECK(bytes_transferred == 42);
649	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
650
651	s.reset();
652	s.next_write_length(length: 1);
653	bytes_transferred = boost::asio::write(s, buffers,
654	completion_condition: boost::asio::transfer_exactly(size: 42));
655	BOOST_ASIO_CHECK(bytes_transferred == 42);
656	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
657
658	s.reset();
659	s.next_write_length(length: 10);
660	bytes_transferred = boost::asio::write(s, buffers,
661	completion_condition: boost::asio::transfer_exactly(size: 42));
662	BOOST_ASIO_CHECK(bytes_transferred == 42);
663	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
664
665	s.reset();
666	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
667	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
668	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
669
670	s.reset();
671	s.next_write_length(length: 1);
672	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
673	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
674	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
675
676	s.reset();
677	s.next_write_length(length: 10);
678	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
679	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
680	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
681
682	s.reset();
683	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
684	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
685	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
686
687	s.reset();
688	s.next_write_length(length: 1);
689	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
690	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
691	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
692
693	s.reset();
694	s.next_write_length(length: 10);
695	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
696	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
697	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
698	}
699
700	void test_3_arg_vector_buffers_write()
701	{
702	boost::asio::io_service ios;
703	test_stream s(ios);
704	std::vector<boost::asio::const_buffer> buffers;
705	buffers.push_back(x: boost::asio::buffer(data: write_data, max_size_in_bytes: 32));
706	buffers.push_back(x: boost::asio::buffer(data: write_data) + 32);
707
708	s.reset();
709	size_t bytes_transferred = boost::asio::write(s, buffers,
710	completion_condition: boost::asio::transfer_all());
711	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
712	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
713
714	s.reset();
715	s.next_write_length(length: 1);
716	bytes_transferred = boost::asio::write(s, buffers,
717	completion_condition: boost::asio::transfer_all());
718	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
719	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
720
721	s.reset();
722	s.next_write_length(length: 10);
723	bytes_transferred = boost::asio::write(s, buffers,
724	completion_condition: boost::asio::transfer_all());
725	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
726	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
727
728	s.reset();
729	bytes_transferred = boost::asio::write(s, buffers,
730	completion_condition: boost::asio::transfer_at_least(minimum: 1));
731	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
732	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
733
734	s.reset();
735	s.next_write_length(length: 1);
736	bytes_transferred = boost::asio::write(s, buffers,
737	completion_condition: boost::asio::transfer_at_least(minimum: 1));
738	BOOST_ASIO_CHECK(bytes_transferred == 1);
739	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
740
741	s.reset();
742	s.next_write_length(length: 10);
743	bytes_transferred = boost::asio::write(s, buffers,
744	completion_condition: boost::asio::transfer_at_least(minimum: 1));
745	BOOST_ASIO_CHECK(bytes_transferred == 10);
746	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
747
748	s.reset();
749	bytes_transferred = boost::asio::write(s, buffers,
750	completion_condition: boost::asio::transfer_at_least(minimum: 10));
751	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
752	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
753
754	s.reset();
755	s.next_write_length(length: 1);
756	bytes_transferred = boost::asio::write(s, buffers,
757	completion_condition: boost::asio::transfer_at_least(minimum: 10));
758	BOOST_ASIO_CHECK(bytes_transferred == 10);
759	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
760
761	s.reset();
762	s.next_write_length(length: 10);
763	bytes_transferred = boost::asio::write(s, buffers,
764	completion_condition: boost::asio::transfer_at_least(minimum: 10));
765	BOOST_ASIO_CHECK(bytes_transferred == 10);
766	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
767
768	s.reset();
769	bytes_transferred = boost::asio::write(s, buffers,
770	completion_condition: boost::asio::transfer_at_least(minimum: 42));
771	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
772	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
773
774	s.reset();
775	s.next_write_length(length: 1);
776	bytes_transferred = boost::asio::write(s, buffers,
777	completion_condition: boost::asio::transfer_at_least(minimum: 42));
778	BOOST_ASIO_CHECK(bytes_transferred == 42);
779	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
780
781	s.reset();
782	s.next_write_length(length: 10);
783	bytes_transferred = boost::asio::write(s, buffers,
784	completion_condition: boost::asio::transfer_at_least(minimum: 42));
785	BOOST_ASIO_CHECK(bytes_transferred == 50);
786	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
787
788	s.reset();
789	bytes_transferred = boost::asio::write(s, buffers,
790	completion_condition: boost::asio::transfer_exactly(size: 1));
791	BOOST_ASIO_CHECK(bytes_transferred == 1);
792	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
793
794	s.reset();
795	s.next_write_length(length: 1);
796	bytes_transferred = boost::asio::write(s, buffers,
797	completion_condition: boost::asio::transfer_exactly(size: 1));
798	BOOST_ASIO_CHECK(bytes_transferred == 1);
799	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
800
801	s.reset();
802	s.next_write_length(length: 10);
803	bytes_transferred = boost::asio::write(s, buffers,
804	completion_condition: boost::asio::transfer_exactly(size: 1));
805	BOOST_ASIO_CHECK(bytes_transferred == 1);
806	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
807
808	s.reset();
809	bytes_transferred = boost::asio::write(s, buffers,
810	completion_condition: boost::asio::transfer_exactly(size: 10));
811	BOOST_ASIO_CHECK(bytes_transferred == 10);
812	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
813
814	s.reset();
815	s.next_write_length(length: 1);
816	bytes_transferred = boost::asio::write(s, buffers,
817	completion_condition: boost::asio::transfer_exactly(size: 10));
818	BOOST_ASIO_CHECK(bytes_transferred == 10);
819	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
820
821	s.reset();
822	s.next_write_length(length: 10);
823	bytes_transferred = boost::asio::write(s, buffers,
824	completion_condition: boost::asio::transfer_exactly(size: 10));
825	BOOST_ASIO_CHECK(bytes_transferred == 10);
826	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
827
828	s.reset();
829	bytes_transferred = boost::asio::write(s, buffers,
830	completion_condition: boost::asio::transfer_exactly(size: 42));
831	BOOST_ASIO_CHECK(bytes_transferred == 42);
832	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
833
834	s.reset();
835	s.next_write_length(length: 1);
836	bytes_transferred = boost::asio::write(s, buffers,
837	completion_condition: boost::asio::transfer_exactly(size: 42));
838	BOOST_ASIO_CHECK(bytes_transferred == 42);
839	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
840
841	s.reset();
842	s.next_write_length(length: 10);
843	bytes_transferred = boost::asio::write(s, buffers,
844	completion_condition: boost::asio::transfer_exactly(size: 42));
845	BOOST_ASIO_CHECK(bytes_transferred == 42);
846	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
847
848	s.reset();
849	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
850	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
851	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
852
853	s.reset();
854	s.next_write_length(length: 1);
855	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
856	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
857	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
858
859	s.reset();
860	s.next_write_length(length: 10);
861	bytes_transferred = boost::asio::write(s, buffers, completion_condition: old_style_transfer_all);
862	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
863	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
864
865	s.reset();
866	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
867	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
868	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
869
870	s.reset();
871	s.next_write_length(length: 1);
872	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
873	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
874	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
875
876	s.reset();
877	s.next_write_length(length: 10);
878	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer);
879	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
880	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
881	}
882
883	void test_4_arg_const_buffers_1_write()
884	{
885	boost::asio::io_service ios;
886	test_stream s(ios);
887	boost::asio::const_buffers_1 buffers
888	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
889
890	s.reset();
891	boost::system::error_code error;
892	size_t bytes_transferred = boost::asio::write(s, buffers,
893	completion_condition: boost::asio::transfer_all(), ec&: error);
894	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
895	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
896	BOOST_ASIO_CHECK(!error);
897
898	s.reset();
899	s.next_write_length(length: 1);
900	error = boost::system::error_code();
901	bytes_transferred = boost::asio::write(s, buffers,
902	completion_condition: boost::asio::transfer_all(), ec&: error);
903	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
904	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
905	BOOST_ASIO_CHECK(!error);
906
907	s.reset();
908	s.next_write_length(length: 10);
909	error = boost::system::error_code();
910	bytes_transferred = boost::asio::write(s, buffers,
911	completion_condition: boost::asio::transfer_all(), ec&: error);
912	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
913	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
914	BOOST_ASIO_CHECK(!error);
915
916	s.reset();
917	error = boost::system::error_code();
918	bytes_transferred = boost::asio::write(s, buffers,
919	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
920	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
921	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
922	BOOST_ASIO_CHECK(!error);
923
924	s.reset();
925	s.next_write_length(length: 1);
926	error = boost::system::error_code();
927	bytes_transferred = boost::asio::write(s, buffers,
928	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
929	BOOST_ASIO_CHECK(bytes_transferred == 1);
930	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
931	BOOST_ASIO_CHECK(!error);
932
933	s.reset();
934	s.next_write_length(length: 10);
935	error = boost::system::error_code();
936	bytes_transferred = boost::asio::write(s, buffers,
937	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
938	BOOST_ASIO_CHECK(bytes_transferred == 10);
939	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
940	BOOST_ASIO_CHECK(!error);
941
942	s.reset();
943	error = boost::system::error_code();
944	bytes_transferred = boost::asio::write(s, buffers,
945	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
946	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
947	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
948	BOOST_ASIO_CHECK(!error);
949
950	s.reset();
951	s.next_write_length(length: 1);
952	error = boost::system::error_code();
953	bytes_transferred = boost::asio::write(s, buffers,
954	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
955	BOOST_ASIO_CHECK(bytes_transferred == 10);
956	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
957	BOOST_ASIO_CHECK(!error);
958
959	s.reset();
960	s.next_write_length(length: 10);
961	error = boost::system::error_code();
962	bytes_transferred = boost::asio::write(s, buffers,
963	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
964	BOOST_ASIO_CHECK(bytes_transferred == 10);
965	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
966	BOOST_ASIO_CHECK(!error);
967
968	s.reset();
969	error = boost::system::error_code();
970	bytes_transferred = boost::asio::write(s, buffers,
971	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
972	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
973	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
974	BOOST_ASIO_CHECK(!error);
975
976	s.reset();
977	s.next_write_length(length: 1);
978	error = boost::system::error_code();
979	bytes_transferred = boost::asio::write(s, buffers,
980	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
981	BOOST_ASIO_CHECK(bytes_transferred == 42);
982	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
983	BOOST_ASIO_CHECK(!error);
984
985	s.reset();
986	s.next_write_length(length: 10);
987	error = boost::system::error_code();
988	bytes_transferred = boost::asio::write(s, buffers,
989	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
990	BOOST_ASIO_CHECK(bytes_transferred == 50);
991	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
992	BOOST_ASIO_CHECK(!error);
993
994	s.reset();
995	error = boost::system::error_code();
996	bytes_transferred = boost::asio::write(s, buffers,
997	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
998	BOOST_ASIO_CHECK(bytes_transferred == 1);
999	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1000	BOOST_ASIO_CHECK(!error);
1001
1002	s.reset();
1003	s.next_write_length(length: 1);
1004	error = boost::system::error_code();
1005	bytes_transferred = boost::asio::write(s, buffers,
1006	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1007	BOOST_ASIO_CHECK(bytes_transferred == 1);
1008	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1009	BOOST_ASIO_CHECK(!error);
1010
1011	s.reset();
1012	s.next_write_length(length: 10);
1013	error = boost::system::error_code();
1014	bytes_transferred = boost::asio::write(s, buffers,
1015	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1016	BOOST_ASIO_CHECK(bytes_transferred == 1);
1017	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1018	BOOST_ASIO_CHECK(!error);
1019
1020	s.reset();
1021	error = boost::system::error_code();
1022	bytes_transferred = boost::asio::write(s, buffers,
1023	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1024	BOOST_ASIO_CHECK(bytes_transferred == 10);
1025	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1026	BOOST_ASIO_CHECK(!error);
1027
1028	s.reset();
1029	s.next_write_length(length: 1);
1030	error = boost::system::error_code();
1031	bytes_transferred = boost::asio::write(s, buffers,
1032	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1033	BOOST_ASIO_CHECK(bytes_transferred == 10);
1034	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1035	BOOST_ASIO_CHECK(!error);
1036
1037	s.reset();
1038	s.next_write_length(length: 10);
1039	error = boost::system::error_code();
1040	bytes_transferred = boost::asio::write(s, buffers,
1041	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1042	BOOST_ASIO_CHECK(bytes_transferred == 10);
1043	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1044	BOOST_ASIO_CHECK(!error);
1045
1046	s.reset();
1047	error = boost::system::error_code();
1048	bytes_transferred = boost::asio::write(s, buffers,
1049	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1050	BOOST_ASIO_CHECK(bytes_transferred == 42);
1051	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1052	BOOST_ASIO_CHECK(!error);
1053
1054	s.reset();
1055	s.next_write_length(length: 1);
1056	error = boost::system::error_code();
1057	bytes_transferred = boost::asio::write(s, buffers,
1058	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1059	BOOST_ASIO_CHECK(bytes_transferred == 42);
1060	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1061	BOOST_ASIO_CHECK(!error);
1062
1063	s.reset();
1064	s.next_write_length(length: 10);
1065	error = boost::system::error_code();
1066	bytes_transferred = boost::asio::write(s, buffers,
1067	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1068	BOOST_ASIO_CHECK(bytes_transferred == 42);
1069	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1070	BOOST_ASIO_CHECK(!error);
1071
1072	s.reset();
1073	bytes_transferred = boost::asio::write(s, buffers,
1074	completion_condition: old_style_transfer_all, ec&: error);
1075	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1076	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1077	BOOST_ASIO_CHECK(!error);
1078
1079	s.reset();
1080	s.next_write_length(length: 1);
1081	error = boost::system::error_code();
1082	bytes_transferred = boost::asio::write(s, buffers,
1083	completion_condition: old_style_transfer_all, ec&: error);
1084	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1085	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1086	BOOST_ASIO_CHECK(!error);
1087
1088	s.reset();
1089	s.next_write_length(length: 10);
1090	error = boost::system::error_code();
1091	bytes_transferred = boost::asio::write(s, buffers,
1092	completion_condition: old_style_transfer_all, ec&: error);
1093	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1094	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1095	BOOST_ASIO_CHECK(!error);
1096
1097	s.reset();
1098	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1099	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1100	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1101	BOOST_ASIO_CHECK(!error);
1102
1103	s.reset();
1104	s.next_write_length(length: 1);
1105	error = boost::system::error_code();
1106	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1107	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1108	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1109	BOOST_ASIO_CHECK(!error);
1110
1111	s.reset();
1112	s.next_write_length(length: 10);
1113	error = boost::system::error_code();
1114	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1115	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1116	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1117	BOOST_ASIO_CHECK(!error);
1118	}
1119
1120	void test_4_arg_mutable_buffers_1_write()
1121	{
1122	boost::asio::io_service ios;
1123	test_stream s(ios);
1124	boost::asio::mutable_buffers_1 buffers
1125	= boost::asio::buffer(data&: mutable_write_data, max_size_in_bytes: sizeof(mutable_write_data));
1126
1127	s.reset();
1128	boost::system::error_code error;
1129	size_t bytes_transferred = boost::asio::write(s, buffers,
1130	completion_condition: boost::asio::transfer_all(), ec&: error);
1131	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1132	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1133	BOOST_ASIO_CHECK(!error);
1134
1135	s.reset();
1136	s.next_write_length(length: 1);
1137	error = boost::system::error_code();
1138	bytes_transferred = boost::asio::write(s, buffers,
1139	completion_condition: boost::asio::transfer_all(), ec&: error);
1140	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1141	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1142	BOOST_ASIO_CHECK(!error);
1143
1144	s.reset();
1145	s.next_write_length(length: 10);
1146	error = boost::system::error_code();
1147	bytes_transferred = boost::asio::write(s, buffers,
1148	completion_condition: boost::asio::transfer_all(), ec&: error);
1149	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1150	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1151	BOOST_ASIO_CHECK(!error);
1152
1153	s.reset();
1154	error = boost::system::error_code();
1155	bytes_transferred = boost::asio::write(s, buffers,
1156	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1157	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1158	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1159	BOOST_ASIO_CHECK(!error);
1160
1161	s.reset();
1162	s.next_write_length(length: 1);
1163	error = boost::system::error_code();
1164	bytes_transferred = boost::asio::write(s, buffers,
1165	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1166	BOOST_ASIO_CHECK(bytes_transferred == 1);
1167	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1168	BOOST_ASIO_CHECK(!error);
1169
1170	s.reset();
1171	s.next_write_length(length: 10);
1172	error = boost::system::error_code();
1173	bytes_transferred = boost::asio::write(s, buffers,
1174	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1175	BOOST_ASIO_CHECK(bytes_transferred == 10);
1176	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1177	BOOST_ASIO_CHECK(!error);
1178
1179	s.reset();
1180	error = boost::system::error_code();
1181	bytes_transferred = boost::asio::write(s, buffers,
1182	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1183	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1184	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1185	BOOST_ASIO_CHECK(!error);
1186
1187	s.reset();
1188	s.next_write_length(length: 1);
1189	error = boost::system::error_code();
1190	bytes_transferred = boost::asio::write(s, buffers,
1191	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1192	BOOST_ASIO_CHECK(bytes_transferred == 10);
1193	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1194	BOOST_ASIO_CHECK(!error);
1195
1196	s.reset();
1197	s.next_write_length(length: 10);
1198	error = boost::system::error_code();
1199	bytes_transferred = boost::asio::write(s, buffers,
1200	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1201	BOOST_ASIO_CHECK(bytes_transferred == 10);
1202	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1203	BOOST_ASIO_CHECK(!error);
1204
1205	s.reset();
1206	error = boost::system::error_code();
1207	bytes_transferred = boost::asio::write(s, buffers,
1208	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1209	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1210	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1211	BOOST_ASIO_CHECK(!error);
1212
1213	s.reset();
1214	s.next_write_length(length: 1);
1215	error = boost::system::error_code();
1216	bytes_transferred = boost::asio::write(s, buffers,
1217	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1218	BOOST_ASIO_CHECK(bytes_transferred == 42);
1219	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1220	BOOST_ASIO_CHECK(!error);
1221
1222	s.reset();
1223	s.next_write_length(length: 10);
1224	error = boost::system::error_code();
1225	bytes_transferred = boost::asio::write(s, buffers,
1226	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1227	BOOST_ASIO_CHECK(bytes_transferred == 50);
1228	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1229	BOOST_ASIO_CHECK(!error);
1230
1231	s.reset();
1232	error = boost::system::error_code();
1233	bytes_transferred = boost::asio::write(s, buffers,
1234	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1235	BOOST_ASIO_CHECK(bytes_transferred == 1);
1236	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1237	BOOST_ASIO_CHECK(!error);
1238
1239	s.reset();
1240	s.next_write_length(length: 1);
1241	error = boost::system::error_code();
1242	bytes_transferred = boost::asio::write(s, buffers,
1243	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1244	BOOST_ASIO_CHECK(bytes_transferred == 1);
1245	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1246	BOOST_ASIO_CHECK(!error);
1247
1248	s.reset();
1249	s.next_write_length(length: 10);
1250	error = boost::system::error_code();
1251	bytes_transferred = boost::asio::write(s, buffers,
1252	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1253	BOOST_ASIO_CHECK(bytes_transferred == 1);
1254	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1255	BOOST_ASIO_CHECK(!error);
1256
1257	s.reset();
1258	error = boost::system::error_code();
1259	bytes_transferred = boost::asio::write(s, buffers,
1260	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1261	BOOST_ASIO_CHECK(bytes_transferred == 10);
1262	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1263	BOOST_ASIO_CHECK(!error);
1264
1265	s.reset();
1266	s.next_write_length(length: 1);
1267	error = boost::system::error_code();
1268	bytes_transferred = boost::asio::write(s, buffers,
1269	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1270	BOOST_ASIO_CHECK(bytes_transferred == 10);
1271	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1272	BOOST_ASIO_CHECK(!error);
1273
1274	s.reset();
1275	s.next_write_length(length: 10);
1276	error = boost::system::error_code();
1277	bytes_transferred = boost::asio::write(s, buffers,
1278	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1279	BOOST_ASIO_CHECK(bytes_transferred == 10);
1280	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1281	BOOST_ASIO_CHECK(!error);
1282
1283	s.reset();
1284	error = boost::system::error_code();
1285	bytes_transferred = boost::asio::write(s, buffers,
1286	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1287	BOOST_ASIO_CHECK(bytes_transferred == 42);
1288	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1289	BOOST_ASIO_CHECK(!error);
1290
1291	s.reset();
1292	s.next_write_length(length: 1);
1293	error = boost::system::error_code();
1294	bytes_transferred = boost::asio::write(s, buffers,
1295	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1296	BOOST_ASIO_CHECK(bytes_transferred == 42);
1297	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1298	BOOST_ASIO_CHECK(!error);
1299
1300	s.reset();
1301	s.next_write_length(length: 10);
1302	error = boost::system::error_code();
1303	bytes_transferred = boost::asio::write(s, buffers,
1304	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1305	BOOST_ASIO_CHECK(bytes_transferred == 42);
1306	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1307	BOOST_ASIO_CHECK(!error);
1308
1309	s.reset();
1310	bytes_transferred = boost::asio::write(s, buffers,
1311	completion_condition: old_style_transfer_all, ec&: error);
1312	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1313	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1314	BOOST_ASIO_CHECK(!error);
1315
1316	s.reset();
1317	s.next_write_length(length: 1);
1318	error = boost::system::error_code();
1319	bytes_transferred = boost::asio::write(s, buffers,
1320	completion_condition: old_style_transfer_all, ec&: error);
1321	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1322	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1323	BOOST_ASIO_CHECK(!error);
1324
1325	s.reset();
1326	s.next_write_length(length: 10);
1327	error = boost::system::error_code();
1328	bytes_transferred = boost::asio::write(s, buffers,
1329	completion_condition: old_style_transfer_all, ec&: error);
1330	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1331	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1332	BOOST_ASIO_CHECK(!error);
1333
1334	s.reset();
1335	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1336	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1337	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1338	BOOST_ASIO_CHECK(!error);
1339
1340	s.reset();
1341	s.next_write_length(length: 1);
1342	error = boost::system::error_code();
1343	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1344	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1345	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1346	BOOST_ASIO_CHECK(!error);
1347
1348	s.reset();
1349	s.next_write_length(length: 10);
1350	error = boost::system::error_code();
1351	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1352	BOOST_ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
1353	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1354	BOOST_ASIO_CHECK(!error);
1355	}
1356
1357	void test_4_arg_vector_buffers_write()
1358	{
1359	boost::asio::io_service ios;
1360	test_stream s(ios);
1361	std::vector<boost::asio::const_buffer> buffers;
1362	buffers.push_back(x: boost::asio::buffer(data: write_data, max_size_in_bytes: 32));
1363	buffers.push_back(x: boost::asio::buffer(data: write_data) + 32);
1364
1365	s.reset();
1366	boost::system::error_code error;
1367	size_t bytes_transferred = boost::asio::write(s, buffers,
1368	completion_condition: boost::asio::transfer_all(), ec&: error);
1369	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1370	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1371	BOOST_ASIO_CHECK(!error);
1372
1373	s.reset();
1374	s.next_write_length(length: 1);
1375	error = boost::system::error_code();
1376	bytes_transferred = boost::asio::write(s, buffers,
1377	completion_condition: boost::asio::transfer_all(), ec&: error);
1378	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1379	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1380	BOOST_ASIO_CHECK(!error);
1381
1382	s.reset();
1383	s.next_write_length(length: 10);
1384	error = boost::system::error_code();
1385	bytes_transferred = boost::asio::write(s, buffers,
1386	completion_condition: boost::asio::transfer_all(), ec&: error);
1387	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1388	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1389	BOOST_ASIO_CHECK(!error);
1390
1391	s.reset();
1392	error = boost::system::error_code();
1393	bytes_transferred = boost::asio::write(s, buffers,
1394	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1395	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1396	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1397	BOOST_ASIO_CHECK(!error);
1398
1399	s.reset();
1400	s.next_write_length(length: 1);
1401	error = boost::system::error_code();
1402	bytes_transferred = boost::asio::write(s, buffers,
1403	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1404	BOOST_ASIO_CHECK(bytes_transferred == 1);
1405	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1406	BOOST_ASIO_CHECK(!error);
1407
1408	s.reset();
1409	s.next_write_length(length: 10);
1410	error = boost::system::error_code();
1411	bytes_transferred = boost::asio::write(s, buffers,
1412	completion_condition: boost::asio::transfer_at_least(minimum: 1), ec&: error);
1413	BOOST_ASIO_CHECK(bytes_transferred == 10);
1414	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1415	BOOST_ASIO_CHECK(!error);
1416
1417	s.reset();
1418	error = boost::system::error_code();
1419	bytes_transferred = boost::asio::write(s, buffers,
1420	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1421	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1422	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1423	BOOST_ASIO_CHECK(!error);
1424
1425	s.reset();
1426	s.next_write_length(length: 1);
1427	error = boost::system::error_code();
1428	bytes_transferred = boost::asio::write(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();
1435	s.next_write_length(length: 10);
1436	error = boost::system::error_code();
1437	bytes_transferred = boost::asio::write(s, buffers,
1438	completion_condition: boost::asio::transfer_at_least(minimum: 10), ec&: error);
1439	BOOST_ASIO_CHECK(bytes_transferred == 10);
1440	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1441	BOOST_ASIO_CHECK(!error);
1442
1443	s.reset();
1444	error = boost::system::error_code();
1445	bytes_transferred = boost::asio::write(s, buffers,
1446	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1447	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1448	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1449	BOOST_ASIO_CHECK(!error);
1450
1451	s.reset();
1452	s.next_write_length(length: 1);
1453	error = boost::system::error_code();
1454	bytes_transferred = boost::asio::write(s, buffers,
1455	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1456	BOOST_ASIO_CHECK(bytes_transferred == 42);
1457	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1458	BOOST_ASIO_CHECK(!error);
1459
1460	s.reset();
1461	s.next_write_length(length: 10);
1462	error = boost::system::error_code();
1463	bytes_transferred = boost::asio::write(s, buffers,
1464	completion_condition: boost::asio::transfer_at_least(minimum: 42), ec&: error);
1465	BOOST_ASIO_CHECK(bytes_transferred == 50);
1466	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
1467	BOOST_ASIO_CHECK(!error);
1468
1469	s.reset();
1470	error = boost::system::error_code();
1471	bytes_transferred = boost::asio::write(s, buffers,
1472	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1473	BOOST_ASIO_CHECK(bytes_transferred == 1);
1474	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1475	BOOST_ASIO_CHECK(!error);
1476
1477	s.reset();
1478	s.next_write_length(length: 1);
1479	error = boost::system::error_code();
1480	bytes_transferred = boost::asio::write(s, buffers,
1481	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1482	BOOST_ASIO_CHECK(bytes_transferred == 1);
1483	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1484	BOOST_ASIO_CHECK(!error);
1485
1486	s.reset();
1487	s.next_write_length(length: 10);
1488	error = boost::system::error_code();
1489	bytes_transferred = boost::asio::write(s, buffers,
1490	completion_condition: boost::asio::transfer_exactly(size: 1), ec&: error);
1491	BOOST_ASIO_CHECK(bytes_transferred == 1);
1492	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
1493	BOOST_ASIO_CHECK(!error);
1494
1495	s.reset();
1496	error = boost::system::error_code();
1497	bytes_transferred = boost::asio::write(s, buffers,
1498	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1499	BOOST_ASIO_CHECK(bytes_transferred == 10);
1500	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1501	BOOST_ASIO_CHECK(!error);
1502
1503	s.reset();
1504	s.next_write_length(length: 1);
1505	error = boost::system::error_code();
1506	bytes_transferred = boost::asio::write(s, buffers,
1507	completion_condition: boost::asio::transfer_exactly(size: 10), ec&: error);
1508	BOOST_ASIO_CHECK(bytes_transferred == 10);
1509	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
1510	BOOST_ASIO_CHECK(!error);
1511
1512	s.reset();
1513	s.next_write_length(length: 10);
1514	error = boost::system::error_code();
1515	bytes_transferred = boost::asio::write(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();
1522	error = boost::system::error_code();
1523	bytes_transferred = boost::asio::write(s, buffers,
1524	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1525	BOOST_ASIO_CHECK(bytes_transferred == 42);
1526	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1527	BOOST_ASIO_CHECK(!error);
1528
1529	s.reset();
1530	s.next_write_length(length: 1);
1531	error = boost::system::error_code();
1532	bytes_transferred = boost::asio::write(s, buffers,
1533	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1534	BOOST_ASIO_CHECK(bytes_transferred == 42);
1535	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1536	BOOST_ASIO_CHECK(!error);
1537
1538	s.reset();
1539	s.next_write_length(length: 10);
1540	error = boost::system::error_code();
1541	bytes_transferred = boost::asio::write(s, buffers,
1542	completion_condition: boost::asio::transfer_exactly(size: 42), ec&: error);
1543	BOOST_ASIO_CHECK(bytes_transferred == 42);
1544	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
1545	BOOST_ASIO_CHECK(!error);
1546
1547	s.reset();
1548	bytes_transferred = boost::asio::write(s, buffers,
1549	completion_condition: old_style_transfer_all, ec&: error);
1550	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1551	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1552	BOOST_ASIO_CHECK(!error);
1553
1554	s.reset();
1555	s.next_write_length(length: 1);
1556	error = boost::system::error_code();
1557	bytes_transferred = boost::asio::write(s, buffers,
1558	completion_condition: old_style_transfer_all, ec&: error);
1559	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1560	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1561	BOOST_ASIO_CHECK(!error);
1562
1563	s.reset();
1564	s.next_write_length(length: 10);
1565	error = boost::system::error_code();
1566	bytes_transferred = boost::asio::write(s, buffers,
1567	completion_condition: old_style_transfer_all, ec&: error);
1568	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1569	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1570	BOOST_ASIO_CHECK(!error);
1571
1572	s.reset();
1573	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1574	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1575	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1576	BOOST_ASIO_CHECK(!error);
1577
1578	s.reset();
1579	s.next_write_length(length: 1);
1580	error = boost::system::error_code();
1581	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1582	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1583	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1584	BOOST_ASIO_CHECK(!error);
1585
1586	s.reset();
1587	s.next_write_length(length: 10);
1588	error = boost::system::error_code();
1589	bytes_transferred = boost::asio::write(s, buffers, completion_condition: short_transfer, ec&: error);
1590	BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data));
1591	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1592	BOOST_ASIO_CHECK(!error);
1593	}
1594
1595	void async_write_handler(const boost::system::error_code& e,
1596	size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
1597	{
1598	*called = true;
1599	BOOST_ASIO_CHECK(!e);
1600	BOOST_ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
1601	}
1602
1603	void test_3_arg_const_buffers_1_async_write()
1604	{
1605	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1606	namespace bindns = boost;
1607	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1608	namespace bindns = std;
1609	using std::placeholders::_1;
1610	using std::placeholders::_2;
1611	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1612
1613	boost::asio::io_service ios;
1614	test_stream s(ios);
1615	boost::asio::const_buffers_1 buffers
1616	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
1617
1618	s.reset();
1619	bool called = false;
1620	boost::asio::async_write(s, buffers,
1621	handler: bindns::bind(f: async_write_handler,
1622	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1623	ios.reset();
1624	ios.run();
1625	BOOST_ASIO_CHECK(called);
1626	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1627
1628	s.reset();
1629	s.next_write_length(length: 1);
1630	called = false;
1631	boost::asio::async_write(s, buffers,
1632	handler: bindns::bind(f: async_write_handler,
1633	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1634	ios.reset();
1635	ios.run();
1636	BOOST_ASIO_CHECK(called);
1637	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1638
1639	s.reset();
1640	s.next_write_length(length: 10);
1641	called = false;
1642	boost::asio::async_write(s, buffers,
1643	handler: bindns::bind(f: async_write_handler,
1644	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1645	ios.reset();
1646	ios.run();
1647	BOOST_ASIO_CHECK(called);
1648	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1649
1650	s.reset();
1651	int i = boost::asio::async_write(s, buffers, handler: archetypes::lazy_handler());
1652	BOOST_ASIO_CHECK(i == 42);
1653	ios.reset();
1654	ios.run();
1655	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1656	}
1657
1658	void test_3_arg_mutable_buffers_1_async_write()
1659	{
1660	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1661	namespace bindns = boost;
1662	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1663	namespace bindns = std;
1664	using std::placeholders::_1;
1665	using std::placeholders::_2;
1666	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1667
1668	boost::asio::io_service ios;
1669	test_stream s(ios);
1670	boost::asio::mutable_buffers_1 buffers
1671	= boost::asio::buffer(data&: mutable_write_data, max_size_in_bytes: sizeof(mutable_write_data));
1672
1673	s.reset();
1674	bool called = false;
1675	boost::asio::async_write(s, buffers,
1676	handler: bindns::bind(f: async_write_handler,
1677	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
1678	ios.reset();
1679	ios.run();
1680	BOOST_ASIO_CHECK(called);
1681	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1682
1683	s.reset();
1684	s.next_write_length(length: 1);
1685	called = false;
1686	boost::asio::async_write(s, buffers,
1687	handler: bindns::bind(f: async_write_handler,
1688	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
1689	ios.reset();
1690	ios.run();
1691	BOOST_ASIO_CHECK(called);
1692	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1693
1694	s.reset();
1695	s.next_write_length(length: 10);
1696	called = false;
1697	boost::asio::async_write(s, buffers,
1698	handler: bindns::bind(f: async_write_handler,
1699	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
1700	ios.reset();
1701	ios.run();
1702	BOOST_ASIO_CHECK(called);
1703	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1704
1705	s.reset();
1706	int i = boost::asio::async_write(s, buffers, handler: archetypes::lazy_handler());
1707	BOOST_ASIO_CHECK(i == 42);
1708	ios.reset();
1709	ios.run();
1710	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
1711	}
1712
1713	void test_3_arg_boost_array_buffers_async_write()
1714	{
1715	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1716	namespace bindns = boost;
1717	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1718	namespace bindns = std;
1719	using std::placeholders::_1;
1720	using std::placeholders::_2;
1721	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1722
1723	#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
1724	boost::asio::io_service ios;
1725	test_stream s(ios);
1726	boost::array<boost::asio::const_buffer, 2> buffers = { .elems: {
1727	boost::asio::buffer(data: write_data, max_size_in_bytes: 32),
1728	boost::asio::buffer(data: write_data) + 32 } };
1729
1730	s.reset();
1731	bool called = false;
1732	boost::asio::async_write(s, buffers,
1733	handler: bindns::bind(f: async_write_handler,
1734	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1735	ios.reset();
1736	ios.run();
1737	BOOST_ASIO_CHECK(called);
1738	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1739
1740	s.reset();
1741	s.next_write_length(length: 1);
1742	called = false;
1743	boost::asio::async_write(s, buffers,
1744	handler: bindns::bind(f: async_write_handler,
1745	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1746	ios.reset();
1747	ios.run();
1748	BOOST_ASIO_CHECK(called);
1749	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1750
1751	s.reset();
1752	s.next_write_length(length: 10);
1753	called = false;
1754	boost::asio::async_write(s, buffers,
1755	handler: bindns::bind(f: async_write_handler,
1756	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1757	ios.reset();
1758	ios.run();
1759	BOOST_ASIO_CHECK(called);
1760	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1761
1762	s.reset();
1763	int i = boost::asio::async_write(s, buffers, handler: archetypes::lazy_handler());
1764	BOOST_ASIO_CHECK(i == 42);
1765	ios.reset();
1766	ios.run();
1767	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1768	#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
1769	}
1770
1771	void test_3_arg_std_array_buffers_async_write()
1772	{
1773	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1774	namespace bindns = boost;
1775	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1776	namespace bindns = std;
1777	using std::placeholders::_1;
1778	using std::placeholders::_2;
1779	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1780
1781	#if defined(BOOST_ASIO_HAS_STD_ARRAY)
1782	boost::asio::io_service ios;
1783	test_stream s(ios);
1784	std::array<boost::asio::const_buffer, 2> buffers = { ._M_elems: {
1785	boost::asio::buffer(data: write_data, max_size_in_bytes: 32),
1786	boost::asio::buffer(data: write_data) + 32 } };
1787
1788	s.reset();
1789	bool called = false;
1790	boost::asio::async_write(s, buffers,
1791	handler: bindns::bind(f: async_write_handler,
1792	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1793	ios.reset();
1794	ios.run();
1795	BOOST_ASIO_CHECK(called);
1796	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1797
1798	s.reset();
1799	s.next_write_length(length: 1);
1800	called = false;
1801	boost::asio::async_write(s, buffers,
1802	handler: bindns::bind(f: async_write_handler,
1803	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1804	ios.reset();
1805	ios.run();
1806	BOOST_ASIO_CHECK(called);
1807	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1808
1809	s.reset();
1810	s.next_write_length(length: 10);
1811	called = false;
1812	boost::asio::async_write(s, buffers,
1813	handler: bindns::bind(f: async_write_handler,
1814	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1815	ios.reset();
1816	ios.run();
1817	BOOST_ASIO_CHECK(called);
1818	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1819
1820	s.reset();
1821	int i = boost::asio::async_write(s, buffers, handler: archetypes::lazy_handler());
1822	BOOST_ASIO_CHECK(i == 42);
1823	ios.reset();
1824	ios.run();
1825	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1826	#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
1827	}
1828
1829	void test_3_arg_vector_buffers_async_write()
1830	{
1831	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1832	namespace bindns = boost;
1833	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1834	namespace bindns = std;
1835	using std::placeholders::_1;
1836	using std::placeholders::_2;
1837	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1838
1839	boost::asio::io_service ios;
1840	test_stream s(ios);
1841	std::vector<boost::asio::const_buffer> buffers;
1842	buffers.push_back(x: boost::asio::buffer(data: write_data, max_size_in_bytes: 32));
1843	buffers.push_back(x: boost::asio::buffer(data: write_data) + 32);
1844
1845	s.reset();
1846	bool called = false;
1847	boost::asio::async_write(s, buffers,
1848	handler: bindns::bind(f: async_write_handler,
1849	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1850	ios.reset();
1851	ios.run();
1852	BOOST_ASIO_CHECK(called);
1853	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1854
1855	s.reset();
1856	s.next_write_length(length: 1);
1857	called = false;
1858	boost::asio::async_write(s, buffers,
1859	handler: bindns::bind(f: async_write_handler,
1860	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1861	ios.reset();
1862	ios.run();
1863	BOOST_ASIO_CHECK(called);
1864	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1865
1866	s.reset();
1867	s.next_write_length(length: 10);
1868	called = false;
1869	boost::asio::async_write(s, buffers,
1870	handler: bindns::bind(f: async_write_handler,
1871	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1872	ios.reset();
1873	ios.run();
1874	BOOST_ASIO_CHECK(called);
1875	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1876
1877	s.reset();
1878	int i = boost::asio::async_write(s, buffers, handler: archetypes::lazy_handler());
1879	BOOST_ASIO_CHECK(i == 42);
1880	ios.reset();
1881	ios.run();
1882	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1883	}
1884
1885	void test_3_arg_streambuf_async_write()
1886	{
1887	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1888	namespace bindns = boost;
1889	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1890	namespace bindns = std;
1891	using std::placeholders::_1;
1892	using std::placeholders::_2;
1893	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1894
1895	boost::asio::io_service ios;
1896	test_stream s(ios);
1897	boost::asio::streambuf sb;
1898	boost::asio::const_buffers_1 buffers
1899	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
1900
1901	s.reset();
1902	sb.consume(n: sb.size());
1903	sb.sputn(s: write_data, n: sizeof(write_data));
1904	bool called = false;
1905	boost::asio::async_write(s, b&: sb,
1906	handler: bindns::bind(f: async_write_handler,
1907	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1908	ios.reset();
1909	ios.run();
1910	BOOST_ASIO_CHECK(called);
1911	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1912
1913	s.reset();
1914	sb.consume(n: sb.size());
1915	sb.sputn(s: write_data, n: sizeof(write_data));
1916	s.next_write_length(length: 1);
1917	called = false;
1918	boost::asio::async_write(s, b&: sb,
1919	handler: bindns::bind(f: async_write_handler,
1920	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1921	ios.reset();
1922	ios.run();
1923	BOOST_ASIO_CHECK(called);
1924	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1925
1926	s.reset();
1927	sb.consume(n: sb.size());
1928	sb.sputn(s: write_data, n: sizeof(write_data));
1929	s.next_write_length(length: 10);
1930	called = false;
1931	boost::asio::async_write(s, b&: sb,
1932	handler: bindns::bind(f: async_write_handler,
1933	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1934	ios.reset();
1935	ios.run();
1936	BOOST_ASIO_CHECK(called);
1937	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1938
1939	s.reset();
1940	sb.consume(n: sb.size());
1941	sb.sputn(s: write_data, n: sizeof(write_data));
1942	int i = boost::asio::async_write(s, b&: sb, handler: archetypes::lazy_handler());
1943	BOOST_ASIO_CHECK(i == 42);
1944	ios.reset();
1945	ios.run();
1946	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1947	}
1948
1949	void test_4_arg_const_buffers_1_async_write()
1950	{
1951	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
1952	namespace bindns = boost;
1953	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
1954	namespace bindns = std;
1955	using std::placeholders::_1;
1956	using std::placeholders::_2;
1957	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
1958
1959	boost::asio::io_service ios;
1960	test_stream s(ios);
1961	boost::asio::const_buffers_1 buffers
1962	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
1963
1964	s.reset();
1965	bool called = false;
1966	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
1967	handler: bindns::bind(f: async_write_handler,
1968	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1969	ios.reset();
1970	ios.run();
1971	BOOST_ASIO_CHECK(called);
1972	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1973
1974	s.reset();
1975	s.next_write_length(length: 1);
1976	called = false;
1977	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
1978	handler: bindns::bind(f: async_write_handler,
1979	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1980	ios.reset();
1981	ios.run();
1982	BOOST_ASIO_CHECK(called);
1983	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1984
1985	s.reset();
1986	s.next_write_length(length: 10);
1987	called = false;
1988	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
1989	handler: bindns::bind(f: async_write_handler,
1990	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
1991	ios.reset();
1992	ios.run();
1993	BOOST_ASIO_CHECK(called);
1994	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
1995
1996	s.reset();
1997	called = false;
1998	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
1999	handler: bindns::bind(f: async_write_handler,
2000	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2001	ios.reset();
2002	ios.run();
2003	BOOST_ASIO_CHECK(called);
2004	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2005
2006	s.reset();
2007	s.next_write_length(length: 1);
2008	called = false;
2009	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2010	handler: bindns::bind(f: async_write_handler,
2011	a1: _1, a2: _2, a3: 1, a4: &called));
2012	ios.reset();
2013	ios.run();
2014	BOOST_ASIO_CHECK(called);
2015	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2016
2017	s.reset();
2018	s.next_write_length(length: 10);
2019	called = false;
2020	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2021	handler: bindns::bind(f: async_write_handler,
2022	a1: _1, a2: _2, a3: 10, a4: &called));
2023	ios.reset();
2024	ios.run();
2025	BOOST_ASIO_CHECK(called);
2026	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2027
2028	s.reset();
2029	called = false;
2030	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2031	handler: bindns::bind(f: async_write_handler,
2032	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2033	ios.reset();
2034	ios.run();
2035	BOOST_ASIO_CHECK(called);
2036	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2037
2038	s.reset();
2039	s.next_write_length(length: 1);
2040	called = false;
2041	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2042	handler: bindns::bind(f: async_write_handler,
2043	a1: _1, a2: _2, a3: 10, a4: &called));
2044	ios.reset();
2045	ios.run();
2046	BOOST_ASIO_CHECK(called);
2047	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2048
2049	s.reset();
2050	s.next_write_length(length: 10);
2051	called = false;
2052	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2053	handler: bindns::bind(f: async_write_handler,
2054	a1: _1, a2: _2, a3: 10, a4: &called));
2055	ios.reset();
2056	ios.run();
2057	BOOST_ASIO_CHECK(called);
2058	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2059
2060	s.reset();
2061	called = false;
2062	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2063	handler: bindns::bind(f: async_write_handler,
2064	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2065	ios.reset();
2066	ios.run();
2067	BOOST_ASIO_CHECK(called);
2068	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2069
2070	s.reset();
2071	s.next_write_length(length: 1);
2072	called = false;
2073	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2074	handler: bindns::bind(f: async_write_handler,
2075	a1: _1, a2: _2, a3: 42, a4: &called));
2076	ios.reset();
2077	ios.run();
2078	BOOST_ASIO_CHECK(called);
2079	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2080
2081	s.reset();
2082	s.next_write_length(length: 10);
2083	called = false;
2084	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2085	handler: bindns::bind(f: async_write_handler,
2086	a1: _1, a2: _2, a3: 50, a4: &called));
2087	ios.reset();
2088	ios.run();
2089	BOOST_ASIO_CHECK(called);
2090	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
2091
2092	s.reset();
2093	called = false;
2094	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2095	handler: bindns::bind(f: async_write_handler,
2096	a1: _1, a2: _2, a3: 1, a4: &called));
2097	ios.reset();
2098	ios.run();
2099	BOOST_ASIO_CHECK(called);
2100	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2101
2102	s.reset();
2103	s.next_write_length(length: 1);
2104	called = false;
2105	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2106	handler: bindns::bind(f: async_write_handler,
2107	a1: _1, a2: _2, a3: 1, a4: &called));
2108	ios.reset();
2109	ios.run();
2110	BOOST_ASIO_CHECK(called);
2111	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2112
2113	s.reset();
2114	s.next_write_length(length: 10);
2115	called = false;
2116	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2117	handler: bindns::bind(f: async_write_handler,
2118	a1: _1, a2: _2, a3: 1, a4: &called));
2119	ios.reset();
2120	ios.run();
2121	BOOST_ASIO_CHECK(called);
2122	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2123
2124	s.reset();
2125	called = false;
2126	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2127	handler: bindns::bind(f: async_write_handler,
2128	a1: _1, a2: _2, a3: 10, a4: &called));
2129	ios.reset();
2130	ios.run();
2131	BOOST_ASIO_CHECK(called);
2132	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2133
2134	s.reset();
2135	s.next_write_length(length: 1);
2136	called = false;
2137	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2138	handler: bindns::bind(f: async_write_handler,
2139	a1: _1, a2: _2, a3: 10, a4: &called));
2140	ios.reset();
2141	ios.run();
2142	BOOST_ASIO_CHECK(called);
2143	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2144
2145	s.reset();
2146	s.next_write_length(length: 10);
2147	called = false;
2148	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2149	handler: bindns::bind(f: async_write_handler,
2150	a1: _1, a2: _2, a3: 10, a4: &called));
2151	ios.reset();
2152	ios.run();
2153	BOOST_ASIO_CHECK(called);
2154	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2155
2156	s.reset();
2157	called = false;
2158	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2159	handler: bindns::bind(f: async_write_handler,
2160	a1: _1, a2: _2, a3: 42, a4: &called));
2161	ios.reset();
2162	ios.run();
2163	BOOST_ASIO_CHECK(called);
2164	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2165
2166	s.reset();
2167	s.next_write_length(length: 1);
2168	called = false;
2169	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2170	handler: bindns::bind(f: async_write_handler,
2171	a1: _1, a2: _2, a3: 42, a4: &called));
2172	ios.reset();
2173	ios.run();
2174	BOOST_ASIO_CHECK(called);
2175	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2176
2177	s.reset();
2178	s.next_write_length(length: 10);
2179	called = false;
2180	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2181	handler: bindns::bind(f: async_write_handler,
2182	a1: _1, a2: _2, a3: 42, a4: &called));
2183	ios.reset();
2184	ios.run();
2185	BOOST_ASIO_CHECK(called);
2186	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2187
2188	s.reset();
2189	called = false;
2190	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2191	handler: bindns::bind(f: async_write_handler,
2192	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2193	ios.reset();
2194	ios.run();
2195	BOOST_ASIO_CHECK(called);
2196	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2197
2198	s.reset();
2199	s.next_write_length(length: 1);
2200	called = false;
2201	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2202	handler: bindns::bind(f: async_write_handler,
2203	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2204	ios.reset();
2205	ios.run();
2206	BOOST_ASIO_CHECK(called);
2207	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2208
2209	s.reset();
2210	s.next_write_length(length: 10);
2211	called = false;
2212	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2213	handler: bindns::bind(f: async_write_handler,
2214	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2215	ios.reset();
2216	ios.run();
2217	BOOST_ASIO_CHECK(called);
2218	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2219
2220	s.reset();
2221	called = false;
2222	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2223	handler: bindns::bind(f: async_write_handler,
2224	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2225	ios.reset();
2226	ios.run();
2227	BOOST_ASIO_CHECK(called);
2228	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2229
2230	s.reset();
2231	s.next_write_length(length: 1);
2232	called = false;
2233	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2234	handler: bindns::bind(f: async_write_handler,
2235	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2236	ios.reset();
2237	ios.run();
2238	BOOST_ASIO_CHECK(called);
2239	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2240
2241	s.reset();
2242	s.next_write_length(length: 10);
2243	called = false;
2244	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2245	handler: bindns::bind(f: async_write_handler,
2246	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2247	ios.reset();
2248	ios.run();
2249	BOOST_ASIO_CHECK(called);
2250	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2251
2252	s.reset();
2253	int i = boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2254	handler: archetypes::lazy_handler());
2255	BOOST_ASIO_CHECK(i == 42);
2256	ios.reset();
2257	ios.run();
2258	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2259	}
2260
2261	void test_4_arg_mutable_buffers_1_async_write()
2262	{
2263	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
2264	namespace bindns = boost;
2265	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2266	namespace bindns = std;
2267	using std::placeholders::_1;
2268	using std::placeholders::_2;
2269	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2270
2271	boost::asio::io_service ios;
2272	test_stream s(ios);
2273	boost::asio::mutable_buffers_1 buffers
2274	= boost::asio::buffer(data&: mutable_write_data, max_size_in_bytes: sizeof(mutable_write_data));
2275
2276	s.reset();
2277	bool called = false;
2278	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2279	handler: bindns::bind(f: async_write_handler,
2280	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2281	ios.reset();
2282	ios.run();
2283	BOOST_ASIO_CHECK(called);
2284	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2285
2286	s.reset();
2287	s.next_write_length(length: 1);
2288	called = false;
2289	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2290	handler: bindns::bind(f: async_write_handler,
2291	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2292	ios.reset();
2293	ios.run();
2294	BOOST_ASIO_CHECK(called);
2295	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2296
2297	s.reset();
2298	s.next_write_length(length: 10);
2299	called = false;
2300	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2301	handler: bindns::bind(f: async_write_handler,
2302	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2303	ios.reset();
2304	ios.run();
2305	BOOST_ASIO_CHECK(called);
2306	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2307
2308	s.reset();
2309	called = false;
2310	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2311	handler: bindns::bind(f: async_write_handler,
2312	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2313	ios.reset();
2314	ios.run();
2315	BOOST_ASIO_CHECK(called);
2316	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2317
2318	s.reset();
2319	s.next_write_length(length: 1);
2320	called = false;
2321	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2322	handler: bindns::bind(f: async_write_handler,
2323	a1: _1, a2: _2, a3: 1, a4: &called));
2324	ios.reset();
2325	ios.run();
2326	BOOST_ASIO_CHECK(called);
2327	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2328
2329	s.reset();
2330	s.next_write_length(length: 10);
2331	called = false;
2332	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2333	handler: bindns::bind(f: async_write_handler,
2334	a1: _1, a2: _2, a3: 10, a4: &called));
2335	ios.reset();
2336	ios.run();
2337	BOOST_ASIO_CHECK(called);
2338	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2339
2340	s.reset();
2341	called = false;
2342	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2343	handler: bindns::bind(f: async_write_handler,
2344	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2345	ios.reset();
2346	ios.run();
2347	BOOST_ASIO_CHECK(called);
2348	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2349
2350	s.reset();
2351	s.next_write_length(length: 1);
2352	called = false;
2353	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2354	handler: bindns::bind(f: async_write_handler,
2355	a1: _1, a2: _2, a3: 10, a4: &called));
2356	ios.reset();
2357	ios.run();
2358	BOOST_ASIO_CHECK(called);
2359	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2360
2361	s.reset();
2362	s.next_write_length(length: 10);
2363	called = false;
2364	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2365	handler: bindns::bind(f: async_write_handler,
2366	a1: _1, a2: _2, a3: 10, a4: &called));
2367	ios.reset();
2368	ios.run();
2369	BOOST_ASIO_CHECK(called);
2370	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2371
2372	s.reset();
2373	called = false;
2374	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2375	handler: bindns::bind(f: async_write_handler,
2376	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2377	ios.reset();
2378	ios.run();
2379	BOOST_ASIO_CHECK(called);
2380	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2381
2382	s.reset();
2383	s.next_write_length(length: 1);
2384	called = false;
2385	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2386	handler: bindns::bind(f: async_write_handler,
2387	a1: _1, a2: _2, a3: 42, a4: &called));
2388	ios.reset();
2389	ios.run();
2390	BOOST_ASIO_CHECK(called);
2391	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2392
2393	s.reset();
2394	s.next_write_length(length: 10);
2395	called = false;
2396	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2397	handler: bindns::bind(f: async_write_handler,
2398	a1: _1, a2: _2, a3: 50, a4: &called));
2399	ios.reset();
2400	ios.run();
2401	BOOST_ASIO_CHECK(called);
2402	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
2403
2404	s.reset();
2405	called = false;
2406	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2407	handler: bindns::bind(f: async_write_handler,
2408	a1: _1, a2: _2, a3: 1, a4: &called));
2409	ios.reset();
2410	ios.run();
2411	BOOST_ASIO_CHECK(called);
2412	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2413
2414	s.reset();
2415	s.next_write_length(length: 1);
2416	called = false;
2417	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2418	handler: bindns::bind(f: async_write_handler,
2419	a1: _1, a2: _2, a3: 1, a4: &called));
2420	ios.reset();
2421	ios.run();
2422	BOOST_ASIO_CHECK(called);
2423	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2424
2425	s.reset();
2426	s.next_write_length(length: 10);
2427	called = false;
2428	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2429	handler: bindns::bind(f: async_write_handler,
2430	a1: _1, a2: _2, a3: 1, a4: &called));
2431	ios.reset();
2432	ios.run();
2433	BOOST_ASIO_CHECK(called);
2434	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2435
2436	s.reset();
2437	called = false;
2438	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2439	handler: bindns::bind(f: async_write_handler,
2440	a1: _1, a2: _2, a3: 10, a4: &called));
2441	ios.reset();
2442	ios.run();
2443	BOOST_ASIO_CHECK(called);
2444	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2445
2446	s.reset();
2447	s.next_write_length(length: 1);
2448	called = false;
2449	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2450	handler: bindns::bind(f: async_write_handler,
2451	a1: _1, a2: _2, a3: 10, a4: &called));
2452	ios.reset();
2453	ios.run();
2454	BOOST_ASIO_CHECK(called);
2455	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2456
2457	s.reset();
2458	s.next_write_length(length: 10);
2459	called = false;
2460	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2461	handler: bindns::bind(f: async_write_handler,
2462	a1: _1, a2: _2, a3: 10, a4: &called));
2463	ios.reset();
2464	ios.run();
2465	BOOST_ASIO_CHECK(called);
2466	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2467
2468	s.reset();
2469	called = false;
2470	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2471	handler: bindns::bind(f: async_write_handler,
2472	a1: _1, a2: _2, a3: 42, a4: &called));
2473	ios.reset();
2474	ios.run();
2475	BOOST_ASIO_CHECK(called);
2476	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2477
2478	s.reset();
2479	s.next_write_length(length: 1);
2480	called = false;
2481	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2482	handler: bindns::bind(f: async_write_handler,
2483	a1: _1, a2: _2, a3: 42, a4: &called));
2484	ios.reset();
2485	ios.run();
2486	BOOST_ASIO_CHECK(called);
2487	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2488
2489	s.reset();
2490	s.next_write_length(length: 10);
2491	called = false;
2492	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2493	handler: bindns::bind(f: async_write_handler,
2494	a1: _1, a2: _2, a3: 42, a4: &called));
2495	ios.reset();
2496	ios.run();
2497	BOOST_ASIO_CHECK(called);
2498	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2499
2500	s.reset();
2501	called = false;
2502	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2503	handler: bindns::bind(f: async_write_handler,
2504	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2505	ios.reset();
2506	ios.run();
2507	BOOST_ASIO_CHECK(called);
2508	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2509
2510	s.reset();
2511	s.next_write_length(length: 1);
2512	called = false;
2513	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2514	handler: bindns::bind(f: async_write_handler,
2515	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2516	ios.reset();
2517	ios.run();
2518	BOOST_ASIO_CHECK(called);
2519	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2520
2521	s.reset();
2522	s.next_write_length(length: 10);
2523	called = false;
2524	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2525	handler: bindns::bind(f: async_write_handler,
2526	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2527	ios.reset();
2528	ios.run();
2529	BOOST_ASIO_CHECK(called);
2530	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2531
2532	s.reset();
2533	called = false;
2534	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2535	handler: bindns::bind(f: async_write_handler,
2536	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2537	ios.reset();
2538	ios.run();
2539	BOOST_ASIO_CHECK(called);
2540	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2541
2542	s.reset();
2543	s.next_write_length(length: 1);
2544	called = false;
2545	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2546	handler: bindns::bind(f: async_write_handler,
2547	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2548	ios.reset();
2549	ios.run();
2550	BOOST_ASIO_CHECK(called);
2551	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2552
2553	s.reset();
2554	s.next_write_length(length: 10);
2555	called = false;
2556	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2557	handler: bindns::bind(f: async_write_handler,
2558	a1: _1, a2: _2, a3: sizeof(mutable_write_data), a4: &called));
2559	ios.reset();
2560	ios.run();
2561	BOOST_ASIO_CHECK(called);
2562	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
2563
2564	s.reset();
2565	int i = boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2566	handler: archetypes::lazy_handler());
2567	BOOST_ASIO_CHECK(i == 42);
2568	ios.reset();
2569	ios.run();
2570	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2571	}
2572
2573	void test_4_arg_boost_array_buffers_async_write()
2574	{
2575	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
2576	namespace bindns = boost;
2577	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2578	namespace bindns = std;
2579	using std::placeholders::_1;
2580	using std::placeholders::_2;
2581	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2582
2583	#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2584	boost::asio::io_service ios;
2585	test_stream s(ios);
2586	boost::array<boost::asio::const_buffer, 2> buffers = { .elems: {
2587	boost::asio::buffer(data: write_data, max_size_in_bytes: 32),
2588	boost::asio::buffer(data: write_data) + 32 } };
2589
2590	s.reset();
2591	bool called = false;
2592	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2593	handler: bindns::bind(f: async_write_handler,
2594	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2595	ios.reset();
2596	ios.run();
2597	BOOST_ASIO_CHECK(called);
2598	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2599
2600	s.reset();
2601	s.next_write_length(length: 1);
2602	called = false;
2603	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2604	handler: bindns::bind(f: async_write_handler,
2605	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2606	ios.reset();
2607	ios.run();
2608	BOOST_ASIO_CHECK(called);
2609	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2610
2611	s.reset();
2612	s.next_write_length(length: 10);
2613	called = false;
2614	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2615	handler: bindns::bind(f: async_write_handler,
2616	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2617	ios.reset();
2618	ios.run();
2619	BOOST_ASIO_CHECK(called);
2620	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2621
2622	s.reset();
2623	called = false;
2624	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2625	handler: bindns::bind(f: async_write_handler,
2626	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2627	ios.reset();
2628	ios.run();
2629	BOOST_ASIO_CHECK(called);
2630	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2631
2632	s.reset();
2633	s.next_write_length(length: 1);
2634	called = false;
2635	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2636	handler: bindns::bind(f: async_write_handler,
2637	a1: _1, a2: _2, a3: 1, a4: &called));
2638	ios.reset();
2639	ios.run();
2640	BOOST_ASIO_CHECK(called);
2641	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2642
2643	s.reset();
2644	s.next_write_length(length: 10);
2645	called = false;
2646	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2647	handler: bindns::bind(f: async_write_handler,
2648	a1: _1, a2: _2, a3: 10, a4: &called));
2649	ios.reset();
2650	ios.run();
2651	BOOST_ASIO_CHECK(called);
2652	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2653
2654	s.reset();
2655	called = false;
2656	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2657	handler: bindns::bind(f: async_write_handler,
2658	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2659	ios.reset();
2660	ios.run();
2661	BOOST_ASIO_CHECK(called);
2662	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2663
2664	s.reset();
2665	s.next_write_length(length: 1);
2666	called = false;
2667	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2668	handler: bindns::bind(f: async_write_handler,
2669	a1: _1, a2: _2, a3: 10, a4: &called));
2670	ios.reset();
2671	ios.run();
2672	BOOST_ASIO_CHECK(called);
2673	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2674
2675	s.reset();
2676	s.next_write_length(length: 10);
2677	called = false;
2678	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2679	handler: bindns::bind(f: async_write_handler,
2680	a1: _1, a2: _2, a3: 10, a4: &called));
2681	ios.reset();
2682	ios.run();
2683	BOOST_ASIO_CHECK(called);
2684	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2685
2686	s.reset();
2687	called = false;
2688	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2689	handler: bindns::bind(f: async_write_handler,
2690	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2691	ios.reset();
2692	ios.run();
2693	BOOST_ASIO_CHECK(called);
2694	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2695
2696	s.reset();
2697	s.next_write_length(length: 1);
2698	called = false;
2699	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2700	handler: bindns::bind(f: async_write_handler,
2701	a1: _1, a2: _2, a3: 42, a4: &called));
2702	ios.reset();
2703	ios.run();
2704	BOOST_ASIO_CHECK(called);
2705	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2706
2707	s.reset();
2708	s.next_write_length(length: 10);
2709	called = false;
2710	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
2711	handler: bindns::bind(f: async_write_handler,
2712	a1: _1, a2: _2, a3: 50, a4: &called));
2713	ios.reset();
2714	ios.run();
2715	BOOST_ASIO_CHECK(called);
2716	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
2717
2718	s.reset();
2719	called = false;
2720	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2721	handler: bindns::bind(f: async_write_handler,
2722	a1: _1, a2: _2, a3: 1, a4: &called));
2723	ios.reset();
2724	ios.run();
2725	BOOST_ASIO_CHECK(called);
2726	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2727
2728	s.reset();
2729	s.next_write_length(length: 1);
2730	called = false;
2731	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2732	handler: bindns::bind(f: async_write_handler,
2733	a1: _1, a2: _2, a3: 1, a4: &called));
2734	ios.reset();
2735	ios.run();
2736	BOOST_ASIO_CHECK(called);
2737	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2738
2739	s.reset();
2740	s.next_write_length(length: 10);
2741	called = false;
2742	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
2743	handler: bindns::bind(f: async_write_handler,
2744	a1: _1, a2: _2, a3: 1, a4: &called));
2745	ios.reset();
2746	ios.run();
2747	BOOST_ASIO_CHECK(called);
2748	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2749
2750	s.reset();
2751	called = false;
2752	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2753	handler: bindns::bind(f: async_write_handler,
2754	a1: _1, a2: _2, a3: 10, a4: &called));
2755	ios.reset();
2756	ios.run();
2757	BOOST_ASIO_CHECK(called);
2758	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2759
2760	s.reset();
2761	s.next_write_length(length: 1);
2762	called = false;
2763	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2764	handler: bindns::bind(f: async_write_handler,
2765	a1: _1, a2: _2, a3: 10, a4: &called));
2766	ios.reset();
2767	ios.run();
2768	BOOST_ASIO_CHECK(called);
2769	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2770
2771	s.reset();
2772	s.next_write_length(length: 10);
2773	called = false;
2774	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
2775	handler: bindns::bind(f: async_write_handler,
2776	a1: _1, a2: _2, a3: 10, a4: &called));
2777	ios.reset();
2778	ios.run();
2779	BOOST_ASIO_CHECK(called);
2780	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2781
2782	s.reset();
2783	called = false;
2784	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2785	handler: bindns::bind(f: async_write_handler,
2786	a1: _1, a2: _2, a3: 42, a4: &called));
2787	ios.reset();
2788	ios.run();
2789	BOOST_ASIO_CHECK(called);
2790	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2791
2792	s.reset();
2793	s.next_write_length(length: 1);
2794	called = false;
2795	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2796	handler: bindns::bind(f: async_write_handler,
2797	a1: _1, a2: _2, a3: 42, a4: &called));
2798	ios.reset();
2799	ios.run();
2800	BOOST_ASIO_CHECK(called);
2801	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2802
2803	s.reset();
2804	s.next_write_length(length: 10);
2805	called = false;
2806	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
2807	handler: bindns::bind(f: async_write_handler,
2808	a1: _1, a2: _2, a3: 42, a4: &called));
2809	ios.reset();
2810	ios.run();
2811	BOOST_ASIO_CHECK(called);
2812	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
2813
2814	s.reset();
2815	called = false;
2816	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2817	handler: bindns::bind(f: async_write_handler,
2818	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2819	ios.reset();
2820	ios.run();
2821	BOOST_ASIO_CHECK(called);
2822	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2823
2824	s.reset();
2825	s.next_write_length(length: 1);
2826	called = false;
2827	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2828	handler: bindns::bind(f: async_write_handler,
2829	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2830	ios.reset();
2831	ios.run();
2832	BOOST_ASIO_CHECK(called);
2833	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2834
2835	s.reset();
2836	s.next_write_length(length: 10);
2837	called = false;
2838	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
2839	handler: bindns::bind(f: async_write_handler,
2840	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2841	ios.reset();
2842	ios.run();
2843	BOOST_ASIO_CHECK(called);
2844	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2845
2846	s.reset();
2847	called = false;
2848	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2849	handler: bindns::bind(f: async_write_handler,
2850	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2851	ios.reset();
2852	ios.run();
2853	BOOST_ASIO_CHECK(called);
2854	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2855
2856	s.reset();
2857	s.next_write_length(length: 1);
2858	called = false;
2859	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2860	handler: bindns::bind(f: async_write_handler,
2861	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2862	ios.reset();
2863	ios.run();
2864	BOOST_ASIO_CHECK(called);
2865	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2866
2867	s.reset();
2868	s.next_write_length(length: 10);
2869	called = false;
2870	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2871	handler: bindns::bind(f: async_write_handler,
2872	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2873	ios.reset();
2874	ios.run();
2875	BOOST_ASIO_CHECK(called);
2876	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2877
2878	s.reset();
2879	int i = boost::asio::async_write(s, buffers, completion_condition: short_transfer,
2880	handler: archetypes::lazy_handler());
2881	BOOST_ASIO_CHECK(i == 42);
2882	ios.reset();
2883	ios.run();
2884	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2885	#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
2886	}
2887
2888	void test_4_arg_std_array_buffers_async_write()
2889	{
2890	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
2891	namespace bindns = boost;
2892	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
2893	namespace bindns = std;
2894	using std::placeholders::_1;
2895	using std::placeholders::_2;
2896	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
2897
2898	#if defined(BOOST_ASIO_HAS_STD_ARRAY)
2899	boost::asio::io_service ios;
2900	test_stream s(ios);
2901	std::array<boost::asio::const_buffer, 2> buffers = { ._M_elems: {
2902	boost::asio::buffer(data: write_data, max_size_in_bytes: 32),
2903	boost::asio::buffer(data: write_data) + 32 } };
2904
2905	s.reset();
2906	bool called = false;
2907	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2908	handler: bindns::bind(f: async_write_handler,
2909	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2910	ios.reset();
2911	ios.run();
2912	BOOST_ASIO_CHECK(called);
2913	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2914
2915	s.reset();
2916	s.next_write_length(length: 1);
2917	called = false;
2918	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2919	handler: bindns::bind(f: async_write_handler,
2920	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2921	ios.reset();
2922	ios.run();
2923	BOOST_ASIO_CHECK(called);
2924	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2925
2926	s.reset();
2927	s.next_write_length(length: 10);
2928	called = false;
2929	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
2930	handler: bindns::bind(f: async_write_handler,
2931	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2932	ios.reset();
2933	ios.run();
2934	BOOST_ASIO_CHECK(called);
2935	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2936
2937	s.reset();
2938	called = false;
2939	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2940	handler: bindns::bind(f: async_write_handler,
2941	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2942	ios.reset();
2943	ios.run();
2944	BOOST_ASIO_CHECK(called);
2945	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2946
2947	s.reset();
2948	s.next_write_length(length: 1);
2949	called = false;
2950	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2951	handler: bindns::bind(f: async_write_handler,
2952	a1: _1, a2: _2, a3: 1, a4: &called));
2953	ios.reset();
2954	ios.run();
2955	BOOST_ASIO_CHECK(called);
2956	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
2957
2958	s.reset();
2959	s.next_write_length(length: 10);
2960	called = false;
2961	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
2962	handler: bindns::bind(f: async_write_handler,
2963	a1: _1, a2: _2, a3: 10, a4: &called));
2964	ios.reset();
2965	ios.run();
2966	BOOST_ASIO_CHECK(called);
2967	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2968
2969	s.reset();
2970	called = false;
2971	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2972	handler: bindns::bind(f: async_write_handler,
2973	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
2974	ios.reset();
2975	ios.run();
2976	BOOST_ASIO_CHECK(called);
2977	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
2978
2979	s.reset();
2980	s.next_write_length(length: 1);
2981	called = false;
2982	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2983	handler: bindns::bind(f: async_write_handler,
2984	a1: _1, a2: _2, a3: 10, a4: &called));
2985	ios.reset();
2986	ios.run();
2987	BOOST_ASIO_CHECK(called);
2988	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
2989
2990	s.reset();
2991	s.next_write_length(length: 10);
2992	called = false;
2993	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
2994	handler: bindns::bind(f: async_write_handler,
2995	a1: _1, a2: _2, a3: 10, a4: &called));
2996	ios.reset();
2997	ios.run();
2998	BOOST_ASIO_CHECK(called);
2999	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3000
3001	s.reset();
3002	called = false;
3003	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3004	handler: bindns::bind(f: async_write_handler,
3005	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3006	ios.reset();
3007	ios.run();
3008	BOOST_ASIO_CHECK(called);
3009	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3010
3011	s.reset();
3012	s.next_write_length(length: 1);
3013	called = false;
3014	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3015	handler: bindns::bind(f: async_write_handler,
3016	a1: _1, a2: _2, a3: 42, a4: &called));
3017	ios.reset();
3018	ios.run();
3019	BOOST_ASIO_CHECK(called);
3020	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3021
3022	s.reset();
3023	s.next_write_length(length: 10);
3024	called = false;
3025	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3026	handler: bindns::bind(f: async_write_handler,
3027	a1: _1, a2: _2, a3: 50, a4: &called));
3028	ios.reset();
3029	ios.run();
3030	BOOST_ASIO_CHECK(called);
3031	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3032
3033	s.reset();
3034	called = false;
3035	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3036	handler: bindns::bind(f: async_write_handler,
3037	a1: _1, a2: _2, a3: 1, a4: &called));
3038	ios.reset();
3039	ios.run();
3040	BOOST_ASIO_CHECK(called);
3041	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3042
3043	s.reset();
3044	s.next_write_length(length: 1);
3045	called = false;
3046	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3047	handler: bindns::bind(f: async_write_handler,
3048	a1: _1, a2: _2, a3: 1, a4: &called));
3049	ios.reset();
3050	ios.run();
3051	BOOST_ASIO_CHECK(called);
3052	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3053
3054	s.reset();
3055	s.next_write_length(length: 10);
3056	called = false;
3057	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3058	handler: bindns::bind(f: async_write_handler,
3059	a1: _1, a2: _2, a3: 1, a4: &called));
3060	ios.reset();
3061	ios.run();
3062	BOOST_ASIO_CHECK(called);
3063	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3064
3065	s.reset();
3066	called = false;
3067	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3068	handler: bindns::bind(f: async_write_handler,
3069	a1: _1, a2: _2, a3: 10, a4: &called));
3070	ios.reset();
3071	ios.run();
3072	BOOST_ASIO_CHECK(called);
3073	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3074
3075	s.reset();
3076	s.next_write_length(length: 1);
3077	called = false;
3078	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3079	handler: bindns::bind(f: async_write_handler,
3080	a1: _1, a2: _2, a3: 10, a4: &called));
3081	ios.reset();
3082	ios.run();
3083	BOOST_ASIO_CHECK(called);
3084	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3085
3086	s.reset();
3087	s.next_write_length(length: 10);
3088	called = false;
3089	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3090	handler: bindns::bind(f: async_write_handler,
3091	a1: _1, a2: _2, a3: 10, a4: &called));
3092	ios.reset();
3093	ios.run();
3094	BOOST_ASIO_CHECK(called);
3095	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3096
3097	s.reset();
3098	called = false;
3099	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3100	handler: bindns::bind(f: async_write_handler,
3101	a1: _1, a2: _2, a3: 42, a4: &called));
3102	ios.reset();
3103	ios.run();
3104	BOOST_ASIO_CHECK(called);
3105	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3106
3107	s.reset();
3108	s.next_write_length(length: 1);
3109	called = false;
3110	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3111	handler: bindns::bind(f: async_write_handler,
3112	a1: _1, a2: _2, a3: 42, a4: &called));
3113	ios.reset();
3114	ios.run();
3115	BOOST_ASIO_CHECK(called);
3116	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3117
3118	s.reset();
3119	s.next_write_length(length: 10);
3120	called = false;
3121	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3122	handler: bindns::bind(f: async_write_handler,
3123	a1: _1, a2: _2, a3: 42, a4: &called));
3124	ios.reset();
3125	ios.run();
3126	BOOST_ASIO_CHECK(called);
3127	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3128
3129	s.reset();
3130	called = false;
3131	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
3132	handler: bindns::bind(f: async_write_handler,
3133	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3134	ios.reset();
3135	ios.run();
3136	BOOST_ASIO_CHECK(called);
3137	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3138
3139	s.reset();
3140	s.next_write_length(length: 1);
3141	called = false;
3142	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
3143	handler: bindns::bind(f: async_write_handler,
3144	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3145	ios.reset();
3146	ios.run();
3147	BOOST_ASIO_CHECK(called);
3148	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3149
3150	s.reset();
3151	s.next_write_length(length: 10);
3152	called = false;
3153	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
3154	handler: bindns::bind(f: async_write_handler,
3155	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3156	ios.reset();
3157	ios.run();
3158	BOOST_ASIO_CHECK(called);
3159	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3160
3161	s.reset();
3162	called = false;
3163	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3164	handler: bindns::bind(f: async_write_handler,
3165	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3166	ios.reset();
3167	ios.run();
3168	BOOST_ASIO_CHECK(called);
3169	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3170
3171	s.reset();
3172	s.next_write_length(length: 1);
3173	called = false;
3174	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3175	handler: bindns::bind(f: async_write_handler,
3176	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3177	ios.reset();
3178	ios.run();
3179	BOOST_ASIO_CHECK(called);
3180	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3181
3182	s.reset();
3183	s.next_write_length(length: 10);
3184	called = false;
3185	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3186	handler: bindns::bind(f: async_write_handler,
3187	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3188	ios.reset();
3189	ios.run();
3190	BOOST_ASIO_CHECK(called);
3191	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3192
3193	s.reset();
3194	int i = boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3195	handler: archetypes::lazy_handler());
3196	BOOST_ASIO_CHECK(i == 42);
3197	ios.reset();
3198	ios.run();
3199	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3200	#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
3201	}
3202
3203	void test_4_arg_vector_buffers_async_write()
3204	{
3205	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
3206	namespace bindns = boost;
3207	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3208	namespace bindns = std;
3209	using std::placeholders::_1;
3210	using std::placeholders::_2;
3211	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3212
3213	boost::asio::io_service ios;
3214	test_stream s(ios);
3215	std::vector<boost::asio::const_buffer> buffers;
3216	buffers.push_back(x: boost::asio::buffer(data: write_data, max_size_in_bytes: 32));
3217	buffers.push_back(x: boost::asio::buffer(data: write_data) + 32);
3218
3219	s.reset();
3220	bool called = false;
3221	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
3222	handler: bindns::bind(f: async_write_handler,
3223	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3224	ios.reset();
3225	ios.run();
3226	BOOST_ASIO_CHECK(called);
3227	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3228
3229	s.reset();
3230	s.next_write_length(length: 1);
3231	called = false;
3232	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
3233	handler: bindns::bind(f: async_write_handler,
3234	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3235	ios.reset();
3236	ios.run();
3237	BOOST_ASIO_CHECK(called);
3238	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3239
3240	s.reset();
3241	s.next_write_length(length: 10);
3242	called = false;
3243	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_all(),
3244	handler: bindns::bind(f: async_write_handler,
3245	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3246	ios.reset();
3247	ios.run();
3248	BOOST_ASIO_CHECK(called);
3249	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3250
3251	s.reset();
3252	called = false;
3253	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3254	handler: bindns::bind(f: async_write_handler,
3255	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3256	ios.reset();
3257	ios.run();
3258	BOOST_ASIO_CHECK(called);
3259	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3260
3261	s.reset();
3262	s.next_write_length(length: 1);
3263	called = false;
3264	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3265	handler: bindns::bind(f: async_write_handler,
3266	a1: _1, a2: _2, a3: 1, a4: &called));
3267	ios.reset();
3268	ios.run();
3269	BOOST_ASIO_CHECK(called);
3270	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3271
3272	s.reset();
3273	s.next_write_length(length: 10);
3274	called = false;
3275	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3276	handler: bindns::bind(f: async_write_handler,
3277	a1: _1, a2: _2, a3: 10, a4: &called));
3278	ios.reset();
3279	ios.run();
3280	BOOST_ASIO_CHECK(called);
3281	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3282
3283	s.reset();
3284	called = false;
3285	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3286	handler: bindns::bind(f: async_write_handler,
3287	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3288	ios.reset();
3289	ios.run();
3290	BOOST_ASIO_CHECK(called);
3291	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3292
3293	s.reset();
3294	s.next_write_length(length: 1);
3295	called = false;
3296	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3297	handler: bindns::bind(f: async_write_handler,
3298	a1: _1, a2: _2, a3: 10, a4: &called));
3299	ios.reset();
3300	ios.run();
3301	BOOST_ASIO_CHECK(called);
3302	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3303
3304	s.reset();
3305	s.next_write_length(length: 10);
3306	called = false;
3307	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3308	handler: bindns::bind(f: async_write_handler,
3309	a1: _1, a2: _2, a3: 10, a4: &called));
3310	ios.reset();
3311	ios.run();
3312	BOOST_ASIO_CHECK(called);
3313	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3314
3315	s.reset();
3316	called = false;
3317	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3318	handler: bindns::bind(f: async_write_handler,
3319	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3320	ios.reset();
3321	ios.run();
3322	BOOST_ASIO_CHECK(called);
3323	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3324
3325	s.reset();
3326	s.next_write_length(length: 1);
3327	called = false;
3328	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3329	handler: bindns::bind(f: async_write_handler,
3330	a1: _1, a2: _2, a3: 42, a4: &called));
3331	ios.reset();
3332	ios.run();
3333	BOOST_ASIO_CHECK(called);
3334	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3335
3336	s.reset();
3337	s.next_write_length(length: 10);
3338	called = false;
3339	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3340	handler: bindns::bind(f: async_write_handler,
3341	a1: _1, a2: _2, a3: 50, a4: &called));
3342	ios.reset();
3343	ios.run();
3344	BOOST_ASIO_CHECK(called);
3345	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3346
3347	s.reset();
3348	called = false;
3349	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3350	handler: bindns::bind(f: async_write_handler,
3351	a1: _1, a2: _2, a3: 1, a4: &called));
3352	ios.reset();
3353	ios.run();
3354	BOOST_ASIO_CHECK(called);
3355	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3356
3357	s.reset();
3358	s.next_write_length(length: 1);
3359	called = false;
3360	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3361	handler: bindns::bind(f: async_write_handler,
3362	a1: _1, a2: _2, a3: 1, a4: &called));
3363	ios.reset();
3364	ios.run();
3365	BOOST_ASIO_CHECK(called);
3366	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3367
3368	s.reset();
3369	s.next_write_length(length: 10);
3370	called = false;
3371	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 1),
3372	handler: bindns::bind(f: async_write_handler,
3373	a1: _1, a2: _2, a3: 1, a4: &called));
3374	ios.reset();
3375	ios.run();
3376	BOOST_ASIO_CHECK(called);
3377	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3378
3379	s.reset();
3380	called = false;
3381	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3382	handler: bindns::bind(f: async_write_handler,
3383	a1: _1, a2: _2, a3: 10, a4: &called));
3384	ios.reset();
3385	ios.run();
3386	BOOST_ASIO_CHECK(called);
3387	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3388
3389	s.reset();
3390	s.next_write_length(length: 1);
3391	called = false;
3392	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3393	handler: bindns::bind(f: async_write_handler,
3394	a1: _1, a2: _2, a3: 10, a4: &called));
3395	ios.reset();
3396	ios.run();
3397	BOOST_ASIO_CHECK(called);
3398	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3399
3400	s.reset();
3401	s.next_write_length(length: 10);
3402	called = false;
3403	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 10),
3404	handler: bindns::bind(f: async_write_handler,
3405	a1: _1, a2: _2, a3: 10, a4: &called));
3406	ios.reset();
3407	ios.run();
3408	BOOST_ASIO_CHECK(called);
3409	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3410
3411	s.reset();
3412	called = false;
3413	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3414	handler: bindns::bind(f: async_write_handler,
3415	a1: _1, a2: _2, a3: 42, a4: &called));
3416	ios.reset();
3417	ios.run();
3418	BOOST_ASIO_CHECK(called);
3419	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3420
3421	s.reset();
3422	s.next_write_length(length: 1);
3423	called = false;
3424	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3425	handler: bindns::bind(f: async_write_handler,
3426	a1: _1, a2: _2, a3: 42, a4: &called));
3427	ios.reset();
3428	ios.run();
3429	BOOST_ASIO_CHECK(called);
3430	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3431
3432	s.reset();
3433	s.next_write_length(length: 10);
3434	called = false;
3435	boost::asio::async_write(s, buffers, completion_condition: boost::asio::transfer_exactly(size: 42),
3436	handler: bindns::bind(f: async_write_handler,
3437	a1: _1, a2: _2, a3: 42, a4: &called));
3438	ios.reset();
3439	ios.run();
3440	BOOST_ASIO_CHECK(called);
3441	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3442
3443	s.reset();
3444	called = false;
3445	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
3446	handler: bindns::bind(f: async_write_handler,
3447	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3448	ios.reset();
3449	ios.run();
3450	BOOST_ASIO_CHECK(called);
3451	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3452
3453	s.reset();
3454	s.next_write_length(length: 1);
3455	called = false;
3456	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
3457	handler: bindns::bind(f: async_write_handler,
3458	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3459	ios.reset();
3460	ios.run();
3461	BOOST_ASIO_CHECK(called);
3462	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3463
3464	s.reset();
3465	s.next_write_length(length: 10);
3466	called = false;
3467	boost::asio::async_write(s, buffers, completion_condition: old_style_transfer_all,
3468	handler: bindns::bind(f: async_write_handler,
3469	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3470	ios.reset();
3471	ios.run();
3472	BOOST_ASIO_CHECK(called);
3473	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3474
3475	s.reset();
3476	called = false;
3477	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3478	handler: bindns::bind(f: async_write_handler,
3479	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3480	ios.reset();
3481	ios.run();
3482	BOOST_ASIO_CHECK(called);
3483	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3484
3485	s.reset();
3486	s.next_write_length(length: 1);
3487	called = false;
3488	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3489	handler: bindns::bind(f: async_write_handler,
3490	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3491	ios.reset();
3492	ios.run();
3493	BOOST_ASIO_CHECK(called);
3494	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3495
3496	s.reset();
3497	s.next_write_length(length: 10);
3498	called = false;
3499	boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3500	handler: bindns::bind(f: async_write_handler,
3501	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3502	ios.reset();
3503	ios.run();
3504	BOOST_ASIO_CHECK(called);
3505	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3506
3507	s.reset();
3508	int i = boost::asio::async_write(s, buffers, completion_condition: short_transfer,
3509	handler: archetypes::lazy_handler());
3510	BOOST_ASIO_CHECK(i == 42);
3511	ios.reset();
3512	ios.run();
3513	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3514	}
3515
3516	void test_4_arg_streambuf_async_write()
3517	{
3518	#if defined(BOOST_ASIO_HAS_BOOST_BIND)
3519	namespace bindns = boost;
3520	#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
3521	namespace bindns = std;
3522	using std::placeholders::_1;
3523	using std::placeholders::_2;
3524	#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
3525
3526	boost::asio::io_service ios;
3527	test_stream s(ios);
3528	boost::asio::streambuf sb;
3529	boost::asio::const_buffers_1 buffers
3530	= boost::asio::buffer(data: write_data, max_size_in_bytes: sizeof(write_data));
3531
3532	s.reset();
3533	sb.consume(n: sb.size());
3534	sb.sputn(s: write_data, n: sizeof(write_data));
3535	bool called = false;
3536	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_all(),
3537	handler: bindns::bind(f: async_write_handler,
3538	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3539	ios.reset();
3540	ios.run();
3541	BOOST_ASIO_CHECK(called);
3542	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3543
3544	s.reset();
3545	sb.consume(n: sb.size());
3546	sb.sputn(s: write_data, n: sizeof(write_data));
3547	s.next_write_length(length: 1);
3548	called = false;
3549	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_all(),
3550	handler: bindns::bind(f: async_write_handler,
3551	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3552	ios.reset();
3553	ios.run();
3554	BOOST_ASIO_CHECK(called);
3555	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3556
3557	s.reset();
3558	sb.consume(n: sb.size());
3559	sb.sputn(s: write_data, n: sizeof(write_data));
3560	s.next_write_length(length: 10);
3561	called = false;
3562	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_all(),
3563	handler: bindns::bind(f: async_write_handler,
3564	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3565	ios.reset();
3566	ios.run();
3567	BOOST_ASIO_CHECK(called);
3568	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3569
3570	s.reset();
3571	sb.consume(n: sb.size());
3572	sb.sputn(s: write_data, n: sizeof(write_data));
3573	called = false;
3574	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3575	handler: bindns::bind(f: async_write_handler,
3576	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3577	ios.reset();
3578	ios.run();
3579	BOOST_ASIO_CHECK(called);
3580	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3581
3582	s.reset();
3583	sb.consume(n: sb.size());
3584	sb.sputn(s: write_data, n: sizeof(write_data));
3585	s.next_write_length(length: 1);
3586	called = false;
3587	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3588	handler: bindns::bind(f: async_write_handler,
3589	a1: _1, a2: _2, a3: 1, a4: &called));
3590	ios.reset();
3591	ios.run();
3592	BOOST_ASIO_CHECK(called);
3593	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3594
3595	s.reset();
3596	sb.consume(n: sb.size());
3597	sb.sputn(s: write_data, n: sizeof(write_data));
3598	s.next_write_length(length: 10);
3599	called = false;
3600	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 1),
3601	handler: bindns::bind(f: async_write_handler,
3602	a1: _1, a2: _2, a3: 10, a4: &called));
3603	ios.reset();
3604	ios.run();
3605	BOOST_ASIO_CHECK(called);
3606	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3607
3608	s.reset();
3609	sb.consume(n: sb.size());
3610	sb.sputn(s: write_data, n: sizeof(write_data));
3611	called = false;
3612	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3613	handler: bindns::bind(f: async_write_handler,
3614	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3615	ios.reset();
3616	ios.run();
3617	BOOST_ASIO_CHECK(called);
3618	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3619
3620	s.reset();
3621	sb.consume(n: sb.size());
3622	sb.sputn(s: write_data, n: sizeof(write_data));
3623	s.next_write_length(length: 1);
3624	called = false;
3625	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3626	handler: bindns::bind(f: async_write_handler,
3627	a1: _1, a2: _2, a3: 10, a4: &called));
3628	ios.reset();
3629	ios.run();
3630	BOOST_ASIO_CHECK(called);
3631	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3632
3633	s.reset();
3634	sb.consume(n: sb.size());
3635	sb.sputn(s: write_data, n: sizeof(write_data));
3636	s.next_write_length(length: 10);
3637	called = false;
3638	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 10),
3639	handler: bindns::bind(f: async_write_handler,
3640	a1: _1, a2: _2, a3: 10, a4: &called));
3641	ios.reset();
3642	ios.run();
3643	BOOST_ASIO_CHECK(called);
3644	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3645
3646	s.reset();
3647	sb.consume(n: sb.size());
3648	sb.sputn(s: write_data, n: sizeof(write_data));
3649	called = false;
3650	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3651	handler: bindns::bind(f: async_write_handler,
3652	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3653	ios.reset();
3654	ios.run();
3655	BOOST_ASIO_CHECK(called);
3656	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3657
3658	s.reset();
3659	sb.consume(n: sb.size());
3660	sb.sputn(s: write_data, n: sizeof(write_data));
3661	s.next_write_length(length: 1);
3662	called = false;
3663	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3664	handler: bindns::bind(f: async_write_handler,
3665	a1: _1, a2: _2, a3: 42, a4: &called));
3666	ios.reset();
3667	ios.run();
3668	BOOST_ASIO_CHECK(called);
3669	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3670
3671	s.reset();
3672	sb.consume(n: sb.size());
3673	sb.sputn(s: write_data, n: sizeof(write_data));
3674	s.next_write_length(length: 10);
3675	called = false;
3676	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_at_least(minimum: 42),
3677	handler: bindns::bind(f: async_write_handler,
3678	a1: _1, a2: _2, a3: 50, a4: &called));
3679	ios.reset();
3680	ios.run();
3681	BOOST_ASIO_CHECK(called);
3682	BOOST_ASIO_CHECK(s.check_buffers(buffers, 50));
3683
3684	s.reset();
3685	sb.consume(n: sb.size());
3686	sb.sputn(s: write_data, n: sizeof(write_data));
3687	called = false;
3688	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
3689	handler: bindns::bind(f: async_write_handler,
3690	a1: _1, a2: _2, a3: 1, a4: &called));
3691	ios.reset();
3692	ios.run();
3693	BOOST_ASIO_CHECK(called);
3694	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3695
3696	s.reset();
3697	sb.consume(n: sb.size());
3698	sb.sputn(s: write_data, n: sizeof(write_data));
3699	s.next_write_length(length: 1);
3700	called = false;
3701	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
3702	handler: bindns::bind(f: async_write_handler,
3703	a1: _1, a2: _2, a3: 1, a4: &called));
3704	ios.reset();
3705	ios.run();
3706	BOOST_ASIO_CHECK(called);
3707	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3708
3709	s.reset();
3710	sb.consume(n: sb.size());
3711	sb.sputn(s: write_data, n: sizeof(write_data));
3712	s.next_write_length(length: 10);
3713	called = false;
3714	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 1),
3715	handler: bindns::bind(f: async_write_handler,
3716	a1: _1, a2: _2, a3: 1, a4: &called));
3717	ios.reset();
3718	ios.run();
3719	BOOST_ASIO_CHECK(called);
3720	BOOST_ASIO_CHECK(s.check_buffers(buffers, 1));
3721
3722	s.reset();
3723	sb.consume(n: sb.size());
3724	sb.sputn(s: write_data, n: sizeof(write_data));
3725	called = false;
3726	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
3727	handler: bindns::bind(f: async_write_handler,
3728	a1: _1, a2: _2, a3: 10, a4: &called));
3729	ios.reset();
3730	ios.run();
3731	BOOST_ASIO_CHECK(called);
3732	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3733
3734	s.reset();
3735	sb.consume(n: sb.size());
3736	sb.sputn(s: write_data, n: sizeof(write_data));
3737	s.next_write_length(length: 1);
3738	called = false;
3739	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
3740	handler: bindns::bind(f: async_write_handler,
3741	a1: _1, a2: _2, a3: 10, a4: &called));
3742	ios.reset();
3743	ios.run();
3744	BOOST_ASIO_CHECK(called);
3745	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3746
3747	s.reset();
3748	sb.consume(n: sb.size());
3749	sb.sputn(s: write_data, n: sizeof(write_data));
3750	s.next_write_length(length: 10);
3751	called = false;
3752	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 10),
3753	handler: bindns::bind(f: async_write_handler,
3754	a1: _1, a2: _2, a3: 10, a4: &called));
3755	ios.reset();
3756	ios.run();
3757	BOOST_ASIO_CHECK(called);
3758	BOOST_ASIO_CHECK(s.check_buffers(buffers, 10));
3759
3760	s.reset();
3761	sb.consume(n: sb.size());
3762	sb.sputn(s: write_data, n: sizeof(write_data));
3763	called = false;
3764	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
3765	handler: bindns::bind(f: async_write_handler,
3766	a1: _1, a2: _2, a3: 42, a4: &called));
3767	ios.reset();
3768	ios.run();
3769	BOOST_ASIO_CHECK(called);
3770	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3771
3772	s.reset();
3773	sb.consume(n: sb.size());
3774	sb.sputn(s: write_data, n: sizeof(write_data));
3775	s.next_write_length(length: 1);
3776	called = false;
3777	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
3778	handler: bindns::bind(f: async_write_handler,
3779	a1: _1, a2: _2, a3: 42, a4: &called));
3780	ios.reset();
3781	ios.run();
3782	BOOST_ASIO_CHECK(called);
3783	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3784
3785	s.reset();
3786	sb.consume(n: sb.size());
3787	sb.sputn(s: write_data, n: sizeof(write_data));
3788	s.next_write_length(length: 10);
3789	called = false;
3790	boost::asio::async_write(s, b&: sb, completion_condition: boost::asio::transfer_exactly(size: 42),
3791	handler: bindns::bind(f: async_write_handler,
3792	a1: _1, a2: _2, a3: 42, a4: &called));
3793	ios.reset();
3794	ios.run();
3795	BOOST_ASIO_CHECK(called);
3796	BOOST_ASIO_CHECK(s.check_buffers(buffers, 42));
3797
3798	s.reset();
3799	sb.consume(n: sb.size());
3800	sb.sputn(s: write_data, n: sizeof(write_data));
3801	called = false;
3802	boost::asio::async_write(s, b&: sb, completion_condition: old_style_transfer_all,
3803	handler: bindns::bind(f: async_write_handler,
3804	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3805	ios.reset();
3806	ios.run();
3807	BOOST_ASIO_CHECK(called);
3808	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3809
3810	s.reset();
3811	sb.consume(n: sb.size());
3812	sb.sputn(s: write_data, n: sizeof(write_data));
3813	s.next_write_length(length: 1);
3814	called = false;
3815	boost::asio::async_write(s, b&: sb, completion_condition: old_style_transfer_all,
3816	handler: bindns::bind(f: async_write_handler,
3817	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3818	ios.reset();
3819	ios.run();
3820	BOOST_ASIO_CHECK(called);
3821	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3822
3823	s.reset();
3824	sb.consume(n: sb.size());
3825	sb.sputn(s: write_data, n: sizeof(write_data));
3826	s.next_write_length(length: 10);
3827	called = false;
3828	boost::asio::async_write(s, b&: sb, completion_condition: old_style_transfer_all,
3829	handler: bindns::bind(f: async_write_handler,
3830	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3831	ios.reset();
3832	ios.run();
3833	BOOST_ASIO_CHECK(called);
3834	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3835
3836	s.reset();
3837	sb.consume(n: sb.size());
3838	sb.sputn(s: write_data, n: sizeof(write_data));
3839	called = false;
3840	boost::asio::async_write(s, b&: sb, completion_condition: short_transfer,
3841	handler: bindns::bind(f: async_write_handler,
3842	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3843	ios.reset();
3844	ios.run();
3845	BOOST_ASIO_CHECK(called);
3846	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3847
3848	s.reset();
3849	sb.consume(n: sb.size());
3850	sb.sputn(s: write_data, n: sizeof(write_data));
3851	s.next_write_length(length: 1);
3852	called = false;
3853	boost::asio::async_write(s, b&: sb, completion_condition: short_transfer,
3854	handler: bindns::bind(f: async_write_handler,
3855	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3856	ios.reset();
3857	ios.run();
3858	BOOST_ASIO_CHECK(called);
3859	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3860
3861	s.reset();
3862	sb.consume(n: sb.size());
3863	sb.sputn(s: write_data, n: sizeof(write_data));
3864	s.next_write_length(length: 10);
3865	called = false;
3866	boost::asio::async_write(s, b&: sb, completion_condition: short_transfer,
3867	handler: bindns::bind(f: async_write_handler,
3868	a1: _1, a2: _2, a3: sizeof(write_data), a4: &called));
3869	ios.reset();
3870	ios.run();
3871	BOOST_ASIO_CHECK(called);
3872	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3873
3874	s.reset();
3875	sb.consume(n: sb.size());
3876	sb.sputn(s: write_data, n: sizeof(write_data));
3877	int i = boost::asio::async_write(s, b&: sb, completion_condition: short_transfer,
3878	handler: archetypes::lazy_handler());
3879	BOOST_ASIO_CHECK(i == 42);
3880	ios.reset();
3881	ios.run();
3882	BOOST_ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
3883	}
3884
3885	BOOST_ASIO_TEST_SUITE
3886	(
3887	"write",
3888	BOOST_ASIO_TEST_CASE(test_2_arg_zero_buffers_write)
3889	BOOST_ASIO_TEST_CASE(test_2_arg_const_buffers_1_write)
3890	BOOST_ASIO_TEST_CASE(test_2_arg_mutable_buffers_1_write)
3891	BOOST_ASIO_TEST_CASE(test_2_arg_vector_buffers_write)
3892	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_write)
3893	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_const_buffers_1_write)
3894	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffers_1_write)
3895	BOOST_ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_write)
3896	BOOST_ASIO_TEST_CASE(test_3_arg_const_buffers_1_write)
3897	BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffers_1_write)
3898	BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_write)
3899	BOOST_ASIO_TEST_CASE(test_4_arg_const_buffers_1_write)
3900	BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffers_1_write)
3901	BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_write)
3902	BOOST_ASIO_TEST_CASE(test_3_arg_const_buffers_1_async_write)
3903	BOOST_ASIO_TEST_CASE(test_3_arg_mutable_buffers_1_async_write)
3904	BOOST_ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_write)
3905	BOOST_ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_write)
3906	BOOST_ASIO_TEST_CASE(test_3_arg_vector_buffers_async_write)
3907	BOOST_ASIO_TEST_CASE(test_3_arg_streambuf_async_write)
3908	BOOST_ASIO_TEST_CASE(test_4_arg_const_buffers_1_async_write)
3909	BOOST_ASIO_TEST_CASE(test_4_arg_mutable_buffers_1_async_write)
3910	BOOST_ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_write)
3911	BOOST_ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_write)
3912	BOOST_ASIO_TEST_CASE(test_4_arg_vector_buffers_async_write)
3913	BOOST_ASIO_TEST_CASE(test_4_arg_streambuf_async_write)
3914	)
3915