]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // buffer.cpp | |
3 | // ~~~~~~~~~~ | |
4 | // | |
11fdf7f2 | 5 | // Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com) |
7c673cae FG |
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/buffer.hpp> | |
18 | ||
19 | #include "unit_test.hpp" | |
20 | ||
21 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
22 | # include <boost/array.hpp> | |
23 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
24 | ||
25 | #if defined(BOOST_ASIO_HAS_STD_ARRAY) | |
26 | # include <array> | |
27 | #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) | |
28 | ||
29 | //------------------------------------------------------------------------------ | |
30 | ||
31 | // buffer_compile test | |
32 | // ~~~~~~~~~~~~~~~~~~~ | |
33 | // The following test checks that all overloads of the buffer function compile | |
34 | // and link correctly. Runtime failures are ignored. | |
35 | ||
36 | namespace buffer_compile { | |
37 | ||
38 | using namespace boost::asio; | |
39 | ||
40 | void test() | |
41 | { | |
42 | try | |
43 | { | |
44 | char raw_data[1024]; | |
45 | const char const_raw_data[1024] = ""; | |
46 | void* void_ptr_data = raw_data; | |
47 | const void* const_void_ptr_data = const_raw_data; | |
48 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
49 | boost::array<char, 1024> array_data; | |
50 | const boost::array<char, 1024>& const_array_data_1 = array_data; | |
51 | boost::array<const char, 1024> const_array_data_2 = { { 0 } }; | |
52 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
53 | #if defined(BOOST_ASIO_HAS_STD_ARRAY) | |
54 | std::array<char, 1024> std_array_data; | |
55 | const std::array<char, 1024>& const_std_array_data_1 = std_array_data; | |
56 | std::array<const char, 1024> const_std_array_data_2 = { { 0 } }; | |
57 | #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) | |
58 | std::vector<char> vector_data(1024); | |
59 | const std::vector<char>& const_vector_data = vector_data; | |
b32b8144 FG |
60 | std::string string_data(1024, ' '); |
61 | const std::string const_string_data(1024, ' '); | |
7c673cae FG |
62 | std::vector<mutable_buffer> mutable_buffer_sequence; |
63 | std::vector<const_buffer> const_buffer_sequence; | |
b32b8144 | 64 | #if defined(BOOST_ASIO_HAS_STD_STRING_VIEW) |
b32b8144 | 65 | std::string_view string_view_data(string_data); |
11fdf7f2 TL |
66 | #elif defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) |
67 | std::experimental::string_view string_view_data(string_data); | |
68 | #endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) | |
7c673cae FG |
69 | |
70 | // mutable_buffer constructors. | |
71 | ||
72 | mutable_buffer mb1; | |
73 | mutable_buffer mb2(void_ptr_data, 1024); | |
74 | mutable_buffer mb3(mb1); | |
75 | ||
b32b8144 FG |
76 | // mutable_buffer functions. |
77 | ||
78 | void* ptr1 = mb1.data(); | |
79 | (void)ptr1; | |
80 | ||
81 | std::size_t n1 = mb1.size(); | |
82 | (void)n1; | |
83 | ||
7c673cae FG |
84 | // mutable_buffer operators. |
85 | ||
b32b8144 | 86 | mb1 += 128; |
7c673cae FG |
87 | mb1 = mb2 + 128; |
88 | mb1 = 128 + mb2; | |
89 | ||
b32b8144 FG |
90 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
91 | ||
7c673cae FG |
92 | // mutable_buffers_1 constructors. |
93 | ||
94 | mutable_buffers_1 mbc1(mb1); | |
95 | mutable_buffers_1 mbc2(mbc1); | |
96 | ||
97 | // mutable_buffers_1 functions. | |
98 | ||
99 | mutable_buffers_1::const_iterator iter1 = mbc1.begin(); | |
100 | (void)iter1; | |
101 | mutable_buffers_1::const_iterator iter2 = mbc1.end(); | |
102 | (void)iter2; | |
103 | ||
b32b8144 FG |
104 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
105 | ||
7c673cae FG |
106 | // const_buffer constructors. |
107 | ||
108 | const_buffer cb1; | |
109 | const_buffer cb2(const_void_ptr_data, 1024); | |
110 | const_buffer cb3(cb1); | |
111 | const_buffer cb4(mb1); | |
112 | ||
b32b8144 FG |
113 | // const_buffer functions. |
114 | ||
115 | const void* ptr2 = cb1.data(); | |
116 | (void)ptr2; | |
117 | ||
118 | std::size_t n2 = cb1.size(); | |
119 | (void)n2; | |
120 | ||
7c673cae FG |
121 | // const_buffer operators. |
122 | ||
b32b8144 | 123 | cb1 += 128; |
7c673cae FG |
124 | cb1 = cb2 + 128; |
125 | cb1 = 128 + cb2; | |
126 | ||
b32b8144 FG |
127 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
128 | ||
7c673cae FG |
129 | // const_buffers_1 constructors. |
130 | ||
131 | const_buffers_1 cbc1(cb1); | |
132 | const_buffers_1 cbc2(cbc1); | |
133 | ||
134 | // const_buffers_1 functions. | |
135 | ||
136 | const_buffers_1::const_iterator iter3 = cbc1.begin(); | |
137 | (void)iter3; | |
138 | const_buffers_1::const_iterator iter4 = cbc1.end(); | |
139 | (void)iter4; | |
140 | ||
b32b8144 FG |
141 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
142 | ||
7c673cae FG |
143 | // buffer_size function overloads. |
144 | ||
145 | std::size_t size1 = buffer_size(mb1); | |
146 | (void)size1; | |
147 | std::size_t size2 = buffer_size(cb1); | |
148 | (void)size2; | |
b32b8144 | 149 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
150 | std::size_t size3 = buffer_size(mbc1); |
151 | (void)size3; | |
152 | std::size_t size4 = buffer_size(cbc1); | |
153 | (void)size4; | |
b32b8144 | 154 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
155 | std::size_t size5 = buffer_size(mutable_buffer_sequence); |
156 | (void)size5; | |
157 | std::size_t size6 = buffer_size(const_buffer_sequence); | |
158 | (void)size6; | |
159 | ||
160 | // buffer_cast function overloads. | |
161 | ||
b32b8144 FG |
162 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
163 | void* ptr3 = buffer_cast<void*>(mb1); | |
164 | (void)ptr3; | |
165 | const void* ptr4 = buffer_cast<const void*>(cb1); | |
166 | (void)ptr4; | |
167 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
7c673cae FG |
168 | |
169 | // buffer function overloads. | |
170 | ||
171 | mb1 = buffer(mb2); | |
172 | mb1 = buffer(mb2, 128); | |
173 | cb1 = buffer(cb2); | |
174 | cb1 = buffer(cb2, 128); | |
175 | mb1 = buffer(void_ptr_data, 1024); | |
176 | cb1 = buffer(const_void_ptr_data, 1024); | |
177 | mb1 = buffer(raw_data); | |
178 | mb1 = buffer(raw_data, 1024); | |
179 | cb1 = buffer(const_raw_data); | |
180 | cb1 = buffer(const_raw_data, 1024); | |
181 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
182 | mb1 = buffer(array_data); | |
183 | mb1 = buffer(array_data, 1024); | |
184 | cb1 = buffer(const_array_data_1); | |
185 | cb1 = buffer(const_array_data_1, 1024); | |
186 | cb1 = buffer(const_array_data_2); | |
187 | cb1 = buffer(const_array_data_2, 1024); | |
188 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
189 | #if defined(BOOST_ASIO_HAS_STD_ARRAY) | |
190 | mb1 = buffer(std_array_data); | |
191 | mb1 = buffer(std_array_data, 1024); | |
192 | cb1 = buffer(const_std_array_data_1); | |
193 | cb1 = buffer(const_std_array_data_1, 1024); | |
194 | cb1 = buffer(const_std_array_data_2); | |
195 | cb1 = buffer(const_std_array_data_2, 1024); | |
196 | #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) | |
197 | mb1 = buffer(vector_data); | |
198 | mb1 = buffer(vector_data, 1024); | |
199 | cb1 = buffer(const_vector_data); | |
200 | cb1 = buffer(const_vector_data, 1024); | |
b32b8144 FG |
201 | mb1 = buffer(string_data); |
202 | mb1 = buffer(string_data, 1024); | |
203 | cb1 = buffer(const_string_data); | |
204 | cb1 = buffer(const_string_data, 1024); | |
11fdf7f2 | 205 | #if defined(BOOST_ASIO_HAS_STRING_VIEW) |
b32b8144 FG |
206 | cb1 = buffer(string_view_data); |
207 | cb1 = buffer(string_view_data, 1024); | |
11fdf7f2 | 208 | #endif // defined(BOOST_ASIO_HAS_STRING_VIEW) |
7c673cae FG |
209 | |
210 | // buffer_copy function overloads. | |
211 | ||
212 | std::size_t size7 = buffer_copy(mb1, cb2); | |
213 | (void)size7; | |
b32b8144 | 214 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
215 | std::size_t size8 = buffer_copy(mb1, cbc2); |
216 | (void)size8; | |
b32b8144 | 217 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
218 | std::size_t size9 = buffer_copy(mb1, mb2); |
219 | (void)size9; | |
b32b8144 | 220 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
221 | std::size_t size10 = buffer_copy(mb1, mbc2); |
222 | (void)size10; | |
b32b8144 | 223 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
224 | std::size_t size11 = buffer_copy(mb1, const_buffer_sequence); |
225 | (void)size11; | |
b32b8144 | 226 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
227 | std::size_t size12 = buffer_copy(mbc1, cb2); |
228 | (void)size12; | |
229 | std::size_t size13 = buffer_copy(mbc1, cbc2); | |
230 | (void)size13; | |
231 | std::size_t size14 = buffer_copy(mbc1, mb2); | |
232 | (void)size14; | |
233 | std::size_t size15 = buffer_copy(mbc1, mbc2); | |
234 | (void)size15; | |
235 | std::size_t size16 = buffer_copy(mbc1, const_buffer_sequence); | |
236 | (void)size16; | |
b32b8144 | 237 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
238 | std::size_t size17 = buffer_copy(mutable_buffer_sequence, cb2); |
239 | (void)size17; | |
b32b8144 | 240 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
241 | std::size_t size18 = buffer_copy(mutable_buffer_sequence, cbc2); |
242 | (void)size18; | |
b32b8144 | 243 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
244 | std::size_t size19 = buffer_copy(mutable_buffer_sequence, mb2); |
245 | (void)size19; | |
b32b8144 | 246 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
247 | std::size_t size20 = buffer_copy(mutable_buffer_sequence, mbc2); |
248 | (void)size20; | |
b32b8144 | 249 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
250 | std::size_t size21 = buffer_copy( |
251 | mutable_buffer_sequence, const_buffer_sequence); | |
252 | (void)size21; | |
253 | std::size_t size22 = buffer_copy(mb1, cb2, 128); | |
254 | (void)size22; | |
b32b8144 | 255 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
256 | std::size_t size23 = buffer_copy(mb1, cbc2, 128); |
257 | (void)size23; | |
b32b8144 | 258 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
259 | std::size_t size24 = buffer_copy(mb1, mb2, 128); |
260 | (void)size24; | |
b32b8144 | 261 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
262 | std::size_t size25 = buffer_copy(mb1, mbc2, 128); |
263 | (void)size25; | |
b32b8144 | 264 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
265 | std::size_t size26 = buffer_copy(mb1, const_buffer_sequence, 128); |
266 | (void)size26; | |
b32b8144 | 267 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
268 | std::size_t size27 = buffer_copy(mbc1, cb2, 128); |
269 | (void)size27; | |
270 | std::size_t size28 = buffer_copy(mbc1, cbc2, 128); | |
271 | (void)size28; | |
272 | std::size_t size29 = buffer_copy(mbc1, mb2, 128); | |
273 | (void)size29; | |
274 | std::size_t size30 = buffer_copy(mbc1, mbc2, 128); | |
275 | (void)size30; | |
276 | std::size_t size31 = buffer_copy(mbc1, const_buffer_sequence, 128); | |
277 | (void)size31; | |
b32b8144 | 278 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
279 | std::size_t size32 = buffer_copy(mutable_buffer_sequence, cb2, 128); |
280 | (void)size32; | |
b32b8144 | 281 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
282 | std::size_t size33 = buffer_copy(mutable_buffer_sequence, cbc2, 128); |
283 | (void)size33; | |
b32b8144 | 284 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
285 | std::size_t size34 = buffer_copy(mutable_buffer_sequence, mb2, 128); |
286 | (void)size34; | |
b32b8144 | 287 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
288 | std::size_t size35 = buffer_copy(mutable_buffer_sequence, mbc2, 128); |
289 | (void)size35; | |
b32b8144 | 290 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
291 | std::size_t size36 = buffer_copy( |
292 | mutable_buffer_sequence, const_buffer_sequence, 128); | |
293 | (void)size36; | |
b32b8144 FG |
294 | |
295 | // dynamic_buffer function overloads. | |
296 | ||
297 | dynamic_string_buffer<char, std::string::traits_type, | |
298 | std::string::allocator_type> db1 = dynamic_buffer(string_data); | |
299 | (void)db1; | |
300 | dynamic_string_buffer<char, std::string::traits_type, | |
301 | std::string::allocator_type> db2 = dynamic_buffer(string_data, 1024); | |
302 | (void)db2; | |
303 | dynamic_vector_buffer<char, std::allocator<char> > | |
304 | db3 = dynamic_buffer(vector_data); | |
305 | (void)db3; | |
306 | dynamic_vector_buffer<char, std::allocator<char> > | |
307 | db4 = dynamic_buffer(vector_data, 1024); | |
308 | (void)db4; | |
309 | ||
310 | // dynamic_buffer member functions. | |
311 | ||
312 | std::size_t size37 = db1.size(); | |
313 | (void)size37; | |
314 | std::size_t size38 = db3.size(); | |
315 | (void)size38; | |
316 | ||
317 | std::size_t size39 = db1.max_size(); | |
318 | (void)size39; | |
319 | std::size_t size40 = db3.max_size(); | |
320 | (void)size40; | |
321 | ||
322 | dynamic_string_buffer<char, std::string::traits_type, | |
323 | std::string::allocator_type>::const_buffers_type | |
324 | cb5 = db1.data(); | |
325 | (void)cb5; | |
326 | dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type | |
327 | cb6 = db3.data(); | |
328 | (void)cb6; | |
329 | ||
330 | dynamic_string_buffer<char, std::string::traits_type, | |
331 | std::string::allocator_type>::mutable_buffers_type mb5 | |
332 | = db1.prepare(1024); | |
333 | (void)mb5; | |
334 | dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type | |
335 | mb6 = db3.prepare(1024); | |
336 | (void)mb6; | |
337 | ||
338 | db1.commit(1024); | |
339 | db3.commit(1024); | |
340 | ||
341 | db1.consume(1024); | |
342 | db3.consume(1024); | |
7c673cae FG |
343 | } |
344 | catch (std::exception&) | |
345 | { | |
346 | } | |
347 | } | |
348 | ||
349 | } // namespace buffer_compile | |
350 | ||
351 | //------------------------------------------------------------------------------ | |
352 | ||
b32b8144 FG |
353 | namespace buffer_copy_runtime { |
354 | ||
355 | using namespace boost::asio; | |
356 | using namespace std; | |
357 | ||
358 | void test() | |
359 | { | |
360 | char dest_data[256]; | |
361 | char source_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; | |
362 | ||
363 | memset(dest_data, 0, sizeof(dest_data)); | |
364 | mutable_buffer mb1 = boost::asio::buffer(dest_data); | |
365 | mutable_buffer mb2 = boost::asio::buffer(source_data); | |
366 | std::size_t n = buffer_copy(mb1, mb2); | |
367 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
368 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
369 | ||
370 | memset(dest_data, 0, sizeof(dest_data)); | |
371 | mb1 = boost::asio::buffer(dest_data); | |
372 | const_buffer cb1 = boost::asio::buffer(source_data); | |
373 | n = buffer_copy(mb1, cb1); | |
374 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
375 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
376 | ||
377 | #if !defined(BOOST_ASIO_NO_DEPRECATED) | |
378 | memset(dest_data, 0, sizeof(dest_data)); | |
379 | mb1 = boost::asio::buffer(dest_data); | |
380 | mutable_buffers_1 mbc1 = boost::asio::buffer(source_data); | |
381 | n = buffer_copy(mb1, mbc1); | |
382 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
383 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
384 | ||
385 | memset(dest_data, 0, sizeof(dest_data)); | |
386 | mb1 = boost::asio::buffer(dest_data); | |
387 | const_buffers_1 cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
388 | n = buffer_copy(mb1, cbc1); | |
389 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
390 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
391 | ||
392 | memset(dest_data, 0, sizeof(dest_data)); | |
393 | mbc1 = boost::asio::buffer(dest_data); | |
394 | mb1 = boost::asio::buffer(source_data); | |
395 | n = buffer_copy(mbc1, mb1); | |
396 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
397 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
398 | ||
399 | memset(dest_data, 0, sizeof(dest_data)); | |
400 | mbc1 = boost::asio::buffer(dest_data); | |
401 | cb1 = boost::asio::buffer(source_data); | |
402 | n = buffer_copy(mbc1, cb1); | |
403 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
404 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
405 | ||
406 | memset(dest_data, 0, sizeof(dest_data)); | |
407 | mbc1 = boost::asio::buffer(dest_data); | |
408 | mutable_buffers_1 mbc2 = boost::asio::buffer(source_data); | |
409 | n = buffer_copy(mbc1, mbc2); | |
410 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
411 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
412 | ||
413 | memset(dest_data, 0, sizeof(dest_data)); | |
414 | mbc1 = boost::asio::buffer(dest_data); | |
415 | cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
416 | n = buffer_copy(mbc1, cbc1); | |
417 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
418 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
419 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
420 | ||
421 | memset(dest_data, 0, sizeof(dest_data)); | |
422 | mb1 = boost::asio::buffer(dest_data); | |
423 | std::vector<mutable_buffer> mv1; | |
424 | mv1.push_back(boost::asio::buffer(source_data, 5)); | |
425 | mv1.push_back(boost::asio::buffer(source_data) + 5); | |
426 | n = buffer_copy(mb1, mv1); | |
427 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
428 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
429 | ||
430 | memset(dest_data, 0, sizeof(dest_data)); | |
431 | mb1 = boost::asio::buffer(dest_data); | |
432 | std::vector<const_buffer> cv1; | |
433 | cv1.push_back(boost::asio::buffer(source_data, 6)); | |
434 | cv1.push_back(boost::asio::buffer(source_data) + 6); | |
435 | n = buffer_copy(mb1, cv1); | |
436 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
437 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
438 | ||
439 | memset(dest_data, 0, sizeof(dest_data)); | |
440 | mv1.clear(); | |
441 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
442 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
443 | cb1 = boost::asio::buffer(source_data); | |
444 | n = buffer_copy(mv1, cb1); | |
445 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
446 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
447 | ||
448 | memset(dest_data, 0, sizeof(dest_data)); | |
449 | mv1.clear(); | |
450 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
451 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
452 | cv1.clear(); | |
453 | cv1.push_back(boost::asio::buffer(source_data, 8)); | |
454 | cv1.push_back(boost::asio::buffer(source_data) + 8); | |
455 | n = buffer_copy(mv1, cv1); | |
456 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
457 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
458 | ||
459 | memset(dest_data, 0, sizeof(dest_data)); | |
460 | mb1 = boost::asio::buffer(dest_data); | |
461 | mb2 = boost::asio::buffer(source_data); | |
462 | n = buffer_copy(mb1, mb2, 10); | |
463 | BOOST_ASIO_CHECK(n == 10); | |
464 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
465 | ||
466 | memset(dest_data, 0, sizeof(dest_data)); | |
467 | mb1 = boost::asio::buffer(dest_data); | |
468 | cb1 = boost::asio::buffer(source_data); | |
469 | n = buffer_copy(mb1, cb1, 10); | |
470 | BOOST_ASIO_CHECK(n == 10); | |
471 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
472 | ||
473 | #if !defined(BOOST_ASIO_NO_DEPRECATED) | |
474 | memset(dest_data, 0, sizeof(dest_data)); | |
475 | mb1 = boost::asio::buffer(dest_data); | |
476 | mbc1 = boost::asio::buffer(source_data); | |
477 | n = buffer_copy(mb1, mbc1, 10); | |
478 | BOOST_ASIO_CHECK(n == 10); | |
479 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
480 | ||
481 | memset(dest_data, 0, sizeof(dest_data)); | |
482 | mb1 = boost::asio::buffer(dest_data); | |
483 | cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
484 | n = buffer_copy(mb1, cbc1, 10); | |
485 | BOOST_ASIO_CHECK(n == 10); | |
486 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
487 | ||
488 | memset(dest_data, 0, sizeof(dest_data)); | |
489 | mbc1 = boost::asio::buffer(dest_data); | |
490 | mb1 = boost::asio::buffer(source_data); | |
491 | n = buffer_copy(mbc1, mb1, 10); | |
492 | BOOST_ASIO_CHECK(n == 10); | |
493 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
494 | ||
495 | memset(dest_data, 0, sizeof(dest_data)); | |
496 | mbc1 = boost::asio::buffer(dest_data); | |
497 | cb1 = boost::asio::buffer(source_data); | |
498 | n = buffer_copy(mbc1, cb1, 10); | |
499 | BOOST_ASIO_CHECK(n == 10); | |
500 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
501 | ||
502 | memset(dest_data, 0, sizeof(dest_data)); | |
503 | mbc1 = boost::asio::buffer(dest_data); | |
504 | mbc2 = boost::asio::buffer(source_data); | |
505 | n = buffer_copy(mbc1, mbc2, 10); | |
506 | BOOST_ASIO_CHECK(n == 10); | |
507 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
508 | ||
509 | memset(dest_data, 0, sizeof(dest_data)); | |
510 | mbc1 = boost::asio::buffer(dest_data); | |
511 | cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
512 | n = buffer_copy(mbc1, cbc1, 10); | |
513 | BOOST_ASIO_CHECK(n == 10); | |
514 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
515 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
516 | ||
517 | memset(dest_data, 0, sizeof(dest_data)); | |
518 | mb1 = boost::asio::buffer(dest_data); | |
519 | mv1.clear(); | |
520 | mv1.push_back(boost::asio::buffer(source_data, 5)); | |
521 | mv1.push_back(boost::asio::buffer(source_data) + 5); | |
522 | n = buffer_copy(mb1, mv1, 10); | |
523 | BOOST_ASIO_CHECK(n == 10); | |
524 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
525 | ||
526 | memset(dest_data, 0, sizeof(dest_data)); | |
527 | mb1 = boost::asio::buffer(dest_data); | |
528 | cv1.clear(); | |
529 | cv1.push_back(boost::asio::buffer(source_data, 6)); | |
530 | cv1.push_back(boost::asio::buffer(source_data) + 6); | |
531 | n = buffer_copy(mb1, cv1, 10); | |
532 | BOOST_ASIO_CHECK(n == 10); | |
533 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
534 | ||
535 | memset(dest_data, 0, sizeof(dest_data)); | |
536 | mv1.clear(); | |
537 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
538 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
539 | cb1 = boost::asio::buffer(source_data); | |
540 | n = buffer_copy(mv1, cb1, 10); | |
541 | BOOST_ASIO_CHECK(n == 10); | |
542 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
543 | ||
544 | memset(dest_data, 0, sizeof(dest_data)); | |
545 | mv1.clear(); | |
546 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
547 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
548 | cv1.clear(); | |
549 | cv1.push_back(boost::asio::buffer(source_data, 8)); | |
550 | cv1.push_back(boost::asio::buffer(source_data) + 8); | |
551 | n = buffer_copy(mv1, cv1, 10); | |
552 | BOOST_ASIO_CHECK(n == 10); | |
553 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
554 | } | |
555 | ||
556 | } // namespace buffer_copy_runtime | |
557 | ||
558 | //------------------------------------------------------------------------------ | |
559 | ||
7c673cae FG |
560 | BOOST_ASIO_TEST_SUITE |
561 | ( | |
562 | "buffer", | |
563 | BOOST_ASIO_COMPILE_TEST_CASE(buffer_compile::test) | |
b32b8144 | 564 | BOOST_ASIO_TEST_CASE(buffer_copy_runtime::test) |
7c673cae | 565 | ) |