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