1 //
2 // read_at.cpp
3 // ~~~~~~~~~~~
4 //
5 // Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6 //
7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9 //
10
11 // Disable autolinking for unit tests.
12 #if !defined(BOOST_ALL_NO_LIB)
13 #define BOOST_ALL_NO_LIB 1
14 #endif // !defined(BOOST_ALL_NO_LIB)
15
16 // Test that header file is self-contained.
17 #include "asio/read_at.hpp"
18
19 #include <cstring>
20 #include "archetypes/async_result.hpp"
21 #include "asio/io_context.hpp"
22 #include "asio/post.hpp"
23 #include "asio/streambuf.hpp"
24 #include "unit_test.hpp"
25
26 #if defined(ASIO_HAS_BOOST_BIND)
27 # include <boost/bind.hpp>
28 #else // defined(ASIO_HAS_BOOST_BIND)
29 # include <functional>
30 #endif // defined(ASIO_HAS_BOOST_BIND)
31
32 #if defined(ASIO_HAS_BOOST_ARRAY)
33 #include <boost/array.hpp>
34 #endif // defined(ASIO_HAS_BOOST_ARRAY)
35
36 #if defined(ASIO_HAS_STD_ARRAY)
37 # include <array>
38 #endif // defined(ASIO_HAS_STD_ARRAY)
39
40 using namespace std; // For memcmp, memcpy and memset.
41
42 class test_random_access_device
43 {
44 public:
45 typedef asio::io_context::executor_type executor_type;
46
test_random_access_device(asio::io_context & io_context)47 test_random_access_device(asio::io_context& io_context)
48 : io_context_(io_context),
49 length_(0),
50 next_read_length_(0)
51 {
52 }
53
get_executor()54 executor_type get_executor() ASIO_NOEXCEPT
55 {
56 return io_context_.get_executor();
57 }
58
reset(const void * data,size_t length)59 void reset(const void* data, size_t length)
60 {
61 ASIO_CHECK(length <= max_length);
62
63 length_ = 0;
64 while (length_ + length < max_length)
65 {
66 memcpy(data_ + length_, data, length);
67 length_ += length;
68 }
69
70 next_read_length_ = length;
71 }
72
next_read_length(size_t length)73 void next_read_length(size_t length)
74 {
75 next_read_length_ = length;
76 }
77
78 template <typename Iterator>
check_buffers(asio::uint64_t offset,Iterator begin,Iterator end,size_t length)79 bool check_buffers(asio::uint64_t offset,
80 Iterator begin, Iterator end, size_t length)
81 {
82 if (offset + length > max_length)
83 return false;
84
85 Iterator iter = begin;
86 size_t checked_length = 0;
87 for (; iter != end && checked_length < length; ++iter)
88 {
89 size_t buffer_length = asio::buffer_size(*iter);
90 if (buffer_length > length - checked_length)
91 buffer_length = length - checked_length;
92 if (memcmp(data_ + offset + checked_length,
93 iter->data(), buffer_length) != 0)
94 return false;
95 checked_length += buffer_length;
96 }
97
98 return true;
99 }
100
101 template <typename Const_Buffers>
check_buffers(asio::uint64_t offset,const Const_Buffers & buffers,size_t length)102 bool check_buffers(asio::uint64_t offset,
103 const Const_Buffers& buffers, size_t length)
104 {
105 return check_buffers(offset, asio::buffer_sequence_begin(buffers),
106 asio::buffer_sequence_end(buffers), length);
107 }
108
109 template <typename Mutable_Buffers>
read_some_at(asio::uint64_t offset,const Mutable_Buffers & buffers)110 size_t read_some_at(asio::uint64_t offset,
111 const Mutable_Buffers& buffers)
112 {
113 return asio::buffer_copy(buffers,
114 asio::buffer(data_, length_) + offset,
115 next_read_length_);
116 }
117
118 template <typename Mutable_Buffers>
read_some_at(asio::uint64_t offset,const Mutable_Buffers & buffers,asio::error_code & ec)119 size_t read_some_at(asio::uint64_t offset,
120 const Mutable_Buffers& buffers, asio::error_code& ec)
121 {
122 ec = asio::error_code();
123 return read_some_at(offset, buffers);
124 }
125
126 template <typename Mutable_Buffers, typename Handler>
async_read_some_at(asio::uint64_t offset,const Mutable_Buffers & buffers,Handler handler)127 void async_read_some_at(asio::uint64_t offset,
128 const Mutable_Buffers& buffers, Handler handler)
129 {
130 size_t bytes_transferred = read_some_at(offset, buffers);
131 asio::post(get_executor(),
132 asio::detail::bind_handler(
133 ASIO_MOVE_CAST(Handler)(handler),
134 asio::error_code(), bytes_transferred));
135 }
136
137 private:
138 asio::io_context& io_context_;
139 enum { max_length = 8192 };
140 char data_[max_length];
141 size_t length_;
142 size_t next_read_length_;
143 };
144
145 static const char read_data[]
146 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
147
test_3_arg_mutable_buffer_read_at()148 void test_3_arg_mutable_buffer_read_at()
149 {
150 asio::io_context ioc;
151 test_random_access_device s(ioc);
152 char read_buf[sizeof(read_data)];
153 asio::mutable_buffer buffers
154 = asio::buffer(read_buf, sizeof(read_buf));
155
156 s.reset(read_data, sizeof(read_data));
157 memset(read_buf, 0, sizeof(read_buf));
158 size_t bytes_transferred = asio::read_at(s, 0, buffers);
159 ASIO_CHECK(bytes_transferred == sizeof(read_data));
160 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
161
162 s.reset(read_data, sizeof(read_data));
163 memset(read_buf, 0, sizeof(read_buf));
164 bytes_transferred = asio::read_at(s, 1234, buffers);
165 ASIO_CHECK(bytes_transferred == sizeof(read_data));
166 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
167
168 s.reset(read_data, sizeof(read_data));
169 s.next_read_length(1);
170 memset(read_buf, 0, sizeof(read_buf));
171 bytes_transferred = asio::read_at(s, 0, buffers);
172 ASIO_CHECK(bytes_transferred == sizeof(read_data));
173 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
174
175 s.reset(read_data, sizeof(read_data));
176 s.next_read_length(1);
177 memset(read_buf, 0, sizeof(read_buf));
178 bytes_transferred = asio::read_at(s, 1234, buffers);
179 ASIO_CHECK(bytes_transferred == sizeof(read_data));
180 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
181
182 s.reset(read_data, sizeof(read_data));
183 s.next_read_length(10);
184 memset(read_buf, 0, sizeof(read_buf));
185 bytes_transferred = asio::read_at(s, 0, buffers);
186 ASIO_CHECK(bytes_transferred == sizeof(read_data));
187 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
188
189 s.reset(read_data, sizeof(read_data));
190 s.next_read_length(10);
191 memset(read_buf, 0, sizeof(read_buf));
192 bytes_transferred = asio::read_at(s, 1234, buffers);
193 ASIO_CHECK(bytes_transferred == sizeof(read_data));
194 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
195 }
196
test_3_arg_vector_buffers_read_at()197 void test_3_arg_vector_buffers_read_at()
198 {
199 asio::io_context ioc;
200 test_random_access_device s(ioc);
201 char read_buf[sizeof(read_data)];
202 std::vector<asio::mutable_buffer> buffers;
203 buffers.push_back(asio::buffer(read_buf, 32));
204 buffers.push_back(asio::buffer(read_buf) + 32);
205
206 s.reset(read_data, sizeof(read_data));
207 memset(read_buf, 0, sizeof(read_buf));
208 size_t bytes_transferred = asio::read_at(s, 0, buffers);
209 ASIO_CHECK(bytes_transferred == sizeof(read_data));
210 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
211
212 s.reset(read_data, sizeof(read_data));
213 memset(read_buf, 0, sizeof(read_buf));
214 bytes_transferred = asio::read_at(s, 1234, buffers);
215 ASIO_CHECK(bytes_transferred == sizeof(read_data));
216 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
217
218 s.reset(read_data, sizeof(read_data));
219 s.next_read_length(1);
220 memset(read_buf, 0, sizeof(read_buf));
221 bytes_transferred = asio::read_at(s, 0, buffers);
222 ASIO_CHECK(bytes_transferred == sizeof(read_data));
223 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
224
225 s.reset(read_data, sizeof(read_data));
226 s.next_read_length(1);
227 memset(read_buf, 0, sizeof(read_buf));
228 bytes_transferred = asio::read_at(s, 1234, buffers);
229 ASIO_CHECK(bytes_transferred == sizeof(read_data));
230 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
231
232 s.reset(read_data, sizeof(read_data));
233 s.next_read_length(10);
234 memset(read_buf, 0, sizeof(read_buf));
235 bytes_transferred = asio::read_at(s, 0, buffers);
236 ASIO_CHECK(bytes_transferred == sizeof(read_data));
237 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
238
239 s.reset(read_data, sizeof(read_data));
240 s.next_read_length(10);
241 memset(read_buf, 0, sizeof(read_buf));
242 bytes_transferred = asio::read_at(s, 1234, buffers);
243 ASIO_CHECK(bytes_transferred == sizeof(read_data));
244 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
245 }
246
test_3_arg_streambuf_read_at()247 void test_3_arg_streambuf_read_at()
248 {
249 asio::io_context ioc;
250 test_random_access_device s(ioc);
251 asio::streambuf sb(sizeof(read_data));
252
253 s.reset(read_data, sizeof(read_data));
254 sb.consume(sb.size());
255 size_t bytes_transferred = asio::read_at(s, 0, sb);
256 ASIO_CHECK(bytes_transferred == sizeof(read_data));
257 ASIO_CHECK(sb.size() == sizeof(read_data));
258 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
259
260 s.reset(read_data, sizeof(read_data));
261 sb.consume(sb.size());
262 bytes_transferred = asio::read_at(s, 1234, sb);
263 ASIO_CHECK(bytes_transferred == sizeof(read_data));
264 ASIO_CHECK(sb.size() == sizeof(read_data));
265 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
266
267 s.reset(read_data, sizeof(read_data));
268 s.next_read_length(1);
269 sb.consume(sb.size());
270 bytes_transferred = asio::read_at(s, 0, sb);
271 ASIO_CHECK(bytes_transferred == sizeof(read_data));
272 ASIO_CHECK(sb.size() == sizeof(read_data));
273 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
274
275 s.reset(read_data, sizeof(read_data));
276 s.next_read_length(1);
277 sb.consume(sb.size());
278 bytes_transferred = asio::read_at(s, 1234, sb);
279 ASIO_CHECK(bytes_transferred == sizeof(read_data));
280 ASIO_CHECK(sb.size() == sizeof(read_data));
281 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
282
283 s.reset(read_data, sizeof(read_data));
284 s.next_read_length(10);
285 sb.consume(sb.size());
286 bytes_transferred = asio::read_at(s, 0, sb);
287 ASIO_CHECK(bytes_transferred == sizeof(read_data));
288 ASIO_CHECK(sb.size() == sizeof(read_data));
289 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
290
291 s.reset(read_data, sizeof(read_data));
292 s.next_read_length(10);
293 sb.consume(sb.size());
294 bytes_transferred = asio::read_at(s, 1234, sb);
295 ASIO_CHECK(bytes_transferred == sizeof(read_data));
296 ASIO_CHECK(sb.size() == sizeof(read_data));
297 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
298 }
299
test_4_arg_nothrow_mutable_buffer_read_at()300 void test_4_arg_nothrow_mutable_buffer_read_at()
301 {
302 asio::io_context ioc;
303 test_random_access_device s(ioc);
304 char read_buf[sizeof(read_data)];
305 asio::mutable_buffer buffers
306 = asio::buffer(read_buf, sizeof(read_buf));
307
308 s.reset(read_data, sizeof(read_data));
309 memset(read_buf, 0, sizeof(read_buf));
310 asio::error_code error;
311 size_t bytes_transferred = asio::read_at(s, 0, buffers, error);
312 ASIO_CHECK(bytes_transferred == sizeof(read_data));
313 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
314 ASIO_CHECK(!error);
315
316 s.reset(read_data, sizeof(read_data));
317 memset(read_buf, 0, sizeof(read_buf));
318 bytes_transferred = asio::read_at(s, 1234, buffers, error);
319 ASIO_CHECK(bytes_transferred == sizeof(read_data));
320 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
321 ASIO_CHECK(!error);
322
323 s.reset(read_data, sizeof(read_data));
324 s.next_read_length(1);
325 memset(read_buf, 0, sizeof(read_buf));
326 bytes_transferred = asio::read_at(s, 0, buffers, error);
327 ASIO_CHECK(bytes_transferred == sizeof(read_data));
328 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
329 ASIO_CHECK(!error);
330
331 s.reset(read_data, sizeof(read_data));
332 s.next_read_length(1);
333 memset(read_buf, 0, sizeof(read_buf));
334 bytes_transferred = asio::read_at(s, 1234, buffers, error);
335 ASIO_CHECK(bytes_transferred == sizeof(read_data));
336 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
337 ASIO_CHECK(!error);
338
339 s.reset(read_data, sizeof(read_data));
340 s.next_read_length(10);
341 memset(read_buf, 0, sizeof(read_buf));
342 bytes_transferred = asio::read_at(s, 0, buffers, error);
343 ASIO_CHECK(bytes_transferred == sizeof(read_data));
344 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
345 ASIO_CHECK(!error);
346
347 s.reset(read_data, sizeof(read_data));
348 s.next_read_length(10);
349 memset(read_buf, 0, sizeof(read_buf));
350 bytes_transferred = asio::read_at(s, 1234, buffers, error);
351 ASIO_CHECK(bytes_transferred == sizeof(read_data));
352 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
353 ASIO_CHECK(!error);
354 }
355
test_4_arg_nothrow_vector_buffers_read_at()356 void test_4_arg_nothrow_vector_buffers_read_at()
357 {
358 asio::io_context ioc;
359 test_random_access_device s(ioc);
360 char read_buf[sizeof(read_data)];
361 std::vector<asio::mutable_buffer> buffers;
362 buffers.push_back(asio::buffer(read_buf, 32));
363 buffers.push_back(asio::buffer(read_buf) + 32);
364
365 s.reset(read_data, sizeof(read_data));
366 memset(read_buf, 0, sizeof(read_buf));
367 asio::error_code error;
368 size_t bytes_transferred = asio::read_at(s, 0, buffers, error);
369 ASIO_CHECK(bytes_transferred == sizeof(read_data));
370 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
371 ASIO_CHECK(!error);
372
373 s.reset(read_data, sizeof(read_data));
374 memset(read_buf, 0, sizeof(read_buf));
375 bytes_transferred = asio::read_at(s, 1234, buffers, error);
376 ASIO_CHECK(bytes_transferred == sizeof(read_data));
377 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
378 ASIO_CHECK(!error);
379
380 s.reset(read_data, sizeof(read_data));
381 s.next_read_length(1);
382 memset(read_buf, 0, sizeof(read_buf));
383 bytes_transferred = asio::read_at(s, 0, buffers, error);
384 ASIO_CHECK(bytes_transferred == sizeof(read_data));
385 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
386 ASIO_CHECK(!error);
387
388 s.reset(read_data, sizeof(read_data));
389 s.next_read_length(1);
390 memset(read_buf, 0, sizeof(read_buf));
391 bytes_transferred = asio::read_at(s, 1234, buffers, error);
392 ASIO_CHECK(bytes_transferred == sizeof(read_data));
393 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
394 ASIO_CHECK(!error);
395
396 s.reset(read_data, sizeof(read_data));
397 s.next_read_length(10);
398 memset(read_buf, 0, sizeof(read_buf));
399 bytes_transferred = asio::read_at(s, 0, buffers, error);
400 ASIO_CHECK(bytes_transferred == sizeof(read_data));
401 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
402 ASIO_CHECK(!error);
403
404 s.reset(read_data, sizeof(read_data));
405 s.next_read_length(10);
406 memset(read_buf, 0, sizeof(read_buf));
407 bytes_transferred = asio::read_at(s, 1234, buffers, error);
408 ASIO_CHECK(bytes_transferred == sizeof(read_data));
409 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
410 ASIO_CHECK(!error);
411 }
412
test_4_arg_nothrow_streambuf_read_at()413 void test_4_arg_nothrow_streambuf_read_at()
414 {
415 asio::io_context ioc;
416 test_random_access_device s(ioc);
417 asio::streambuf sb(sizeof(read_data));
418
419 s.reset(read_data, sizeof(read_data));
420 sb.consume(sb.size());
421 asio::error_code error;
422 size_t bytes_transferred = asio::read_at(s, 0, sb, error);
423 ASIO_CHECK(bytes_transferred == sizeof(read_data));
424 ASIO_CHECK(sb.size() == sizeof(read_data));
425 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
426 ASIO_CHECK(!error);
427
428 s.reset(read_data, sizeof(read_data));
429 sb.consume(sb.size());
430 bytes_transferred = asio::read_at(s, 1234, sb, error);
431 ASIO_CHECK(bytes_transferred == sizeof(read_data));
432 ASIO_CHECK(sb.size() == sizeof(read_data));
433 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
434 ASIO_CHECK(!error);
435
436 s.reset(read_data, sizeof(read_data));
437 s.next_read_length(1);
438 sb.consume(sb.size());
439 bytes_transferred = asio::read_at(s, 0, sb, error);
440 ASIO_CHECK(bytes_transferred == sizeof(read_data));
441 ASIO_CHECK(sb.size() == sizeof(read_data));
442 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
443 ASIO_CHECK(!error);
444
445 s.reset(read_data, sizeof(read_data));
446 s.next_read_length(1);
447 sb.consume(sb.size());
448 bytes_transferred = asio::read_at(s, 1234, sb, error);
449 ASIO_CHECK(bytes_transferred == sizeof(read_data));
450 ASIO_CHECK(sb.size() == sizeof(read_data));
451 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
452 ASIO_CHECK(!error);
453
454 s.reset(read_data, sizeof(read_data));
455 s.next_read_length(10);
456 sb.consume(sb.size());
457 bytes_transferred = asio::read_at(s, 0, sb, error);
458 ASIO_CHECK(bytes_transferred == sizeof(read_data));
459 ASIO_CHECK(sb.size() == sizeof(read_data));
460 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
461 ASIO_CHECK(!error);
462
463 s.reset(read_data, sizeof(read_data));
464 s.next_read_length(10);
465 sb.consume(sb.size());
466 bytes_transferred = asio::read_at(s, 1234, sb, error);
467 ASIO_CHECK(bytes_transferred == sizeof(read_data));
468 ASIO_CHECK(sb.size() == sizeof(read_data));
469 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
470 ASIO_CHECK(!error);
471 }
472
old_style_transfer_all(const asio::error_code & ec,size_t)473 bool old_style_transfer_all(const asio::error_code& ec,
474 size_t /*bytes_transferred*/)
475 {
476 return !!ec;
477 }
478
short_transfer(const asio::error_code & ec,size_t)479 size_t short_transfer(const asio::error_code& ec,
480 size_t /*bytes_transferred*/)
481 {
482 return !!ec ? 0 : 3;
483 }
484
test_4_arg_mutable_buffer_read_at()485 void test_4_arg_mutable_buffer_read_at()
486 {
487 asio::io_context ioc;
488 test_random_access_device s(ioc);
489 char read_buf[sizeof(read_data)];
490 asio::mutable_buffer buffers
491 = asio::buffer(read_buf, sizeof(read_buf));
492
493 s.reset(read_data, sizeof(read_data));
494 memset(read_buf, 0, sizeof(read_buf));
495 size_t bytes_transferred = asio::read_at(s, 0, buffers,
496 asio::transfer_all());
497 ASIO_CHECK(bytes_transferred == sizeof(read_data));
498 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
499
500 s.reset(read_data, sizeof(read_data));
501 memset(read_buf, 0, sizeof(read_buf));
502 bytes_transferred = asio::read_at(s, 1234, buffers,
503 asio::transfer_all());
504 ASIO_CHECK(bytes_transferred == sizeof(read_data));
505 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
506
507 s.reset(read_data, sizeof(read_data));
508 s.next_read_length(1);
509 memset(read_buf, 0, sizeof(read_buf));
510 bytes_transferred = asio::read_at(s, 0, buffers,
511 asio::transfer_all());
512 ASIO_CHECK(bytes_transferred == sizeof(read_data));
513 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
514
515 s.reset(read_data, sizeof(read_data));
516 s.next_read_length(1);
517 memset(read_buf, 0, sizeof(read_buf));
518 bytes_transferred = asio::read_at(s, 1234, buffers,
519 asio::transfer_all());
520 ASIO_CHECK(bytes_transferred == sizeof(read_data));
521 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
522
523 s.reset(read_data, sizeof(read_data));
524 s.next_read_length(10);
525 memset(read_buf, 0, sizeof(read_buf));
526 bytes_transferred = asio::read_at(s, 0, buffers,
527 asio::transfer_all());
528 ASIO_CHECK(bytes_transferred == sizeof(read_data));
529 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
530
531 s.reset(read_data, sizeof(read_data));
532 s.next_read_length(10);
533 memset(read_buf, 0, sizeof(read_buf));
534 bytes_transferred = asio::read_at(s, 1234, buffers,
535 asio::transfer_all());
536 ASIO_CHECK(bytes_transferred == sizeof(read_data));
537 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
538
539 s.reset(read_data, sizeof(read_data));
540 memset(read_buf, 0, sizeof(read_buf));
541 bytes_transferred = asio::read_at(s, 0, buffers,
542 asio::transfer_at_least(1));
543 ASIO_CHECK(bytes_transferred == sizeof(read_data));
544 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
545
546 s.reset(read_data, sizeof(read_data));
547 memset(read_buf, 0, sizeof(read_buf));
548 bytes_transferred = asio::read_at(s, 1234, buffers,
549 asio::transfer_at_least(1));
550 ASIO_CHECK(bytes_transferred == sizeof(read_data));
551 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
552
553 s.reset(read_data, sizeof(read_data));
554 s.next_read_length(1);
555 memset(read_buf, 0, sizeof(read_buf));
556 bytes_transferred = asio::read_at(s, 0, buffers,
557 asio::transfer_at_least(1));
558 ASIO_CHECK(bytes_transferred == 1);
559 ASIO_CHECK(s.check_buffers(0, buffers, 1));
560
561 s.reset(read_data, sizeof(read_data));
562 s.next_read_length(1);
563 memset(read_buf, 0, sizeof(read_buf));
564 bytes_transferred = asio::read_at(s, 1234, buffers,
565 asio::transfer_at_least(1));
566 ASIO_CHECK(bytes_transferred == 1);
567 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
568
569 s.reset(read_data, sizeof(read_data));
570 s.next_read_length(10);
571 memset(read_buf, 0, sizeof(read_buf));
572 bytes_transferred = asio::read_at(s, 0, buffers,
573 asio::transfer_at_least(1));
574 ASIO_CHECK(bytes_transferred == 10);
575 ASIO_CHECK(s.check_buffers(0, buffers, 10));
576
577 s.reset(read_data, sizeof(read_data));
578 s.next_read_length(10);
579 memset(read_buf, 0, sizeof(read_buf));
580 bytes_transferred = asio::read_at(s, 1234, buffers,
581 asio::transfer_at_least(1));
582 ASIO_CHECK(bytes_transferred == 10);
583 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
584
585 s.reset(read_data, sizeof(read_data));
586 memset(read_buf, 0, sizeof(read_buf));
587 bytes_transferred = asio::read_at(s, 0, buffers,
588 asio::transfer_at_least(10));
589 ASIO_CHECK(bytes_transferred == sizeof(read_data));
590 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
591
592 s.reset(read_data, sizeof(read_data));
593 memset(read_buf, 0, sizeof(read_buf));
594 bytes_transferred = asio::read_at(s, 1234, buffers,
595 asio::transfer_at_least(10));
596 ASIO_CHECK(bytes_transferred == sizeof(read_data));
597 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
598
599 s.reset(read_data, sizeof(read_data));
600 s.next_read_length(1);
601 memset(read_buf, 0, sizeof(read_buf));
602 bytes_transferred = asio::read_at(s, 0, buffers,
603 asio::transfer_at_least(10));
604 ASIO_CHECK(bytes_transferred == 10);
605 ASIO_CHECK(s.check_buffers(0, buffers, 10));
606
607 s.reset(read_data, sizeof(read_data));
608 s.next_read_length(1);
609 memset(read_buf, 0, sizeof(read_buf));
610 bytes_transferred = asio::read_at(s, 1234, buffers,
611 asio::transfer_at_least(10));
612 ASIO_CHECK(bytes_transferred == 10);
613 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
614
615 s.reset(read_data, sizeof(read_data));
616 s.next_read_length(10);
617 memset(read_buf, 0, sizeof(read_buf));
618 bytes_transferred = asio::read_at(s, 0, buffers,
619 asio::transfer_at_least(10));
620 ASIO_CHECK(bytes_transferred == 10);
621 ASIO_CHECK(s.check_buffers(0, buffers, 10));
622
623 s.reset(read_data, sizeof(read_data));
624 s.next_read_length(10);
625 memset(read_buf, 0, sizeof(read_buf));
626 bytes_transferred = asio::read_at(s, 1234, buffers,
627 asio::transfer_at_least(10));
628 ASIO_CHECK(bytes_transferred == 10);
629 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
630
631 s.reset(read_data, sizeof(read_data));
632 memset(read_buf, 0, sizeof(read_buf));
633 bytes_transferred = asio::read_at(s, 0, buffers,
634 asio::transfer_at_least(42));
635 ASIO_CHECK(bytes_transferred == sizeof(read_data));
636 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
637
638 s.reset(read_data, sizeof(read_data));
639 memset(read_buf, 0, sizeof(read_buf));
640 bytes_transferred = asio::read_at(s, 1234, buffers,
641 asio::transfer_at_least(42));
642 ASIO_CHECK(bytes_transferred == sizeof(read_data));
643 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
644
645 s.reset(read_data, sizeof(read_data));
646 s.next_read_length(1);
647 memset(read_buf, 0, sizeof(read_buf));
648 bytes_transferred = asio::read_at(s, 0, buffers,
649 asio::transfer_at_least(42));
650 ASIO_CHECK(bytes_transferred == 42);
651 ASIO_CHECK(s.check_buffers(0, buffers, 42));
652
653 s.reset(read_data, sizeof(read_data));
654 s.next_read_length(1);
655 memset(read_buf, 0, sizeof(read_buf));
656 bytes_transferred = asio::read_at(s, 1234, buffers,
657 asio::transfer_at_least(42));
658 ASIO_CHECK(bytes_transferred == 42);
659 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
660
661 s.reset(read_data, sizeof(read_data));
662 s.next_read_length(10);
663 memset(read_buf, 0, sizeof(read_buf));
664 bytes_transferred = asio::read_at(s, 0, buffers,
665 asio::transfer_at_least(42));
666 ASIO_CHECK(bytes_transferred == 50);
667 ASIO_CHECK(s.check_buffers(0, buffers, 50));
668
669 s.reset(read_data, sizeof(read_data));
670 s.next_read_length(10);
671 memset(read_buf, 0, sizeof(read_buf));
672 bytes_transferred = asio::read_at(s, 1234, buffers,
673 asio::transfer_at_least(42));
674 ASIO_CHECK(bytes_transferred == 50);
675 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
676
677 s.reset(read_data, sizeof(read_data));
678 memset(read_buf, 0, sizeof(read_buf));
679 bytes_transferred = asio::read_at(s, 0, buffers,
680 asio::transfer_exactly(1));
681 ASIO_CHECK(bytes_transferred == 1);
682 ASIO_CHECK(s.check_buffers(0, buffers, 1));
683
684 s.reset(read_data, sizeof(read_data));
685 memset(read_buf, 0, sizeof(read_buf));
686 bytes_transferred = asio::read_at(s, 1234, buffers,
687 asio::transfer_exactly(1));
688 ASIO_CHECK(bytes_transferred == 1);
689 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
690
691 s.reset(read_data, sizeof(read_data));
692 s.next_read_length(1);
693 memset(read_buf, 0, sizeof(read_buf));
694 bytes_transferred = asio::read_at(s, 0, buffers,
695 asio::transfer_exactly(1));
696 ASIO_CHECK(bytes_transferred == 1);
697 ASIO_CHECK(s.check_buffers(0, buffers, 1));
698
699 s.reset(read_data, sizeof(read_data));
700 s.next_read_length(1);
701 memset(read_buf, 0, sizeof(read_buf));
702 bytes_transferred = asio::read_at(s, 1234, buffers,
703 asio::transfer_exactly(1));
704 ASIO_CHECK(bytes_transferred == 1);
705 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
706
707 s.reset(read_data, sizeof(read_data));
708 s.next_read_length(10);
709 memset(read_buf, 0, sizeof(read_buf));
710 bytes_transferred = asio::read_at(s, 0, buffers,
711 asio::transfer_exactly(1));
712 ASIO_CHECK(bytes_transferred == 1);
713 ASIO_CHECK(s.check_buffers(0, buffers, 1));
714
715 s.reset(read_data, sizeof(read_data));
716 s.next_read_length(10);
717 memset(read_buf, 0, sizeof(read_buf));
718 bytes_transferred = asio::read_at(s, 1234, buffers,
719 asio::transfer_exactly(1));
720 ASIO_CHECK(bytes_transferred == 1);
721 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
722
723 s.reset(read_data, sizeof(read_data));
724 memset(read_buf, 0, sizeof(read_buf));
725 bytes_transferred = asio::read_at(s, 0, buffers,
726 asio::transfer_exactly(10));
727 ASIO_CHECK(bytes_transferred == 10);
728 ASIO_CHECK(s.check_buffers(0, buffers, 10));
729
730 s.reset(read_data, sizeof(read_data));
731 memset(read_buf, 0, sizeof(read_buf));
732 bytes_transferred = asio::read_at(s, 1234, buffers,
733 asio::transfer_exactly(10));
734 ASIO_CHECK(bytes_transferred == 10);
735 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
736
737 s.reset(read_data, sizeof(read_data));
738 s.next_read_length(1);
739 memset(read_buf, 0, sizeof(read_buf));
740 bytes_transferred = asio::read_at(s, 0, buffers,
741 asio::transfer_exactly(10));
742 ASIO_CHECK(bytes_transferred == 10);
743 ASIO_CHECK(s.check_buffers(0, buffers, 10));
744
745 s.reset(read_data, sizeof(read_data));
746 s.next_read_length(1);
747 memset(read_buf, 0, sizeof(read_buf));
748 bytes_transferred = asio::read_at(s, 1234, buffers,
749 asio::transfer_exactly(10));
750 ASIO_CHECK(bytes_transferred == 10);
751 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
752
753 s.reset(read_data, sizeof(read_data));
754 s.next_read_length(10);
755 memset(read_buf, 0, sizeof(read_buf));
756 bytes_transferred = asio::read_at(s, 0, buffers,
757 asio::transfer_exactly(10));
758 ASIO_CHECK(bytes_transferred == 10);
759 ASIO_CHECK(s.check_buffers(0, buffers, 10));
760
761 s.reset(read_data, sizeof(read_data));
762 s.next_read_length(10);
763 memset(read_buf, 0, sizeof(read_buf));
764 bytes_transferred = asio::read_at(s, 1234, buffers,
765 asio::transfer_exactly(10));
766 ASIO_CHECK(bytes_transferred == 10);
767 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
768
769 s.reset(read_data, sizeof(read_data));
770 memset(read_buf, 0, sizeof(read_buf));
771 bytes_transferred = asio::read_at(s, 0, buffers,
772 asio::transfer_exactly(42));
773 ASIO_CHECK(bytes_transferred == 42);
774 ASIO_CHECK(s.check_buffers(0, buffers, 42));
775
776 s.reset(read_data, sizeof(read_data));
777 memset(read_buf, 0, sizeof(read_buf));
778 bytes_transferred = asio::read_at(s, 1234, buffers,
779 asio::transfer_exactly(42));
780 ASIO_CHECK(bytes_transferred == 42);
781 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
782
783 s.reset(read_data, sizeof(read_data));
784 s.next_read_length(1);
785 memset(read_buf, 0, sizeof(read_buf));
786 bytes_transferred = asio::read_at(s, 0, buffers,
787 asio::transfer_exactly(42));
788 ASIO_CHECK(bytes_transferred == 42);
789 ASIO_CHECK(s.check_buffers(0, buffers, 42));
790
791 s.reset(read_data, sizeof(read_data));
792 s.next_read_length(1);
793 memset(read_buf, 0, sizeof(read_buf));
794 bytes_transferred = asio::read_at(s, 1234, buffers,
795 asio::transfer_exactly(42));
796 ASIO_CHECK(bytes_transferred == 42);
797 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
798
799 s.reset(read_data, sizeof(read_data));
800 s.next_read_length(10);
801 memset(read_buf, 0, sizeof(read_buf));
802 bytes_transferred = asio::read_at(s, 0, buffers,
803 asio::transfer_exactly(42));
804 ASIO_CHECK(bytes_transferred == 42);
805 ASIO_CHECK(s.check_buffers(0, buffers, 42));
806
807 s.reset(read_data, sizeof(read_data));
808 s.next_read_length(10);
809 memset(read_buf, 0, sizeof(read_buf));
810 bytes_transferred = asio::read_at(s, 1234, buffers,
811 asio::transfer_exactly(42));
812 ASIO_CHECK(bytes_transferred == 42);
813 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
814
815 s.reset(read_data, sizeof(read_data));
816 memset(read_buf, 0, sizeof(read_buf));
817 bytes_transferred = asio::read_at(s, 0, buffers,
818 old_style_transfer_all);
819 ASIO_CHECK(bytes_transferred == sizeof(read_data));
820 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
821
822 s.reset(read_data, sizeof(read_data));
823 memset(read_buf, 0, sizeof(read_buf));
824 bytes_transferred = asio::read_at(s, 1234, buffers,
825 old_style_transfer_all);
826 ASIO_CHECK(bytes_transferred == sizeof(read_data));
827 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
828
829 s.reset(read_data, sizeof(read_data));
830 s.next_read_length(1);
831 memset(read_buf, 0, sizeof(read_buf));
832 bytes_transferred = asio::read_at(s, 0, buffers,
833 old_style_transfer_all);
834 ASIO_CHECK(bytes_transferred == sizeof(read_data));
835 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
836
837 s.reset(read_data, sizeof(read_data));
838 s.next_read_length(1);
839 memset(read_buf, 0, sizeof(read_buf));
840 bytes_transferred = asio::read_at(s, 1234, buffers,
841 old_style_transfer_all);
842 ASIO_CHECK(bytes_transferred == sizeof(read_data));
843 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
844
845 s.reset(read_data, sizeof(read_data));
846 s.next_read_length(10);
847 memset(read_buf, 0, sizeof(read_buf));
848 bytes_transferred = asio::read_at(s, 0, buffers,
849 old_style_transfer_all);
850 ASIO_CHECK(bytes_transferred == sizeof(read_data));
851 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
852
853 s.reset(read_data, sizeof(read_data));
854 s.next_read_length(10);
855 memset(read_buf, 0, sizeof(read_buf));
856 bytes_transferred = asio::read_at(s, 1234, buffers,
857 old_style_transfer_all);
858 ASIO_CHECK(bytes_transferred == sizeof(read_data));
859 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
860
861 s.reset(read_data, sizeof(read_data));
862 memset(read_buf, 0, sizeof(read_buf));
863 bytes_transferred = asio::read_at(s, 0, buffers, short_transfer);
864 ASIO_CHECK(bytes_transferred == sizeof(read_data));
865 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
866
867 s.reset(read_data, sizeof(read_data));
868 memset(read_buf, 0, sizeof(read_buf));
869 bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer);
870 ASIO_CHECK(bytes_transferred == sizeof(read_data));
871 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
872
873 s.reset(read_data, sizeof(read_data));
874 s.next_read_length(1);
875 memset(read_buf, 0, sizeof(read_buf));
876 bytes_transferred = asio::read_at(s, 0, buffers, short_transfer);
877 ASIO_CHECK(bytes_transferred == sizeof(read_data));
878 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
879
880 s.reset(read_data, sizeof(read_data));
881 s.next_read_length(1);
882 memset(read_buf, 0, sizeof(read_buf));
883 bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer);
884 ASIO_CHECK(bytes_transferred == sizeof(read_data));
885 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
886
887 s.reset(read_data, sizeof(read_data));
888 s.next_read_length(10);
889 memset(read_buf, 0, sizeof(read_buf));
890 bytes_transferred = asio::read_at(s, 0, buffers, short_transfer);
891 ASIO_CHECK(bytes_transferred == sizeof(read_data));
892 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
893
894 s.reset(read_data, sizeof(read_data));
895 s.next_read_length(10);
896 memset(read_buf, 0, sizeof(read_buf));
897 bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer);
898 ASIO_CHECK(bytes_transferred == sizeof(read_data));
899 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
900 }
901
test_4_arg_vector_buffers_read_at()902 void test_4_arg_vector_buffers_read_at()
903 {
904 asio::io_context ioc;
905 test_random_access_device s(ioc);
906 char read_buf[sizeof(read_data)];
907 std::vector<asio::mutable_buffer> buffers;
908 buffers.push_back(asio::buffer(read_buf, 32));
909 buffers.push_back(asio::buffer(read_buf) + 32);
910
911 s.reset(read_data, sizeof(read_data));
912 memset(read_buf, 0, sizeof(read_buf));
913 size_t bytes_transferred = asio::read_at(s, 0, buffers,
914 asio::transfer_all());
915 ASIO_CHECK(bytes_transferred == sizeof(read_data));
916 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
917
918 s.reset(read_data, sizeof(read_data));
919 memset(read_buf, 0, sizeof(read_buf));
920 bytes_transferred = asio::read_at(s, 1234, buffers,
921 asio::transfer_all());
922 ASIO_CHECK(bytes_transferred == sizeof(read_data));
923 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
924
925 s.reset(read_data, sizeof(read_data));
926 s.next_read_length(1);
927 memset(read_buf, 0, sizeof(read_buf));
928 bytes_transferred = asio::read_at(s, 0, buffers,
929 asio::transfer_all());
930 ASIO_CHECK(bytes_transferred == sizeof(read_data));
931 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
932
933 s.reset(read_data, sizeof(read_data));
934 s.next_read_length(1);
935 memset(read_buf, 0, sizeof(read_buf));
936 bytes_transferred = asio::read_at(s, 1234, buffers,
937 asio::transfer_all());
938 ASIO_CHECK(bytes_transferred == sizeof(read_data));
939 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
940
941 s.reset(read_data, sizeof(read_data));
942 s.next_read_length(10);
943 memset(read_buf, 0, sizeof(read_buf));
944 bytes_transferred = asio::read_at(s, 0, buffers,
945 asio::transfer_all());
946 ASIO_CHECK(bytes_transferred == sizeof(read_data));
947 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
948
949 s.reset(read_data, sizeof(read_data));
950 s.next_read_length(10);
951 memset(read_buf, 0, sizeof(read_buf));
952 bytes_transferred = asio::read_at(s, 1234, buffers,
953 asio::transfer_all());
954 ASIO_CHECK(bytes_transferred == sizeof(read_data));
955 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
956
957 s.reset(read_data, sizeof(read_data));
958 memset(read_buf, 0, sizeof(read_buf));
959 bytes_transferred = asio::read_at(s, 0, buffers,
960 asio::transfer_at_least(1));
961 ASIO_CHECK(bytes_transferred == sizeof(read_data));
962 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
963
964 s.reset(read_data, sizeof(read_data));
965 memset(read_buf, 0, sizeof(read_buf));
966 bytes_transferred = asio::read_at(s, 1234, buffers,
967 asio::transfer_at_least(1));
968 ASIO_CHECK(bytes_transferred == sizeof(read_data));
969 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
970
971 s.reset(read_data, sizeof(read_data));
972 s.next_read_length(1);
973 memset(read_buf, 0, sizeof(read_buf));
974 bytes_transferred = asio::read_at(s, 0, buffers,
975 asio::transfer_at_least(1));
976 ASIO_CHECK(bytes_transferred == 1);
977 ASIO_CHECK(s.check_buffers(0, buffers, 1));
978
979 s.reset(read_data, sizeof(read_data));
980 s.next_read_length(1);
981 memset(read_buf, 0, sizeof(read_buf));
982 bytes_transferred = asio::read_at(s, 1234, buffers,
983 asio::transfer_at_least(1));
984 ASIO_CHECK(bytes_transferred == 1);
985 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
986
987 s.reset(read_data, sizeof(read_data));
988 s.next_read_length(10);
989 memset(read_buf, 0, sizeof(read_buf));
990 bytes_transferred = asio::read_at(s, 0, buffers,
991 asio::transfer_at_least(1));
992 ASIO_CHECK(bytes_transferred == 10);
993 ASIO_CHECK(s.check_buffers(0, buffers, 10));
994
995 s.reset(read_data, sizeof(read_data));
996 s.next_read_length(10);
997 memset(read_buf, 0, sizeof(read_buf));
998 bytes_transferred = asio::read_at(s, 1234, buffers,
999 asio::transfer_at_least(1));
1000 ASIO_CHECK(bytes_transferred == 10);
1001 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1002
1003 s.reset(read_data, sizeof(read_data));
1004 memset(read_buf, 0, sizeof(read_buf));
1005 bytes_transferred = asio::read_at(s, 0, buffers,
1006 asio::transfer_at_least(10));
1007 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1008 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1009
1010 s.reset(read_data, sizeof(read_data));
1011 memset(read_buf, 0, sizeof(read_buf));
1012 bytes_transferred = asio::read_at(s, 1234, buffers,
1013 asio::transfer_at_least(10));
1014 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1015 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1016
1017 s.reset(read_data, sizeof(read_data));
1018 s.next_read_length(1);
1019 memset(read_buf, 0, sizeof(read_buf));
1020 bytes_transferred = asio::read_at(s, 0, buffers,
1021 asio::transfer_at_least(10));
1022 ASIO_CHECK(bytes_transferred == 10);
1023 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1024
1025 s.reset(read_data, sizeof(read_data));
1026 s.next_read_length(1);
1027 memset(read_buf, 0, sizeof(read_buf));
1028 bytes_transferred = asio::read_at(s, 1234, buffers,
1029 asio::transfer_at_least(10));
1030 ASIO_CHECK(bytes_transferred == 10);
1031 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1032
1033 s.reset(read_data, sizeof(read_data));
1034 s.next_read_length(10);
1035 memset(read_buf, 0, sizeof(read_buf));
1036 bytes_transferred = asio::read_at(s, 0, buffers,
1037 asio::transfer_at_least(10));
1038 ASIO_CHECK(bytes_transferred == 10);
1039 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1040
1041 s.reset(read_data, sizeof(read_data));
1042 s.next_read_length(10);
1043 memset(read_buf, 0, sizeof(read_buf));
1044 bytes_transferred = asio::read_at(s, 1234, buffers,
1045 asio::transfer_at_least(10));
1046 ASIO_CHECK(bytes_transferred == 10);
1047 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1048
1049 s.reset(read_data, sizeof(read_data));
1050 memset(read_buf, 0, sizeof(read_buf));
1051 bytes_transferred = asio::read_at(s, 0, buffers,
1052 asio::transfer_at_least(42));
1053 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1054 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1055
1056 s.reset(read_data, sizeof(read_data));
1057 memset(read_buf, 0, sizeof(read_buf));
1058 bytes_transferred = asio::read_at(s, 1234, buffers,
1059 asio::transfer_at_least(42));
1060 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1061 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1062
1063 s.reset(read_data, sizeof(read_data));
1064 s.next_read_length(1);
1065 memset(read_buf, 0, sizeof(read_buf));
1066 bytes_transferred = asio::read_at(s, 0, buffers,
1067 asio::transfer_at_least(42));
1068 ASIO_CHECK(bytes_transferred == 42);
1069 ASIO_CHECK(s.check_buffers(0, buffers, 42));
1070
1071 s.reset(read_data, sizeof(read_data));
1072 s.next_read_length(1);
1073 memset(read_buf, 0, sizeof(read_buf));
1074 bytes_transferred = asio::read_at(s, 1234, buffers,
1075 asio::transfer_at_least(42));
1076 ASIO_CHECK(bytes_transferred == 42);
1077 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1078
1079 s.reset(read_data, sizeof(read_data));
1080 s.next_read_length(10);
1081 memset(read_buf, 0, sizeof(read_buf));
1082 bytes_transferred = asio::read_at(s, 0, buffers,
1083 asio::transfer_at_least(42));
1084 ASIO_CHECK(bytes_transferred == 50);
1085 ASIO_CHECK(s.check_buffers(0, buffers, 50));
1086
1087 s.reset(read_data, sizeof(read_data));
1088 s.next_read_length(10);
1089 memset(read_buf, 0, sizeof(read_buf));
1090 bytes_transferred = asio::read_at(s, 1234, buffers,
1091 asio::transfer_at_least(42));
1092 ASIO_CHECK(bytes_transferred == 50);
1093 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
1094
1095 s.reset(read_data, sizeof(read_data));
1096 memset(read_buf, 0, sizeof(read_buf));
1097 bytes_transferred = asio::read_at(s, 0, buffers,
1098 asio::transfer_exactly(1));
1099 ASIO_CHECK(bytes_transferred == 1);
1100 ASIO_CHECK(s.check_buffers(0, buffers, 1));
1101
1102 s.reset(read_data, sizeof(read_data));
1103 memset(read_buf, 0, sizeof(read_buf));
1104 bytes_transferred = asio::read_at(s, 1234, buffers,
1105 asio::transfer_exactly(1));
1106 ASIO_CHECK(bytes_transferred == 1);
1107 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1108
1109 s.reset(read_data, sizeof(read_data));
1110 s.next_read_length(1);
1111 memset(read_buf, 0, sizeof(read_buf));
1112 bytes_transferred = asio::read_at(s, 0, buffers,
1113 asio::transfer_exactly(1));
1114 ASIO_CHECK(bytes_transferred == 1);
1115 ASIO_CHECK(s.check_buffers(0, buffers, 1));
1116
1117 s.reset(read_data, sizeof(read_data));
1118 s.next_read_length(1);
1119 memset(read_buf, 0, sizeof(read_buf));
1120 bytes_transferred = asio::read_at(s, 1234, buffers,
1121 asio::transfer_exactly(1));
1122 ASIO_CHECK(bytes_transferred == 1);
1123 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1124
1125 s.reset(read_data, sizeof(read_data));
1126 s.next_read_length(10);
1127 memset(read_buf, 0, sizeof(read_buf));
1128 bytes_transferred = asio::read_at(s, 0, buffers,
1129 asio::transfer_exactly(1));
1130 ASIO_CHECK(bytes_transferred == 1);
1131 ASIO_CHECK(s.check_buffers(0, buffers, 1));
1132
1133 s.reset(read_data, sizeof(read_data));
1134 s.next_read_length(10);
1135 memset(read_buf, 0, sizeof(read_buf));
1136 bytes_transferred = asio::read_at(s, 1234, buffers,
1137 asio::transfer_exactly(1));
1138 ASIO_CHECK(bytes_transferred == 1);
1139 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1140
1141 s.reset(read_data, sizeof(read_data));
1142 memset(read_buf, 0, sizeof(read_buf));
1143 bytes_transferred = asio::read_at(s, 0, buffers,
1144 asio::transfer_exactly(10));
1145 ASIO_CHECK(bytes_transferred == 10);
1146 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1147
1148 s.reset(read_data, sizeof(read_data));
1149 memset(read_buf, 0, sizeof(read_buf));
1150 bytes_transferred = asio::read_at(s, 1234, buffers,
1151 asio::transfer_exactly(10));
1152 ASIO_CHECK(bytes_transferred == 10);
1153 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1154
1155 s.reset(read_data, sizeof(read_data));
1156 s.next_read_length(1);
1157 memset(read_buf, 0, sizeof(read_buf));
1158 bytes_transferred = asio::read_at(s, 0, buffers,
1159 asio::transfer_exactly(10));
1160 ASIO_CHECK(bytes_transferred == 10);
1161 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1162
1163 s.reset(read_data, sizeof(read_data));
1164 s.next_read_length(1);
1165 memset(read_buf, 0, sizeof(read_buf));
1166 bytes_transferred = asio::read_at(s, 1234, buffers,
1167 asio::transfer_exactly(10));
1168 ASIO_CHECK(bytes_transferred == 10);
1169 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1170
1171 s.reset(read_data, sizeof(read_data));
1172 s.next_read_length(10);
1173 memset(read_buf, 0, sizeof(read_buf));
1174 bytes_transferred = asio::read_at(s, 0, buffers,
1175 asio::transfer_exactly(10));
1176 ASIO_CHECK(bytes_transferred == 10);
1177 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1178
1179 s.reset(read_data, sizeof(read_data));
1180 s.next_read_length(10);
1181 memset(read_buf, 0, sizeof(read_buf));
1182 bytes_transferred = asio::read_at(s, 1234, buffers,
1183 asio::transfer_exactly(10));
1184 ASIO_CHECK(bytes_transferred == 10);
1185 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1186
1187 s.reset(read_data, sizeof(read_data));
1188 memset(read_buf, 0, sizeof(read_buf));
1189 bytes_transferred = asio::read_at(s, 0, buffers,
1190 asio::transfer_exactly(42));
1191 ASIO_CHECK(bytes_transferred == 42);
1192 ASIO_CHECK(s.check_buffers(0, buffers, 42));
1193
1194 s.reset(read_data, sizeof(read_data));
1195 memset(read_buf, 0, sizeof(read_buf));
1196 bytes_transferred = asio::read_at(s, 1234, buffers,
1197 asio::transfer_exactly(42));
1198 ASIO_CHECK(bytes_transferred == 42);
1199 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1200
1201 s.reset(read_data, sizeof(read_data));
1202 s.next_read_length(1);
1203 memset(read_buf, 0, sizeof(read_buf));
1204 bytes_transferred = asio::read_at(s, 0, buffers,
1205 asio::transfer_exactly(42));
1206 ASIO_CHECK(bytes_transferred == 42);
1207 ASIO_CHECK(s.check_buffers(0, buffers, 42));
1208
1209 s.reset(read_data, sizeof(read_data));
1210 s.next_read_length(1);
1211 memset(read_buf, 0, sizeof(read_buf));
1212 bytes_transferred = asio::read_at(s, 1234, buffers,
1213 asio::transfer_exactly(42));
1214 ASIO_CHECK(bytes_transferred == 42);
1215 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1216
1217 s.reset(read_data, sizeof(read_data));
1218 s.next_read_length(10);
1219 memset(read_buf, 0, sizeof(read_buf));
1220 bytes_transferred = asio::read_at(s, 0, buffers,
1221 asio::transfer_exactly(42));
1222 ASIO_CHECK(bytes_transferred == 42);
1223 ASIO_CHECK(s.check_buffers(0, buffers, 42));
1224
1225 s.reset(read_data, sizeof(read_data));
1226 s.next_read_length(10);
1227 memset(read_buf, 0, sizeof(read_buf));
1228 bytes_transferred = asio::read_at(s, 1234, buffers,
1229 asio::transfer_exactly(42));
1230 ASIO_CHECK(bytes_transferred == 42);
1231 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
1232
1233 s.reset(read_data, sizeof(read_data));
1234 memset(read_buf, 0, sizeof(read_buf));
1235 bytes_transferred = asio::read_at(s, 0, buffers,
1236 old_style_transfer_all);
1237 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1238 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1239
1240 s.reset(read_data, sizeof(read_data));
1241 memset(read_buf, 0, sizeof(read_buf));
1242 bytes_transferred = asio::read_at(s, 1234, buffers,
1243 old_style_transfer_all);
1244 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1245 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1246
1247 s.reset(read_data, sizeof(read_data));
1248 s.next_read_length(1);
1249 memset(read_buf, 0, sizeof(read_buf));
1250 bytes_transferred = asio::read_at(s, 0, buffers,
1251 old_style_transfer_all);
1252 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1253 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1254
1255 s.reset(read_data, sizeof(read_data));
1256 s.next_read_length(1);
1257 memset(read_buf, 0, sizeof(read_buf));
1258 bytes_transferred = asio::read_at(s, 1234, buffers,
1259 old_style_transfer_all);
1260 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1261 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1262
1263 s.reset(read_data, sizeof(read_data));
1264 s.next_read_length(10);
1265 memset(read_buf, 0, sizeof(read_buf));
1266 bytes_transferred = asio::read_at(s, 0, buffers,
1267 old_style_transfer_all);
1268 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1269 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1270
1271 s.reset(read_data, sizeof(read_data));
1272 s.next_read_length(10);
1273 memset(read_buf, 0, sizeof(read_buf));
1274 bytes_transferred = asio::read_at(s, 1234, buffers,
1275 old_style_transfer_all);
1276 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1277 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1278
1279 s.reset(read_data, sizeof(read_data));
1280 memset(read_buf, 0, sizeof(read_buf));
1281 bytes_transferred = asio::read_at(s, 0, buffers, short_transfer);
1282 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1283 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1284
1285 s.reset(read_data, sizeof(read_data));
1286 memset(read_buf, 0, sizeof(read_buf));
1287 bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer);
1288 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1289 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1290
1291 s.reset(read_data, sizeof(read_data));
1292 s.next_read_length(1);
1293 memset(read_buf, 0, sizeof(read_buf));
1294 bytes_transferred = asio::read_at(s, 0, buffers, short_transfer);
1295 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1296 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1297
1298 s.reset(read_data, sizeof(read_data));
1299 s.next_read_length(1);
1300 memset(read_buf, 0, sizeof(read_buf));
1301 bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer);
1302 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1303 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1304
1305 s.reset(read_data, sizeof(read_data));
1306 s.next_read_length(10);
1307 memset(read_buf, 0, sizeof(read_buf));
1308 bytes_transferred = asio::read_at(s, 0, buffers, short_transfer);
1309 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1310 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1311
1312 s.reset(read_data, sizeof(read_data));
1313 s.next_read_length(10);
1314 memset(read_buf, 0, sizeof(read_buf));
1315 bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer);
1316 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1317 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1318 }
1319
test_4_arg_streambuf_read_at()1320 void test_4_arg_streambuf_read_at()
1321 {
1322 asio::io_context ioc;
1323 test_random_access_device s(ioc);
1324 asio::streambuf sb(sizeof(read_data));
1325
1326 s.reset(read_data, sizeof(read_data));
1327 sb.consume(sb.size());
1328 size_t bytes_transferred = asio::read_at(s, 0, sb,
1329 asio::transfer_all());
1330 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1331 ASIO_CHECK(sb.size() == sizeof(read_data));
1332 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1333
1334 s.reset(read_data, sizeof(read_data));
1335 sb.consume(sb.size());
1336 bytes_transferred = asio::read_at(s, 1234, sb,
1337 asio::transfer_all());
1338 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1339 ASIO_CHECK(sb.size() == sizeof(read_data));
1340 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1341
1342 s.reset(read_data, sizeof(read_data));
1343 s.next_read_length(1);
1344 sb.consume(sb.size());
1345 bytes_transferred = asio::read_at(s, 0, sb,
1346 asio::transfer_all());
1347 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1348 ASIO_CHECK(sb.size() == sizeof(read_data));
1349 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1350
1351 s.reset(read_data, sizeof(read_data));
1352 s.next_read_length(1);
1353 sb.consume(sb.size());
1354 bytes_transferred = asio::read_at(s, 1234, sb,
1355 asio::transfer_all());
1356 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1357 ASIO_CHECK(sb.size() == sizeof(read_data));
1358 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1359
1360 s.reset(read_data, sizeof(read_data));
1361 s.next_read_length(10);
1362 sb.consume(sb.size());
1363 bytes_transferred = asio::read_at(s, 0, sb,
1364 asio::transfer_all());
1365 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1366 ASIO_CHECK(sb.size() == sizeof(read_data));
1367 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1368
1369 s.reset(read_data, sizeof(read_data));
1370 s.next_read_length(10);
1371 sb.consume(sb.size());
1372 bytes_transferred = asio::read_at(s, 1234, sb,
1373 asio::transfer_all());
1374 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1375 ASIO_CHECK(sb.size() == sizeof(read_data));
1376 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1377
1378 s.reset(read_data, sizeof(read_data));
1379 sb.consume(sb.size());
1380 bytes_transferred = asio::read_at(s, 0, sb,
1381 asio::transfer_at_least(1));
1382 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1383 ASIO_CHECK(sb.size() == sizeof(read_data));
1384 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1385
1386 s.reset(read_data, sizeof(read_data));
1387 sb.consume(sb.size());
1388 bytes_transferred = asio::read_at(s, 1234, sb,
1389 asio::transfer_at_least(1));
1390 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1391 ASIO_CHECK(sb.size() == sizeof(read_data));
1392 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1393
1394 s.reset(read_data, sizeof(read_data));
1395 s.next_read_length(1);
1396 sb.consume(sb.size());
1397 bytes_transferred = asio::read_at(s, 0, sb,
1398 asio::transfer_at_least(1));
1399 ASIO_CHECK(bytes_transferred == 1);
1400 ASIO_CHECK(sb.size() == 1);
1401 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1402
1403 s.reset(read_data, sizeof(read_data));
1404 s.next_read_length(1);
1405 sb.consume(sb.size());
1406 bytes_transferred = asio::read_at(s, 1234, sb,
1407 asio::transfer_at_least(1));
1408 ASIO_CHECK(bytes_transferred == 1);
1409 ASIO_CHECK(sb.size() == 1);
1410 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1411
1412 s.reset(read_data, sizeof(read_data));
1413 s.next_read_length(10);
1414 sb.consume(sb.size());
1415 bytes_transferred = asio::read_at(s, 0, sb,
1416 asio::transfer_at_least(1));
1417 ASIO_CHECK(bytes_transferred == 10);
1418 ASIO_CHECK(sb.size() == 10);
1419 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1420
1421 s.reset(read_data, sizeof(read_data));
1422 s.next_read_length(10);
1423 sb.consume(sb.size());
1424 bytes_transferred = asio::read_at(s, 1234, sb,
1425 asio::transfer_at_least(1));
1426 ASIO_CHECK(bytes_transferred == 10);
1427 ASIO_CHECK(sb.size() == 10);
1428 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1429
1430 s.reset(read_data, sizeof(read_data));
1431 sb.consume(sb.size());
1432 bytes_transferred = asio::read_at(s, 0, sb,
1433 asio::transfer_at_least(10));
1434 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1435 ASIO_CHECK(sb.size() == sizeof(read_data));
1436 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1437
1438 s.reset(read_data, sizeof(read_data));
1439 sb.consume(sb.size());
1440 bytes_transferred = asio::read_at(s, 1234, sb,
1441 asio::transfer_at_least(10));
1442 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1443 ASIO_CHECK(sb.size() == sizeof(read_data));
1444 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1445
1446 s.reset(read_data, sizeof(read_data));
1447 s.next_read_length(1);
1448 sb.consume(sb.size());
1449 bytes_transferred = asio::read_at(s, 0, sb,
1450 asio::transfer_at_least(10));
1451 ASIO_CHECK(bytes_transferred == 10);
1452 ASIO_CHECK(sb.size() == 10);
1453 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1454
1455 s.reset(read_data, sizeof(read_data));
1456 s.next_read_length(1);
1457 sb.consume(sb.size());
1458 bytes_transferred = asio::read_at(s, 1234, sb,
1459 asio::transfer_at_least(10));
1460 ASIO_CHECK(bytes_transferred == 10);
1461 ASIO_CHECK(sb.size() == 10);
1462 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1463
1464 s.reset(read_data, sizeof(read_data));
1465 s.next_read_length(10);
1466 sb.consume(sb.size());
1467 bytes_transferred = asio::read_at(s, 0, sb,
1468 asio::transfer_at_least(10));
1469 ASIO_CHECK(bytes_transferred == 10);
1470 ASIO_CHECK(sb.size() == 10);
1471 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1472
1473 s.reset(read_data, sizeof(read_data));
1474 s.next_read_length(10);
1475 sb.consume(sb.size());
1476 bytes_transferred = asio::read_at(s, 1234, sb,
1477 asio::transfer_at_least(10));
1478 ASIO_CHECK(bytes_transferred == 10);
1479 ASIO_CHECK(sb.size() == 10);
1480 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1481
1482 s.reset(read_data, sizeof(read_data));
1483 sb.consume(sb.size());
1484 bytes_transferred = asio::read_at(s, 0, sb,
1485 asio::transfer_at_least(42));
1486 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1487 ASIO_CHECK(sb.size() == sizeof(read_data));
1488 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1489
1490 s.reset(read_data, sizeof(read_data));
1491 sb.consume(sb.size());
1492 bytes_transferred = asio::read_at(s, 1234, sb,
1493 asio::transfer_at_least(42));
1494 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1495 ASIO_CHECK(sb.size() == sizeof(read_data));
1496 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1497
1498 s.reset(read_data, sizeof(read_data));
1499 s.next_read_length(1);
1500 sb.consume(sb.size());
1501 bytes_transferred = asio::read_at(s, 0, sb,
1502 asio::transfer_at_least(42));
1503 ASIO_CHECK(bytes_transferred == 42);
1504 ASIO_CHECK(sb.size() == 42);
1505 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1506
1507 s.reset(read_data, sizeof(read_data));
1508 s.next_read_length(1);
1509 sb.consume(sb.size());
1510 bytes_transferred = asio::read_at(s, 1234, sb,
1511 asio::transfer_at_least(42));
1512 ASIO_CHECK(bytes_transferred == 42);
1513 ASIO_CHECK(sb.size() == 42);
1514 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1515
1516 s.reset(read_data, sizeof(read_data));
1517 s.next_read_length(10);
1518 sb.consume(sb.size());
1519 bytes_transferred = asio::read_at(s, 0, sb,
1520 asio::transfer_at_least(42));
1521 ASIO_CHECK(bytes_transferred == 50);
1522 ASIO_CHECK(sb.size() == 50);
1523 ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
1524
1525 s.reset(read_data, sizeof(read_data));
1526 s.next_read_length(10);
1527 sb.consume(sb.size());
1528 bytes_transferred = asio::read_at(s, 1234, sb,
1529 asio::transfer_at_least(42));
1530 ASIO_CHECK(bytes_transferred == 50);
1531 ASIO_CHECK(sb.size() == 50);
1532 ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
1533
1534 s.reset(read_data, sizeof(read_data));
1535 sb.consume(sb.size());
1536 bytes_transferred = asio::read_at(s, 0, sb,
1537 asio::transfer_exactly(1));
1538 ASIO_CHECK(bytes_transferred == 1);
1539 ASIO_CHECK(sb.size() == 1);
1540 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1541
1542 s.reset(read_data, sizeof(read_data));
1543 sb.consume(sb.size());
1544 bytes_transferred = asio::read_at(s, 1234, sb,
1545 asio::transfer_exactly(1));
1546 ASIO_CHECK(bytes_transferred == 1);
1547 ASIO_CHECK(sb.size() == 1);
1548 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1549
1550 s.reset(read_data, sizeof(read_data));
1551 s.next_read_length(1);
1552 sb.consume(sb.size());
1553 bytes_transferred = asio::read_at(s, 0, sb,
1554 asio::transfer_exactly(1));
1555 ASIO_CHECK(bytes_transferred == 1);
1556 ASIO_CHECK(sb.size() == 1);
1557 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1558
1559 s.reset(read_data, sizeof(read_data));
1560 s.next_read_length(1);
1561 sb.consume(sb.size());
1562 bytes_transferred = asio::read_at(s, 1234, sb,
1563 asio::transfer_exactly(1));
1564 ASIO_CHECK(bytes_transferred == 1);
1565 ASIO_CHECK(sb.size() == 1);
1566 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1567
1568 s.reset(read_data, sizeof(read_data));
1569 s.next_read_length(10);
1570 sb.consume(sb.size());
1571 bytes_transferred = asio::read_at(s, 0, sb,
1572 asio::transfer_exactly(1));
1573 ASIO_CHECK(bytes_transferred == 1);
1574 ASIO_CHECK(sb.size() == 1);
1575 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
1576
1577 s.reset(read_data, sizeof(read_data));
1578 s.next_read_length(10);
1579 sb.consume(sb.size());
1580 bytes_transferred = asio::read_at(s, 1234, sb,
1581 asio::transfer_exactly(1));
1582 ASIO_CHECK(bytes_transferred == 1);
1583 ASIO_CHECK(sb.size() == 1);
1584 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
1585
1586 s.reset(read_data, sizeof(read_data));
1587 sb.consume(sb.size());
1588 bytes_transferred = asio::read_at(s, 0, sb,
1589 asio::transfer_exactly(10));
1590 ASIO_CHECK(bytes_transferred == 10);
1591 ASIO_CHECK(sb.size() == 10);
1592 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1593
1594 s.reset(read_data, sizeof(read_data));
1595 sb.consume(sb.size());
1596 bytes_transferred = asio::read_at(s, 1234, sb,
1597 asio::transfer_exactly(10));
1598 ASIO_CHECK(bytes_transferred == 10);
1599 ASIO_CHECK(sb.size() == 10);
1600 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1601
1602 s.reset(read_data, sizeof(read_data));
1603 s.next_read_length(1);
1604 sb.consume(sb.size());
1605 bytes_transferred = asio::read_at(s, 0, sb,
1606 asio::transfer_exactly(10));
1607 ASIO_CHECK(bytes_transferred == 10);
1608 ASIO_CHECK(sb.size() == 10);
1609 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1610
1611 s.reset(read_data, sizeof(read_data));
1612 s.next_read_length(1);
1613 sb.consume(sb.size());
1614 bytes_transferred = asio::read_at(s, 1234, sb,
1615 asio::transfer_exactly(10));
1616 ASIO_CHECK(bytes_transferred == 10);
1617 ASIO_CHECK(sb.size() == 10);
1618 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1619
1620 s.reset(read_data, sizeof(read_data));
1621 s.next_read_length(10);
1622 sb.consume(sb.size());
1623 bytes_transferred = asio::read_at(s, 0, sb,
1624 asio::transfer_exactly(10));
1625 ASIO_CHECK(bytes_transferred == 10);
1626 ASIO_CHECK(sb.size() == 10);
1627 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
1628
1629 s.reset(read_data, sizeof(read_data));
1630 s.next_read_length(10);
1631 sb.consume(sb.size());
1632 bytes_transferred = asio::read_at(s, 1234, sb,
1633 asio::transfer_exactly(10));
1634 ASIO_CHECK(bytes_transferred == 10);
1635 ASIO_CHECK(sb.size() == 10);
1636 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
1637
1638 s.reset(read_data, sizeof(read_data));
1639 sb.consume(sb.size());
1640 bytes_transferred = asio::read_at(s, 0, sb,
1641 asio::transfer_exactly(42));
1642 ASIO_CHECK(bytes_transferred == 42);
1643 ASIO_CHECK(sb.size() == 42);
1644 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1645
1646 s.reset(read_data, sizeof(read_data));
1647 sb.consume(sb.size());
1648 bytes_transferred = asio::read_at(s, 1234, sb,
1649 asio::transfer_exactly(42));
1650 ASIO_CHECK(bytes_transferred == 42);
1651 ASIO_CHECK(sb.size() == 42);
1652 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1653
1654 s.reset(read_data, sizeof(read_data));
1655 s.next_read_length(1);
1656 sb.consume(sb.size());
1657 bytes_transferred = asio::read_at(s, 0, sb,
1658 asio::transfer_exactly(42));
1659 ASIO_CHECK(bytes_transferred == 42);
1660 ASIO_CHECK(sb.size() == 42);
1661 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1662
1663 s.reset(read_data, sizeof(read_data));
1664 s.next_read_length(1);
1665 sb.consume(sb.size());
1666 bytes_transferred = asio::read_at(s, 1234, sb,
1667 asio::transfer_exactly(42));
1668 ASIO_CHECK(bytes_transferred == 42);
1669 ASIO_CHECK(sb.size() == 42);
1670 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1671
1672 s.reset(read_data, sizeof(read_data));
1673 s.next_read_length(10);
1674 sb.consume(sb.size());
1675 bytes_transferred = asio::read_at(s, 0, sb,
1676 asio::transfer_exactly(42));
1677 ASIO_CHECK(bytes_transferred == 42);
1678 ASIO_CHECK(sb.size() == 42);
1679 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
1680
1681 s.reset(read_data, sizeof(read_data));
1682 s.next_read_length(10);
1683 sb.consume(sb.size());
1684 bytes_transferred = asio::read_at(s, 1234, sb,
1685 asio::transfer_exactly(42));
1686 ASIO_CHECK(bytes_transferred == 42);
1687 ASIO_CHECK(sb.size() == 42);
1688 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
1689
1690 s.reset(read_data, sizeof(read_data));
1691 sb.consume(sb.size());
1692 bytes_transferred = asio::read_at(s, 0, sb,
1693 old_style_transfer_all);
1694 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1695 ASIO_CHECK(sb.size() == sizeof(read_data));
1696 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1697
1698 s.reset(read_data, sizeof(read_data));
1699 sb.consume(sb.size());
1700 bytes_transferred = asio::read_at(s, 1234, sb,
1701 old_style_transfer_all);
1702 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1703 ASIO_CHECK(sb.size() == sizeof(read_data));
1704 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1705
1706 s.reset(read_data, sizeof(read_data));
1707 s.next_read_length(1);
1708 sb.consume(sb.size());
1709 bytes_transferred = asio::read_at(s, 0, sb,
1710 old_style_transfer_all);
1711 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1712 ASIO_CHECK(sb.size() == sizeof(read_data));
1713 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1714
1715 s.reset(read_data, sizeof(read_data));
1716 s.next_read_length(1);
1717 sb.consume(sb.size());
1718 bytes_transferred = asio::read_at(s, 1234, sb,
1719 old_style_transfer_all);
1720 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1721 ASIO_CHECK(sb.size() == sizeof(read_data));
1722 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1723
1724 s.reset(read_data, sizeof(read_data));
1725 s.next_read_length(10);
1726 sb.consume(sb.size());
1727 bytes_transferred = asio::read_at(s, 0, sb,
1728 old_style_transfer_all);
1729 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1730 ASIO_CHECK(sb.size() == sizeof(read_data));
1731 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1732
1733 s.reset(read_data, sizeof(read_data));
1734 s.next_read_length(10);
1735 sb.consume(sb.size());
1736 bytes_transferred = asio::read_at(s, 1234, sb,
1737 old_style_transfer_all);
1738 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1739 ASIO_CHECK(sb.size() == sizeof(read_data));
1740 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1741
1742 s.reset(read_data, sizeof(read_data));
1743 sb.consume(sb.size());
1744 bytes_transferred = asio::read_at(s, 0, sb, short_transfer);
1745 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1746 ASIO_CHECK(sb.size() == sizeof(read_data));
1747 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1748
1749 s.reset(read_data, sizeof(read_data));
1750 sb.consume(sb.size());
1751 bytes_transferred = asio::read_at(s, 1234, sb, short_transfer);
1752 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1753 ASIO_CHECK(sb.size() == sizeof(read_data));
1754 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1755
1756 s.reset(read_data, sizeof(read_data));
1757 s.next_read_length(1);
1758 sb.consume(sb.size());
1759 bytes_transferred = asio::read_at(s, 0, sb, short_transfer);
1760 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1761 ASIO_CHECK(sb.size() == sizeof(read_data));
1762 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1763
1764 s.reset(read_data, sizeof(read_data));
1765 s.next_read_length(1);
1766 sb.consume(sb.size());
1767 bytes_transferred = asio::read_at(s, 1234, sb, short_transfer);
1768 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1769 ASIO_CHECK(sb.size() == sizeof(read_data));
1770 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1771
1772 s.reset(read_data, sizeof(read_data));
1773 s.next_read_length(10);
1774 sb.consume(sb.size());
1775 bytes_transferred = asio::read_at(s, 0, sb, short_transfer);
1776 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1777 ASIO_CHECK(sb.size() == sizeof(read_data));
1778 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
1779
1780 s.reset(read_data, sizeof(read_data));
1781 s.next_read_length(10);
1782 sb.consume(sb.size());
1783 bytes_transferred = asio::read_at(s, 1234, sb, short_transfer);
1784 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1785 ASIO_CHECK(sb.size() == sizeof(read_data));
1786 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
1787 }
1788
test_5_arg_mutable_buffer_read_at()1789 void test_5_arg_mutable_buffer_read_at()
1790 {
1791 asio::io_context ioc;
1792 test_random_access_device s(ioc);
1793 char read_buf[sizeof(read_data)];
1794 asio::mutable_buffer buffers
1795 = asio::buffer(read_buf, sizeof(read_buf));
1796
1797 s.reset(read_data, sizeof(read_data));
1798 memset(read_buf, 0, sizeof(read_buf));
1799 asio::error_code error;
1800 size_t bytes_transferred = asio::read_at(s, 0, buffers,
1801 asio::transfer_all(), error);
1802 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1803 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1804 ASIO_CHECK(!error);
1805
1806 s.reset(read_data, sizeof(read_data));
1807 memset(read_buf, 0, sizeof(read_buf));
1808 bytes_transferred = asio::read_at(s, 1234, buffers,
1809 asio::transfer_all(), error);
1810 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1811 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1812 ASIO_CHECK(!error);
1813
1814 s.reset(read_data, sizeof(read_data));
1815 s.next_read_length(1);
1816 memset(read_buf, 0, sizeof(read_buf));
1817 error = asio::error_code();
1818 bytes_transferred = asio::read_at(s, 0, buffers,
1819 asio::transfer_all(), error);
1820 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1821 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1822 ASIO_CHECK(!error);
1823
1824 s.reset(read_data, sizeof(read_data));
1825 s.next_read_length(1);
1826 memset(read_buf, 0, sizeof(read_buf));
1827 error = asio::error_code();
1828 bytes_transferred = asio::read_at(s, 1234, buffers,
1829 asio::transfer_all(), error);
1830 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1831 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1832 ASIO_CHECK(!error);
1833
1834 s.reset(read_data, sizeof(read_data));
1835 s.next_read_length(10);
1836 memset(read_buf, 0, sizeof(read_buf));
1837 error = asio::error_code();
1838 bytes_transferred = asio::read_at(s, 0, buffers,
1839 asio::transfer_all(), error);
1840 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1841 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1842 ASIO_CHECK(!error);
1843
1844 s.reset(read_data, sizeof(read_data));
1845 s.next_read_length(10);
1846 memset(read_buf, 0, sizeof(read_buf));
1847 error = asio::error_code();
1848 bytes_transferred = asio::read_at(s, 1234, buffers,
1849 asio::transfer_all(), error);
1850 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1851 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1852 ASIO_CHECK(!error);
1853
1854 s.reset(read_data, sizeof(read_data));
1855 memset(read_buf, 0, sizeof(read_buf));
1856 error = asio::error_code();
1857 bytes_transferred = asio::read_at(s, 0, buffers,
1858 asio::transfer_at_least(1), error);
1859 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1860 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1861 ASIO_CHECK(!error);
1862
1863 s.reset(read_data, sizeof(read_data));
1864 memset(read_buf, 0, sizeof(read_buf));
1865 error = asio::error_code();
1866 bytes_transferred = asio::read_at(s, 1234, buffers,
1867 asio::transfer_at_least(1), error);
1868 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1869 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1870 ASIO_CHECK(!error);
1871
1872 s.reset(read_data, sizeof(read_data));
1873 s.next_read_length(1);
1874 memset(read_buf, 0, sizeof(read_buf));
1875 error = asio::error_code();
1876 bytes_transferred = asio::read_at(s, 0, buffers,
1877 asio::transfer_at_least(1), error);
1878 ASIO_CHECK(bytes_transferred == 1);
1879 ASIO_CHECK(s.check_buffers(0, buffers, 1));
1880 ASIO_CHECK(!error);
1881
1882 s.reset(read_data, sizeof(read_data));
1883 s.next_read_length(1);
1884 memset(read_buf, 0, sizeof(read_buf));
1885 error = asio::error_code();
1886 bytes_transferred = asio::read_at(s, 1234, buffers,
1887 asio::transfer_at_least(1), error);
1888 ASIO_CHECK(bytes_transferred == 1);
1889 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
1890 ASIO_CHECK(!error);
1891
1892 s.reset(read_data, sizeof(read_data));
1893 s.next_read_length(10);
1894 memset(read_buf, 0, sizeof(read_buf));
1895 error = asio::error_code();
1896 bytes_transferred = asio::read_at(s, 0, buffers,
1897 asio::transfer_at_least(1), error);
1898 ASIO_CHECK(bytes_transferred == 10);
1899 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1900 ASIO_CHECK(!error);
1901
1902 s.reset(read_data, sizeof(read_data));
1903 s.next_read_length(10);
1904 memset(read_buf, 0, sizeof(read_buf));
1905 error = asio::error_code();
1906 bytes_transferred = asio::read_at(s, 1234, buffers,
1907 asio::transfer_at_least(1), error);
1908 ASIO_CHECK(bytes_transferred == 10);
1909 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1910 ASIO_CHECK(!error);
1911
1912 s.reset(read_data, sizeof(read_data));
1913 memset(read_buf, 0, sizeof(read_buf));
1914 error = asio::error_code();
1915 bytes_transferred = asio::read_at(s, 0, buffers,
1916 asio::transfer_at_least(10), error);
1917 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1918 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1919 ASIO_CHECK(!error);
1920
1921 s.reset(read_data, sizeof(read_data));
1922 memset(read_buf, 0, sizeof(read_buf));
1923 error = asio::error_code();
1924 bytes_transferred = asio::read_at(s, 1234, buffers,
1925 asio::transfer_at_least(10), error);
1926 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1927 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1928 ASIO_CHECK(!error);
1929
1930 s.reset(read_data, sizeof(read_data));
1931 s.next_read_length(1);
1932 memset(read_buf, 0, sizeof(read_buf));
1933 error = asio::error_code();
1934 bytes_transferred = asio::read_at(s, 0, buffers,
1935 asio::transfer_at_least(10), error);
1936 ASIO_CHECK(bytes_transferred == 10);
1937 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1938 ASIO_CHECK(!error);
1939
1940 s.reset(read_data, sizeof(read_data));
1941 s.next_read_length(1);
1942 memset(read_buf, 0, sizeof(read_buf));
1943 error = asio::error_code();
1944 bytes_transferred = asio::read_at(s, 1234, buffers,
1945 asio::transfer_at_least(10), error);
1946 ASIO_CHECK(bytes_transferred == 10);
1947 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1948 ASIO_CHECK(!error);
1949
1950 s.reset(read_data, sizeof(read_data));
1951 s.next_read_length(10);
1952 memset(read_buf, 0, sizeof(read_buf));
1953 error = asio::error_code();
1954 bytes_transferred = asio::read_at(s, 0, buffers,
1955 asio::transfer_at_least(10), error);
1956 ASIO_CHECK(bytes_transferred == 10);
1957 ASIO_CHECK(s.check_buffers(0, buffers, 10));
1958 ASIO_CHECK(!error);
1959
1960 s.reset(read_data, sizeof(read_data));
1961 s.next_read_length(10);
1962 memset(read_buf, 0, sizeof(read_buf));
1963 error = asio::error_code();
1964 bytes_transferred = asio::read_at(s, 1234, buffers,
1965 asio::transfer_at_least(10), error);
1966 ASIO_CHECK(bytes_transferred == 10);
1967 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
1968 ASIO_CHECK(!error);
1969
1970 s.reset(read_data, sizeof(read_data));
1971 memset(read_buf, 0, sizeof(read_buf));
1972 error = asio::error_code();
1973 bytes_transferred = asio::read_at(s, 0, buffers,
1974 asio::transfer_at_least(42), error);
1975 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1976 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
1977 ASIO_CHECK(!error);
1978
1979 s.reset(read_data, sizeof(read_data));
1980 memset(read_buf, 0, sizeof(read_buf));
1981 error = asio::error_code();
1982 bytes_transferred = asio::read_at(s, 1234, buffers,
1983 asio::transfer_at_least(42), error);
1984 ASIO_CHECK(bytes_transferred == sizeof(read_data));
1985 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
1986 ASIO_CHECK(!error);
1987
1988 s.reset(read_data, sizeof(read_data));
1989 s.next_read_length(1);
1990 memset(read_buf, 0, sizeof(read_buf));
1991 error = asio::error_code();
1992 bytes_transferred = asio::read_at(s, 0, buffers,
1993 asio::transfer_at_least(42), error);
1994 ASIO_CHECK(bytes_transferred == 42);
1995 ASIO_CHECK(s.check_buffers(0, buffers, 42));
1996 ASIO_CHECK(!error);
1997
1998 s.reset(read_data, sizeof(read_data));
1999 s.next_read_length(1);
2000 memset(read_buf, 0, sizeof(read_buf));
2001 error = asio::error_code();
2002 bytes_transferred = asio::read_at(s, 1234, buffers,
2003 asio::transfer_at_least(42), error);
2004 ASIO_CHECK(bytes_transferred == 42);
2005 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2006 ASIO_CHECK(!error);
2007
2008 s.reset(read_data, sizeof(read_data));
2009 s.next_read_length(10);
2010 memset(read_buf, 0, sizeof(read_buf));
2011 error = asio::error_code();
2012 bytes_transferred = asio::read_at(s, 0, buffers,
2013 asio::transfer_at_least(42), error);
2014 ASIO_CHECK(bytes_transferred == 50);
2015 ASIO_CHECK(s.check_buffers(0, buffers, 50));
2016 ASIO_CHECK(!error);
2017
2018 s.reset(read_data, sizeof(read_data));
2019 s.next_read_length(10);
2020 memset(read_buf, 0, sizeof(read_buf));
2021 error = asio::error_code();
2022 bytes_transferred = asio::read_at(s, 1234, buffers,
2023 asio::transfer_at_least(42), error);
2024 ASIO_CHECK(bytes_transferred == 50);
2025 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
2026 ASIO_CHECK(!error);
2027
2028 s.reset(read_data, sizeof(read_data));
2029 memset(read_buf, 0, sizeof(read_buf));
2030 error = asio::error_code();
2031 bytes_transferred = asio::read_at(s, 0, buffers,
2032 asio::transfer_exactly(1), error);
2033 ASIO_CHECK(bytes_transferred == 1);
2034 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2035 ASIO_CHECK(!error);
2036
2037 s.reset(read_data, sizeof(read_data));
2038 memset(read_buf, 0, sizeof(read_buf));
2039 error = asio::error_code();
2040 bytes_transferred = asio::read_at(s, 1234, buffers,
2041 asio::transfer_exactly(1), error);
2042 ASIO_CHECK(bytes_transferred == 1);
2043 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2044 ASIO_CHECK(!error);
2045
2046 s.reset(read_data, sizeof(read_data));
2047 s.next_read_length(1);
2048 memset(read_buf, 0, sizeof(read_buf));
2049 error = asio::error_code();
2050 bytes_transferred = asio::read_at(s, 0, buffers,
2051 asio::transfer_exactly(1), error);
2052 ASIO_CHECK(bytes_transferred == 1);
2053 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2054 ASIO_CHECK(!error);
2055
2056 s.reset(read_data, sizeof(read_data));
2057 s.next_read_length(1);
2058 memset(read_buf, 0, sizeof(read_buf));
2059 error = asio::error_code();
2060 bytes_transferred = asio::read_at(s, 1234, buffers,
2061 asio::transfer_exactly(1), error);
2062 ASIO_CHECK(bytes_transferred == 1);
2063 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2064 ASIO_CHECK(!error);
2065
2066 s.reset(read_data, sizeof(read_data));
2067 s.next_read_length(10);
2068 memset(read_buf, 0, sizeof(read_buf));
2069 error = asio::error_code();
2070 bytes_transferred = asio::read_at(s, 0, buffers,
2071 asio::transfer_exactly(1), error);
2072 ASIO_CHECK(bytes_transferred == 1);
2073 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2074 ASIO_CHECK(!error);
2075
2076 s.reset(read_data, sizeof(read_data));
2077 s.next_read_length(10);
2078 memset(read_buf, 0, sizeof(read_buf));
2079 error = asio::error_code();
2080 bytes_transferred = asio::read_at(s, 1234, buffers,
2081 asio::transfer_exactly(1), error);
2082 ASIO_CHECK(bytes_transferred == 1);
2083 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2084 ASIO_CHECK(!error);
2085
2086 s.reset(read_data, sizeof(read_data));
2087 memset(read_buf, 0, sizeof(read_buf));
2088 error = asio::error_code();
2089 bytes_transferred = asio::read_at(s, 0, buffers,
2090 asio::transfer_exactly(10), error);
2091 ASIO_CHECK(bytes_transferred == 10);
2092 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2093 ASIO_CHECK(!error);
2094
2095 s.reset(read_data, sizeof(read_data));
2096 memset(read_buf, 0, sizeof(read_buf));
2097 error = asio::error_code();
2098 bytes_transferred = asio::read_at(s, 1234, buffers,
2099 asio::transfer_exactly(10), error);
2100 ASIO_CHECK(bytes_transferred == 10);
2101 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2102 ASIO_CHECK(!error);
2103
2104 s.reset(read_data, sizeof(read_data));
2105 s.next_read_length(1);
2106 memset(read_buf, 0, sizeof(read_buf));
2107 error = asio::error_code();
2108 bytes_transferred = asio::read_at(s, 0, buffers,
2109 asio::transfer_exactly(10), error);
2110 ASIO_CHECK(bytes_transferred == 10);
2111 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2112 ASIO_CHECK(!error);
2113
2114 s.reset(read_data, sizeof(read_data));
2115 s.next_read_length(1);
2116 memset(read_buf, 0, sizeof(read_buf));
2117 error = asio::error_code();
2118 bytes_transferred = asio::read_at(s, 1234, buffers,
2119 asio::transfer_exactly(10), error);
2120 ASIO_CHECK(bytes_transferred == 10);
2121 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2122 ASIO_CHECK(!error);
2123
2124 s.reset(read_data, sizeof(read_data));
2125 s.next_read_length(10);
2126 memset(read_buf, 0, sizeof(read_buf));
2127 error = asio::error_code();
2128 bytes_transferred = asio::read_at(s, 0, buffers,
2129 asio::transfer_exactly(10), error);
2130 ASIO_CHECK(bytes_transferred == 10);
2131 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2132 ASIO_CHECK(!error);
2133
2134 s.reset(read_data, sizeof(read_data));
2135 s.next_read_length(10);
2136 memset(read_buf, 0, sizeof(read_buf));
2137 error = asio::error_code();
2138 bytes_transferred = asio::read_at(s, 1234, buffers,
2139 asio::transfer_exactly(10), error);
2140 ASIO_CHECK(bytes_transferred == 10);
2141 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2142 ASIO_CHECK(!error);
2143
2144 s.reset(read_data, sizeof(read_data));
2145 memset(read_buf, 0, sizeof(read_buf));
2146 error = asio::error_code();
2147 bytes_transferred = asio::read_at(s, 0, buffers,
2148 asio::transfer_exactly(42), error);
2149 ASIO_CHECK(bytes_transferred == 42);
2150 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2151 ASIO_CHECK(!error);
2152
2153 s.reset(read_data, sizeof(read_data));
2154 memset(read_buf, 0, sizeof(read_buf));
2155 error = asio::error_code();
2156 bytes_transferred = asio::read_at(s, 1234, buffers,
2157 asio::transfer_exactly(42), error);
2158 ASIO_CHECK(bytes_transferred == 42);
2159 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2160 ASIO_CHECK(!error);
2161
2162 s.reset(read_data, sizeof(read_data));
2163 s.next_read_length(1);
2164 memset(read_buf, 0, sizeof(read_buf));
2165 error = asio::error_code();
2166 bytes_transferred = asio::read_at(s, 0, buffers,
2167 asio::transfer_exactly(42), error);
2168 ASIO_CHECK(bytes_transferred == 42);
2169 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2170 ASIO_CHECK(!error);
2171
2172 s.reset(read_data, sizeof(read_data));
2173 s.next_read_length(1);
2174 memset(read_buf, 0, sizeof(read_buf));
2175 error = asio::error_code();
2176 bytes_transferred = asio::read_at(s, 1234, buffers,
2177 asio::transfer_exactly(42), error);
2178 ASIO_CHECK(bytes_transferred == 42);
2179 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2180 ASIO_CHECK(!error);
2181
2182 s.reset(read_data, sizeof(read_data));
2183 s.next_read_length(10);
2184 memset(read_buf, 0, sizeof(read_buf));
2185 error = asio::error_code();
2186 bytes_transferred = asio::read_at(s, 0, buffers,
2187 asio::transfer_exactly(42), error);
2188 ASIO_CHECK(bytes_transferred == 42);
2189 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2190 ASIO_CHECK(!error);
2191
2192 s.reset(read_data, sizeof(read_data));
2193 s.next_read_length(10);
2194 memset(read_buf, 0, sizeof(read_buf));
2195 error = asio::error_code();
2196 bytes_transferred = asio::read_at(s, 1234, buffers,
2197 asio::transfer_exactly(42), error);
2198 ASIO_CHECK(bytes_transferred == 42);
2199 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2200 ASIO_CHECK(!error);
2201
2202 s.reset(read_data, sizeof(read_data));
2203 memset(read_buf, 0, sizeof(read_buf));
2204 bytes_transferred = asio::read_at(s, 0, buffers,
2205 old_style_transfer_all, error);
2206 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2207 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2208 ASIO_CHECK(!error);
2209
2210 s.reset(read_data, sizeof(read_data));
2211 memset(read_buf, 0, sizeof(read_buf));
2212 bytes_transferred = asio::read_at(s, 1234, buffers,
2213 old_style_transfer_all, error);
2214 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2215 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2216 ASIO_CHECK(!error);
2217
2218 s.reset(read_data, sizeof(read_data));
2219 s.next_read_length(1);
2220 memset(read_buf, 0, sizeof(read_buf));
2221 error = asio::error_code();
2222 bytes_transferred = asio::read_at(s, 0, buffers,
2223 old_style_transfer_all, error);
2224 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2225 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2226 ASIO_CHECK(!error);
2227
2228 s.reset(read_data, sizeof(read_data));
2229 s.next_read_length(1);
2230 memset(read_buf, 0, sizeof(read_buf));
2231 error = asio::error_code();
2232 bytes_transferred = asio::read_at(s, 1234, buffers,
2233 old_style_transfer_all, error);
2234 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2235 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2236 ASIO_CHECK(!error);
2237
2238 s.reset(read_data, sizeof(read_data));
2239 s.next_read_length(10);
2240 memset(read_buf, 0, sizeof(read_buf));
2241 error = asio::error_code();
2242 bytes_transferred = asio::read_at(s, 0, buffers,
2243 old_style_transfer_all, error);
2244 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2245 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2246 ASIO_CHECK(!error);
2247
2248 s.reset(read_data, sizeof(read_data));
2249 s.next_read_length(10);
2250 memset(read_buf, 0, sizeof(read_buf));
2251 error = asio::error_code();
2252 bytes_transferred = asio::read_at(s, 1234, buffers,
2253 old_style_transfer_all, error);
2254 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2255 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2256 ASIO_CHECK(!error);
2257
2258 s.reset(read_data, sizeof(read_data));
2259 memset(read_buf, 0, sizeof(read_buf));
2260 bytes_transferred = asio::read_at(s, 0, buffers,
2261 short_transfer, error);
2262 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2263 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2264 ASIO_CHECK(!error);
2265
2266 s.reset(read_data, sizeof(read_data));
2267 memset(read_buf, 0, sizeof(read_buf));
2268 bytes_transferred = asio::read_at(s, 1234, buffers,
2269 short_transfer, error);
2270 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2271 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2272 ASIO_CHECK(!error);
2273
2274 s.reset(read_data, sizeof(read_data));
2275 s.next_read_length(1);
2276 memset(read_buf, 0, sizeof(read_buf));
2277 error = asio::error_code();
2278 bytes_transferred = asio::read_at(s, 0, buffers,
2279 short_transfer, error);
2280 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2281 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2282 ASIO_CHECK(!error);
2283
2284 s.reset(read_data, sizeof(read_data));
2285 s.next_read_length(1);
2286 memset(read_buf, 0, sizeof(read_buf));
2287 error = asio::error_code();
2288 bytes_transferred = asio::read_at(s, 1234, buffers,
2289 short_transfer, error);
2290 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2291 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2292 ASIO_CHECK(!error);
2293
2294 s.reset(read_data, sizeof(read_data));
2295 s.next_read_length(10);
2296 memset(read_buf, 0, sizeof(read_buf));
2297 error = asio::error_code();
2298 bytes_transferred = asio::read_at(s, 0, buffers,
2299 short_transfer, error);
2300 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2301 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2302 ASIO_CHECK(!error);
2303
2304 s.reset(read_data, sizeof(read_data));
2305 s.next_read_length(10);
2306 memset(read_buf, 0, sizeof(read_buf));
2307 error = asio::error_code();
2308 bytes_transferred = asio::read_at(s, 1234, buffers,
2309 short_transfer, error);
2310 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2311 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2312 ASIO_CHECK(!error);
2313 }
2314
test_5_arg_vector_buffers_read_at()2315 void test_5_arg_vector_buffers_read_at()
2316 {
2317 asio::io_context ioc;
2318 test_random_access_device s(ioc);
2319 char read_buf[sizeof(read_data)];
2320 std::vector<asio::mutable_buffer> buffers;
2321 buffers.push_back(asio::buffer(read_buf, 32));
2322 buffers.push_back(asio::buffer(read_buf) + 32);
2323
2324 s.reset(read_data, sizeof(read_data));
2325 memset(read_buf, 0, sizeof(read_buf));
2326 asio::error_code error;
2327 size_t bytes_transferred = asio::read_at(s, 0, buffers,
2328 asio::transfer_all(), error);
2329 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2330 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2331 ASIO_CHECK(!error);
2332
2333 s.reset(read_data, sizeof(read_data));
2334 memset(read_buf, 0, sizeof(read_buf));
2335 bytes_transferred = asio::read_at(s, 1234, buffers,
2336 asio::transfer_all(), error);
2337 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2338 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2339 ASIO_CHECK(!error);
2340
2341 s.reset(read_data, sizeof(read_data));
2342 s.next_read_length(1);
2343 memset(read_buf, 0, sizeof(read_buf));
2344 error = asio::error_code();
2345 bytes_transferred = asio::read_at(s, 0, buffers,
2346 asio::transfer_all(), error);
2347 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2348 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2349 ASIO_CHECK(!error);
2350
2351 s.reset(read_data, sizeof(read_data));
2352 s.next_read_length(1);
2353 memset(read_buf, 0, sizeof(read_buf));
2354 error = asio::error_code();
2355 bytes_transferred = asio::read_at(s, 1234, buffers,
2356 asio::transfer_all(), error);
2357 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2358 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2359 ASIO_CHECK(!error);
2360
2361 s.reset(read_data, sizeof(read_data));
2362 s.next_read_length(10);
2363 memset(read_buf, 0, sizeof(read_buf));
2364 error = asio::error_code();
2365 bytes_transferred = asio::read_at(s, 0, buffers,
2366 asio::transfer_all(), error);
2367 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2368 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2369 ASIO_CHECK(!error);
2370
2371 s.reset(read_data, sizeof(read_data));
2372 s.next_read_length(10);
2373 memset(read_buf, 0, sizeof(read_buf));
2374 error = asio::error_code();
2375 bytes_transferred = asio::read_at(s, 1234, buffers,
2376 asio::transfer_all(), error);
2377 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2378 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2379 ASIO_CHECK(!error);
2380
2381 s.reset(read_data, sizeof(read_data));
2382 memset(read_buf, 0, sizeof(read_buf));
2383 error = asio::error_code();
2384 bytes_transferred = asio::read_at(s, 0, buffers,
2385 asio::transfer_at_least(1), error);
2386 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2387 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2388 ASIO_CHECK(!error);
2389
2390 s.reset(read_data, sizeof(read_data));
2391 memset(read_buf, 0, sizeof(read_buf));
2392 error = asio::error_code();
2393 bytes_transferred = asio::read_at(s, 1234, buffers,
2394 asio::transfer_at_least(1), error);
2395 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2396 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2397 ASIO_CHECK(!error);
2398
2399 s.reset(read_data, sizeof(read_data));
2400 s.next_read_length(1);
2401 memset(read_buf, 0, sizeof(read_buf));
2402 error = asio::error_code();
2403 bytes_transferred = asio::read_at(s, 0, buffers,
2404 asio::transfer_at_least(1), error);
2405 ASIO_CHECK(bytes_transferred == 1);
2406 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2407 ASIO_CHECK(!error);
2408
2409 s.reset(read_data, sizeof(read_data));
2410 s.next_read_length(1);
2411 memset(read_buf, 0, sizeof(read_buf));
2412 error = asio::error_code();
2413 bytes_transferred = asio::read_at(s, 1234, buffers,
2414 asio::transfer_at_least(1), error);
2415 ASIO_CHECK(bytes_transferred == 1);
2416 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2417 ASIO_CHECK(!error);
2418
2419 s.reset(read_data, sizeof(read_data));
2420 s.next_read_length(10);
2421 memset(read_buf, 0, sizeof(read_buf));
2422 error = asio::error_code();
2423 bytes_transferred = asio::read_at(s, 0, buffers,
2424 asio::transfer_at_least(1), error);
2425 ASIO_CHECK(bytes_transferred == 10);
2426 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2427 ASIO_CHECK(!error);
2428
2429 s.reset(read_data, sizeof(read_data));
2430 s.next_read_length(10);
2431 memset(read_buf, 0, sizeof(read_buf));
2432 error = asio::error_code();
2433 bytes_transferred = asio::read_at(s, 1234, buffers,
2434 asio::transfer_at_least(1), error);
2435 ASIO_CHECK(bytes_transferred == 10);
2436 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2437 ASIO_CHECK(!error);
2438
2439 s.reset(read_data, sizeof(read_data));
2440 memset(read_buf, 0, sizeof(read_buf));
2441 error = asio::error_code();
2442 bytes_transferred = asio::read_at(s, 0, buffers,
2443 asio::transfer_at_least(10), error);
2444 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2445 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2446 ASIO_CHECK(!error);
2447
2448 s.reset(read_data, sizeof(read_data));
2449 memset(read_buf, 0, sizeof(read_buf));
2450 error = asio::error_code();
2451 bytes_transferred = asio::read_at(s, 1234, buffers,
2452 asio::transfer_at_least(10), error);
2453 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2454 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2455 ASIO_CHECK(!error);
2456
2457 s.reset(read_data, sizeof(read_data));
2458 s.next_read_length(1);
2459 memset(read_buf, 0, sizeof(read_buf));
2460 error = asio::error_code();
2461 bytes_transferred = asio::read_at(s, 0, buffers,
2462 asio::transfer_at_least(10), error);
2463 ASIO_CHECK(bytes_transferred == 10);
2464 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2465 ASIO_CHECK(!error);
2466
2467 s.reset(read_data, sizeof(read_data));
2468 s.next_read_length(1);
2469 memset(read_buf, 0, sizeof(read_buf));
2470 error = asio::error_code();
2471 bytes_transferred = asio::read_at(s, 1234, buffers,
2472 asio::transfer_at_least(10), error);
2473 ASIO_CHECK(bytes_transferred == 10);
2474 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2475 ASIO_CHECK(!error);
2476
2477 s.reset(read_data, sizeof(read_data));
2478 s.next_read_length(10);
2479 memset(read_buf, 0, sizeof(read_buf));
2480 error = asio::error_code();
2481 bytes_transferred = asio::read_at(s, 0, buffers,
2482 asio::transfer_at_least(10), error);
2483 ASIO_CHECK(bytes_transferred == 10);
2484 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2485 ASIO_CHECK(!error);
2486
2487 s.reset(read_data, sizeof(read_data));
2488 s.next_read_length(10);
2489 memset(read_buf, 0, sizeof(read_buf));
2490 error = asio::error_code();
2491 bytes_transferred = asio::read_at(s, 1234, buffers,
2492 asio::transfer_at_least(10), error);
2493 ASIO_CHECK(bytes_transferred == 10);
2494 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2495 ASIO_CHECK(!error);
2496
2497 s.reset(read_data, sizeof(read_data));
2498 memset(read_buf, 0, sizeof(read_buf));
2499 error = asio::error_code();
2500 bytes_transferred = asio::read_at(s, 0, buffers,
2501 asio::transfer_at_least(42), error);
2502 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2503 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2504 ASIO_CHECK(!error);
2505
2506 s.reset(read_data, sizeof(read_data));
2507 memset(read_buf, 0, sizeof(read_buf));
2508 error = asio::error_code();
2509 bytes_transferred = asio::read_at(s, 1234, buffers,
2510 asio::transfer_at_least(42), error);
2511 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2512 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2513 ASIO_CHECK(!error);
2514
2515 s.reset(read_data, sizeof(read_data));
2516 s.next_read_length(1);
2517 memset(read_buf, 0, sizeof(read_buf));
2518 error = asio::error_code();
2519 bytes_transferred = asio::read_at(s, 0, buffers,
2520 asio::transfer_at_least(42), error);
2521 ASIO_CHECK(bytes_transferred == 42);
2522 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2523 ASIO_CHECK(!error);
2524
2525 s.reset(read_data, sizeof(read_data));
2526 s.next_read_length(1);
2527 memset(read_buf, 0, sizeof(read_buf));
2528 error = asio::error_code();
2529 bytes_transferred = asio::read_at(s, 1234, buffers,
2530 asio::transfer_at_least(42), error);
2531 ASIO_CHECK(bytes_transferred == 42);
2532 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2533 ASIO_CHECK(!error);
2534
2535 s.reset(read_data, sizeof(read_data));
2536 s.next_read_length(10);
2537 memset(read_buf, 0, sizeof(read_buf));
2538 error = asio::error_code();
2539 bytes_transferred = asio::read_at(s, 0, buffers,
2540 asio::transfer_at_least(42), error);
2541 ASIO_CHECK(bytes_transferred == 50);
2542 ASIO_CHECK(s.check_buffers(0, buffers, 50));
2543 ASIO_CHECK(!error);
2544
2545 s.reset(read_data, sizeof(read_data));
2546 s.next_read_length(10);
2547 memset(read_buf, 0, sizeof(read_buf));
2548 error = asio::error_code();
2549 bytes_transferred = asio::read_at(s, 1234, buffers,
2550 asio::transfer_at_least(42), error);
2551 ASIO_CHECK(bytes_transferred == 50);
2552 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
2553 ASIO_CHECK(!error);
2554
2555 s.reset(read_data, sizeof(read_data));
2556 memset(read_buf, 0, sizeof(read_buf));
2557 error = asio::error_code();
2558 bytes_transferred = asio::read_at(s, 0, buffers,
2559 asio::transfer_exactly(1), error);
2560 ASIO_CHECK(bytes_transferred == 1);
2561 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2562 ASIO_CHECK(!error);
2563
2564 s.reset(read_data, sizeof(read_data));
2565 memset(read_buf, 0, sizeof(read_buf));
2566 error = asio::error_code();
2567 bytes_transferred = asio::read_at(s, 1234, buffers,
2568 asio::transfer_exactly(1), error);
2569 ASIO_CHECK(bytes_transferred == 1);
2570 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2571 ASIO_CHECK(!error);
2572
2573 s.reset(read_data, sizeof(read_data));
2574 s.next_read_length(1);
2575 memset(read_buf, 0, sizeof(read_buf));
2576 error = asio::error_code();
2577 bytes_transferred = asio::read_at(s, 0, buffers,
2578 asio::transfer_exactly(1), error);
2579 ASIO_CHECK(bytes_transferred == 1);
2580 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2581 ASIO_CHECK(!error);
2582
2583 s.reset(read_data, sizeof(read_data));
2584 s.next_read_length(1);
2585 memset(read_buf, 0, sizeof(read_buf));
2586 error = asio::error_code();
2587 bytes_transferred = asio::read_at(s, 1234, buffers,
2588 asio::transfer_exactly(1), error);
2589 ASIO_CHECK(bytes_transferred == 1);
2590 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2591 ASIO_CHECK(!error);
2592
2593 s.reset(read_data, sizeof(read_data));
2594 s.next_read_length(10);
2595 memset(read_buf, 0, sizeof(read_buf));
2596 error = asio::error_code();
2597 bytes_transferred = asio::read_at(s, 0, buffers,
2598 asio::transfer_exactly(1), error);
2599 ASIO_CHECK(bytes_transferred == 1);
2600 ASIO_CHECK(s.check_buffers(0, buffers, 1));
2601 ASIO_CHECK(!error);
2602
2603 s.reset(read_data, sizeof(read_data));
2604 s.next_read_length(10);
2605 memset(read_buf, 0, sizeof(read_buf));
2606 error = asio::error_code();
2607 bytes_transferred = asio::read_at(s, 1234, buffers,
2608 asio::transfer_exactly(1), error);
2609 ASIO_CHECK(bytes_transferred == 1);
2610 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
2611 ASIO_CHECK(!error);
2612
2613 s.reset(read_data, sizeof(read_data));
2614 memset(read_buf, 0, sizeof(read_buf));
2615 error = asio::error_code();
2616 bytes_transferred = asio::read_at(s, 0, buffers,
2617 asio::transfer_exactly(10), error);
2618 ASIO_CHECK(bytes_transferred == 10);
2619 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2620 ASIO_CHECK(!error);
2621
2622 s.reset(read_data, sizeof(read_data));
2623 memset(read_buf, 0, sizeof(read_buf));
2624 error = asio::error_code();
2625 bytes_transferred = asio::read_at(s, 1234, buffers,
2626 asio::transfer_exactly(10), error);
2627 ASIO_CHECK(bytes_transferred == 10);
2628 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2629 ASIO_CHECK(!error);
2630
2631 s.reset(read_data, sizeof(read_data));
2632 s.next_read_length(1);
2633 memset(read_buf, 0, sizeof(read_buf));
2634 error = asio::error_code();
2635 bytes_transferred = asio::read_at(s, 0, buffers,
2636 asio::transfer_exactly(10), error);
2637 ASIO_CHECK(bytes_transferred == 10);
2638 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2639 ASIO_CHECK(!error);
2640
2641 s.reset(read_data, sizeof(read_data));
2642 s.next_read_length(1);
2643 memset(read_buf, 0, sizeof(read_buf));
2644 error = asio::error_code();
2645 bytes_transferred = asio::read_at(s, 1234, buffers,
2646 asio::transfer_exactly(10), error);
2647 ASIO_CHECK(bytes_transferred == 10);
2648 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2649 ASIO_CHECK(!error);
2650
2651 s.reset(read_data, sizeof(read_data));
2652 s.next_read_length(10);
2653 memset(read_buf, 0, sizeof(read_buf));
2654 error = asio::error_code();
2655 bytes_transferred = asio::read_at(s, 0, buffers,
2656 asio::transfer_exactly(10), error);
2657 ASIO_CHECK(bytes_transferred == 10);
2658 ASIO_CHECK(s.check_buffers(0, buffers, 10));
2659 ASIO_CHECK(!error);
2660
2661 s.reset(read_data, sizeof(read_data));
2662 s.next_read_length(10);
2663 memset(read_buf, 0, sizeof(read_buf));
2664 error = asio::error_code();
2665 bytes_transferred = asio::read_at(s, 1234, buffers,
2666 asio::transfer_exactly(10), error);
2667 ASIO_CHECK(bytes_transferred == 10);
2668 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
2669 ASIO_CHECK(!error);
2670
2671 s.reset(read_data, sizeof(read_data));
2672 memset(read_buf, 0, sizeof(read_buf));
2673 error = asio::error_code();
2674 bytes_transferred = asio::read_at(s, 0, buffers,
2675 asio::transfer_exactly(42), error);
2676 ASIO_CHECK(bytes_transferred == 42);
2677 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2678 ASIO_CHECK(!error);
2679
2680 s.reset(read_data, sizeof(read_data));
2681 memset(read_buf, 0, sizeof(read_buf));
2682 error = asio::error_code();
2683 bytes_transferred = asio::read_at(s, 1234, buffers,
2684 asio::transfer_exactly(42), error);
2685 ASIO_CHECK(bytes_transferred == 42);
2686 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2687 ASIO_CHECK(!error);
2688
2689 s.reset(read_data, sizeof(read_data));
2690 s.next_read_length(1);
2691 memset(read_buf, 0, sizeof(read_buf));
2692 error = asio::error_code();
2693 bytes_transferred = asio::read_at(s, 0, buffers,
2694 asio::transfer_exactly(42), error);
2695 ASIO_CHECK(bytes_transferred == 42);
2696 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2697 ASIO_CHECK(!error);
2698
2699 s.reset(read_data, sizeof(read_data));
2700 s.next_read_length(1);
2701 memset(read_buf, 0, sizeof(read_buf));
2702 error = asio::error_code();
2703 bytes_transferred = asio::read_at(s, 1234, buffers,
2704 asio::transfer_exactly(42), error);
2705 ASIO_CHECK(bytes_transferred == 42);
2706 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2707 ASIO_CHECK(!error);
2708
2709 s.reset(read_data, sizeof(read_data));
2710 s.next_read_length(10);
2711 memset(read_buf, 0, sizeof(read_buf));
2712 error = asio::error_code();
2713 bytes_transferred = asio::read_at(s, 0, buffers,
2714 asio::transfer_exactly(42), error);
2715 ASIO_CHECK(bytes_transferred == 42);
2716 ASIO_CHECK(s.check_buffers(0, buffers, 42));
2717 ASIO_CHECK(!error);
2718
2719 s.reset(read_data, sizeof(read_data));
2720 s.next_read_length(10);
2721 memset(read_buf, 0, sizeof(read_buf));
2722 error = asio::error_code();
2723 bytes_transferred = asio::read_at(s, 1234, buffers,
2724 asio::transfer_exactly(42), error);
2725 ASIO_CHECK(bytes_transferred == 42);
2726 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
2727 ASIO_CHECK(!error);
2728
2729 s.reset(read_data, sizeof(read_data));
2730 memset(read_buf, 0, sizeof(read_buf));
2731 bytes_transferred = asio::read_at(s, 0, buffers,
2732 old_style_transfer_all, error);
2733 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2734 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2735 ASIO_CHECK(!error);
2736
2737 s.reset(read_data, sizeof(read_data));
2738 memset(read_buf, 0, sizeof(read_buf));
2739 bytes_transferred = asio::read_at(s, 1234, buffers,
2740 old_style_transfer_all, error);
2741 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2742 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2743 ASIO_CHECK(!error);
2744
2745 s.reset(read_data, sizeof(read_data));
2746 s.next_read_length(1);
2747 memset(read_buf, 0, sizeof(read_buf));
2748 error = asio::error_code();
2749 bytes_transferred = asio::read_at(s, 0, buffers,
2750 old_style_transfer_all, error);
2751 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2752 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2753 ASIO_CHECK(!error);
2754
2755 s.reset(read_data, sizeof(read_data));
2756 s.next_read_length(1);
2757 memset(read_buf, 0, sizeof(read_buf));
2758 error = asio::error_code();
2759 bytes_transferred = asio::read_at(s, 1234, buffers,
2760 old_style_transfer_all, error);
2761 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2762 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2763 ASIO_CHECK(!error);
2764
2765 s.reset(read_data, sizeof(read_data));
2766 s.next_read_length(10);
2767 memset(read_buf, 0, sizeof(read_buf));
2768 error = asio::error_code();
2769 bytes_transferred = asio::read_at(s, 0, buffers,
2770 old_style_transfer_all, error);
2771 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2772 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2773 ASIO_CHECK(!error);
2774
2775 s.reset(read_data, sizeof(read_data));
2776 s.next_read_length(10);
2777 memset(read_buf, 0, sizeof(read_buf));
2778 error = asio::error_code();
2779 bytes_transferred = asio::read_at(s, 1234, buffers,
2780 old_style_transfer_all, error);
2781 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2782 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2783 ASIO_CHECK(!error);
2784
2785 s.reset(read_data, sizeof(read_data));
2786 memset(read_buf, 0, sizeof(read_buf));
2787 bytes_transferred = asio::read_at(s, 0, buffers,
2788 short_transfer, error);
2789 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2790 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2791 ASIO_CHECK(!error);
2792
2793 s.reset(read_data, sizeof(read_data));
2794 memset(read_buf, 0, sizeof(read_buf));
2795 bytes_transferred = asio::read_at(s, 1234, buffers,
2796 short_transfer, error);
2797 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2798 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2799 ASIO_CHECK(!error);
2800
2801 s.reset(read_data, sizeof(read_data));
2802 s.next_read_length(1);
2803 memset(read_buf, 0, sizeof(read_buf));
2804 error = asio::error_code();
2805 bytes_transferred = asio::read_at(s, 0, buffers,
2806 short_transfer, error);
2807 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2808 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2809 ASIO_CHECK(!error);
2810
2811 s.reset(read_data, sizeof(read_data));
2812 s.next_read_length(1);
2813 memset(read_buf, 0, sizeof(read_buf));
2814 error = asio::error_code();
2815 bytes_transferred = asio::read_at(s, 1234, buffers,
2816 short_transfer, error);
2817 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2818 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2819 ASIO_CHECK(!error);
2820
2821 s.reset(read_data, sizeof(read_data));
2822 s.next_read_length(10);
2823 memset(read_buf, 0, sizeof(read_buf));
2824 error = asio::error_code();
2825 bytes_transferred = asio::read_at(s, 0, buffers,
2826 short_transfer, error);
2827 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2828 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
2829 ASIO_CHECK(!error);
2830
2831 s.reset(read_data, sizeof(read_data));
2832 s.next_read_length(10);
2833 memset(read_buf, 0, sizeof(read_buf));
2834 error = asio::error_code();
2835 bytes_transferred = asio::read_at(s, 1234, buffers,
2836 short_transfer, error);
2837 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2838 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
2839 ASIO_CHECK(!error);
2840 }
2841
test_5_arg_streambuf_read_at()2842 void test_5_arg_streambuf_read_at()
2843 {
2844 asio::io_context ioc;
2845 test_random_access_device s(ioc);
2846 asio::streambuf sb(sizeof(read_data));
2847
2848 s.reset(read_data, sizeof(read_data));
2849 sb.consume(sb.size());
2850 asio::error_code error;
2851 size_t bytes_transferred = asio::read_at(s, 0, sb,
2852 asio::transfer_all(), error);
2853 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2854 ASIO_CHECK(sb.size() == sizeof(read_data));
2855 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2856 ASIO_CHECK(!error);
2857
2858 s.reset(read_data, sizeof(read_data));
2859 sb.consume(sb.size());
2860 bytes_transferred = asio::read_at(s, 1234, sb,
2861 asio::transfer_all(), error);
2862 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2863 ASIO_CHECK(sb.size() == sizeof(read_data));
2864 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2865 ASIO_CHECK(!error);
2866
2867 s.reset(read_data, sizeof(read_data));
2868 s.next_read_length(1);
2869 sb.consume(sb.size());
2870 error = asio::error_code();
2871 bytes_transferred = asio::read_at(s, 0, sb,
2872 asio::transfer_all(), error);
2873 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2874 ASIO_CHECK(sb.size() == sizeof(read_data));
2875 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2876 ASIO_CHECK(!error);
2877
2878 s.reset(read_data, sizeof(read_data));
2879 s.next_read_length(1);
2880 sb.consume(sb.size());
2881 error = asio::error_code();
2882 bytes_transferred = asio::read_at(s, 1234, sb,
2883 asio::transfer_all(), error);
2884 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2885 ASIO_CHECK(sb.size() == sizeof(read_data));
2886 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2887 ASIO_CHECK(!error);
2888
2889 s.reset(read_data, sizeof(read_data));
2890 s.next_read_length(10);
2891 sb.consume(sb.size());
2892 error = asio::error_code();
2893 bytes_transferred = asio::read_at(s, 0, sb,
2894 asio::transfer_all(), error);
2895 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2896 ASIO_CHECK(sb.size() == sizeof(read_data));
2897 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2898 ASIO_CHECK(!error);
2899
2900 s.reset(read_data, sizeof(read_data));
2901 s.next_read_length(10);
2902 sb.consume(sb.size());
2903 error = asio::error_code();
2904 bytes_transferred = asio::read_at(s, 1234, sb,
2905 asio::transfer_all(), error);
2906 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2907 ASIO_CHECK(sb.size() == sizeof(read_data));
2908 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2909 ASIO_CHECK(!error);
2910
2911 s.reset(read_data, sizeof(read_data));
2912 sb.consume(sb.size());
2913 error = asio::error_code();
2914 bytes_transferred = asio::read_at(s, 0, sb,
2915 asio::transfer_at_least(1), error);
2916 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2917 ASIO_CHECK(sb.size() == sizeof(read_data));
2918 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2919 ASIO_CHECK(!error);
2920
2921 s.reset(read_data, sizeof(read_data));
2922 sb.consume(sb.size());
2923 error = asio::error_code();
2924 bytes_transferred = asio::read_at(s, 1234, sb,
2925 asio::transfer_at_least(1), error);
2926 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2927 ASIO_CHECK(sb.size() == sizeof(read_data));
2928 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2929 ASIO_CHECK(!error);
2930
2931 s.reset(read_data, sizeof(read_data));
2932 s.next_read_length(1);
2933 sb.consume(sb.size());
2934 error = asio::error_code();
2935 bytes_transferred = asio::read_at(s, 0, sb,
2936 asio::transfer_at_least(1), error);
2937 ASIO_CHECK(bytes_transferred == 1);
2938 ASIO_CHECK(sb.size() == 1);
2939 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
2940 ASIO_CHECK(!error);
2941
2942 s.reset(read_data, sizeof(read_data));
2943 s.next_read_length(1);
2944 sb.consume(sb.size());
2945 error = asio::error_code();
2946 bytes_transferred = asio::read_at(s, 1234, sb,
2947 asio::transfer_at_least(1), error);
2948 ASIO_CHECK(bytes_transferred == 1);
2949 ASIO_CHECK(sb.size() == 1);
2950 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
2951 ASIO_CHECK(!error);
2952
2953 s.reset(read_data, sizeof(read_data));
2954 s.next_read_length(10);
2955 sb.consume(sb.size());
2956 error = asio::error_code();
2957 bytes_transferred = asio::read_at(s, 0, sb,
2958 asio::transfer_at_least(1), error);
2959 ASIO_CHECK(bytes_transferred == 10);
2960 ASIO_CHECK(sb.size() == 10);
2961 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
2962 ASIO_CHECK(!error);
2963
2964 s.reset(read_data, sizeof(read_data));
2965 s.next_read_length(10);
2966 sb.consume(sb.size());
2967 error = asio::error_code();
2968 bytes_transferred = asio::read_at(s, 1234, sb,
2969 asio::transfer_at_least(1), error);
2970 ASIO_CHECK(bytes_transferred == 10);
2971 ASIO_CHECK(sb.size() == 10);
2972 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
2973 ASIO_CHECK(!error);
2974
2975 s.reset(read_data, sizeof(read_data));
2976 sb.consume(sb.size());
2977 error = asio::error_code();
2978 bytes_transferred = asio::read_at(s, 0, sb,
2979 asio::transfer_at_least(10), error);
2980 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2981 ASIO_CHECK(sb.size() == sizeof(read_data));
2982 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
2983 ASIO_CHECK(!error);
2984
2985 s.reset(read_data, sizeof(read_data));
2986 sb.consume(sb.size());
2987 error = asio::error_code();
2988 bytes_transferred = asio::read_at(s, 1234, sb,
2989 asio::transfer_at_least(10), error);
2990 ASIO_CHECK(bytes_transferred == sizeof(read_data));
2991 ASIO_CHECK(sb.size() == sizeof(read_data));
2992 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
2993 ASIO_CHECK(!error);
2994
2995 s.reset(read_data, sizeof(read_data));
2996 s.next_read_length(1);
2997 sb.consume(sb.size());
2998 error = asio::error_code();
2999 bytes_transferred = asio::read_at(s, 0, sb,
3000 asio::transfer_at_least(10), error);
3001 ASIO_CHECK(bytes_transferred == 10);
3002 ASIO_CHECK(sb.size() == 10);
3003 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3004 ASIO_CHECK(!error);
3005
3006 s.reset(read_data, sizeof(read_data));
3007 s.next_read_length(1);
3008 sb.consume(sb.size());
3009 error = asio::error_code();
3010 bytes_transferred = asio::read_at(s, 1234, sb,
3011 asio::transfer_at_least(10), error);
3012 ASIO_CHECK(bytes_transferred == 10);
3013 ASIO_CHECK(sb.size() == 10);
3014 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3015 ASIO_CHECK(!error);
3016
3017 s.reset(read_data, sizeof(read_data));
3018 s.next_read_length(10);
3019 sb.consume(sb.size());
3020 error = asio::error_code();
3021 bytes_transferred = asio::read_at(s, 0, sb,
3022 asio::transfer_at_least(10), error);
3023 ASIO_CHECK(bytes_transferred == 10);
3024 ASIO_CHECK(sb.size() == 10);
3025 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3026 ASIO_CHECK(!error);
3027
3028 s.reset(read_data, sizeof(read_data));
3029 s.next_read_length(10);
3030 sb.consume(sb.size());
3031 error = asio::error_code();
3032 bytes_transferred = asio::read_at(s, 1234, sb,
3033 asio::transfer_at_least(10), error);
3034 ASIO_CHECK(bytes_transferred == 10);
3035 ASIO_CHECK(sb.size() == 10);
3036 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3037 ASIO_CHECK(!error);
3038
3039 s.reset(read_data, sizeof(read_data));
3040 sb.consume(sb.size());
3041 error = asio::error_code();
3042 bytes_transferred = asio::read_at(s, 0, sb,
3043 asio::transfer_at_least(42), error);
3044 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3045 ASIO_CHECK(sb.size() == sizeof(read_data));
3046 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3047 ASIO_CHECK(!error);
3048
3049 s.reset(read_data, sizeof(read_data));
3050 sb.consume(sb.size());
3051 error = asio::error_code();
3052 bytes_transferred = asio::read_at(s, 1234, sb,
3053 asio::transfer_at_least(42), error);
3054 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3055 ASIO_CHECK(sb.size() == sizeof(read_data));
3056 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3057 ASIO_CHECK(!error);
3058
3059 s.reset(read_data, sizeof(read_data));
3060 s.next_read_length(1);
3061 sb.consume(sb.size());
3062 error = asio::error_code();
3063 bytes_transferred = asio::read_at(s, 0, sb,
3064 asio::transfer_at_least(42), error);
3065 ASIO_CHECK(bytes_transferred == 42);
3066 ASIO_CHECK(sb.size() == 42);
3067 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3068 ASIO_CHECK(!error);
3069
3070 s.reset(read_data, sizeof(read_data));
3071 s.next_read_length(1);
3072 sb.consume(sb.size());
3073 error = asio::error_code();
3074 bytes_transferred = asio::read_at(s, 1234, sb,
3075 asio::transfer_at_least(42), error);
3076 ASIO_CHECK(bytes_transferred == 42);
3077 ASIO_CHECK(sb.size() == 42);
3078 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3079 ASIO_CHECK(!error);
3080
3081 s.reset(read_data, sizeof(read_data));
3082 s.next_read_length(10);
3083 sb.consume(sb.size());
3084 error = asio::error_code();
3085 bytes_transferred = asio::read_at(s, 0, sb,
3086 asio::transfer_at_least(42), error);
3087 ASIO_CHECK(bytes_transferred == 50);
3088 ASIO_CHECK(sb.size() == 50);
3089 ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
3090 ASIO_CHECK(!error);
3091
3092 s.reset(read_data, sizeof(read_data));
3093 s.next_read_length(10);
3094 sb.consume(sb.size());
3095 error = asio::error_code();
3096 bytes_transferred = asio::read_at(s, 1234, sb,
3097 asio::transfer_at_least(42), error);
3098 ASIO_CHECK(bytes_transferred == 50);
3099 ASIO_CHECK(sb.size() == 50);
3100 ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
3101 ASIO_CHECK(!error);
3102
3103 s.reset(read_data, sizeof(read_data));
3104 sb.consume(sb.size());
3105 error = asio::error_code();
3106 bytes_transferred = asio::read_at(s, 0, sb,
3107 asio::transfer_exactly(1), error);
3108 ASIO_CHECK(bytes_transferred == 1);
3109 ASIO_CHECK(sb.size() == 1);
3110 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
3111 ASIO_CHECK(!error);
3112
3113 s.reset(read_data, sizeof(read_data));
3114 sb.consume(sb.size());
3115 error = asio::error_code();
3116 bytes_transferred = asio::read_at(s, 1234, sb,
3117 asio::transfer_exactly(1), error);
3118 ASIO_CHECK(bytes_transferred == 1);
3119 ASIO_CHECK(sb.size() == 1);
3120 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
3121 ASIO_CHECK(!error);
3122
3123 s.reset(read_data, sizeof(read_data));
3124 s.next_read_length(1);
3125 sb.consume(sb.size());
3126 error = asio::error_code();
3127 bytes_transferred = asio::read_at(s, 0, sb,
3128 asio::transfer_exactly(1), error);
3129 ASIO_CHECK(bytes_transferred == 1);
3130 ASIO_CHECK(sb.size() == 1);
3131 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
3132 ASIO_CHECK(!error);
3133
3134 s.reset(read_data, sizeof(read_data));
3135 s.next_read_length(1);
3136 sb.consume(sb.size());
3137 error = asio::error_code();
3138 bytes_transferred = asio::read_at(s, 1234, sb,
3139 asio::transfer_exactly(1), error);
3140 ASIO_CHECK(bytes_transferred == 1);
3141 ASIO_CHECK(sb.size() == 1);
3142 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
3143 ASIO_CHECK(!error);
3144
3145 s.reset(read_data, sizeof(read_data));
3146 s.next_read_length(10);
3147 sb.consume(sb.size());
3148 error = asio::error_code();
3149 bytes_transferred = asio::read_at(s, 0, sb,
3150 asio::transfer_exactly(1), error);
3151 ASIO_CHECK(bytes_transferred == 1);
3152 ASIO_CHECK(sb.size() == 1);
3153 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
3154 ASIO_CHECK(!error);
3155
3156 s.reset(read_data, sizeof(read_data));
3157 s.next_read_length(10);
3158 sb.consume(sb.size());
3159 error = asio::error_code();
3160 bytes_transferred = asio::read_at(s, 1234, sb,
3161 asio::transfer_exactly(1), error);
3162 ASIO_CHECK(bytes_transferred == 1);
3163 ASIO_CHECK(sb.size() == 1);
3164 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
3165 ASIO_CHECK(!error);
3166
3167 s.reset(read_data, sizeof(read_data));
3168 sb.consume(sb.size());
3169 error = asio::error_code();
3170 bytes_transferred = asio::read_at(s, 0, sb,
3171 asio::transfer_exactly(10), error);
3172 ASIO_CHECK(bytes_transferred == 10);
3173 ASIO_CHECK(sb.size() == 10);
3174 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3175 ASIO_CHECK(!error);
3176
3177 s.reset(read_data, sizeof(read_data));
3178 sb.consume(sb.size());
3179 error = asio::error_code();
3180 bytes_transferred = asio::read_at(s, 1234, sb,
3181 asio::transfer_exactly(10), error);
3182 ASIO_CHECK(bytes_transferred == 10);
3183 ASIO_CHECK(sb.size() == 10);
3184 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3185 ASIO_CHECK(!error);
3186
3187 s.reset(read_data, sizeof(read_data));
3188 s.next_read_length(1);
3189 sb.consume(sb.size());
3190 error = asio::error_code();
3191 bytes_transferred = asio::read_at(s, 0, sb,
3192 asio::transfer_exactly(10), error);
3193 ASIO_CHECK(bytes_transferred == 10);
3194 ASIO_CHECK(sb.size() == 10);
3195 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3196 ASIO_CHECK(!error);
3197
3198 s.reset(read_data, sizeof(read_data));
3199 s.next_read_length(1);
3200 sb.consume(sb.size());
3201 error = asio::error_code();
3202 bytes_transferred = asio::read_at(s, 1234, sb,
3203 asio::transfer_exactly(10), error);
3204 ASIO_CHECK(bytes_transferred == 10);
3205 ASIO_CHECK(sb.size() == 10);
3206 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3207 ASIO_CHECK(!error);
3208
3209 s.reset(read_data, sizeof(read_data));
3210 s.next_read_length(10);
3211 sb.consume(sb.size());
3212 error = asio::error_code();
3213 bytes_transferred = asio::read_at(s, 0, sb,
3214 asio::transfer_exactly(10), error);
3215 ASIO_CHECK(bytes_transferred == 10);
3216 ASIO_CHECK(sb.size() == 10);
3217 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
3218 ASIO_CHECK(!error);
3219
3220 s.reset(read_data, sizeof(read_data));
3221 s.next_read_length(10);
3222 sb.consume(sb.size());
3223 error = asio::error_code();
3224 bytes_transferred = asio::read_at(s, 1234, sb,
3225 asio::transfer_exactly(10), error);
3226 ASIO_CHECK(bytes_transferred == 10);
3227 ASIO_CHECK(sb.size() == 10);
3228 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
3229 ASIO_CHECK(!error);
3230
3231 s.reset(read_data, sizeof(read_data));
3232 sb.consume(sb.size());
3233 error = asio::error_code();
3234 bytes_transferred = asio::read_at(s, 0, sb,
3235 asio::transfer_exactly(42), error);
3236 ASIO_CHECK(bytes_transferred == 42);
3237 ASIO_CHECK(sb.size() == 42);
3238 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3239 ASIO_CHECK(!error);
3240
3241 s.reset(read_data, sizeof(read_data));
3242 sb.consume(sb.size());
3243 error = asio::error_code();
3244 bytes_transferred = asio::read_at(s, 1234, sb,
3245 asio::transfer_exactly(42), error);
3246 ASIO_CHECK(bytes_transferred == 42);
3247 ASIO_CHECK(sb.size() == 42);
3248 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3249 ASIO_CHECK(!error);
3250
3251 s.reset(read_data, sizeof(read_data));
3252 s.next_read_length(1);
3253 sb.consume(sb.size());
3254 error = asio::error_code();
3255 bytes_transferred = asio::read_at(s, 0, sb,
3256 asio::transfer_exactly(42), error);
3257 ASIO_CHECK(bytes_transferred == 42);
3258 ASIO_CHECK(sb.size() == 42);
3259 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3260 ASIO_CHECK(!error);
3261
3262 s.reset(read_data, sizeof(read_data));
3263 s.next_read_length(1);
3264 sb.consume(sb.size());
3265 error = asio::error_code();
3266 bytes_transferred = asio::read_at(s, 1234, sb,
3267 asio::transfer_exactly(42), error);
3268 ASIO_CHECK(bytes_transferred == 42);
3269 ASIO_CHECK(sb.size() == 42);
3270 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3271 ASIO_CHECK(!error);
3272
3273 s.reset(read_data, sizeof(read_data));
3274 s.next_read_length(10);
3275 sb.consume(sb.size());
3276 error = asio::error_code();
3277 bytes_transferred = asio::read_at(s, 0, sb,
3278 asio::transfer_exactly(42), error);
3279 ASIO_CHECK(bytes_transferred == 42);
3280 ASIO_CHECK(sb.size() == 42);
3281 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
3282 ASIO_CHECK(!error);
3283
3284 s.reset(read_data, sizeof(read_data));
3285 s.next_read_length(10);
3286 sb.consume(sb.size());
3287 error = asio::error_code();
3288 bytes_transferred = asio::read_at(s, 1234, sb,
3289 asio::transfer_exactly(42), error);
3290 ASIO_CHECK(bytes_transferred == 42);
3291 ASIO_CHECK(sb.size() == 42);
3292 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
3293 ASIO_CHECK(!error);
3294
3295 s.reset(read_data, sizeof(read_data));
3296 sb.consume(sb.size());
3297 bytes_transferred = asio::read_at(s, 0, sb,
3298 old_style_transfer_all, error);
3299 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3300 ASIO_CHECK(sb.size() == sizeof(read_data));
3301 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3302 ASIO_CHECK(!error);
3303
3304 s.reset(read_data, sizeof(read_data));
3305 sb.consume(sb.size());
3306 bytes_transferred = asio::read_at(s, 1234, sb,
3307 old_style_transfer_all, error);
3308 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3309 ASIO_CHECK(sb.size() == sizeof(read_data));
3310 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3311 ASIO_CHECK(!error);
3312
3313 s.reset(read_data, sizeof(read_data));
3314 s.next_read_length(1);
3315 sb.consume(sb.size());
3316 error = asio::error_code();
3317 bytes_transferred = asio::read_at(s, 0, sb,
3318 old_style_transfer_all, error);
3319 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3320 ASIO_CHECK(sb.size() == sizeof(read_data));
3321 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3322 ASIO_CHECK(!error);
3323
3324 s.reset(read_data, sizeof(read_data));
3325 s.next_read_length(1);
3326 sb.consume(sb.size());
3327 error = asio::error_code();
3328 bytes_transferred = asio::read_at(s, 1234, sb,
3329 old_style_transfer_all, error);
3330 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3331 ASIO_CHECK(sb.size() == sizeof(read_data));
3332 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3333 ASIO_CHECK(!error);
3334
3335 s.reset(read_data, sizeof(read_data));
3336 s.next_read_length(10);
3337 sb.consume(sb.size());
3338 error = asio::error_code();
3339 bytes_transferred = asio::read_at(s, 0, sb,
3340 old_style_transfer_all, error);
3341 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3342 ASIO_CHECK(sb.size() == sizeof(read_data));
3343 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3344 ASIO_CHECK(!error);
3345
3346 s.reset(read_data, sizeof(read_data));
3347 s.next_read_length(10);
3348 sb.consume(sb.size());
3349 error = asio::error_code();
3350 bytes_transferred = asio::read_at(s, 1234, sb,
3351 old_style_transfer_all, error);
3352 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3353 ASIO_CHECK(sb.size() == sizeof(read_data));
3354 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3355 ASIO_CHECK(!error);
3356
3357 s.reset(read_data, sizeof(read_data));
3358 sb.consume(sb.size());
3359 bytes_transferred = asio::read_at(s, 0, sb,
3360 short_transfer, error);
3361 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3362 ASIO_CHECK(sb.size() == sizeof(read_data));
3363 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3364 ASIO_CHECK(!error);
3365
3366 s.reset(read_data, sizeof(read_data));
3367 sb.consume(sb.size());
3368 bytes_transferred = asio::read_at(s, 1234, sb,
3369 short_transfer, error);
3370 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3371 ASIO_CHECK(sb.size() == sizeof(read_data));
3372 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3373 ASIO_CHECK(!error);
3374
3375 s.reset(read_data, sizeof(read_data));
3376 s.next_read_length(1);
3377 sb.consume(sb.size());
3378 error = asio::error_code();
3379 bytes_transferred = asio::read_at(s, 0, sb,
3380 short_transfer, error);
3381 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3382 ASIO_CHECK(sb.size() == sizeof(read_data));
3383 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3384 ASIO_CHECK(!error);
3385
3386 s.reset(read_data, sizeof(read_data));
3387 s.next_read_length(1);
3388 sb.consume(sb.size());
3389 error = asio::error_code();
3390 bytes_transferred = asio::read_at(s, 1234, sb,
3391 short_transfer, error);
3392 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3393 ASIO_CHECK(sb.size() == sizeof(read_data));
3394 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3395 ASIO_CHECK(!error);
3396
3397 s.reset(read_data, sizeof(read_data));
3398 s.next_read_length(10);
3399 sb.consume(sb.size());
3400 error = asio::error_code();
3401 bytes_transferred = asio::read_at(s, 0, sb,
3402 short_transfer, error);
3403 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3404 ASIO_CHECK(sb.size() == sizeof(read_data));
3405 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3406 ASIO_CHECK(!error);
3407
3408 s.reset(read_data, sizeof(read_data));
3409 s.next_read_length(10);
3410 sb.consume(sb.size());
3411 error = asio::error_code();
3412 bytes_transferred = asio::read_at(s, 1234, sb,
3413 short_transfer, error);
3414 ASIO_CHECK(bytes_transferred == sizeof(read_data));
3415 ASIO_CHECK(sb.size() == sizeof(read_data));
3416 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3417 ASIO_CHECK(!error);
3418 }
3419
async_read_handler(const asio::error_code & e,size_t bytes_transferred,size_t expected_bytes_transferred,bool * called)3420 void async_read_handler(const asio::error_code& e,
3421 size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
3422 {
3423 *called = true;
3424 ASIO_CHECK(!e);
3425 ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
3426 }
3427
test_4_arg_mutable_buffer_async_read_at()3428 void test_4_arg_mutable_buffer_async_read_at()
3429 {
3430 #if defined(ASIO_HAS_BOOST_BIND)
3431 namespace bindns = boost;
3432 #else // defined(ASIO_HAS_BOOST_BIND)
3433 namespace bindns = std;
3434 using std::placeholders::_1;
3435 using std::placeholders::_2;
3436 #endif // defined(ASIO_HAS_BOOST_BIND)
3437
3438 asio::io_context ioc;
3439 test_random_access_device s(ioc);
3440 char read_buf[sizeof(read_data)];
3441 asio::mutable_buffer buffers
3442 = asio::buffer(read_buf, sizeof(read_buf));
3443
3444 s.reset(read_data, sizeof(read_data));
3445 memset(read_buf, 0, sizeof(read_buf));
3446 bool called = false;
3447 asio::async_read_at(s, 0, buffers,
3448 bindns::bind(async_read_handler,
3449 _1, _2, sizeof(read_data), &called));
3450 ioc.restart();
3451 ioc.run();
3452 ASIO_CHECK(called);
3453 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3454
3455 s.reset(read_data, sizeof(read_data));
3456 memset(read_buf, 0, sizeof(read_buf));
3457 called = false;
3458 asio::async_read_at(s, 1234, buffers,
3459 bindns::bind(async_read_handler,
3460 _1, _2, sizeof(read_data), &called));
3461 ioc.restart();
3462 ioc.run();
3463 ASIO_CHECK(called);
3464 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3465
3466 s.reset(read_data, sizeof(read_data));
3467 s.next_read_length(1);
3468 memset(read_buf, 0, sizeof(read_buf));
3469 called = false;
3470 asio::async_read_at(s, 0, buffers,
3471 bindns::bind(async_read_handler,
3472 _1, _2, sizeof(read_data), &called));
3473 ioc.restart();
3474 ioc.run();
3475 ASIO_CHECK(called);
3476 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3477
3478 s.reset(read_data, sizeof(read_data));
3479 s.next_read_length(1);
3480 memset(read_buf, 0, sizeof(read_buf));
3481 called = false;
3482 asio::async_read_at(s, 1234, buffers,
3483 bindns::bind(async_read_handler,
3484 _1, _2, sizeof(read_data), &called));
3485 ioc.restart();
3486 ioc.run();
3487 ASIO_CHECK(called);
3488 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3489
3490 s.reset(read_data, sizeof(read_data));
3491 s.next_read_length(10);
3492 memset(read_buf, 0, sizeof(read_buf));
3493 called = false;
3494 asio::async_read_at(s, 0, buffers,
3495 bindns::bind(async_read_handler,
3496 _1, _2, sizeof(read_data), &called));
3497 ioc.restart();
3498 ioc.run();
3499 ASIO_CHECK(called);
3500 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3501
3502 s.reset(read_data, sizeof(read_data));
3503 s.next_read_length(10);
3504 memset(read_buf, 0, sizeof(read_buf));
3505 called = false;
3506 asio::async_read_at(s, 1234, buffers,
3507 bindns::bind(async_read_handler,
3508 _1, _2, sizeof(read_data), &called));
3509 ioc.restart();
3510 ioc.run();
3511 ASIO_CHECK(called);
3512 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3513
3514 s.reset(read_data, sizeof(read_data));
3515 memset(read_buf, 0, sizeof(read_buf));
3516 int i = asio::async_read_at(s, 1234, buffers,
3517 archetypes::lazy_handler());
3518 ASIO_CHECK(i == 42);
3519 ioc.restart();
3520 ioc.run();
3521 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3522 }
3523
test_4_arg_boost_array_buffers_async_read_at()3524 void test_4_arg_boost_array_buffers_async_read_at()
3525 {
3526 #if defined(ASIO_HAS_BOOST_BIND)
3527 namespace bindns = boost;
3528 #else // defined(ASIO_HAS_BOOST_BIND)
3529 namespace bindns = std;
3530 using std::placeholders::_1;
3531 using std::placeholders::_2;
3532 #endif // defined(ASIO_HAS_BOOST_BIND)
3533
3534 #if defined(ASIO_HAS_BOOST_ARRAY)
3535 asio::io_context ioc;
3536 test_random_access_device s(ioc);
3537 char read_buf[sizeof(read_data)];
3538 boost::array<asio::mutable_buffer, 2> buffers = { {
3539 asio::buffer(read_buf, 32),
3540 asio::buffer(read_buf) + 32 } };
3541
3542 s.reset(read_data, sizeof(read_data));
3543 memset(read_buf, 0, sizeof(read_buf));
3544 bool called = false;
3545 asio::async_read_at(s, 0, buffers,
3546 bindns::bind(async_read_handler,
3547 _1, _2, sizeof(read_data), &called));
3548 ioc.restart();
3549 ioc.run();
3550 ASIO_CHECK(called);
3551 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3552
3553 s.reset(read_data, sizeof(read_data));
3554 memset(read_buf, 0, sizeof(read_buf));
3555 called = false;
3556 asio::async_read_at(s, 1234, buffers,
3557 bindns::bind(async_read_handler,
3558 _1, _2, sizeof(read_data), &called));
3559 ioc.restart();
3560 ioc.run();
3561 ASIO_CHECK(called);
3562 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3563
3564 s.reset(read_data, sizeof(read_data));
3565 s.next_read_length(1);
3566 memset(read_buf, 0, sizeof(read_buf));
3567 called = false;
3568 asio::async_read_at(s, 0, buffers,
3569 bindns::bind(async_read_handler,
3570 _1, _2, sizeof(read_data), &called));
3571 ioc.restart();
3572 ioc.run();
3573 ASIO_CHECK(called);
3574 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3575
3576 s.reset(read_data, sizeof(read_data));
3577 s.next_read_length(1);
3578 memset(read_buf, 0, sizeof(read_buf));
3579 called = false;
3580 asio::async_read_at(s, 1234, buffers,
3581 bindns::bind(async_read_handler,
3582 _1, _2, sizeof(read_data), &called));
3583 ioc.restart();
3584 ioc.run();
3585 ASIO_CHECK(called);
3586 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3587
3588 s.reset(read_data, sizeof(read_data));
3589 s.next_read_length(10);
3590 memset(read_buf, 0, sizeof(read_buf));
3591 called = false;
3592 asio::async_read_at(s, 0, buffers,
3593 bindns::bind(async_read_handler,
3594 _1, _2, sizeof(read_data), &called));
3595 ioc.restart();
3596 ioc.run();
3597 ASIO_CHECK(called);
3598 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3599
3600 s.reset(read_data, sizeof(read_data));
3601 s.next_read_length(10);
3602 memset(read_buf, 0, sizeof(read_buf));
3603 called = false;
3604 asio::async_read_at(s, 1234, buffers,
3605 bindns::bind(async_read_handler,
3606 _1, _2, sizeof(read_data), &called));
3607 ioc.restart();
3608 ioc.run();
3609 ASIO_CHECK(called);
3610 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3611
3612 s.reset(read_data, sizeof(read_data));
3613 memset(read_buf, 0, sizeof(read_buf));
3614 int i = asio::async_read_at(s, 1234, buffers,
3615 archetypes::lazy_handler());
3616 ASIO_CHECK(i == 42);
3617 ioc.restart();
3618 ioc.run();
3619 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3620 #endif // defined(ASIO_HAS_BOOST_ARRAY)
3621 }
3622
test_4_arg_std_array_buffers_async_read_at()3623 void test_4_arg_std_array_buffers_async_read_at()
3624 {
3625 #if defined(ASIO_HAS_BOOST_BIND)
3626 namespace bindns = boost;
3627 #else // defined(ASIO_HAS_BOOST_BIND)
3628 namespace bindns = std;
3629 using std::placeholders::_1;
3630 using std::placeholders::_2;
3631 #endif // defined(ASIO_HAS_BOOST_BIND)
3632
3633 #if defined(ASIO_HAS_STD_ARRAY)
3634 asio::io_context ioc;
3635 test_random_access_device s(ioc);
3636 char read_buf[sizeof(read_data)];
3637 std::array<asio::mutable_buffer, 2> buffers = { {
3638 asio::buffer(read_buf, 32),
3639 asio::buffer(read_buf) + 32 } };
3640
3641 s.reset(read_data, sizeof(read_data));
3642 memset(read_buf, 0, sizeof(read_buf));
3643 bool called = false;
3644 asio::async_read_at(s, 0, buffers,
3645 bindns::bind(async_read_handler,
3646 _1, _2, sizeof(read_data), &called));
3647 ioc.restart();
3648 ioc.run();
3649 ASIO_CHECK(called);
3650 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3651
3652 s.reset(read_data, sizeof(read_data));
3653 memset(read_buf, 0, sizeof(read_buf));
3654 called = false;
3655 asio::async_read_at(s, 1234, buffers,
3656 bindns::bind(async_read_handler,
3657 _1, _2, sizeof(read_data), &called));
3658 ioc.restart();
3659 ioc.run();
3660 ASIO_CHECK(called);
3661 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3662
3663 s.reset(read_data, sizeof(read_data));
3664 s.next_read_length(1);
3665 memset(read_buf, 0, sizeof(read_buf));
3666 called = false;
3667 asio::async_read_at(s, 0, buffers,
3668 bindns::bind(async_read_handler,
3669 _1, _2, sizeof(read_data), &called));
3670 ioc.restart();
3671 ioc.run();
3672 ASIO_CHECK(called);
3673 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3674
3675 s.reset(read_data, sizeof(read_data));
3676 s.next_read_length(1);
3677 memset(read_buf, 0, sizeof(read_buf));
3678 called = false;
3679 asio::async_read_at(s, 1234, buffers,
3680 bindns::bind(async_read_handler,
3681 _1, _2, sizeof(read_data), &called));
3682 ioc.restart();
3683 ioc.run();
3684 ASIO_CHECK(called);
3685 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3686
3687 s.reset(read_data, sizeof(read_data));
3688 s.next_read_length(10);
3689 memset(read_buf, 0, sizeof(read_buf));
3690 called = false;
3691 asio::async_read_at(s, 0, buffers,
3692 bindns::bind(async_read_handler,
3693 _1, _2, sizeof(read_data), &called));
3694 ioc.restart();
3695 ioc.run();
3696 ASIO_CHECK(called);
3697 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3698
3699 s.reset(read_data, sizeof(read_data));
3700 s.next_read_length(10);
3701 memset(read_buf, 0, sizeof(read_buf));
3702 called = false;
3703 asio::async_read_at(s, 1234, buffers,
3704 bindns::bind(async_read_handler,
3705 _1, _2, sizeof(read_data), &called));
3706 ioc.restart();
3707 ioc.run();
3708 ASIO_CHECK(called);
3709 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3710
3711 s.reset(read_data, sizeof(read_data));
3712 memset(read_buf, 0, sizeof(read_buf));
3713 int i = asio::async_read_at(s, 1234, buffers,
3714 archetypes::lazy_handler());
3715 ASIO_CHECK(i == 42);
3716 ioc.restart();
3717 ioc.run();
3718 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3719 #endif // defined(ASIO_HAS_STD_ARRAY)
3720 }
3721
test_4_arg_vector_buffers_async_read_at()3722 void test_4_arg_vector_buffers_async_read_at()
3723 {
3724 #if defined(ASIO_HAS_BOOST_BIND)
3725 namespace bindns = boost;
3726 #else // defined(ASIO_HAS_BOOST_BIND)
3727 namespace bindns = std;
3728 using std::placeholders::_1;
3729 using std::placeholders::_2;
3730 #endif // defined(ASIO_HAS_BOOST_BIND)
3731
3732 asio::io_context ioc;
3733 test_random_access_device s(ioc);
3734 char read_buf[sizeof(read_data)];
3735 std::vector<asio::mutable_buffer> buffers;
3736 buffers.push_back(asio::buffer(read_buf, 32));
3737 buffers.push_back(asio::buffer(read_buf) + 32);
3738
3739 s.reset(read_data, sizeof(read_data));
3740 memset(read_buf, 0, sizeof(read_buf));
3741 bool called = false;
3742 asio::async_read_at(s, 0, buffers,
3743 bindns::bind(async_read_handler,
3744 _1, _2, sizeof(read_data), &called));
3745 ioc.restart();
3746 ioc.run();
3747 ASIO_CHECK(called);
3748 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3749
3750 s.reset(read_data, sizeof(read_data));
3751 memset(read_buf, 0, sizeof(read_buf));
3752 called = false;
3753 asio::async_read_at(s, 1234, buffers,
3754 bindns::bind(async_read_handler,
3755 _1, _2, sizeof(read_data), &called));
3756 ioc.restart();
3757 ioc.run();
3758 ASIO_CHECK(called);
3759 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3760
3761 s.reset(read_data, sizeof(read_data));
3762 s.next_read_length(1);
3763 memset(read_buf, 0, sizeof(read_buf));
3764 called = false;
3765 asio::async_read_at(s, 0, buffers,
3766 bindns::bind(async_read_handler,
3767 _1, _2, sizeof(read_data), &called));
3768 ioc.restart();
3769 ioc.run();
3770 ASIO_CHECK(called);
3771 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3772
3773 s.reset(read_data, sizeof(read_data));
3774 s.next_read_length(1);
3775 memset(read_buf, 0, sizeof(read_buf));
3776 called = false;
3777 asio::async_read_at(s, 1234, buffers,
3778 bindns::bind(async_read_handler,
3779 _1, _2, sizeof(read_data), &called));
3780 ioc.restart();
3781 ioc.run();
3782 ASIO_CHECK(called);
3783 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3784
3785 s.reset(read_data, sizeof(read_data));
3786 s.next_read_length(10);
3787 memset(read_buf, 0, sizeof(read_buf));
3788 called = false;
3789 asio::async_read_at(s, 0, buffers,
3790 bindns::bind(async_read_handler,
3791 _1, _2, sizeof(read_data), &called));
3792 ioc.restart();
3793 ioc.run();
3794 ASIO_CHECK(called);
3795 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3796
3797 s.reset(read_data, sizeof(read_data));
3798 s.next_read_length(10);
3799 memset(read_buf, 0, sizeof(read_buf));
3800 called = false;
3801 asio::async_read_at(s, 1234, buffers,
3802 bindns::bind(async_read_handler,
3803 _1, _2, sizeof(read_data), &called));
3804 ioc.restart();
3805 ioc.run();
3806 ASIO_CHECK(called);
3807 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3808
3809 s.reset(read_data, sizeof(read_data));
3810 memset(read_buf, 0, sizeof(read_buf));
3811 int i = asio::async_read_at(s, 1234, buffers,
3812 archetypes::lazy_handler());
3813 ASIO_CHECK(i == 42);
3814 ioc.restart();
3815 ioc.run();
3816 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3817 }
3818
test_4_arg_streambuf_async_read_at()3819 void test_4_arg_streambuf_async_read_at()
3820 {
3821 #if defined(ASIO_HAS_BOOST_BIND)
3822 namespace bindns = boost;
3823 #else // defined(ASIO_HAS_BOOST_BIND)
3824 namespace bindns = std;
3825 using std::placeholders::_1;
3826 using std::placeholders::_2;
3827 #endif // defined(ASIO_HAS_BOOST_BIND)
3828
3829 asio::io_context ioc;
3830 test_random_access_device s(ioc);
3831 asio::streambuf sb(sizeof(read_data));
3832
3833 s.reset(read_data, sizeof(read_data));
3834 sb.consume(sb.size());
3835 bool called = false;
3836 asio::async_read_at(s, 0, sb,
3837 bindns::bind(async_read_handler,
3838 _1, _2, sizeof(read_data), &called));
3839 ioc.restart();
3840 ioc.run();
3841 ASIO_CHECK(called);
3842 ASIO_CHECK(sb.size() == sizeof(read_data));
3843 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3844
3845 s.reset(read_data, sizeof(read_data));
3846 sb.consume(sb.size());
3847 called = false;
3848 asio::async_read_at(s, 1234, sb,
3849 bindns::bind(async_read_handler,
3850 _1, _2, sizeof(read_data), &called));
3851 ioc.restart();
3852 ioc.run();
3853 ASIO_CHECK(called);
3854 ASIO_CHECK(sb.size() == sizeof(read_data));
3855 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3856
3857 s.reset(read_data, sizeof(read_data));
3858 s.next_read_length(1);
3859 sb.consume(sb.size());
3860 called = false;
3861 asio::async_read_at(s, 0, sb,
3862 bindns::bind(async_read_handler,
3863 _1, _2, sizeof(read_data), &called));
3864 ioc.restart();
3865 ioc.run();
3866 ASIO_CHECK(called);
3867 ASIO_CHECK(sb.size() == sizeof(read_data));
3868 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3869
3870 s.reset(read_data, sizeof(read_data));
3871 s.next_read_length(1);
3872 sb.consume(sb.size());
3873 called = false;
3874 asio::async_read_at(s, 1234, sb,
3875 bindns::bind(async_read_handler,
3876 _1, _2, sizeof(read_data), &called));
3877 ioc.restart();
3878 ioc.run();
3879 ASIO_CHECK(called);
3880 ASIO_CHECK(sb.size() == sizeof(read_data));
3881 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3882
3883 s.reset(read_data, sizeof(read_data));
3884 s.next_read_length(10);
3885 sb.consume(sb.size());
3886 called = false;
3887 asio::async_read_at(s, 0, sb,
3888 bindns::bind(async_read_handler,
3889 _1, _2, sizeof(read_data), &called));
3890 ioc.restart();
3891 ioc.run();
3892 ASIO_CHECK(called);
3893 ASIO_CHECK(sb.size() == sizeof(read_data));
3894 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
3895
3896 s.reset(read_data, sizeof(read_data));
3897 s.next_read_length(10);
3898 sb.consume(sb.size());
3899 called = false;
3900 asio::async_read_at(s, 1234, sb,
3901 bindns::bind(async_read_handler,
3902 _1, _2, sizeof(read_data), &called));
3903 ioc.restart();
3904 ioc.run();
3905 ASIO_CHECK(called);
3906 ASIO_CHECK(sb.size() == sizeof(read_data));
3907 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3908
3909 s.reset(read_data, sizeof(read_data));
3910 sb.consume(sb.size());
3911 int i = asio::async_read_at(s, 1234, sb,
3912 archetypes::lazy_handler());
3913 ASIO_CHECK(i == 42);
3914 ioc.restart();
3915 ioc.run();
3916 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
3917 }
3918
test_5_arg_mutable_buffer_async_read_at()3919 void test_5_arg_mutable_buffer_async_read_at()
3920 {
3921 #if defined(ASIO_HAS_BOOST_BIND)
3922 namespace bindns = boost;
3923 #else // defined(ASIO_HAS_BOOST_BIND)
3924 namespace bindns = std;
3925 using std::placeholders::_1;
3926 using std::placeholders::_2;
3927 #endif // defined(ASIO_HAS_BOOST_BIND)
3928
3929 asio::io_context ioc;
3930 test_random_access_device s(ioc);
3931 char read_buf[sizeof(read_data)];
3932 asio::mutable_buffer buffers
3933 = asio::buffer(read_buf, sizeof(read_buf));
3934
3935 s.reset(read_data, sizeof(read_data));
3936 memset(read_buf, 0, sizeof(read_buf));
3937 bool called = false;
3938 asio::async_read_at(s, 0, buffers,
3939 asio::transfer_all(),
3940 bindns::bind(async_read_handler,
3941 _1, _2, sizeof(read_data), &called));
3942 ioc.restart();
3943 ioc.run();
3944 ASIO_CHECK(called);
3945 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3946
3947 s.reset(read_data, sizeof(read_data));
3948 memset(read_buf, 0, sizeof(read_buf));
3949 called = false;
3950 asio::async_read_at(s, 1234, buffers,
3951 asio::transfer_all(),
3952 bindns::bind(async_read_handler,
3953 _1, _2, sizeof(read_data), &called));
3954 ioc.restart();
3955 ioc.run();
3956 ASIO_CHECK(called);
3957 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3958
3959 s.reset(read_data, sizeof(read_data));
3960 s.next_read_length(1);
3961 memset(read_buf, 0, sizeof(read_buf));
3962 called = false;
3963 asio::async_read_at(s, 0, buffers,
3964 asio::transfer_all(),
3965 bindns::bind(async_read_handler,
3966 _1, _2, sizeof(read_data), &called));
3967 ioc.restart();
3968 ioc.run();
3969 ASIO_CHECK(called);
3970 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3971
3972 s.reset(read_data, sizeof(read_data));
3973 s.next_read_length(1);
3974 memset(read_buf, 0, sizeof(read_buf));
3975 called = false;
3976 asio::async_read_at(s, 1234, buffers,
3977 asio::transfer_all(),
3978 bindns::bind(async_read_handler,
3979 _1, _2, sizeof(read_data), &called));
3980 ioc.restart();
3981 ioc.run();
3982 ASIO_CHECK(called);
3983 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
3984
3985 s.reset(read_data, sizeof(read_data));
3986 s.next_read_length(10);
3987 memset(read_buf, 0, sizeof(read_buf));
3988 called = false;
3989 asio::async_read_at(s, 0, buffers,
3990 asio::transfer_all(),
3991 bindns::bind(async_read_handler,
3992 _1, _2, sizeof(read_data), &called));
3993 ioc.restart();
3994 ioc.run();
3995 ASIO_CHECK(called);
3996 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
3997
3998 s.reset(read_data, sizeof(read_data));
3999 s.next_read_length(10);
4000 memset(read_buf, 0, sizeof(read_buf));
4001 called = false;
4002 asio::async_read_at(s, 1234, buffers,
4003 asio::transfer_all(),
4004 bindns::bind(async_read_handler,
4005 _1, _2, sizeof(read_data), &called));
4006 ioc.restart();
4007 ioc.run();
4008 ASIO_CHECK(called);
4009 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4010
4011 s.reset(read_data, sizeof(read_data));
4012 memset(read_buf, 0, sizeof(read_buf));
4013 called = false;
4014 asio::async_read_at(s, 0, buffers,
4015 asio::transfer_at_least(1),
4016 bindns::bind(async_read_handler,
4017 _1, _2, sizeof(read_data), &called));
4018 ioc.restart();
4019 ioc.run();
4020 ASIO_CHECK(called);
4021 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4022
4023 s.reset(read_data, sizeof(read_data));
4024 memset(read_buf, 0, sizeof(read_buf));
4025 called = false;
4026 asio::async_read_at(s, 1234, buffers,
4027 asio::transfer_at_least(1),
4028 bindns::bind(async_read_handler,
4029 _1, _2, sizeof(read_data), &called));
4030 ioc.restart();
4031 ioc.run();
4032 ASIO_CHECK(called);
4033 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4034
4035 s.reset(read_data, sizeof(read_data));
4036 s.next_read_length(1);
4037 memset(read_buf, 0, sizeof(read_buf));
4038 called = false;
4039 asio::async_read_at(s, 0, buffers,
4040 asio::transfer_at_least(1),
4041 bindns::bind(async_read_handler,
4042 _1, _2, 1, &called));
4043 ioc.restart();
4044 ioc.run();
4045 ASIO_CHECK(called);
4046 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4047
4048 s.reset(read_data, sizeof(read_data));
4049 s.next_read_length(1);
4050 memset(read_buf, 0, sizeof(read_buf));
4051 called = false;
4052 asio::async_read_at(s, 1234, buffers,
4053 asio::transfer_at_least(1),
4054 bindns::bind(async_read_handler,
4055 _1, _2, 1, &called));
4056 ioc.restart();
4057 ioc.run();
4058 ASIO_CHECK(called);
4059 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4060
4061 s.reset(read_data, sizeof(read_data));
4062 s.next_read_length(10);
4063 memset(read_buf, 0, sizeof(read_buf));
4064 called = false;
4065 asio::async_read_at(s, 0, buffers,
4066 asio::transfer_at_least(1),
4067 bindns::bind(async_read_handler,
4068 _1, _2, 10, &called));
4069 ioc.restart();
4070 ioc.run();
4071 ASIO_CHECK(called);
4072 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4073
4074 s.reset(read_data, sizeof(read_data));
4075 s.next_read_length(10);
4076 memset(read_buf, 0, sizeof(read_buf));
4077 called = false;
4078 asio::async_read_at(s, 1234, buffers,
4079 asio::transfer_at_least(1),
4080 bindns::bind(async_read_handler,
4081 _1, _2, 10, &called));
4082 ioc.restart();
4083 ioc.run();
4084 ASIO_CHECK(called);
4085 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4086
4087 s.reset(read_data, sizeof(read_data));
4088 memset(read_buf, 0, sizeof(read_buf));
4089 called = false;
4090 asio::async_read_at(s, 0, buffers,
4091 asio::transfer_at_least(10),
4092 bindns::bind(async_read_handler,
4093 _1, _2, sizeof(read_data), &called));
4094 ioc.restart();
4095 ioc.run();
4096 ASIO_CHECK(called);
4097 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4098
4099 s.reset(read_data, sizeof(read_data));
4100 memset(read_buf, 0, sizeof(read_buf));
4101 called = false;
4102 asio::async_read_at(s, 1234, buffers,
4103 asio::transfer_at_least(10),
4104 bindns::bind(async_read_handler,
4105 _1, _2, sizeof(read_data), &called));
4106 ioc.restart();
4107 ioc.run();
4108 ASIO_CHECK(called);
4109 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4110
4111 s.reset(read_data, sizeof(read_data));
4112 s.next_read_length(1);
4113 memset(read_buf, 0, sizeof(read_buf));
4114 called = false;
4115 asio::async_read_at(s, 0, buffers,
4116 asio::transfer_at_least(10),
4117 bindns::bind(async_read_handler,
4118 _1, _2, 10, &called));
4119 ioc.restart();
4120 ioc.run();
4121 ASIO_CHECK(called);
4122 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4123
4124 s.reset(read_data, sizeof(read_data));
4125 s.next_read_length(1);
4126 memset(read_buf, 0, sizeof(read_buf));
4127 called = false;
4128 asio::async_read_at(s, 1234, buffers,
4129 asio::transfer_at_least(10),
4130 bindns::bind(async_read_handler,
4131 _1, _2, 10, &called));
4132 ioc.restart();
4133 ioc.run();
4134 ASIO_CHECK(called);
4135 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4136
4137 s.reset(read_data, sizeof(read_data));
4138 s.next_read_length(10);
4139 memset(read_buf, 0, sizeof(read_buf));
4140 called = false;
4141 asio::async_read_at(s, 0, buffers,
4142 asio::transfer_at_least(10),
4143 bindns::bind(async_read_handler,
4144 _1, _2, 10, &called));
4145 ioc.restart();
4146 ioc.run();
4147 ASIO_CHECK(called);
4148 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4149
4150 s.reset(read_data, sizeof(read_data));
4151 s.next_read_length(10);
4152 memset(read_buf, 0, sizeof(read_buf));
4153 called = false;
4154 asio::async_read_at(s, 1234, buffers,
4155 asio::transfer_at_least(10),
4156 bindns::bind(async_read_handler,
4157 _1, _2, 10, &called));
4158 ioc.restart();
4159 ioc.run();
4160 ASIO_CHECK(called);
4161 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4162
4163 s.reset(read_data, sizeof(read_data));
4164 memset(read_buf, 0, sizeof(read_buf));
4165 called = false;
4166 asio::async_read_at(s, 0, buffers,
4167 asio::transfer_at_least(42),
4168 bindns::bind(async_read_handler,
4169 _1, _2, sizeof(read_data), &called));
4170 ioc.restart();
4171 ioc.run();
4172 ASIO_CHECK(called);
4173 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4174
4175 s.reset(read_data, sizeof(read_data));
4176 memset(read_buf, 0, sizeof(read_buf));
4177 called = false;
4178 asio::async_read_at(s, 1234, buffers,
4179 asio::transfer_at_least(42),
4180 bindns::bind(async_read_handler,
4181 _1, _2, sizeof(read_data), &called));
4182 ioc.restart();
4183 ioc.run();
4184 ASIO_CHECK(called);
4185 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4186
4187 s.reset(read_data, sizeof(read_data));
4188 s.next_read_length(1);
4189 memset(read_buf, 0, sizeof(read_buf));
4190 called = false;
4191 asio::async_read_at(s, 0, buffers,
4192 asio::transfer_at_least(42),
4193 bindns::bind(async_read_handler,
4194 _1, _2, 42, &called));
4195 ioc.restart();
4196 ioc.run();
4197 ASIO_CHECK(called);
4198 ASIO_CHECK(s.check_buffers(0, buffers, 42));
4199
4200 s.reset(read_data, sizeof(read_data));
4201 s.next_read_length(1);
4202 memset(read_buf, 0, sizeof(read_buf));
4203 called = false;
4204 asio::async_read_at(s, 1234, buffers,
4205 asio::transfer_at_least(42),
4206 bindns::bind(async_read_handler,
4207 _1, _2, 42, &called));
4208 ioc.restart();
4209 ioc.run();
4210 ASIO_CHECK(called);
4211 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4212
4213 s.reset(read_data, sizeof(read_data));
4214 s.next_read_length(10);
4215 memset(read_buf, 0, sizeof(read_buf));
4216 called = false;
4217 asio::async_read_at(s, 0, buffers,
4218 asio::transfer_at_least(42),
4219 bindns::bind(async_read_handler,
4220 _1, _2, 50, &called));
4221 ioc.restart();
4222 ioc.run();
4223 ASIO_CHECK(called);
4224 ASIO_CHECK(s.check_buffers(0, buffers, 50));
4225
4226 s.reset(read_data, sizeof(read_data));
4227 s.next_read_length(10);
4228 memset(read_buf, 0, sizeof(read_buf));
4229 called = false;
4230 asio::async_read_at(s, 1234, buffers,
4231 asio::transfer_at_least(42),
4232 bindns::bind(async_read_handler,
4233 _1, _2, 50, &called));
4234 ioc.restart();
4235 ioc.run();
4236 ASIO_CHECK(called);
4237 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
4238
4239 s.reset(read_data, sizeof(read_data));
4240 memset(read_buf, 0, sizeof(read_buf));
4241 called = false;
4242 asio::async_read_at(s, 0, buffers,
4243 asio::transfer_exactly(1),
4244 bindns::bind(async_read_handler,
4245 _1, _2, 1, &called));
4246 ioc.restart();
4247 ioc.run();
4248 ASIO_CHECK(called);
4249 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4250
4251 s.reset(read_data, sizeof(read_data));
4252 memset(read_buf, 0, sizeof(read_buf));
4253 called = false;
4254 asio::async_read_at(s, 1234, buffers,
4255 asio::transfer_exactly(1),
4256 bindns::bind(async_read_handler,
4257 _1, _2, 1, &called));
4258 ioc.restart();
4259 ioc.run();
4260 ASIO_CHECK(called);
4261 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4262
4263 s.reset(read_data, sizeof(read_data));
4264 s.next_read_length(1);
4265 memset(read_buf, 0, sizeof(read_buf));
4266 called = false;
4267 asio::async_read_at(s, 0, buffers,
4268 asio::transfer_exactly(1),
4269 bindns::bind(async_read_handler,
4270 _1, _2, 1, &called));
4271 ioc.restart();
4272 ioc.run();
4273 ASIO_CHECK(called);
4274 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4275
4276 s.reset(read_data, sizeof(read_data));
4277 s.next_read_length(1);
4278 memset(read_buf, 0, sizeof(read_buf));
4279 called = false;
4280 asio::async_read_at(s, 1234, buffers,
4281 asio::transfer_exactly(1),
4282 bindns::bind(async_read_handler,
4283 _1, _2, 1, &called));
4284 ioc.restart();
4285 ioc.run();
4286 ASIO_CHECK(called);
4287 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4288
4289 s.reset(read_data, sizeof(read_data));
4290 s.next_read_length(10);
4291 memset(read_buf, 0, sizeof(read_buf));
4292 called = false;
4293 asio::async_read_at(s, 0, buffers,
4294 asio::transfer_exactly(1),
4295 bindns::bind(async_read_handler,
4296 _1, _2, 1, &called));
4297 ioc.restart();
4298 ioc.run();
4299 ASIO_CHECK(called);
4300 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4301
4302 s.reset(read_data, sizeof(read_data));
4303 s.next_read_length(10);
4304 memset(read_buf, 0, sizeof(read_buf));
4305 called = false;
4306 asio::async_read_at(s, 1234, buffers,
4307 asio::transfer_exactly(1),
4308 bindns::bind(async_read_handler,
4309 _1, _2, 1, &called));
4310 ioc.restart();
4311 ioc.run();
4312 ASIO_CHECK(called);
4313 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4314
4315 s.reset(read_data, sizeof(read_data));
4316 memset(read_buf, 0, sizeof(read_buf));
4317 called = false;
4318 asio::async_read_at(s, 0, buffers,
4319 asio::transfer_exactly(10),
4320 bindns::bind(async_read_handler,
4321 _1, _2, 10, &called));
4322 ioc.restart();
4323 ioc.run();
4324 ASIO_CHECK(called);
4325 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4326
4327 s.reset(read_data, sizeof(read_data));
4328 memset(read_buf, 0, sizeof(read_buf));
4329 called = false;
4330 asio::async_read_at(s, 1234, buffers,
4331 asio::transfer_exactly(10),
4332 bindns::bind(async_read_handler,
4333 _1, _2, 10, &called));
4334 ioc.restart();
4335 ioc.run();
4336 ASIO_CHECK(called);
4337 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4338
4339 s.reset(read_data, sizeof(read_data));
4340 s.next_read_length(1);
4341 memset(read_buf, 0, sizeof(read_buf));
4342 called = false;
4343 asio::async_read_at(s, 0, buffers,
4344 asio::transfer_exactly(10),
4345 bindns::bind(async_read_handler,
4346 _1, _2, 10, &called));
4347 ioc.restart();
4348 ioc.run();
4349 ASIO_CHECK(called);
4350 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4351
4352 s.reset(read_data, sizeof(read_data));
4353 s.next_read_length(1);
4354 memset(read_buf, 0, sizeof(read_buf));
4355 called = false;
4356 asio::async_read_at(s, 1234, buffers,
4357 asio::transfer_exactly(10),
4358 bindns::bind(async_read_handler,
4359 _1, _2, 10, &called));
4360 ioc.restart();
4361 ioc.run();
4362 ASIO_CHECK(called);
4363 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4364
4365 s.reset(read_data, sizeof(read_data));
4366 s.next_read_length(10);
4367 memset(read_buf, 0, sizeof(read_buf));
4368 called = false;
4369 asio::async_read_at(s, 0, buffers,
4370 asio::transfer_exactly(10),
4371 bindns::bind(async_read_handler,
4372 _1, _2, 10, &called));
4373 ioc.restart();
4374 ioc.run();
4375 ASIO_CHECK(called);
4376 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4377
4378 s.reset(read_data, sizeof(read_data));
4379 s.next_read_length(10);
4380 memset(read_buf, 0, sizeof(read_buf));
4381 called = false;
4382 asio::async_read_at(s, 1234, buffers,
4383 asio::transfer_exactly(10),
4384 bindns::bind(async_read_handler,
4385 _1, _2, 10, &called));
4386 ioc.restart();
4387 ioc.run();
4388 ASIO_CHECK(called);
4389 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4390
4391 s.reset(read_data, sizeof(read_data));
4392 memset(read_buf, 0, sizeof(read_buf));
4393 called = false;
4394 asio::async_read_at(s, 0, buffers,
4395 asio::transfer_exactly(42),
4396 bindns::bind(async_read_handler,
4397 _1, _2, 42, &called));
4398 ioc.restart();
4399 ioc.run();
4400 ASIO_CHECK(called);
4401 ASIO_CHECK(s.check_buffers(0, buffers, 42));
4402
4403 s.reset(read_data, sizeof(read_data));
4404 memset(read_buf, 0, sizeof(read_buf));
4405 called = false;
4406 asio::async_read_at(s, 1234, buffers,
4407 asio::transfer_exactly(42),
4408 bindns::bind(async_read_handler,
4409 _1, _2, 42, &called));
4410 ioc.restart();
4411 ioc.run();
4412 ASIO_CHECK(called);
4413 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4414
4415 s.reset(read_data, sizeof(read_data));
4416 s.next_read_length(1);
4417 memset(read_buf, 0, sizeof(read_buf));
4418 called = false;
4419 asio::async_read_at(s, 0, buffers,
4420 asio::transfer_exactly(42),
4421 bindns::bind(async_read_handler,
4422 _1, _2, 42, &called));
4423 ioc.restart();
4424 ioc.run();
4425 ASIO_CHECK(called);
4426 ASIO_CHECK(s.check_buffers(0, buffers, 42));
4427
4428 s.reset(read_data, sizeof(read_data));
4429 s.next_read_length(1);
4430 memset(read_buf, 0, sizeof(read_buf));
4431 called = false;
4432 asio::async_read_at(s, 1234, buffers,
4433 asio::transfer_exactly(42),
4434 bindns::bind(async_read_handler,
4435 _1, _2, 42, &called));
4436 ioc.restart();
4437 ioc.run();
4438 ASIO_CHECK(called);
4439 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4440
4441 s.reset(read_data, sizeof(read_data));
4442 s.next_read_length(10);
4443 memset(read_buf, 0, sizeof(read_buf));
4444 called = false;
4445 asio::async_read_at(s, 0, buffers,
4446 asio::transfer_exactly(42),
4447 bindns::bind(async_read_handler,
4448 _1, _2, 42, &called));
4449 ioc.restart();
4450 ioc.run();
4451 ASIO_CHECK(called);
4452 ASIO_CHECK(s.check_buffers(0, buffers, 42));
4453
4454 s.reset(read_data, sizeof(read_data));
4455 s.next_read_length(10);
4456 memset(read_buf, 0, sizeof(read_buf));
4457 called = false;
4458 asio::async_read_at(s, 1234, buffers,
4459 asio::transfer_exactly(42),
4460 bindns::bind(async_read_handler,
4461 _1, _2, 42, &called));
4462 ioc.restart();
4463 ioc.run();
4464 ASIO_CHECK(called);
4465 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4466
4467 s.reset(read_data, sizeof(read_data));
4468 memset(read_buf, 0, sizeof(read_buf));
4469 called = false;
4470 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
4471 bindns::bind(async_read_handler,
4472 _1, _2, sizeof(read_data), &called));
4473 ioc.restart();
4474 ioc.run();
4475 ASIO_CHECK(called);
4476 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4477
4478 s.reset(read_data, sizeof(read_data));
4479 memset(read_buf, 0, sizeof(read_buf));
4480 called = false;
4481 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
4482 bindns::bind(async_read_handler,
4483 _1, _2, sizeof(read_data), &called));
4484 ioc.restart();
4485 ioc.run();
4486 ASIO_CHECK(called);
4487 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4488
4489 s.reset(read_data, sizeof(read_data));
4490 s.next_read_length(1);
4491 memset(read_buf, 0, sizeof(read_buf));
4492 called = false;
4493 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
4494 bindns::bind(async_read_handler,
4495 _1, _2, sizeof(read_data), &called));
4496 ioc.restart();
4497 ioc.run();
4498 ASIO_CHECK(called);
4499 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4500
4501 s.reset(read_data, sizeof(read_data));
4502 s.next_read_length(1);
4503 memset(read_buf, 0, sizeof(read_buf));
4504 called = false;
4505 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
4506 bindns::bind(async_read_handler,
4507 _1, _2, sizeof(read_data), &called));
4508 ioc.restart();
4509 ioc.run();
4510 ASIO_CHECK(called);
4511 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4512
4513 s.reset(read_data, sizeof(read_data));
4514 s.next_read_length(10);
4515 memset(read_buf, 0, sizeof(read_buf));
4516 called = false;
4517 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
4518 bindns::bind(async_read_handler,
4519 _1, _2, sizeof(read_data), &called));
4520 ioc.restart();
4521 ioc.run();
4522 ASIO_CHECK(called);
4523 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4524
4525 s.reset(read_data, sizeof(read_data));
4526 s.next_read_length(10);
4527 memset(read_buf, 0, sizeof(read_buf));
4528 called = false;
4529 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
4530 bindns::bind(async_read_handler,
4531 _1, _2, sizeof(read_data), &called));
4532 ioc.restart();
4533 ioc.run();
4534 ASIO_CHECK(called);
4535 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4536
4537 s.reset(read_data, sizeof(read_data));
4538 memset(read_buf, 0, sizeof(read_buf));
4539 called = false;
4540 asio::async_read_at(s, 0, buffers, short_transfer,
4541 bindns::bind(async_read_handler,
4542 _1, _2, sizeof(read_data), &called));
4543 ioc.restart();
4544 ioc.run();
4545 ASIO_CHECK(called);
4546 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4547
4548 s.reset(read_data, sizeof(read_data));
4549 memset(read_buf, 0, sizeof(read_buf));
4550 called = false;
4551 asio::async_read_at(s, 1234, buffers, short_transfer,
4552 bindns::bind(async_read_handler,
4553 _1, _2, sizeof(read_data), &called));
4554 ioc.restart();
4555 ioc.run();
4556 ASIO_CHECK(called);
4557 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4558
4559 s.reset(read_data, sizeof(read_data));
4560 s.next_read_length(1);
4561 memset(read_buf, 0, sizeof(read_buf));
4562 called = false;
4563 asio::async_read_at(s, 0, buffers, short_transfer,
4564 bindns::bind(async_read_handler,
4565 _1, _2, sizeof(read_data), &called));
4566 ioc.restart();
4567 ioc.run();
4568 ASIO_CHECK(called);
4569 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4570
4571 s.reset(read_data, sizeof(read_data));
4572 s.next_read_length(1);
4573 memset(read_buf, 0, sizeof(read_buf));
4574 called = false;
4575 asio::async_read_at(s, 1234, buffers, short_transfer,
4576 bindns::bind(async_read_handler,
4577 _1, _2, sizeof(read_data), &called));
4578 ioc.restart();
4579 ioc.run();
4580 ASIO_CHECK(called);
4581 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4582
4583 s.reset(read_data, sizeof(read_data));
4584 s.next_read_length(10);
4585 memset(read_buf, 0, sizeof(read_buf));
4586 called = false;
4587 asio::async_read_at(s, 0, buffers, short_transfer,
4588 bindns::bind(async_read_handler,
4589 _1, _2, sizeof(read_data), &called));
4590 ioc.restart();
4591 ioc.run();
4592 ASIO_CHECK(called);
4593 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4594
4595 s.reset(read_data, sizeof(read_data));
4596 s.next_read_length(10);
4597 memset(read_buf, 0, sizeof(read_buf));
4598 called = false;
4599 asio::async_read_at(s, 1234, buffers, short_transfer,
4600 bindns::bind(async_read_handler,
4601 _1, _2, sizeof(read_data), &called));
4602 ioc.restart();
4603 ioc.run();
4604 ASIO_CHECK(called);
4605 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4606
4607 s.reset(read_data, sizeof(read_data));
4608 memset(read_buf, 0, sizeof(read_buf));
4609 int i = asio::async_read_at(s, 1234, buffers,
4610 short_transfer, archetypes::lazy_handler());
4611 ASIO_CHECK(i == 42);
4612 ioc.restart();
4613 ioc.run();
4614 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4615 }
4616
test_5_arg_boost_array_buffers_async_read_at()4617 void test_5_arg_boost_array_buffers_async_read_at()
4618 {
4619 #if defined(ASIO_HAS_BOOST_BIND)
4620 namespace bindns = boost;
4621 #else // defined(ASIO_HAS_BOOST_BIND)
4622 namespace bindns = std;
4623 using std::placeholders::_1;
4624 using std::placeholders::_2;
4625 #endif // defined(ASIO_HAS_BOOST_BIND)
4626
4627 #if defined(ASIO_HAS_BOOST_ARRAY)
4628 asio::io_context ioc;
4629 test_random_access_device s(ioc);
4630 char read_buf[sizeof(read_data)];
4631 boost::array<asio::mutable_buffer, 2> buffers = { {
4632 asio::buffer(read_buf, 32),
4633 asio::buffer(read_buf) + 32 } };
4634
4635 s.reset(read_data, sizeof(read_data));
4636 memset(read_buf, 0, sizeof(read_buf));
4637 bool called = false;
4638 asio::async_read_at(s, 0, buffers,
4639 asio::transfer_all(),
4640 bindns::bind(async_read_handler,
4641 _1, _2, sizeof(read_data), &called));
4642 ioc.restart();
4643 ioc.run();
4644 ASIO_CHECK(called);
4645 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4646
4647 s.reset(read_data, sizeof(read_data));
4648 memset(read_buf, 0, sizeof(read_buf));
4649 called = false;
4650 asio::async_read_at(s, 1234, buffers,
4651 asio::transfer_all(),
4652 bindns::bind(async_read_handler,
4653 _1, _2, sizeof(read_data), &called));
4654 ioc.restart();
4655 ioc.run();
4656 ASIO_CHECK(called);
4657 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4658
4659 s.reset(read_data, sizeof(read_data));
4660 s.next_read_length(1);
4661 memset(read_buf, 0, sizeof(read_buf));
4662 called = false;
4663 asio::async_read_at(s, 0, buffers,
4664 asio::transfer_all(),
4665 bindns::bind(async_read_handler,
4666 _1, _2, sizeof(read_data), &called));
4667 ioc.restart();
4668 ioc.run();
4669 ASIO_CHECK(called);
4670 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4671
4672 s.reset(read_data, sizeof(read_data));
4673 s.next_read_length(1);
4674 memset(read_buf, 0, sizeof(read_buf));
4675 called = false;
4676 asio::async_read_at(s, 1234, buffers,
4677 asio::transfer_all(),
4678 bindns::bind(async_read_handler,
4679 _1, _2, sizeof(read_data), &called));
4680 ioc.restart();
4681 ioc.run();
4682 ASIO_CHECK(called);
4683 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4684
4685 s.reset(read_data, sizeof(read_data));
4686 s.next_read_length(10);
4687 memset(read_buf, 0, sizeof(read_buf));
4688 called = false;
4689 asio::async_read_at(s, 0, buffers,
4690 asio::transfer_all(),
4691 bindns::bind(async_read_handler,
4692 _1, _2, sizeof(read_data), &called));
4693 ioc.restart();
4694 ioc.run();
4695 ASIO_CHECK(called);
4696 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4697
4698 s.reset(read_data, sizeof(read_data));
4699 s.next_read_length(10);
4700 memset(read_buf, 0, sizeof(read_buf));
4701 called = false;
4702 asio::async_read_at(s, 1234, buffers,
4703 asio::transfer_all(),
4704 bindns::bind(async_read_handler,
4705 _1, _2, sizeof(read_data), &called));
4706 ioc.restart();
4707 ioc.run();
4708 ASIO_CHECK(called);
4709 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4710
4711 s.reset(read_data, sizeof(read_data));
4712 memset(read_buf, 0, sizeof(read_buf));
4713 called = false;
4714 asio::async_read_at(s, 0, buffers,
4715 asio::transfer_at_least(1),
4716 bindns::bind(async_read_handler,
4717 _1, _2, sizeof(read_data), &called));
4718 ioc.restart();
4719 ioc.run();
4720 ASIO_CHECK(called);
4721 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4722
4723 s.reset(read_data, sizeof(read_data));
4724 memset(read_buf, 0, sizeof(read_buf));
4725 called = false;
4726 asio::async_read_at(s, 1234, buffers,
4727 asio::transfer_at_least(1),
4728 bindns::bind(async_read_handler,
4729 _1, _2, sizeof(read_data), &called));
4730 ioc.restart();
4731 ioc.run();
4732 ASIO_CHECK(called);
4733 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4734
4735 s.reset(read_data, sizeof(read_data));
4736 s.next_read_length(1);
4737 memset(read_buf, 0, sizeof(read_buf));
4738 called = false;
4739 asio::async_read_at(s, 0, buffers,
4740 asio::transfer_at_least(1),
4741 bindns::bind(async_read_handler,
4742 _1, _2, 1, &called));
4743 ioc.restart();
4744 ioc.run();
4745 ASIO_CHECK(called);
4746 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4747
4748 s.reset(read_data, sizeof(read_data));
4749 s.next_read_length(1);
4750 memset(read_buf, 0, sizeof(read_buf));
4751 called = false;
4752 asio::async_read_at(s, 1234, buffers,
4753 asio::transfer_at_least(1),
4754 bindns::bind(async_read_handler,
4755 _1, _2, 1, &called));
4756 ioc.restart();
4757 ioc.run();
4758 ASIO_CHECK(called);
4759 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4760
4761 s.reset(read_data, sizeof(read_data));
4762 s.next_read_length(10);
4763 memset(read_buf, 0, sizeof(read_buf));
4764 called = false;
4765 asio::async_read_at(s, 0, buffers,
4766 asio::transfer_at_least(1),
4767 bindns::bind(async_read_handler,
4768 _1, _2, 10, &called));
4769 ioc.restart();
4770 ioc.run();
4771 ASIO_CHECK(called);
4772 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4773
4774 s.reset(read_data, sizeof(read_data));
4775 s.next_read_length(10);
4776 memset(read_buf, 0, sizeof(read_buf));
4777 called = false;
4778 asio::async_read_at(s, 1234, buffers,
4779 asio::transfer_at_least(1),
4780 bindns::bind(async_read_handler,
4781 _1, _2, 10, &called));
4782 ioc.restart();
4783 ioc.run();
4784 ASIO_CHECK(called);
4785 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4786
4787 s.reset(read_data, sizeof(read_data));
4788 memset(read_buf, 0, sizeof(read_buf));
4789 called = false;
4790 asio::async_read_at(s, 0, buffers,
4791 asio::transfer_at_least(10),
4792 bindns::bind(async_read_handler,
4793 _1, _2, sizeof(read_data), &called));
4794 ioc.restart();
4795 ioc.run();
4796 ASIO_CHECK(called);
4797 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4798
4799 s.reset(read_data, sizeof(read_data));
4800 memset(read_buf, 0, sizeof(read_buf));
4801 called = false;
4802 asio::async_read_at(s, 1234, buffers,
4803 asio::transfer_at_least(10),
4804 bindns::bind(async_read_handler,
4805 _1, _2, sizeof(read_data), &called));
4806 ioc.restart();
4807 ioc.run();
4808 ASIO_CHECK(called);
4809 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4810
4811 s.reset(read_data, sizeof(read_data));
4812 s.next_read_length(1);
4813 memset(read_buf, 0, sizeof(read_buf));
4814 called = false;
4815 asio::async_read_at(s, 0, buffers,
4816 asio::transfer_at_least(10),
4817 bindns::bind(async_read_handler,
4818 _1, _2, 10, &called));
4819 ioc.restart();
4820 ioc.run();
4821 ASIO_CHECK(called);
4822 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4823
4824 s.reset(read_data, sizeof(read_data));
4825 s.next_read_length(1);
4826 memset(read_buf, 0, sizeof(read_buf));
4827 called = false;
4828 asio::async_read_at(s, 1234, buffers,
4829 asio::transfer_at_least(10),
4830 bindns::bind(async_read_handler,
4831 _1, _2, 10, &called));
4832 ioc.restart();
4833 ioc.run();
4834 ASIO_CHECK(called);
4835 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4836
4837 s.reset(read_data, sizeof(read_data));
4838 s.next_read_length(10);
4839 memset(read_buf, 0, sizeof(read_buf));
4840 called = false;
4841 asio::async_read_at(s, 0, buffers,
4842 asio::transfer_at_least(10),
4843 bindns::bind(async_read_handler,
4844 _1, _2, 10, &called));
4845 ioc.restart();
4846 ioc.run();
4847 ASIO_CHECK(called);
4848 ASIO_CHECK(s.check_buffers(0, buffers, 10));
4849
4850 s.reset(read_data, sizeof(read_data));
4851 s.next_read_length(10);
4852 memset(read_buf, 0, sizeof(read_buf));
4853 called = false;
4854 asio::async_read_at(s, 1234, buffers,
4855 asio::transfer_at_least(10),
4856 bindns::bind(async_read_handler,
4857 _1, _2, 10, &called));
4858 ioc.restart();
4859 ioc.run();
4860 ASIO_CHECK(called);
4861 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
4862
4863 s.reset(read_data, sizeof(read_data));
4864 memset(read_buf, 0, sizeof(read_buf));
4865 called = false;
4866 asio::async_read_at(s, 0, buffers,
4867 asio::transfer_at_least(42),
4868 bindns::bind(async_read_handler,
4869 _1, _2, sizeof(read_data), &called));
4870 ioc.restart();
4871 ioc.run();
4872 ASIO_CHECK(called);
4873 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
4874
4875 s.reset(read_data, sizeof(read_data));
4876 memset(read_buf, 0, sizeof(read_buf));
4877 called = false;
4878 asio::async_read_at(s, 1234, buffers,
4879 asio::transfer_at_least(42),
4880 bindns::bind(async_read_handler,
4881 _1, _2, sizeof(read_data), &called));
4882 ioc.restart();
4883 ioc.run();
4884 ASIO_CHECK(called);
4885 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
4886
4887 s.reset(read_data, sizeof(read_data));
4888 s.next_read_length(1);
4889 memset(read_buf, 0, sizeof(read_buf));
4890 called = false;
4891 asio::async_read_at(s, 0, buffers,
4892 asio::transfer_at_least(42),
4893 bindns::bind(async_read_handler,
4894 _1, _2, 42, &called));
4895 ioc.restart();
4896 ioc.run();
4897 ASIO_CHECK(called);
4898 ASIO_CHECK(s.check_buffers(0, buffers, 42));
4899
4900 s.reset(read_data, sizeof(read_data));
4901 s.next_read_length(1);
4902 memset(read_buf, 0, sizeof(read_buf));
4903 called = false;
4904 asio::async_read_at(s, 1234, buffers,
4905 asio::transfer_at_least(42),
4906 bindns::bind(async_read_handler,
4907 _1, _2, 42, &called));
4908 ioc.restart();
4909 ioc.run();
4910 ASIO_CHECK(called);
4911 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
4912
4913 s.reset(read_data, sizeof(read_data));
4914 s.next_read_length(10);
4915 memset(read_buf, 0, sizeof(read_buf));
4916 called = false;
4917 asio::async_read_at(s, 0, buffers,
4918 asio::transfer_at_least(42),
4919 bindns::bind(async_read_handler,
4920 _1, _2, 50, &called));
4921 ioc.restart();
4922 ioc.run();
4923 ASIO_CHECK(called);
4924 ASIO_CHECK(s.check_buffers(0, buffers, 50));
4925
4926 s.reset(read_data, sizeof(read_data));
4927 s.next_read_length(10);
4928 memset(read_buf, 0, sizeof(read_buf));
4929 called = false;
4930 asio::async_read_at(s, 1234, buffers,
4931 asio::transfer_at_least(42),
4932 bindns::bind(async_read_handler,
4933 _1, _2, 50, &called));
4934 ioc.restart();
4935 ioc.run();
4936 ASIO_CHECK(called);
4937 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
4938
4939 s.reset(read_data, sizeof(read_data));
4940 memset(read_buf, 0, sizeof(read_buf));
4941 called = false;
4942 asio::async_read_at(s, 0, buffers,
4943 asio::transfer_exactly(1),
4944 bindns::bind(async_read_handler,
4945 _1, _2, 1, &called));
4946 ioc.restart();
4947 ioc.run();
4948 ASIO_CHECK(called);
4949 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4950
4951 s.reset(read_data, sizeof(read_data));
4952 memset(read_buf, 0, sizeof(read_buf));
4953 called = false;
4954 asio::async_read_at(s, 1234, buffers,
4955 asio::transfer_exactly(1),
4956 bindns::bind(async_read_handler,
4957 _1, _2, 1, &called));
4958 ioc.restart();
4959 ioc.run();
4960 ASIO_CHECK(called);
4961 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4962
4963 s.reset(read_data, sizeof(read_data));
4964 s.next_read_length(1);
4965 memset(read_buf, 0, sizeof(read_buf));
4966 called = false;
4967 asio::async_read_at(s, 0, buffers,
4968 asio::transfer_exactly(1),
4969 bindns::bind(async_read_handler,
4970 _1, _2, 1, &called));
4971 ioc.restart();
4972 ioc.run();
4973 ASIO_CHECK(called);
4974 ASIO_CHECK(s.check_buffers(0, buffers, 1));
4975
4976 s.reset(read_data, sizeof(read_data));
4977 s.next_read_length(1);
4978 memset(read_buf, 0, sizeof(read_buf));
4979 called = false;
4980 asio::async_read_at(s, 1234, buffers,
4981 asio::transfer_exactly(1),
4982 bindns::bind(async_read_handler,
4983 _1, _2, 1, &called));
4984 ioc.restart();
4985 ioc.run();
4986 ASIO_CHECK(called);
4987 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
4988
4989 s.reset(read_data, sizeof(read_data));
4990 s.next_read_length(10);
4991 memset(read_buf, 0, sizeof(read_buf));
4992 called = false;
4993 asio::async_read_at(s, 0, buffers,
4994 asio::transfer_exactly(1),
4995 bindns::bind(async_read_handler,
4996 _1, _2, 1, &called));
4997 ioc.restart();
4998 ioc.run();
4999 ASIO_CHECK(called);
5000 ASIO_CHECK(s.check_buffers(0, buffers, 1));
5001
5002 s.reset(read_data, sizeof(read_data));
5003 s.next_read_length(10);
5004 memset(read_buf, 0, sizeof(read_buf));
5005 called = false;
5006 asio::async_read_at(s, 1234, buffers,
5007 asio::transfer_exactly(1),
5008 bindns::bind(async_read_handler,
5009 _1, _2, 1, &called));
5010 ioc.restart();
5011 ioc.run();
5012 ASIO_CHECK(called);
5013 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5014
5015 s.reset(read_data, sizeof(read_data));
5016 memset(read_buf, 0, sizeof(read_buf));
5017 called = false;
5018 asio::async_read_at(s, 0, buffers,
5019 asio::transfer_exactly(10),
5020 bindns::bind(async_read_handler,
5021 _1, _2, 10, &called));
5022 ioc.restart();
5023 ioc.run();
5024 ASIO_CHECK(called);
5025 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5026
5027 s.reset(read_data, sizeof(read_data));
5028 memset(read_buf, 0, sizeof(read_buf));
5029 called = false;
5030 asio::async_read_at(s, 1234, buffers,
5031 asio::transfer_exactly(10),
5032 bindns::bind(async_read_handler,
5033 _1, _2, 10, &called));
5034 ioc.restart();
5035 ioc.run();
5036 ASIO_CHECK(called);
5037 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5038
5039 s.reset(read_data, sizeof(read_data));
5040 s.next_read_length(1);
5041 memset(read_buf, 0, sizeof(read_buf));
5042 called = false;
5043 asio::async_read_at(s, 0, buffers,
5044 asio::transfer_exactly(10),
5045 bindns::bind(async_read_handler,
5046 _1, _2, 10, &called));
5047 ioc.restart();
5048 ioc.run();
5049 ASIO_CHECK(called);
5050 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5051
5052 s.reset(read_data, sizeof(read_data));
5053 s.next_read_length(1);
5054 memset(read_buf, 0, sizeof(read_buf));
5055 called = false;
5056 asio::async_read_at(s, 1234, buffers,
5057 asio::transfer_exactly(10),
5058 bindns::bind(async_read_handler,
5059 _1, _2, 10, &called));
5060 ioc.restart();
5061 ioc.run();
5062 ASIO_CHECK(called);
5063 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5064
5065 s.reset(read_data, sizeof(read_data));
5066 s.next_read_length(10);
5067 memset(read_buf, 0, sizeof(read_buf));
5068 called = false;
5069 asio::async_read_at(s, 0, buffers,
5070 asio::transfer_exactly(10),
5071 bindns::bind(async_read_handler,
5072 _1, _2, 10, &called));
5073 ioc.restart();
5074 ioc.run();
5075 ASIO_CHECK(called);
5076 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5077
5078 s.reset(read_data, sizeof(read_data));
5079 s.next_read_length(10);
5080 memset(read_buf, 0, sizeof(read_buf));
5081 called = false;
5082 asio::async_read_at(s, 1234, buffers,
5083 asio::transfer_exactly(10),
5084 bindns::bind(async_read_handler,
5085 _1, _2, 10, &called));
5086 ioc.restart();
5087 ioc.run();
5088 ASIO_CHECK(called);
5089 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5090
5091 s.reset(read_data, sizeof(read_data));
5092 memset(read_buf, 0, sizeof(read_buf));
5093 called = false;
5094 asio::async_read_at(s, 0, buffers,
5095 asio::transfer_exactly(42),
5096 bindns::bind(async_read_handler,
5097 _1, _2, 42, &called));
5098 ioc.restart();
5099 ioc.run();
5100 ASIO_CHECK(called);
5101 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5102
5103 s.reset(read_data, sizeof(read_data));
5104 memset(read_buf, 0, sizeof(read_buf));
5105 called = false;
5106 asio::async_read_at(s, 1234, buffers,
5107 asio::transfer_exactly(42),
5108 bindns::bind(async_read_handler,
5109 _1, _2, 42, &called));
5110 ioc.restart();
5111 ioc.run();
5112 ASIO_CHECK(called);
5113 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5114
5115 s.reset(read_data, sizeof(read_data));
5116 s.next_read_length(1);
5117 memset(read_buf, 0, sizeof(read_buf));
5118 called = false;
5119 asio::async_read_at(s, 0, buffers,
5120 asio::transfer_exactly(42),
5121 bindns::bind(async_read_handler,
5122 _1, _2, 42, &called));
5123 ioc.restart();
5124 ioc.run();
5125 ASIO_CHECK(called);
5126 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5127
5128 s.reset(read_data, sizeof(read_data));
5129 s.next_read_length(1);
5130 memset(read_buf, 0, sizeof(read_buf));
5131 called = false;
5132 asio::async_read_at(s, 1234, buffers,
5133 asio::transfer_exactly(42),
5134 bindns::bind(async_read_handler,
5135 _1, _2, 42, &called));
5136 ioc.restart();
5137 ioc.run();
5138 ASIO_CHECK(called);
5139 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5140
5141 s.reset(read_data, sizeof(read_data));
5142 s.next_read_length(10);
5143 memset(read_buf, 0, sizeof(read_buf));
5144 called = false;
5145 asio::async_read_at(s, 0, buffers,
5146 asio::transfer_exactly(42),
5147 bindns::bind(async_read_handler,
5148 _1, _2, 42, &called));
5149 ioc.restart();
5150 ioc.run();
5151 ASIO_CHECK(called);
5152 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5153
5154 s.reset(read_data, sizeof(read_data));
5155 s.next_read_length(10);
5156 memset(read_buf, 0, sizeof(read_buf));
5157 called = false;
5158 asio::async_read_at(s, 1234, buffers,
5159 asio::transfer_exactly(42),
5160 bindns::bind(async_read_handler,
5161 _1, _2, 42, &called));
5162 ioc.restart();
5163 ioc.run();
5164 ASIO_CHECK(called);
5165 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5166
5167 s.reset(read_data, sizeof(read_data));
5168 memset(read_buf, 0, sizeof(read_buf));
5169 called = false;
5170 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5171 bindns::bind(async_read_handler,
5172 _1, _2, sizeof(read_data), &called));
5173 ioc.restart();
5174 ioc.run();
5175 ASIO_CHECK(called);
5176 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5177
5178 s.reset(read_data, sizeof(read_data));
5179 memset(read_buf, 0, sizeof(read_buf));
5180 called = false;
5181 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5182 bindns::bind(async_read_handler,
5183 _1, _2, sizeof(read_data), &called));
5184 ioc.restart();
5185 ioc.run();
5186 ASIO_CHECK(called);
5187 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5188
5189 s.reset(read_data, sizeof(read_data));
5190 s.next_read_length(1);
5191 memset(read_buf, 0, sizeof(read_buf));
5192 called = false;
5193 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5194 bindns::bind(async_read_handler,
5195 _1, _2, sizeof(read_data), &called));
5196 ioc.restart();
5197 ioc.run();
5198 ASIO_CHECK(called);
5199 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5200
5201 s.reset(read_data, sizeof(read_data));
5202 s.next_read_length(1);
5203 memset(read_buf, 0, sizeof(read_buf));
5204 called = false;
5205 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5206 bindns::bind(async_read_handler,
5207 _1, _2, sizeof(read_data), &called));
5208 ioc.restart();
5209 ioc.run();
5210 ASIO_CHECK(called);
5211 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5212
5213 s.reset(read_data, sizeof(read_data));
5214 s.next_read_length(10);
5215 memset(read_buf, 0, sizeof(read_buf));
5216 called = false;
5217 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5218 bindns::bind(async_read_handler,
5219 _1, _2, sizeof(read_data), &called));
5220 ioc.restart();
5221 ioc.run();
5222 ASIO_CHECK(called);
5223 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5224
5225 s.reset(read_data, sizeof(read_data));
5226 s.next_read_length(10);
5227 memset(read_buf, 0, sizeof(read_buf));
5228 called = false;
5229 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5230 bindns::bind(async_read_handler,
5231 _1, _2, sizeof(read_data), &called));
5232 ioc.restart();
5233 ioc.run();
5234 ASIO_CHECK(called);
5235 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5236
5237 s.reset(read_data, sizeof(read_data));
5238 memset(read_buf, 0, sizeof(read_buf));
5239 called = false;
5240 asio::async_read_at(s, 0, buffers, short_transfer,
5241 bindns::bind(async_read_handler,
5242 _1, _2, sizeof(read_data), &called));
5243 ioc.restart();
5244 ioc.run();
5245 ASIO_CHECK(called);
5246 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5247
5248 s.reset(read_data, sizeof(read_data));
5249 memset(read_buf, 0, sizeof(read_buf));
5250 called = false;
5251 asio::async_read_at(s, 1234, buffers, short_transfer,
5252 bindns::bind(async_read_handler,
5253 _1, _2, sizeof(read_data), &called));
5254 ioc.restart();
5255 ioc.run();
5256 ASIO_CHECK(called);
5257 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5258
5259 s.reset(read_data, sizeof(read_data));
5260 s.next_read_length(1);
5261 memset(read_buf, 0, sizeof(read_buf));
5262 called = false;
5263 asio::async_read_at(s, 0, buffers, short_transfer,
5264 bindns::bind(async_read_handler,
5265 _1, _2, sizeof(read_data), &called));
5266 ioc.restart();
5267 ioc.run();
5268 ASIO_CHECK(called);
5269 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5270
5271 s.reset(read_data, sizeof(read_data));
5272 s.next_read_length(1);
5273 memset(read_buf, 0, sizeof(read_buf));
5274 called = false;
5275 asio::async_read_at(s, 1234, buffers, short_transfer,
5276 bindns::bind(async_read_handler,
5277 _1, _2, sizeof(read_data), &called));
5278 ioc.restart();
5279 ioc.run();
5280 ASIO_CHECK(called);
5281 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5282
5283 s.reset(read_data, sizeof(read_data));
5284 s.next_read_length(10);
5285 memset(read_buf, 0, sizeof(read_buf));
5286 called = false;
5287 asio::async_read_at(s, 0, buffers, short_transfer,
5288 bindns::bind(async_read_handler,
5289 _1, _2, sizeof(read_data), &called));
5290 ioc.restart();
5291 ioc.run();
5292 ASIO_CHECK(called);
5293 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5294
5295 s.reset(read_data, sizeof(read_data));
5296 s.next_read_length(10);
5297 memset(read_buf, 0, sizeof(read_buf));
5298 called = false;
5299 asio::async_read_at(s, 1234, buffers, short_transfer,
5300 bindns::bind(async_read_handler,
5301 _1, _2, sizeof(read_data), &called));
5302 ioc.restart();
5303 ioc.run();
5304 ASIO_CHECK(called);
5305 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5306
5307 s.reset(read_data, sizeof(read_data));
5308 memset(read_buf, 0, sizeof(read_buf));
5309 int i = asio::async_read_at(s, 1234, buffers,
5310 short_transfer, archetypes::lazy_handler());
5311 ASIO_CHECK(i == 42);
5312 ioc.restart();
5313 ioc.run();
5314 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5315 #endif // defined(ASIO_HAS_BOOST_ARRAY)
5316 }
5317
test_5_arg_std_array_buffers_async_read_at()5318 void test_5_arg_std_array_buffers_async_read_at()
5319 {
5320 #if defined(ASIO_HAS_BOOST_BIND)
5321 namespace bindns = boost;
5322 #else // defined(ASIO_HAS_BOOST_BIND)
5323 namespace bindns = std;
5324 using std::placeholders::_1;
5325 using std::placeholders::_2;
5326 #endif // defined(ASIO_HAS_BOOST_BIND)
5327
5328 #if defined(ASIO_HAS_STD_ARRAY)
5329 asio::io_context ioc;
5330 test_random_access_device s(ioc);
5331 char read_buf[sizeof(read_data)];
5332 std::array<asio::mutable_buffer, 2> buffers = { {
5333 asio::buffer(read_buf, 32),
5334 asio::buffer(read_buf) + 32 } };
5335
5336 s.reset(read_data, sizeof(read_data));
5337 memset(read_buf, 0, sizeof(read_buf));
5338 bool called = false;
5339 asio::async_read_at(s, 0, buffers,
5340 asio::transfer_all(),
5341 bindns::bind(async_read_handler,
5342 _1, _2, sizeof(read_data), &called));
5343 ioc.restart();
5344 ioc.run();
5345 ASIO_CHECK(called);
5346 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5347
5348 s.reset(read_data, sizeof(read_data));
5349 memset(read_buf, 0, sizeof(read_buf));
5350 called = false;
5351 asio::async_read_at(s, 1234, buffers,
5352 asio::transfer_all(),
5353 bindns::bind(async_read_handler,
5354 _1, _2, sizeof(read_data), &called));
5355 ioc.restart();
5356 ioc.run();
5357 ASIO_CHECK(called);
5358 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5359
5360 s.reset(read_data, sizeof(read_data));
5361 s.next_read_length(1);
5362 memset(read_buf, 0, sizeof(read_buf));
5363 called = false;
5364 asio::async_read_at(s, 0, buffers,
5365 asio::transfer_all(),
5366 bindns::bind(async_read_handler,
5367 _1, _2, sizeof(read_data), &called));
5368 ioc.restart();
5369 ioc.run();
5370 ASIO_CHECK(called);
5371 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5372
5373 s.reset(read_data, sizeof(read_data));
5374 s.next_read_length(1);
5375 memset(read_buf, 0, sizeof(read_buf));
5376 called = false;
5377 asio::async_read_at(s, 1234, buffers,
5378 asio::transfer_all(),
5379 bindns::bind(async_read_handler,
5380 _1, _2, sizeof(read_data), &called));
5381 ioc.restart();
5382 ioc.run();
5383 ASIO_CHECK(called);
5384 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5385
5386 s.reset(read_data, sizeof(read_data));
5387 s.next_read_length(10);
5388 memset(read_buf, 0, sizeof(read_buf));
5389 called = false;
5390 asio::async_read_at(s, 0, buffers,
5391 asio::transfer_all(),
5392 bindns::bind(async_read_handler,
5393 _1, _2, sizeof(read_data), &called));
5394 ioc.restart();
5395 ioc.run();
5396 ASIO_CHECK(called);
5397 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5398
5399 s.reset(read_data, sizeof(read_data));
5400 s.next_read_length(10);
5401 memset(read_buf, 0, sizeof(read_buf));
5402 called = false;
5403 asio::async_read_at(s, 1234, buffers,
5404 asio::transfer_all(),
5405 bindns::bind(async_read_handler,
5406 _1, _2, sizeof(read_data), &called));
5407 ioc.restart();
5408 ioc.run();
5409 ASIO_CHECK(called);
5410 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5411
5412 s.reset(read_data, sizeof(read_data));
5413 memset(read_buf, 0, sizeof(read_buf));
5414 called = false;
5415 asio::async_read_at(s, 0, buffers,
5416 asio::transfer_at_least(1),
5417 bindns::bind(async_read_handler,
5418 _1, _2, sizeof(read_data), &called));
5419 ioc.restart();
5420 ioc.run();
5421 ASIO_CHECK(called);
5422 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5423
5424 s.reset(read_data, sizeof(read_data));
5425 memset(read_buf, 0, sizeof(read_buf));
5426 called = false;
5427 asio::async_read_at(s, 1234, buffers,
5428 asio::transfer_at_least(1),
5429 bindns::bind(async_read_handler,
5430 _1, _2, sizeof(read_data), &called));
5431 ioc.restart();
5432 ioc.run();
5433 ASIO_CHECK(called);
5434 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5435
5436 s.reset(read_data, sizeof(read_data));
5437 s.next_read_length(1);
5438 memset(read_buf, 0, sizeof(read_buf));
5439 called = false;
5440 asio::async_read_at(s, 0, buffers,
5441 asio::transfer_at_least(1),
5442 bindns::bind(async_read_handler,
5443 _1, _2, 1, &called));
5444 ioc.restart();
5445 ioc.run();
5446 ASIO_CHECK(called);
5447 ASIO_CHECK(s.check_buffers(0, buffers, 1));
5448
5449 s.reset(read_data, sizeof(read_data));
5450 s.next_read_length(1);
5451 memset(read_buf, 0, sizeof(read_buf));
5452 called = false;
5453 asio::async_read_at(s, 1234, buffers,
5454 asio::transfer_at_least(1),
5455 bindns::bind(async_read_handler,
5456 _1, _2, 1, &called));
5457 ioc.restart();
5458 ioc.run();
5459 ASIO_CHECK(called);
5460 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5461
5462 s.reset(read_data, sizeof(read_data));
5463 s.next_read_length(10);
5464 memset(read_buf, 0, sizeof(read_buf));
5465 called = false;
5466 asio::async_read_at(s, 0, buffers,
5467 asio::transfer_at_least(1),
5468 bindns::bind(async_read_handler,
5469 _1, _2, 10, &called));
5470 ioc.restart();
5471 ioc.run();
5472 ASIO_CHECK(called);
5473 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5474
5475 s.reset(read_data, sizeof(read_data));
5476 s.next_read_length(10);
5477 memset(read_buf, 0, sizeof(read_buf));
5478 called = false;
5479 asio::async_read_at(s, 1234, buffers,
5480 asio::transfer_at_least(1),
5481 bindns::bind(async_read_handler,
5482 _1, _2, 10, &called));
5483 ioc.restart();
5484 ioc.run();
5485 ASIO_CHECK(called);
5486 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5487
5488 s.reset(read_data, sizeof(read_data));
5489 memset(read_buf, 0, sizeof(read_buf));
5490 called = false;
5491 asio::async_read_at(s, 0, buffers,
5492 asio::transfer_at_least(10),
5493 bindns::bind(async_read_handler,
5494 _1, _2, sizeof(read_data), &called));
5495 ioc.restart();
5496 ioc.run();
5497 ASIO_CHECK(called);
5498 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5499
5500 s.reset(read_data, sizeof(read_data));
5501 memset(read_buf, 0, sizeof(read_buf));
5502 called = false;
5503 asio::async_read_at(s, 1234, buffers,
5504 asio::transfer_at_least(10),
5505 bindns::bind(async_read_handler,
5506 _1, _2, sizeof(read_data), &called));
5507 ioc.restart();
5508 ioc.run();
5509 ASIO_CHECK(called);
5510 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5511
5512 s.reset(read_data, sizeof(read_data));
5513 s.next_read_length(1);
5514 memset(read_buf, 0, sizeof(read_buf));
5515 called = false;
5516 asio::async_read_at(s, 0, buffers,
5517 asio::transfer_at_least(10),
5518 bindns::bind(async_read_handler,
5519 _1, _2, 10, &called));
5520 ioc.restart();
5521 ioc.run();
5522 ASIO_CHECK(called);
5523 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5524
5525 s.reset(read_data, sizeof(read_data));
5526 s.next_read_length(1);
5527 memset(read_buf, 0, sizeof(read_buf));
5528 called = false;
5529 asio::async_read_at(s, 1234, buffers,
5530 asio::transfer_at_least(10),
5531 bindns::bind(async_read_handler,
5532 _1, _2, 10, &called));
5533 ioc.restart();
5534 ioc.run();
5535 ASIO_CHECK(called);
5536 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5537
5538 s.reset(read_data, sizeof(read_data));
5539 s.next_read_length(10);
5540 memset(read_buf, 0, sizeof(read_buf));
5541 called = false;
5542 asio::async_read_at(s, 0, buffers,
5543 asio::transfer_at_least(10),
5544 bindns::bind(async_read_handler,
5545 _1, _2, 10, &called));
5546 ioc.restart();
5547 ioc.run();
5548 ASIO_CHECK(called);
5549 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5550
5551 s.reset(read_data, sizeof(read_data));
5552 s.next_read_length(10);
5553 memset(read_buf, 0, sizeof(read_buf));
5554 called = false;
5555 asio::async_read_at(s, 1234, buffers,
5556 asio::transfer_at_least(10),
5557 bindns::bind(async_read_handler,
5558 _1, _2, 10, &called));
5559 ioc.restart();
5560 ioc.run();
5561 ASIO_CHECK(called);
5562 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5563
5564 s.reset(read_data, sizeof(read_data));
5565 memset(read_buf, 0, sizeof(read_buf));
5566 called = false;
5567 asio::async_read_at(s, 0, buffers,
5568 asio::transfer_at_least(42),
5569 bindns::bind(async_read_handler,
5570 _1, _2, sizeof(read_data), &called));
5571 ioc.restart();
5572 ioc.run();
5573 ASIO_CHECK(called);
5574 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5575
5576 s.reset(read_data, sizeof(read_data));
5577 memset(read_buf, 0, sizeof(read_buf));
5578 called = false;
5579 asio::async_read_at(s, 1234, buffers,
5580 asio::transfer_at_least(42),
5581 bindns::bind(async_read_handler,
5582 _1, _2, sizeof(read_data), &called));
5583 ioc.restart();
5584 ioc.run();
5585 ASIO_CHECK(called);
5586 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5587
5588 s.reset(read_data, sizeof(read_data));
5589 s.next_read_length(1);
5590 memset(read_buf, 0, sizeof(read_buf));
5591 called = false;
5592 asio::async_read_at(s, 0, buffers,
5593 asio::transfer_at_least(42),
5594 bindns::bind(async_read_handler,
5595 _1, _2, 42, &called));
5596 ioc.restart();
5597 ioc.run();
5598 ASIO_CHECK(called);
5599 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5600
5601 s.reset(read_data, sizeof(read_data));
5602 s.next_read_length(1);
5603 memset(read_buf, 0, sizeof(read_buf));
5604 called = false;
5605 asio::async_read_at(s, 1234, buffers,
5606 asio::transfer_at_least(42),
5607 bindns::bind(async_read_handler,
5608 _1, _2, 42, &called));
5609 ioc.restart();
5610 ioc.run();
5611 ASIO_CHECK(called);
5612 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5613
5614 s.reset(read_data, sizeof(read_data));
5615 s.next_read_length(10);
5616 memset(read_buf, 0, sizeof(read_buf));
5617 called = false;
5618 asio::async_read_at(s, 0, buffers,
5619 asio::transfer_at_least(42),
5620 bindns::bind(async_read_handler,
5621 _1, _2, 50, &called));
5622 ioc.restart();
5623 ioc.run();
5624 ASIO_CHECK(called);
5625 ASIO_CHECK(s.check_buffers(0, buffers, 50));
5626
5627 s.reset(read_data, sizeof(read_data));
5628 s.next_read_length(10);
5629 memset(read_buf, 0, sizeof(read_buf));
5630 called = false;
5631 asio::async_read_at(s, 1234, buffers,
5632 asio::transfer_at_least(42),
5633 bindns::bind(async_read_handler,
5634 _1, _2, 50, &called));
5635 ioc.restart();
5636 ioc.run();
5637 ASIO_CHECK(called);
5638 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
5639
5640 s.reset(read_data, sizeof(read_data));
5641 memset(read_buf, 0, sizeof(read_buf));
5642 called = false;
5643 asio::async_read_at(s, 0, buffers,
5644 asio::transfer_exactly(1),
5645 bindns::bind(async_read_handler,
5646 _1, _2, 1, &called));
5647 ioc.restart();
5648 ioc.run();
5649 ASIO_CHECK(called);
5650 ASIO_CHECK(s.check_buffers(0, buffers, 1));
5651
5652 s.reset(read_data, sizeof(read_data));
5653 memset(read_buf, 0, sizeof(read_buf));
5654 called = false;
5655 asio::async_read_at(s, 1234, buffers,
5656 asio::transfer_exactly(1),
5657 bindns::bind(async_read_handler,
5658 _1, _2, 1, &called));
5659 ioc.restart();
5660 ioc.run();
5661 ASIO_CHECK(called);
5662 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5663
5664 s.reset(read_data, sizeof(read_data));
5665 s.next_read_length(1);
5666 memset(read_buf, 0, sizeof(read_buf));
5667 called = false;
5668 asio::async_read_at(s, 0, buffers,
5669 asio::transfer_exactly(1),
5670 bindns::bind(async_read_handler,
5671 _1, _2, 1, &called));
5672 ioc.restart();
5673 ioc.run();
5674 ASIO_CHECK(called);
5675 ASIO_CHECK(s.check_buffers(0, buffers, 1));
5676
5677 s.reset(read_data, sizeof(read_data));
5678 s.next_read_length(1);
5679 memset(read_buf, 0, sizeof(read_buf));
5680 called = false;
5681 asio::async_read_at(s, 1234, buffers,
5682 asio::transfer_exactly(1),
5683 bindns::bind(async_read_handler,
5684 _1, _2, 1, &called));
5685 ioc.restart();
5686 ioc.run();
5687 ASIO_CHECK(called);
5688 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5689
5690 s.reset(read_data, sizeof(read_data));
5691 s.next_read_length(10);
5692 memset(read_buf, 0, sizeof(read_buf));
5693 called = false;
5694 asio::async_read_at(s, 0, buffers,
5695 asio::transfer_exactly(1),
5696 bindns::bind(async_read_handler,
5697 _1, _2, 1, &called));
5698 ioc.restart();
5699 ioc.run();
5700 ASIO_CHECK(called);
5701 ASIO_CHECK(s.check_buffers(0, buffers, 1));
5702
5703 s.reset(read_data, sizeof(read_data));
5704 s.next_read_length(10);
5705 memset(read_buf, 0, sizeof(read_buf));
5706 called = false;
5707 asio::async_read_at(s, 1234, buffers,
5708 asio::transfer_exactly(1),
5709 bindns::bind(async_read_handler,
5710 _1, _2, 1, &called));
5711 ioc.restart();
5712 ioc.run();
5713 ASIO_CHECK(called);
5714 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
5715
5716 s.reset(read_data, sizeof(read_data));
5717 memset(read_buf, 0, sizeof(read_buf));
5718 called = false;
5719 asio::async_read_at(s, 0, buffers,
5720 asio::transfer_exactly(10),
5721 bindns::bind(async_read_handler,
5722 _1, _2, 10, &called));
5723 ioc.restart();
5724 ioc.run();
5725 ASIO_CHECK(called);
5726 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5727
5728 s.reset(read_data, sizeof(read_data));
5729 memset(read_buf, 0, sizeof(read_buf));
5730 called = false;
5731 asio::async_read_at(s, 1234, buffers,
5732 asio::transfer_exactly(10),
5733 bindns::bind(async_read_handler,
5734 _1, _2, 10, &called));
5735 ioc.restart();
5736 ioc.run();
5737 ASIO_CHECK(called);
5738 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5739
5740 s.reset(read_data, sizeof(read_data));
5741 s.next_read_length(1);
5742 memset(read_buf, 0, sizeof(read_buf));
5743 called = false;
5744 asio::async_read_at(s, 0, buffers,
5745 asio::transfer_exactly(10),
5746 bindns::bind(async_read_handler,
5747 _1, _2, 10, &called));
5748 ioc.restart();
5749 ioc.run();
5750 ASIO_CHECK(called);
5751 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5752
5753 s.reset(read_data, sizeof(read_data));
5754 s.next_read_length(1);
5755 memset(read_buf, 0, sizeof(read_buf));
5756 called = false;
5757 asio::async_read_at(s, 1234, buffers,
5758 asio::transfer_exactly(10),
5759 bindns::bind(async_read_handler,
5760 _1, _2, 10, &called));
5761 ioc.restart();
5762 ioc.run();
5763 ASIO_CHECK(called);
5764 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5765
5766 s.reset(read_data, sizeof(read_data));
5767 s.next_read_length(10);
5768 memset(read_buf, 0, sizeof(read_buf));
5769 called = false;
5770 asio::async_read_at(s, 0, buffers,
5771 asio::transfer_exactly(10),
5772 bindns::bind(async_read_handler,
5773 _1, _2, 10, &called));
5774 ioc.restart();
5775 ioc.run();
5776 ASIO_CHECK(called);
5777 ASIO_CHECK(s.check_buffers(0, buffers, 10));
5778
5779 s.reset(read_data, sizeof(read_data));
5780 s.next_read_length(10);
5781 memset(read_buf, 0, sizeof(read_buf));
5782 called = false;
5783 asio::async_read_at(s, 1234, buffers,
5784 asio::transfer_exactly(10),
5785 bindns::bind(async_read_handler,
5786 _1, _2, 10, &called));
5787 ioc.restart();
5788 ioc.run();
5789 ASIO_CHECK(called);
5790 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
5791
5792 s.reset(read_data, sizeof(read_data));
5793 memset(read_buf, 0, sizeof(read_buf));
5794 called = false;
5795 asio::async_read_at(s, 0, buffers,
5796 asio::transfer_exactly(42),
5797 bindns::bind(async_read_handler,
5798 _1, _2, 42, &called));
5799 ioc.restart();
5800 ioc.run();
5801 ASIO_CHECK(called);
5802 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5803
5804 s.reset(read_data, sizeof(read_data));
5805 memset(read_buf, 0, sizeof(read_buf));
5806 called = false;
5807 asio::async_read_at(s, 1234, buffers,
5808 asio::transfer_exactly(42),
5809 bindns::bind(async_read_handler,
5810 _1, _2, 42, &called));
5811 ioc.restart();
5812 ioc.run();
5813 ASIO_CHECK(called);
5814 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5815
5816 s.reset(read_data, sizeof(read_data));
5817 s.next_read_length(1);
5818 memset(read_buf, 0, sizeof(read_buf));
5819 called = false;
5820 asio::async_read_at(s, 0, buffers,
5821 asio::transfer_exactly(42),
5822 bindns::bind(async_read_handler,
5823 _1, _2, 42, &called));
5824 ioc.restart();
5825 ioc.run();
5826 ASIO_CHECK(called);
5827 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5828
5829 s.reset(read_data, sizeof(read_data));
5830 s.next_read_length(1);
5831 memset(read_buf, 0, sizeof(read_buf));
5832 called = false;
5833 asio::async_read_at(s, 1234, buffers,
5834 asio::transfer_exactly(42),
5835 bindns::bind(async_read_handler,
5836 _1, _2, 42, &called));
5837 ioc.restart();
5838 ioc.run();
5839 ASIO_CHECK(called);
5840 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5841
5842 s.reset(read_data, sizeof(read_data));
5843 s.next_read_length(10);
5844 memset(read_buf, 0, sizeof(read_buf));
5845 called = false;
5846 asio::async_read_at(s, 0, buffers,
5847 asio::transfer_exactly(42),
5848 bindns::bind(async_read_handler,
5849 _1, _2, 42, &called));
5850 ioc.restart();
5851 ioc.run();
5852 ASIO_CHECK(called);
5853 ASIO_CHECK(s.check_buffers(0, buffers, 42));
5854
5855 s.reset(read_data, sizeof(read_data));
5856 s.next_read_length(10);
5857 memset(read_buf, 0, sizeof(read_buf));
5858 called = false;
5859 asio::async_read_at(s, 1234, buffers,
5860 asio::transfer_exactly(42),
5861 bindns::bind(async_read_handler,
5862 _1, _2, 42, &called));
5863 ioc.restart();
5864 ioc.run();
5865 ASIO_CHECK(called);
5866 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
5867
5868 s.reset(read_data, sizeof(read_data));
5869 memset(read_buf, 0, sizeof(read_buf));
5870 called = false;
5871 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5872 bindns::bind(async_read_handler,
5873 _1, _2, sizeof(read_data), &called));
5874 ioc.restart();
5875 ioc.run();
5876 ASIO_CHECK(called);
5877 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5878
5879 s.reset(read_data, sizeof(read_data));
5880 memset(read_buf, 0, sizeof(read_buf));
5881 called = false;
5882 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5883 bindns::bind(async_read_handler,
5884 _1, _2, sizeof(read_data), &called));
5885 ioc.restart();
5886 ioc.run();
5887 ASIO_CHECK(called);
5888 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5889
5890 s.reset(read_data, sizeof(read_data));
5891 s.next_read_length(1);
5892 memset(read_buf, 0, sizeof(read_buf));
5893 called = false;
5894 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5895 bindns::bind(async_read_handler,
5896 _1, _2, sizeof(read_data), &called));
5897 ioc.restart();
5898 ioc.run();
5899 ASIO_CHECK(called);
5900 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5901
5902 s.reset(read_data, sizeof(read_data));
5903 s.next_read_length(1);
5904 memset(read_buf, 0, sizeof(read_buf));
5905 called = false;
5906 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5907 bindns::bind(async_read_handler,
5908 _1, _2, sizeof(read_data), &called));
5909 ioc.restart();
5910 ioc.run();
5911 ASIO_CHECK(called);
5912 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5913
5914 s.reset(read_data, sizeof(read_data));
5915 s.next_read_length(10);
5916 memset(read_buf, 0, sizeof(read_buf));
5917 called = false;
5918 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
5919 bindns::bind(async_read_handler,
5920 _1, _2, sizeof(read_data), &called));
5921 ioc.restart();
5922 ioc.run();
5923 ASIO_CHECK(called);
5924 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5925
5926 s.reset(read_data, sizeof(read_data));
5927 s.next_read_length(10);
5928 memset(read_buf, 0, sizeof(read_buf));
5929 called = false;
5930 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
5931 bindns::bind(async_read_handler,
5932 _1, _2, sizeof(read_data), &called));
5933 ioc.restart();
5934 ioc.run();
5935 ASIO_CHECK(called);
5936 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5937
5938 s.reset(read_data, sizeof(read_data));
5939 memset(read_buf, 0, sizeof(read_buf));
5940 called = false;
5941 asio::async_read_at(s, 0, buffers, short_transfer,
5942 bindns::bind(async_read_handler,
5943 _1, _2, sizeof(read_data), &called));
5944 ioc.restart();
5945 ioc.run();
5946 ASIO_CHECK(called);
5947 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5948
5949 s.reset(read_data, sizeof(read_data));
5950 memset(read_buf, 0, sizeof(read_buf));
5951 called = false;
5952 asio::async_read_at(s, 1234, buffers, short_transfer,
5953 bindns::bind(async_read_handler,
5954 _1, _2, sizeof(read_data), &called));
5955 ioc.restart();
5956 ioc.run();
5957 ASIO_CHECK(called);
5958 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5959
5960 s.reset(read_data, sizeof(read_data));
5961 s.next_read_length(1);
5962 memset(read_buf, 0, sizeof(read_buf));
5963 called = false;
5964 asio::async_read_at(s, 0, buffers, short_transfer,
5965 bindns::bind(async_read_handler,
5966 _1, _2, sizeof(read_data), &called));
5967 ioc.restart();
5968 ioc.run();
5969 ASIO_CHECK(called);
5970 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5971
5972 s.reset(read_data, sizeof(read_data));
5973 s.next_read_length(1);
5974 memset(read_buf, 0, sizeof(read_buf));
5975 called = false;
5976 asio::async_read_at(s, 1234, buffers, short_transfer,
5977 bindns::bind(async_read_handler,
5978 _1, _2, sizeof(read_data), &called));
5979 ioc.restart();
5980 ioc.run();
5981 ASIO_CHECK(called);
5982 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
5983
5984 s.reset(read_data, sizeof(read_data));
5985 s.next_read_length(10);
5986 memset(read_buf, 0, sizeof(read_buf));
5987 called = false;
5988 asio::async_read_at(s, 0, buffers, short_transfer,
5989 bindns::bind(async_read_handler,
5990 _1, _2, sizeof(read_data), &called));
5991 ioc.restart();
5992 ioc.run();
5993 ASIO_CHECK(called);
5994 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
5995
5996 s.reset(read_data, sizeof(read_data));
5997 s.next_read_length(10);
5998 memset(read_buf, 0, sizeof(read_buf));
5999 called = false;
6000 asio::async_read_at(s, 1234, buffers, short_transfer,
6001 bindns::bind(async_read_handler,
6002 _1, _2, sizeof(read_data), &called));
6003 ioc.restart();
6004 ioc.run();
6005 ASIO_CHECK(called);
6006 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6007
6008 s.reset(read_data, sizeof(read_data));
6009 memset(read_buf, 0, sizeof(read_buf));
6010 int i = asio::async_read_at(s, 1234, buffers,
6011 short_transfer, archetypes::lazy_handler());
6012 ASIO_CHECK(i == 42);
6013 ioc.restart();
6014 ioc.run();
6015 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6016 #endif // defined(ASIO_HAS_STD_ARRAY)
6017 }
6018
test_5_arg_vector_buffers_async_read_at()6019 void test_5_arg_vector_buffers_async_read_at()
6020 {
6021 #if defined(ASIO_HAS_BOOST_BIND)
6022 namespace bindns = boost;
6023 #else // defined(ASIO_HAS_BOOST_BIND)
6024 namespace bindns = std;
6025 using std::placeholders::_1;
6026 using std::placeholders::_2;
6027 #endif // defined(ASIO_HAS_BOOST_BIND)
6028
6029 asio::io_context ioc;
6030 test_random_access_device s(ioc);
6031 char read_buf[sizeof(read_data)];
6032 std::vector<asio::mutable_buffer> buffers;
6033 buffers.push_back(asio::buffer(read_buf, 32));
6034 buffers.push_back(asio::buffer(read_buf) + 32);
6035
6036 s.reset(read_data, sizeof(read_data));
6037 memset(read_buf, 0, sizeof(read_buf));
6038 bool called = false;
6039 asio::async_read_at(s, 0, buffers,
6040 asio::transfer_all(),
6041 bindns::bind(async_read_handler,
6042 _1, _2, sizeof(read_data), &called));
6043 ioc.restart();
6044 ioc.run();
6045 ASIO_CHECK(called);
6046 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6047
6048 s.reset(read_data, sizeof(read_data));
6049 memset(read_buf, 0, sizeof(read_buf));
6050 called = false;
6051 asio::async_read_at(s, 1234, buffers,
6052 asio::transfer_all(),
6053 bindns::bind(async_read_handler,
6054 _1, _2, sizeof(read_data), &called));
6055 ioc.restart();
6056 ioc.run();
6057 ASIO_CHECK(called);
6058 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6059
6060 s.reset(read_data, sizeof(read_data));
6061 s.next_read_length(1);
6062 memset(read_buf, 0, sizeof(read_buf));
6063 called = false;
6064 asio::async_read_at(s, 0, buffers,
6065 asio::transfer_all(),
6066 bindns::bind(async_read_handler,
6067 _1, _2, sizeof(read_data), &called));
6068 ioc.restart();
6069 ioc.run();
6070 ASIO_CHECK(called);
6071 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6072
6073 s.reset(read_data, sizeof(read_data));
6074 s.next_read_length(1);
6075 memset(read_buf, 0, sizeof(read_buf));
6076 called = false;
6077 asio::async_read_at(s, 1234, buffers,
6078 asio::transfer_all(),
6079 bindns::bind(async_read_handler,
6080 _1, _2, sizeof(read_data), &called));
6081 ioc.restart();
6082 ioc.run();
6083 ASIO_CHECK(called);
6084 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6085
6086 s.reset(read_data, sizeof(read_data));
6087 s.next_read_length(10);
6088 memset(read_buf, 0, sizeof(read_buf));
6089 called = false;
6090 asio::async_read_at(s, 0, buffers,
6091 asio::transfer_all(),
6092 bindns::bind(async_read_handler,
6093 _1, _2, sizeof(read_data), &called));
6094 ioc.restart();
6095 ioc.run();
6096 ASIO_CHECK(called);
6097 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6098
6099 s.reset(read_data, sizeof(read_data));
6100 s.next_read_length(10);
6101 memset(read_buf, 0, sizeof(read_buf));
6102 called = false;
6103 asio::async_read_at(s, 1234, buffers,
6104 asio::transfer_all(),
6105 bindns::bind(async_read_handler,
6106 _1, _2, sizeof(read_data), &called));
6107 ioc.restart();
6108 ioc.run();
6109 ASIO_CHECK(called);
6110 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6111
6112 s.reset(read_data, sizeof(read_data));
6113 memset(read_buf, 0, sizeof(read_buf));
6114 called = false;
6115 asio::async_read_at(s, 0, buffers,
6116 asio::transfer_at_least(1),
6117 bindns::bind(async_read_handler,
6118 _1, _2, sizeof(read_data), &called));
6119 ioc.restart();
6120 ioc.run();
6121 ASIO_CHECK(called);
6122 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6123
6124 s.reset(read_data, sizeof(read_data));
6125 memset(read_buf, 0, sizeof(read_buf));
6126 called = false;
6127 asio::async_read_at(s, 1234, buffers,
6128 asio::transfer_at_least(1),
6129 bindns::bind(async_read_handler,
6130 _1, _2, sizeof(read_data), &called));
6131 ioc.restart();
6132 ioc.run();
6133 ASIO_CHECK(called);
6134 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6135
6136 s.reset(read_data, sizeof(read_data));
6137 s.next_read_length(1);
6138 memset(read_buf, 0, sizeof(read_buf));
6139 called = false;
6140 asio::async_read_at(s, 0, buffers,
6141 asio::transfer_at_least(1),
6142 bindns::bind(async_read_handler,
6143 _1, _2, 1, &called));
6144 ioc.restart();
6145 ioc.run();
6146 ASIO_CHECK(called);
6147 ASIO_CHECK(s.check_buffers(0, buffers, 1));
6148
6149 s.reset(read_data, sizeof(read_data));
6150 s.next_read_length(1);
6151 memset(read_buf, 0, sizeof(read_buf));
6152 called = false;
6153 asio::async_read_at(s, 1234, buffers,
6154 asio::transfer_at_least(1),
6155 bindns::bind(async_read_handler,
6156 _1, _2, 1, &called));
6157 ioc.restart();
6158 ioc.run();
6159 ASIO_CHECK(called);
6160 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6161
6162 s.reset(read_data, sizeof(read_data));
6163 s.next_read_length(10);
6164 memset(read_buf, 0, sizeof(read_buf));
6165 called = false;
6166 asio::async_read_at(s, 0, buffers,
6167 asio::transfer_at_least(1),
6168 bindns::bind(async_read_handler,
6169 _1, _2, 10, &called));
6170 ioc.restart();
6171 ioc.run();
6172 ASIO_CHECK(called);
6173 ASIO_CHECK(s.check_buffers(0, buffers, 10));
6174
6175 s.reset(read_data, sizeof(read_data));
6176 s.next_read_length(10);
6177 memset(read_buf, 0, sizeof(read_buf));
6178 called = false;
6179 asio::async_read_at(s, 1234, buffers,
6180 asio::transfer_at_least(1),
6181 bindns::bind(async_read_handler,
6182 _1, _2, 10, &called));
6183 ioc.restart();
6184 ioc.run();
6185 ASIO_CHECK(called);
6186 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6187
6188 s.reset(read_data, sizeof(read_data));
6189 memset(read_buf, 0, sizeof(read_buf));
6190 called = false;
6191 asio::async_read_at(s, 0, buffers,
6192 asio::transfer_at_least(10),
6193 bindns::bind(async_read_handler,
6194 _1, _2, sizeof(read_data), &called));
6195 ioc.restart();
6196 ioc.run();
6197 ASIO_CHECK(called);
6198 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6199
6200 s.reset(read_data, sizeof(read_data));
6201 memset(read_buf, 0, sizeof(read_buf));
6202 called = false;
6203 asio::async_read_at(s, 1234, buffers,
6204 asio::transfer_at_least(10),
6205 bindns::bind(async_read_handler,
6206 _1, _2, sizeof(read_data), &called));
6207 ioc.restart();
6208 ioc.run();
6209 ASIO_CHECK(called);
6210 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6211
6212 s.reset(read_data, sizeof(read_data));
6213 s.next_read_length(1);
6214 memset(read_buf, 0, sizeof(read_buf));
6215 called = false;
6216 asio::async_read_at(s, 0, buffers,
6217 asio::transfer_at_least(10),
6218 bindns::bind(async_read_handler,
6219 _1, _2, 10, &called));
6220 ioc.restart();
6221 ioc.run();
6222 ASIO_CHECK(called);
6223 ASIO_CHECK(s.check_buffers(0, buffers, 10));
6224
6225 s.reset(read_data, sizeof(read_data));
6226 s.next_read_length(1);
6227 memset(read_buf, 0, sizeof(read_buf));
6228 called = false;
6229 asio::async_read_at(s, 1234, buffers,
6230 asio::transfer_at_least(10),
6231 bindns::bind(async_read_handler,
6232 _1, _2, 10, &called));
6233 ioc.restart();
6234 ioc.run();
6235 ASIO_CHECK(called);
6236 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6237
6238 s.reset(read_data, sizeof(read_data));
6239 s.next_read_length(10);
6240 memset(read_buf, 0, sizeof(read_buf));
6241 called = false;
6242 asio::async_read_at(s, 0, buffers,
6243 asio::transfer_at_least(10),
6244 bindns::bind(async_read_handler,
6245 _1, _2, 10, &called));
6246 ioc.restart();
6247 ioc.run();
6248 ASIO_CHECK(called);
6249 ASIO_CHECK(s.check_buffers(0, buffers, 10));
6250
6251 s.reset(read_data, sizeof(read_data));
6252 s.next_read_length(10);
6253 memset(read_buf, 0, sizeof(read_buf));
6254 called = false;
6255 asio::async_read_at(s, 1234, buffers,
6256 asio::transfer_at_least(10),
6257 bindns::bind(async_read_handler,
6258 _1, _2, 10, &called));
6259 ioc.restart();
6260 ioc.run();
6261 ASIO_CHECK(called);
6262 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6263
6264 s.reset(read_data, sizeof(read_data));
6265 memset(read_buf, 0, sizeof(read_buf));
6266 called = false;
6267 asio::async_read_at(s, 0, buffers,
6268 asio::transfer_at_least(42),
6269 bindns::bind(async_read_handler,
6270 _1, _2, sizeof(read_data), &called));
6271 ioc.restart();
6272 ioc.run();
6273 ASIO_CHECK(called);
6274 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6275
6276 s.reset(read_data, sizeof(read_data));
6277 memset(read_buf, 0, sizeof(read_buf));
6278 called = false;
6279 asio::async_read_at(s, 1234, buffers,
6280 asio::transfer_at_least(42),
6281 bindns::bind(async_read_handler,
6282 _1, _2, sizeof(read_data), &called));
6283 ioc.restart();
6284 ioc.run();
6285 ASIO_CHECK(called);
6286 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6287
6288 s.reset(read_data, sizeof(read_data));
6289 s.next_read_length(1);
6290 memset(read_buf, 0, sizeof(read_buf));
6291 called = false;
6292 asio::async_read_at(s, 0, buffers,
6293 asio::transfer_at_least(42),
6294 bindns::bind(async_read_handler,
6295 _1, _2, 42, &called));
6296 ioc.restart();
6297 ioc.run();
6298 ASIO_CHECK(called);
6299 ASIO_CHECK(s.check_buffers(0, buffers, 42));
6300
6301 s.reset(read_data, sizeof(read_data));
6302 s.next_read_length(1);
6303 memset(read_buf, 0, sizeof(read_buf));
6304 called = false;
6305 asio::async_read_at(s, 1234, buffers,
6306 asio::transfer_at_least(42),
6307 bindns::bind(async_read_handler,
6308 _1, _2, 42, &called));
6309 ioc.restart();
6310 ioc.run();
6311 ASIO_CHECK(called);
6312 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6313
6314 s.reset(read_data, sizeof(read_data));
6315 s.next_read_length(10);
6316 memset(read_buf, 0, sizeof(read_buf));
6317 called = false;
6318 asio::async_read_at(s, 0, buffers,
6319 asio::transfer_at_least(42),
6320 bindns::bind(async_read_handler,
6321 _1, _2, 50, &called));
6322 ioc.restart();
6323 ioc.run();
6324 ASIO_CHECK(called);
6325 ASIO_CHECK(s.check_buffers(0, buffers, 50));
6326
6327 s.reset(read_data, sizeof(read_data));
6328 s.next_read_length(10);
6329 memset(read_buf, 0, sizeof(read_buf));
6330 called = false;
6331 asio::async_read_at(s, 1234, buffers,
6332 asio::transfer_at_least(42),
6333 bindns::bind(async_read_handler,
6334 _1, _2, 50, &called));
6335 ioc.restart();
6336 ioc.run();
6337 ASIO_CHECK(called);
6338 ASIO_CHECK(s.check_buffers(1234, buffers, 50));
6339
6340 s.reset(read_data, sizeof(read_data));
6341 memset(read_buf, 0, sizeof(read_buf));
6342 called = false;
6343 asio::async_read_at(s, 0, buffers,
6344 asio::transfer_exactly(1),
6345 bindns::bind(async_read_handler,
6346 _1, _2, 1, &called));
6347 ioc.restart();
6348 ioc.run();
6349 ASIO_CHECK(called);
6350 ASIO_CHECK(s.check_buffers(0, buffers, 1));
6351
6352 s.reset(read_data, sizeof(read_data));
6353 memset(read_buf, 0, sizeof(read_buf));
6354 called = false;
6355 asio::async_read_at(s, 1234, buffers,
6356 asio::transfer_exactly(1),
6357 bindns::bind(async_read_handler,
6358 _1, _2, 1, &called));
6359 ioc.restart();
6360 ioc.run();
6361 ASIO_CHECK(called);
6362 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6363
6364 s.reset(read_data, sizeof(read_data));
6365 s.next_read_length(1);
6366 memset(read_buf, 0, sizeof(read_buf));
6367 called = false;
6368 asio::async_read_at(s, 0, buffers,
6369 asio::transfer_exactly(1),
6370 bindns::bind(async_read_handler,
6371 _1, _2, 1, &called));
6372 ioc.restart();
6373 ioc.run();
6374 ASIO_CHECK(called);
6375 ASIO_CHECK(s.check_buffers(0, buffers, 1));
6376
6377 s.reset(read_data, sizeof(read_data));
6378 s.next_read_length(1);
6379 memset(read_buf, 0, sizeof(read_buf));
6380 called = false;
6381 asio::async_read_at(s, 1234, buffers,
6382 asio::transfer_exactly(1),
6383 bindns::bind(async_read_handler,
6384 _1, _2, 1, &called));
6385 ioc.restart();
6386 ioc.run();
6387 ASIO_CHECK(called);
6388 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6389
6390 s.reset(read_data, sizeof(read_data));
6391 s.next_read_length(10);
6392 memset(read_buf, 0, sizeof(read_buf));
6393 called = false;
6394 asio::async_read_at(s, 0, buffers,
6395 asio::transfer_exactly(1),
6396 bindns::bind(async_read_handler,
6397 _1, _2, 1, &called));
6398 ioc.restart();
6399 ioc.run();
6400 ASIO_CHECK(called);
6401 ASIO_CHECK(s.check_buffers(0, buffers, 1));
6402
6403 s.reset(read_data, sizeof(read_data));
6404 s.next_read_length(10);
6405 memset(read_buf, 0, sizeof(read_buf));
6406 called = false;
6407 asio::async_read_at(s, 1234, buffers,
6408 asio::transfer_exactly(1),
6409 bindns::bind(async_read_handler,
6410 _1, _2, 1, &called));
6411 ioc.restart();
6412 ioc.run();
6413 ASIO_CHECK(called);
6414 ASIO_CHECK(s.check_buffers(1234, buffers, 1));
6415
6416 s.reset(read_data, sizeof(read_data));
6417 memset(read_buf, 0, sizeof(read_buf));
6418 called = false;
6419 asio::async_read_at(s, 0, buffers,
6420 asio::transfer_exactly(10),
6421 bindns::bind(async_read_handler,
6422 _1, _2, 10, &called));
6423 ioc.restart();
6424 ioc.run();
6425 ASIO_CHECK(called);
6426 ASIO_CHECK(s.check_buffers(0, buffers, 10));
6427
6428 s.reset(read_data, sizeof(read_data));
6429 memset(read_buf, 0, sizeof(read_buf));
6430 called = false;
6431 asio::async_read_at(s, 1234, buffers,
6432 asio::transfer_exactly(10),
6433 bindns::bind(async_read_handler,
6434 _1, _2, 10, &called));
6435 ioc.restart();
6436 ioc.run();
6437 ASIO_CHECK(called);
6438 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6439
6440 s.reset(read_data, sizeof(read_data));
6441 s.next_read_length(1);
6442 memset(read_buf, 0, sizeof(read_buf));
6443 called = false;
6444 asio::async_read_at(s, 0, buffers,
6445 asio::transfer_exactly(10),
6446 bindns::bind(async_read_handler,
6447 _1, _2, 10, &called));
6448 ioc.restart();
6449 ioc.run();
6450 ASIO_CHECK(called);
6451 ASIO_CHECK(s.check_buffers(0, buffers, 10));
6452
6453 s.reset(read_data, sizeof(read_data));
6454 s.next_read_length(1);
6455 memset(read_buf, 0, sizeof(read_buf));
6456 called = false;
6457 asio::async_read_at(s, 1234, buffers,
6458 asio::transfer_exactly(10),
6459 bindns::bind(async_read_handler,
6460 _1, _2, 10, &called));
6461 ioc.restart();
6462 ioc.run();
6463 ASIO_CHECK(called);
6464 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6465
6466 s.reset(read_data, sizeof(read_data));
6467 s.next_read_length(10);
6468 memset(read_buf, 0, sizeof(read_buf));
6469 called = false;
6470 asio::async_read_at(s, 0, buffers,
6471 asio::transfer_exactly(10),
6472 bindns::bind(async_read_handler,
6473 _1, _2, 10, &called));
6474 ioc.restart();
6475 ioc.run();
6476 ASIO_CHECK(called);
6477 ASIO_CHECK(s.check_buffers(0, buffers, 10));
6478
6479 s.reset(read_data, sizeof(read_data));
6480 s.next_read_length(10);
6481 memset(read_buf, 0, sizeof(read_buf));
6482 called = false;
6483 asio::async_read_at(s, 1234, buffers,
6484 asio::transfer_exactly(10),
6485 bindns::bind(async_read_handler,
6486 _1, _2, 10, &called));
6487 ioc.restart();
6488 ioc.run();
6489 ASIO_CHECK(called);
6490 ASIO_CHECK(s.check_buffers(1234, buffers, 10));
6491
6492 s.reset(read_data, sizeof(read_data));
6493 memset(read_buf, 0, sizeof(read_buf));
6494 called = false;
6495 asio::async_read_at(s, 0, buffers,
6496 asio::transfer_exactly(42),
6497 bindns::bind(async_read_handler,
6498 _1, _2, 42, &called));
6499 ioc.restart();
6500 ioc.run();
6501 ASIO_CHECK(called);
6502 ASIO_CHECK(s.check_buffers(0, buffers, 42));
6503
6504 s.reset(read_data, sizeof(read_data));
6505 memset(read_buf, 0, sizeof(read_buf));
6506 called = false;
6507 asio::async_read_at(s, 1234, buffers,
6508 asio::transfer_exactly(42),
6509 bindns::bind(async_read_handler,
6510 _1, _2, 42, &called));
6511 ioc.restart();
6512 ioc.run();
6513 ASIO_CHECK(called);
6514 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6515
6516 s.reset(read_data, sizeof(read_data));
6517 s.next_read_length(1);
6518 memset(read_buf, 0, sizeof(read_buf));
6519 called = false;
6520 asio::async_read_at(s, 0, buffers,
6521 asio::transfer_exactly(42),
6522 bindns::bind(async_read_handler,
6523 _1, _2, 42, &called));
6524 ioc.restart();
6525 ioc.run();
6526 ASIO_CHECK(called);
6527 ASIO_CHECK(s.check_buffers(0, buffers, 42));
6528
6529 s.reset(read_data, sizeof(read_data));
6530 s.next_read_length(1);
6531 memset(read_buf, 0, sizeof(read_buf));
6532 called = false;
6533 asio::async_read_at(s, 1234, buffers,
6534 asio::transfer_exactly(42),
6535 bindns::bind(async_read_handler,
6536 _1, _2, 42, &called));
6537 ioc.restart();
6538 ioc.run();
6539 ASIO_CHECK(called);
6540 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6541
6542 s.reset(read_data, sizeof(read_data));
6543 s.next_read_length(10);
6544 memset(read_buf, 0, sizeof(read_buf));
6545 called = false;
6546 asio::async_read_at(s, 0, buffers,
6547 asio::transfer_exactly(42),
6548 bindns::bind(async_read_handler,
6549 _1, _2, 42, &called));
6550 ioc.restart();
6551 ioc.run();
6552 ASIO_CHECK(called);
6553 ASIO_CHECK(s.check_buffers(0, buffers, 42));
6554
6555 s.reset(read_data, sizeof(read_data));
6556 s.next_read_length(10);
6557 memset(read_buf, 0, sizeof(read_buf));
6558 called = false;
6559 asio::async_read_at(s, 1234, buffers,
6560 asio::transfer_exactly(42),
6561 bindns::bind(async_read_handler,
6562 _1, _2, 42, &called));
6563 ioc.restart();
6564 ioc.run();
6565 ASIO_CHECK(called);
6566 ASIO_CHECK(s.check_buffers(1234, buffers, 42));
6567
6568 s.reset(read_data, sizeof(read_data));
6569 memset(read_buf, 0, sizeof(read_buf));
6570 called = false;
6571 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
6572 bindns::bind(async_read_handler,
6573 _1, _2, sizeof(read_data), &called));
6574 ioc.restart();
6575 ioc.run();
6576 ASIO_CHECK(called);
6577 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6578
6579 s.reset(read_data, sizeof(read_data));
6580 memset(read_buf, 0, sizeof(read_buf));
6581 called = false;
6582 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
6583 bindns::bind(async_read_handler,
6584 _1, _2, sizeof(read_data), &called));
6585 ioc.restart();
6586 ioc.run();
6587 ASIO_CHECK(called);
6588 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6589
6590 s.reset(read_data, sizeof(read_data));
6591 s.next_read_length(1);
6592 memset(read_buf, 0, sizeof(read_buf));
6593 called = false;
6594 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
6595 bindns::bind(async_read_handler,
6596 _1, _2, sizeof(read_data), &called));
6597 ioc.restart();
6598 ioc.run();
6599 ASIO_CHECK(called);
6600 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6601
6602 s.reset(read_data, sizeof(read_data));
6603 s.next_read_length(1);
6604 memset(read_buf, 0, sizeof(read_buf));
6605 called = false;
6606 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
6607 bindns::bind(async_read_handler,
6608 _1, _2, sizeof(read_data), &called));
6609 ioc.restart();
6610 ioc.run();
6611 ASIO_CHECK(called);
6612 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6613
6614 s.reset(read_data, sizeof(read_data));
6615 s.next_read_length(10);
6616 memset(read_buf, 0, sizeof(read_buf));
6617 called = false;
6618 asio::async_read_at(s, 0, buffers, old_style_transfer_all,
6619 bindns::bind(async_read_handler,
6620 _1, _2, sizeof(read_data), &called));
6621 ioc.restart();
6622 ioc.run();
6623 ASIO_CHECK(called);
6624 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6625
6626 s.reset(read_data, sizeof(read_data));
6627 s.next_read_length(10);
6628 memset(read_buf, 0, sizeof(read_buf));
6629 called = false;
6630 asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
6631 bindns::bind(async_read_handler,
6632 _1, _2, sizeof(read_data), &called));
6633 ioc.restart();
6634 ioc.run();
6635 ASIO_CHECK(called);
6636 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6637
6638 s.reset(read_data, sizeof(read_data));
6639 memset(read_buf, 0, sizeof(read_buf));
6640 called = false;
6641 asio::async_read_at(s, 0, buffers, short_transfer,
6642 bindns::bind(async_read_handler,
6643 _1, _2, sizeof(read_data), &called));
6644 ioc.restart();
6645 ioc.run();
6646 ASIO_CHECK(called);
6647 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6648
6649 s.reset(read_data, sizeof(read_data));
6650 memset(read_buf, 0, sizeof(read_buf));
6651 called = false;
6652 asio::async_read_at(s, 1234, buffers, short_transfer,
6653 bindns::bind(async_read_handler,
6654 _1, _2, sizeof(read_data), &called));
6655 ioc.restart();
6656 ioc.run();
6657 ASIO_CHECK(called);
6658 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6659
6660 s.reset(read_data, sizeof(read_data));
6661 s.next_read_length(1);
6662 memset(read_buf, 0, sizeof(read_buf));
6663 called = false;
6664 asio::async_read_at(s, 0, buffers, short_transfer,
6665 bindns::bind(async_read_handler,
6666 _1, _2, sizeof(read_data), &called));
6667 ioc.restart();
6668 ioc.run();
6669 ASIO_CHECK(called);
6670 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6671
6672 s.reset(read_data, sizeof(read_data));
6673 s.next_read_length(1);
6674 memset(read_buf, 0, sizeof(read_buf));
6675 called = false;
6676 asio::async_read_at(s, 1234, buffers, short_transfer,
6677 bindns::bind(async_read_handler,
6678 _1, _2, sizeof(read_data), &called));
6679 ioc.restart();
6680 ioc.run();
6681 ASIO_CHECK(called);
6682 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6683
6684 s.reset(read_data, sizeof(read_data));
6685 s.next_read_length(10);
6686 memset(read_buf, 0, sizeof(read_buf));
6687 called = false;
6688 asio::async_read_at(s, 0, buffers, short_transfer,
6689 bindns::bind(async_read_handler,
6690 _1, _2, sizeof(read_data), &called));
6691 ioc.restart();
6692 ioc.run();
6693 ASIO_CHECK(called);
6694 ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
6695
6696 s.reset(read_data, sizeof(read_data));
6697 s.next_read_length(10);
6698 memset(read_buf, 0, sizeof(read_buf));
6699 called = false;
6700 asio::async_read_at(s, 1234, buffers, short_transfer,
6701 bindns::bind(async_read_handler,
6702 _1, _2, sizeof(read_data), &called));
6703 ioc.restart();
6704 ioc.run();
6705 ASIO_CHECK(called);
6706 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6707
6708 s.reset(read_data, sizeof(read_data));
6709 memset(read_buf, 0, sizeof(read_buf));
6710 int i = asio::async_read_at(s, 1234, buffers,
6711 short_transfer, archetypes::lazy_handler());
6712 ASIO_CHECK(i == 42);
6713 ioc.restart();
6714 ioc.run();
6715 ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
6716 }
6717
test_5_arg_streambuf_async_read_at()6718 void test_5_arg_streambuf_async_read_at()
6719 {
6720 #if defined(ASIO_HAS_BOOST_BIND)
6721 namespace bindns = boost;
6722 #else // defined(ASIO_HAS_BOOST_BIND)
6723 namespace bindns = std;
6724 using std::placeholders::_1;
6725 using std::placeholders::_2;
6726 #endif // defined(ASIO_HAS_BOOST_BIND)
6727
6728 asio::io_context ioc;
6729 test_random_access_device s(ioc);
6730 asio::streambuf sb(sizeof(read_data));
6731
6732 s.reset(read_data, sizeof(read_data));
6733 sb.consume(sb.size());
6734 bool called = false;
6735 asio::async_read_at(s, 0, sb,
6736 asio::transfer_all(),
6737 bindns::bind(async_read_handler,
6738 _1, _2, sizeof(read_data), &called));
6739 ioc.restart();
6740 ioc.run();
6741 ASIO_CHECK(called);
6742 ASIO_CHECK(sb.size() == sizeof(read_data));
6743 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6744
6745 s.reset(read_data, sizeof(read_data));
6746 sb.consume(sb.size());
6747 called = false;
6748 asio::async_read_at(s, 1234, sb,
6749 asio::transfer_all(),
6750 bindns::bind(async_read_handler,
6751 _1, _2, sizeof(read_data), &called));
6752 ioc.restart();
6753 ioc.run();
6754 ASIO_CHECK(called);
6755 ASIO_CHECK(sb.size() == sizeof(read_data));
6756 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6757
6758 s.reset(read_data, sizeof(read_data));
6759 s.next_read_length(1);
6760 sb.consume(sb.size());
6761 called = false;
6762 asio::async_read_at(s, 0, sb,
6763 asio::transfer_all(),
6764 bindns::bind(async_read_handler,
6765 _1, _2, sizeof(read_data), &called));
6766 ioc.restart();
6767 ioc.run();
6768 ASIO_CHECK(called);
6769 ASIO_CHECK(sb.size() == sizeof(read_data));
6770 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6771
6772 s.reset(read_data, sizeof(read_data));
6773 s.next_read_length(1);
6774 sb.consume(sb.size());
6775 called = false;
6776 asio::async_read_at(s, 1234, sb,
6777 asio::transfer_all(),
6778 bindns::bind(async_read_handler,
6779 _1, _2, sizeof(read_data), &called));
6780 ioc.restart();
6781 ioc.run();
6782 ASIO_CHECK(called);
6783 ASIO_CHECK(sb.size() == sizeof(read_data));
6784 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6785
6786 s.reset(read_data, sizeof(read_data));
6787 s.next_read_length(10);
6788 sb.consume(sb.size());
6789 called = false;
6790 asio::async_read_at(s, 0, sb,
6791 asio::transfer_all(),
6792 bindns::bind(async_read_handler,
6793 _1, _2, sizeof(read_data), &called));
6794 ioc.restart();
6795 ioc.run();
6796 ASIO_CHECK(called);
6797 ASIO_CHECK(sb.size() == sizeof(read_data));
6798 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6799
6800 s.reset(read_data, sizeof(read_data));
6801 s.next_read_length(10);
6802 sb.consume(sb.size());
6803 called = false;
6804 asio::async_read_at(s, 1234, sb,
6805 asio::transfer_all(),
6806 bindns::bind(async_read_handler,
6807 _1, _2, sizeof(read_data), &called));
6808 ioc.restart();
6809 ioc.run();
6810 ASIO_CHECK(called);
6811 ASIO_CHECK(sb.size() == sizeof(read_data));
6812 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6813
6814 s.reset(read_data, sizeof(read_data));
6815 sb.consume(sb.size());
6816 called = false;
6817 asio::async_read_at(s, 0, sb,
6818 asio::transfer_at_least(1),
6819 bindns::bind(async_read_handler,
6820 _1, _2, sizeof(read_data), &called));
6821 ioc.restart();
6822 ioc.run();
6823 ASIO_CHECK(called);
6824 ASIO_CHECK(sb.size() == sizeof(read_data));
6825 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6826
6827 s.reset(read_data, sizeof(read_data));
6828 sb.consume(sb.size());
6829 called = false;
6830 asio::async_read_at(s, 1234, sb,
6831 asio::transfer_at_least(1),
6832 bindns::bind(async_read_handler,
6833 _1, _2, sizeof(read_data), &called));
6834 ioc.restart();
6835 ioc.run();
6836 ASIO_CHECK(called);
6837 ASIO_CHECK(sb.size() == sizeof(read_data));
6838 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6839
6840 s.reset(read_data, sizeof(read_data));
6841 s.next_read_length(1);
6842 sb.consume(sb.size());
6843 called = false;
6844 asio::async_read_at(s, 0, sb,
6845 asio::transfer_at_least(1),
6846 bindns::bind(async_read_handler,
6847 _1, _2, 1, &called));
6848 ioc.restart();
6849 ioc.run();
6850 ASIO_CHECK(called);
6851 ASIO_CHECK(sb.size() == 1);
6852 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
6853
6854 s.reset(read_data, sizeof(read_data));
6855 s.next_read_length(1);
6856 sb.consume(sb.size());
6857 called = false;
6858 asio::async_read_at(s, 1234, sb,
6859 asio::transfer_at_least(1),
6860 bindns::bind(async_read_handler,
6861 _1, _2, 1, &called));
6862 ioc.restart();
6863 ioc.run();
6864 ASIO_CHECK(called);
6865 ASIO_CHECK(sb.size() == 1);
6866 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
6867
6868 s.reset(read_data, sizeof(read_data));
6869 s.next_read_length(10);
6870 sb.consume(sb.size());
6871 called = false;
6872 asio::async_read_at(s, 0, sb,
6873 asio::transfer_at_least(1),
6874 bindns::bind(async_read_handler,
6875 _1, _2, 10, &called));
6876 ioc.restart();
6877 ioc.run();
6878 ASIO_CHECK(called);
6879 ASIO_CHECK(sb.size() == 10);
6880 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
6881
6882 s.reset(read_data, sizeof(read_data));
6883 s.next_read_length(10);
6884 sb.consume(sb.size());
6885 called = false;
6886 asio::async_read_at(s, 1234, sb,
6887 asio::transfer_at_least(1),
6888 bindns::bind(async_read_handler,
6889 _1, _2, 10, &called));
6890 ioc.restart();
6891 ioc.run();
6892 ASIO_CHECK(called);
6893 ASIO_CHECK(sb.size() == 10);
6894 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
6895
6896 s.reset(read_data, sizeof(read_data));
6897 sb.consume(sb.size());
6898 called = false;
6899 asio::async_read_at(s, 0, sb,
6900 asio::transfer_at_least(10),
6901 bindns::bind(async_read_handler,
6902 _1, _2, sizeof(read_data), &called));
6903 ioc.restart();
6904 ioc.run();
6905 ASIO_CHECK(called);
6906 ASIO_CHECK(sb.size() == sizeof(read_data));
6907 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6908
6909 s.reset(read_data, sizeof(read_data));
6910 sb.consume(sb.size());
6911 called = false;
6912 asio::async_read_at(s, 1234, sb,
6913 asio::transfer_at_least(10),
6914 bindns::bind(async_read_handler,
6915 _1, _2, sizeof(read_data), &called));
6916 ioc.restart();
6917 ioc.run();
6918 ASIO_CHECK(called);
6919 ASIO_CHECK(sb.size() == sizeof(read_data));
6920 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
6921
6922 s.reset(read_data, sizeof(read_data));
6923 s.next_read_length(1);
6924 sb.consume(sb.size());
6925 called = false;
6926 asio::async_read_at(s, 0, sb,
6927 asio::transfer_at_least(10),
6928 bindns::bind(async_read_handler,
6929 _1, _2, 10, &called));
6930 ioc.restart();
6931 ioc.run();
6932 ASIO_CHECK(called);
6933 ASIO_CHECK(sb.size() == 10);
6934 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
6935
6936 s.reset(read_data, sizeof(read_data));
6937 s.next_read_length(1);
6938 sb.consume(sb.size());
6939 called = false;
6940 asio::async_read_at(s, 1234, sb,
6941 asio::transfer_at_least(10),
6942 bindns::bind(async_read_handler,
6943 _1, _2, 10, &called));
6944 ioc.restart();
6945 ioc.run();
6946 ASIO_CHECK(called);
6947 ASIO_CHECK(sb.size() == 10);
6948 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
6949
6950 s.reset(read_data, sizeof(read_data));
6951 s.next_read_length(10);
6952 sb.consume(sb.size());
6953 called = false;
6954 asio::async_read_at(s, 0, sb,
6955 asio::transfer_at_least(10),
6956 bindns::bind(async_read_handler,
6957 _1, _2, 10, &called));
6958 ioc.restart();
6959 ioc.run();
6960 ASIO_CHECK(called);
6961 ASIO_CHECK(sb.size() == 10);
6962 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
6963
6964 s.reset(read_data, sizeof(read_data));
6965 s.next_read_length(10);
6966 sb.consume(sb.size());
6967 called = false;
6968 asio::async_read_at(s, 1234, sb,
6969 asio::transfer_at_least(10),
6970 bindns::bind(async_read_handler,
6971 _1, _2, 10, &called));
6972 ioc.restart();
6973 ioc.run();
6974 ASIO_CHECK(called);
6975 ASIO_CHECK(sb.size() == 10);
6976 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
6977
6978 s.reset(read_data, sizeof(read_data));
6979 sb.consume(sb.size());
6980 called = false;
6981 asio::async_read_at(s, 0, sb,
6982 asio::transfer_at_least(42),
6983 bindns::bind(async_read_handler,
6984 _1, _2, sizeof(read_data), &called));
6985 ioc.restart();
6986 ioc.run();
6987 ASIO_CHECK(called);
6988 ASIO_CHECK(sb.size() == sizeof(read_data));
6989 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
6990
6991 s.reset(read_data, sizeof(read_data));
6992 sb.consume(sb.size());
6993 called = false;
6994 asio::async_read_at(s, 1234, sb,
6995 asio::transfer_at_least(42),
6996 bindns::bind(async_read_handler,
6997 _1, _2, sizeof(read_data), &called));
6998 ioc.restart();
6999 ioc.run();
7000 ASIO_CHECK(called);
7001 ASIO_CHECK(sb.size() == sizeof(read_data));
7002 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7003
7004 s.reset(read_data, sizeof(read_data));
7005 s.next_read_length(1);
7006 sb.consume(sb.size());
7007 called = false;
7008 asio::async_read_at(s, 0, sb,
7009 asio::transfer_at_least(42),
7010 bindns::bind(async_read_handler,
7011 _1, _2, 42, &called));
7012 ioc.restart();
7013 ioc.run();
7014 ASIO_CHECK(called);
7015 ASIO_CHECK(sb.size() == 42);
7016 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7017
7018 s.reset(read_data, sizeof(read_data));
7019 s.next_read_length(1);
7020 sb.consume(sb.size());
7021 called = false;
7022 asio::async_read_at(s, 1234, sb,
7023 asio::transfer_at_least(42),
7024 bindns::bind(async_read_handler,
7025 _1, _2, 42, &called));
7026 ioc.restart();
7027 ioc.run();
7028 ASIO_CHECK(called);
7029 ASIO_CHECK(sb.size() == 42);
7030 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7031
7032 s.reset(read_data, sizeof(read_data));
7033 s.next_read_length(10);
7034 sb.consume(sb.size());
7035 called = false;
7036 asio::async_read_at(s, 0, sb,
7037 asio::transfer_at_least(42),
7038 bindns::bind(async_read_handler,
7039 _1, _2, 50, &called));
7040 ioc.restart();
7041 ioc.run();
7042 ASIO_CHECK(called);
7043 ASIO_CHECK(sb.size() == 50);
7044 ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
7045
7046 s.reset(read_data, sizeof(read_data));
7047 s.next_read_length(10);
7048 sb.consume(sb.size());
7049 called = false;
7050 asio::async_read_at(s, 1234, sb,
7051 asio::transfer_at_least(42),
7052 bindns::bind(async_read_handler,
7053 _1, _2, 50, &called));
7054 ioc.restart();
7055 ioc.run();
7056 ASIO_CHECK(called);
7057 ASIO_CHECK(sb.size() == 50);
7058 ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
7059
7060 s.reset(read_data, sizeof(read_data));
7061 sb.consume(sb.size());
7062 called = false;
7063 asio::async_read_at(s, 0, sb,
7064 asio::transfer_exactly(1),
7065 bindns::bind(async_read_handler,
7066 _1, _2, 1, &called));
7067 ioc.restart();
7068 ioc.run();
7069 ASIO_CHECK(called);
7070 ASIO_CHECK(sb.size() == 1);
7071 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
7072
7073 s.reset(read_data, sizeof(read_data));
7074 sb.consume(sb.size());
7075 called = false;
7076 asio::async_read_at(s, 1234, sb,
7077 asio::transfer_exactly(1),
7078 bindns::bind(async_read_handler,
7079 _1, _2, 1, &called));
7080 ioc.restart();
7081 ioc.run();
7082 ASIO_CHECK(called);
7083 ASIO_CHECK(sb.size() == 1);
7084 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
7085
7086 s.reset(read_data, sizeof(read_data));
7087 s.next_read_length(1);
7088 sb.consume(sb.size());
7089 called = false;
7090 asio::async_read_at(s, 0, sb,
7091 asio::transfer_exactly(1),
7092 bindns::bind(async_read_handler,
7093 _1, _2, 1, &called));
7094 ioc.restart();
7095 ioc.run();
7096 ASIO_CHECK(called);
7097 ASIO_CHECK(sb.size() == 1);
7098 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
7099
7100 s.reset(read_data, sizeof(read_data));
7101 s.next_read_length(1);
7102 sb.consume(sb.size());
7103 called = false;
7104 asio::async_read_at(s, 1234, sb,
7105 asio::transfer_exactly(1),
7106 bindns::bind(async_read_handler,
7107 _1, _2, 1, &called));
7108 ioc.restart();
7109 ioc.run();
7110 ASIO_CHECK(called);
7111 ASIO_CHECK(sb.size() == 1);
7112 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
7113
7114 s.reset(read_data, sizeof(read_data));
7115 s.next_read_length(10);
7116 sb.consume(sb.size());
7117 called = false;
7118 asio::async_read_at(s, 0, sb,
7119 asio::transfer_exactly(1),
7120 bindns::bind(async_read_handler,
7121 _1, _2, 1, &called));
7122 ioc.restart();
7123 ioc.run();
7124 ASIO_CHECK(called);
7125 ASIO_CHECK(sb.size() == 1);
7126 ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
7127
7128 s.reset(read_data, sizeof(read_data));
7129 s.next_read_length(10);
7130 sb.consume(sb.size());
7131 called = false;
7132 asio::async_read_at(s, 1234, sb,
7133 asio::transfer_exactly(1),
7134 bindns::bind(async_read_handler,
7135 _1, _2, 1, &called));
7136 ioc.restart();
7137 ioc.run();
7138 ASIO_CHECK(called);
7139 ASIO_CHECK(sb.size() == 1);
7140 ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
7141
7142 s.reset(read_data, sizeof(read_data));
7143 sb.consume(sb.size());
7144 called = false;
7145 asio::async_read_at(s, 0, sb,
7146 asio::transfer_exactly(10),
7147 bindns::bind(async_read_handler,
7148 _1, _2, 10, &called));
7149 ioc.restart();
7150 ioc.run();
7151 ASIO_CHECK(called);
7152 ASIO_CHECK(sb.size() == 10);
7153 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
7154
7155 s.reset(read_data, sizeof(read_data));
7156 sb.consume(sb.size());
7157 called = false;
7158 asio::async_read_at(s, 1234, sb,
7159 asio::transfer_exactly(10),
7160 bindns::bind(async_read_handler,
7161 _1, _2, 10, &called));
7162 ioc.restart();
7163 ioc.run();
7164 ASIO_CHECK(called);
7165 ASIO_CHECK(sb.size() == 10);
7166 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
7167
7168 s.reset(read_data, sizeof(read_data));
7169 s.next_read_length(1);
7170 sb.consume(sb.size());
7171 called = false;
7172 asio::async_read_at(s, 0, sb,
7173 asio::transfer_exactly(10),
7174 bindns::bind(async_read_handler,
7175 _1, _2, 10, &called));
7176 ioc.restart();
7177 ioc.run();
7178 ASIO_CHECK(called);
7179 ASIO_CHECK(sb.size() == 10);
7180 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
7181
7182 s.reset(read_data, sizeof(read_data));
7183 s.next_read_length(1);
7184 sb.consume(sb.size());
7185 called = false;
7186 asio::async_read_at(s, 1234, sb,
7187 asio::transfer_exactly(10),
7188 bindns::bind(async_read_handler,
7189 _1, _2, 10, &called));
7190 ioc.restart();
7191 ioc.run();
7192 ASIO_CHECK(called);
7193 ASIO_CHECK(sb.size() == 10);
7194 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
7195
7196 s.reset(read_data, sizeof(read_data));
7197 s.next_read_length(10);
7198 sb.consume(sb.size());
7199 called = false;
7200 asio::async_read_at(s, 0, sb,
7201 asio::transfer_exactly(10),
7202 bindns::bind(async_read_handler,
7203 _1, _2, 10, &called));
7204 ioc.restart();
7205 ioc.run();
7206 ASIO_CHECK(called);
7207 ASIO_CHECK(sb.size() == 10);
7208 ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
7209
7210 s.reset(read_data, sizeof(read_data));
7211 s.next_read_length(10);
7212 sb.consume(sb.size());
7213 called = false;
7214 asio::async_read_at(s, 1234, sb,
7215 asio::transfer_exactly(10),
7216 bindns::bind(async_read_handler,
7217 _1, _2, 10, &called));
7218 ioc.restart();
7219 ioc.run();
7220 ASIO_CHECK(called);
7221 ASIO_CHECK(sb.size() == 10);
7222 ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
7223
7224 s.reset(read_data, sizeof(read_data));
7225 sb.consume(sb.size());
7226 called = false;
7227 asio::async_read_at(s, 0, sb,
7228 asio::transfer_exactly(42),
7229 bindns::bind(async_read_handler,
7230 _1, _2, 42, &called));
7231 ioc.restart();
7232 ioc.run();
7233 ASIO_CHECK(called);
7234 ASIO_CHECK(sb.size() == 42);
7235 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7236
7237 s.reset(read_data, sizeof(read_data));
7238 sb.consume(sb.size());
7239 called = false;
7240 asio::async_read_at(s, 1234, sb,
7241 asio::transfer_exactly(42),
7242 bindns::bind(async_read_handler,
7243 _1, _2, 42, &called));
7244 ioc.restart();
7245 ioc.run();
7246 ASIO_CHECK(called);
7247 ASIO_CHECK(sb.size() == 42);
7248 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7249
7250 s.reset(read_data, sizeof(read_data));
7251 s.next_read_length(1);
7252 sb.consume(sb.size());
7253 called = false;
7254 asio::async_read_at(s, 0, sb,
7255 asio::transfer_exactly(42),
7256 bindns::bind(async_read_handler,
7257 _1, _2, 42, &called));
7258 ioc.restart();
7259 ioc.run();
7260 ASIO_CHECK(called);
7261 ASIO_CHECK(sb.size() == 42);
7262 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7263
7264 s.reset(read_data, sizeof(read_data));
7265 s.next_read_length(1);
7266 sb.consume(sb.size());
7267 called = false;
7268 asio::async_read_at(s, 1234, sb,
7269 asio::transfer_exactly(42),
7270 bindns::bind(async_read_handler,
7271 _1, _2, 42, &called));
7272 ioc.restart();
7273 ioc.run();
7274 ASIO_CHECK(called);
7275 ASIO_CHECK(sb.size() == 42);
7276 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7277
7278 s.reset(read_data, sizeof(read_data));
7279 s.next_read_length(10);
7280 sb.consume(sb.size());
7281 called = false;
7282 asio::async_read_at(s, 0, sb,
7283 asio::transfer_exactly(42),
7284 bindns::bind(async_read_handler,
7285 _1, _2, 42, &called));
7286 ioc.restart();
7287 ioc.run();
7288 ASIO_CHECK(called);
7289 ASIO_CHECK(sb.size() == 42);
7290 ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
7291
7292 s.reset(read_data, sizeof(read_data));
7293 s.next_read_length(10);
7294 sb.consume(sb.size());
7295 called = false;
7296 asio::async_read_at(s, 1234, sb,
7297 asio::transfer_exactly(42),
7298 bindns::bind(async_read_handler,
7299 _1, _2, 42, &called));
7300 ioc.restart();
7301 ioc.run();
7302 ASIO_CHECK(called);
7303 ASIO_CHECK(sb.size() == 42);
7304 ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
7305
7306 s.reset(read_data, sizeof(read_data));
7307 sb.consume(sb.size());
7308 called = false;
7309 asio::async_read_at(s, 0, sb, old_style_transfer_all,
7310 bindns::bind(async_read_handler,
7311 _1, _2, sizeof(read_data), &called));
7312 ioc.restart();
7313 ioc.run();
7314 ASIO_CHECK(called);
7315 ASIO_CHECK(sb.size() == sizeof(read_data));
7316 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7317
7318 s.reset(read_data, sizeof(read_data));
7319 sb.consume(sb.size());
7320 called = false;
7321 asio::async_read_at(s, 1234, sb, old_style_transfer_all,
7322 bindns::bind(async_read_handler,
7323 _1, _2, sizeof(read_data), &called));
7324 ioc.restart();
7325 ioc.run();
7326 ASIO_CHECK(called);
7327 ASIO_CHECK(sb.size() == sizeof(read_data));
7328 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7329
7330 s.reset(read_data, sizeof(read_data));
7331 s.next_read_length(1);
7332 sb.consume(sb.size());
7333 called = false;
7334 asio::async_read_at(s, 0, sb, old_style_transfer_all,
7335 bindns::bind(async_read_handler,
7336 _1, _2, sizeof(read_data), &called));
7337 ioc.restart();
7338 ioc.run();
7339 ASIO_CHECK(called);
7340 ASIO_CHECK(sb.size() == sizeof(read_data));
7341 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7342
7343 s.reset(read_data, sizeof(read_data));
7344 s.next_read_length(1);
7345 sb.consume(sb.size());
7346 called = false;
7347 asio::async_read_at(s, 1234, sb, old_style_transfer_all,
7348 bindns::bind(async_read_handler,
7349 _1, _2, sizeof(read_data), &called));
7350 ioc.restart();
7351 ioc.run();
7352 ASIO_CHECK(called);
7353 ASIO_CHECK(sb.size() == sizeof(read_data));
7354 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7355
7356 s.reset(read_data, sizeof(read_data));
7357 s.next_read_length(10);
7358 sb.consume(sb.size());
7359 called = false;
7360 asio::async_read_at(s, 0, sb, old_style_transfer_all,
7361 bindns::bind(async_read_handler,
7362 _1, _2, sizeof(read_data), &called));
7363 ioc.restart();
7364 ioc.run();
7365 ASIO_CHECK(called);
7366 ASIO_CHECK(sb.size() == sizeof(read_data));
7367 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7368
7369 s.reset(read_data, sizeof(read_data));
7370 s.next_read_length(10);
7371 sb.consume(sb.size());
7372 called = false;
7373 asio::async_read_at(s, 1234, sb, old_style_transfer_all,
7374 bindns::bind(async_read_handler,
7375 _1, _2, sizeof(read_data), &called));
7376 ioc.restart();
7377 ioc.run();
7378 ASIO_CHECK(called);
7379 ASIO_CHECK(sb.size() == sizeof(read_data));
7380 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7381
7382 s.reset(read_data, sizeof(read_data));
7383 sb.consume(sb.size());
7384 called = false;
7385 asio::async_read_at(s, 0, sb, short_transfer,
7386 bindns::bind(async_read_handler,
7387 _1, _2, sizeof(read_data), &called));
7388 ioc.restart();
7389 ioc.run();
7390 ASIO_CHECK(called);
7391 ASIO_CHECK(sb.size() == sizeof(read_data));
7392 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7393
7394 s.reset(read_data, sizeof(read_data));
7395 sb.consume(sb.size());
7396 called = false;
7397 asio::async_read_at(s, 1234, sb, short_transfer,
7398 bindns::bind(async_read_handler,
7399 _1, _2, sizeof(read_data), &called));
7400 ioc.restart();
7401 ioc.run();
7402 ASIO_CHECK(called);
7403 ASIO_CHECK(sb.size() == sizeof(read_data));
7404 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7405
7406 s.reset(read_data, sizeof(read_data));
7407 s.next_read_length(1);
7408 sb.consume(sb.size());
7409 called = false;
7410 asio::async_read_at(s, 0, sb, short_transfer,
7411 bindns::bind(async_read_handler,
7412 _1, _2, sizeof(read_data), &called));
7413 ioc.restart();
7414 ioc.run();
7415 ASIO_CHECK(called);
7416 ASIO_CHECK(sb.size() == sizeof(read_data));
7417 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7418
7419 s.reset(read_data, sizeof(read_data));
7420 s.next_read_length(1);
7421 sb.consume(sb.size());
7422 called = false;
7423 asio::async_read_at(s, 1234, sb, short_transfer,
7424 bindns::bind(async_read_handler,
7425 _1, _2, sizeof(read_data), &called));
7426 ioc.restart();
7427 ioc.run();
7428 ASIO_CHECK(called);
7429 ASIO_CHECK(sb.size() == sizeof(read_data));
7430 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7431
7432 s.reset(read_data, sizeof(read_data));
7433 s.next_read_length(10);
7434 sb.consume(sb.size());
7435 called = false;
7436 asio::async_read_at(s, 0, sb, short_transfer,
7437 bindns::bind(async_read_handler,
7438 _1, _2, sizeof(read_data), &called));
7439 ioc.restart();
7440 ioc.run();
7441 ASIO_CHECK(called);
7442 ASIO_CHECK(sb.size() == sizeof(read_data));
7443 ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
7444
7445 s.reset(read_data, sizeof(read_data));
7446 s.next_read_length(10);
7447 sb.consume(sb.size());
7448 called = false;
7449 asio::async_read_at(s, 1234, sb, short_transfer,
7450 bindns::bind(async_read_handler,
7451 _1, _2, sizeof(read_data), &called));
7452 ioc.restart();
7453 ioc.run();
7454 ASIO_CHECK(called);
7455 ASIO_CHECK(sb.size() == sizeof(read_data));
7456 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7457
7458 s.reset(read_data, sizeof(read_data));
7459 sb.consume(sb.size());
7460 int i = asio::async_read_at(s, 1234, sb,
7461 short_transfer, archetypes::lazy_handler());
7462 ASIO_CHECK(i == 42);
7463 ioc.restart();
7464 ioc.run();
7465 ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
7466 }
7467
7468 ASIO_TEST_SUITE
7469 (
7470 "read_at",
7471 ASIO_TEST_CASE(test_3_arg_mutable_buffer_read_at)
7472 ASIO_TEST_CASE(test_3_arg_vector_buffers_read_at)
7473 ASIO_TEST_CASE(test_3_arg_streambuf_read_at)
7474 ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffer_read_at)
7475 ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_read_at)
7476 ASIO_TEST_CASE(test_4_arg_nothrow_streambuf_read_at)
7477 ASIO_TEST_CASE(test_4_arg_mutable_buffer_read_at)
7478 ASIO_TEST_CASE(test_4_arg_vector_buffers_read_at)
7479 ASIO_TEST_CASE(test_4_arg_streambuf_read_at)
7480 ASIO_TEST_CASE(test_5_arg_mutable_buffer_read_at)
7481 ASIO_TEST_CASE(test_5_arg_vector_buffers_read_at)
7482 ASIO_TEST_CASE(test_5_arg_streambuf_read_at)
7483 ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read_at)
7484 ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read_at)
7485 ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read_at)
7486 ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read_at)
7487 ASIO_TEST_CASE(test_4_arg_streambuf_async_read_at)
7488 ASIO_TEST_CASE(test_5_arg_mutable_buffer_async_read_at)
7489 ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_read_at)
7490 ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_read_at)
7491 ASIO_TEST_CASE(test_5_arg_vector_buffers_async_read_at)
7492 ASIO_TEST_CASE(test_5_arg_streambuf_async_read_at)
7493 )
7494