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