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