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