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