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