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

source code of boost/libs/asio/test/read.cpp