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