]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // buffer.cpp | |
3 | // ~~~~~~~~~~ | |
4 | // | |
1e59de90 | 5 | // Copyright (c) 2003-2022 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); | |
92f5a8d4 | 75 | (void)mb3; |
7c673cae | 76 | |
b32b8144 FG |
77 | // mutable_buffer functions. |
78 | ||
79 | void* ptr1 = mb1.data(); | |
80 | (void)ptr1; | |
81 | ||
82 | std::size_t n1 = mb1.size(); | |
83 | (void)n1; | |
84 | ||
7c673cae FG |
85 | // mutable_buffer operators. |
86 | ||
b32b8144 | 87 | mb1 += 128; |
7c673cae FG |
88 | mb1 = mb2 + 128; |
89 | mb1 = 128 + mb2; | |
90 | ||
b32b8144 FG |
91 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
92 | ||
7c673cae FG |
93 | // mutable_buffers_1 constructors. |
94 | ||
95 | mutable_buffers_1 mbc1(mb1); | |
96 | mutable_buffers_1 mbc2(mbc1); | |
97 | ||
98 | // mutable_buffers_1 functions. | |
99 | ||
100 | mutable_buffers_1::const_iterator iter1 = mbc1.begin(); | |
101 | (void)iter1; | |
102 | mutable_buffers_1::const_iterator iter2 = mbc1.end(); | |
103 | (void)iter2; | |
104 | ||
b32b8144 FG |
105 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
106 | ||
7c673cae FG |
107 | // const_buffer constructors. |
108 | ||
109 | const_buffer cb1; | |
110 | const_buffer cb2(const_void_ptr_data, 1024); | |
111 | const_buffer cb3(cb1); | |
92f5a8d4 | 112 | (void)cb3; |
7c673cae | 113 | const_buffer cb4(mb1); |
92f5a8d4 | 114 | (void)cb4; |
7c673cae | 115 | |
b32b8144 FG |
116 | // const_buffer functions. |
117 | ||
118 | const void* ptr2 = cb1.data(); | |
119 | (void)ptr2; | |
120 | ||
121 | std::size_t n2 = cb1.size(); | |
122 | (void)n2; | |
123 | ||
7c673cae FG |
124 | // const_buffer operators. |
125 | ||
b32b8144 | 126 | cb1 += 128; |
7c673cae FG |
127 | cb1 = cb2 + 128; |
128 | cb1 = 128 + cb2; | |
129 | ||
b32b8144 FG |
130 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
131 | ||
7c673cae FG |
132 | // const_buffers_1 constructors. |
133 | ||
134 | const_buffers_1 cbc1(cb1); | |
135 | const_buffers_1 cbc2(cbc1); | |
136 | ||
137 | // const_buffers_1 functions. | |
138 | ||
139 | const_buffers_1::const_iterator iter3 = cbc1.begin(); | |
140 | (void)iter3; | |
141 | const_buffers_1::const_iterator iter4 = cbc1.end(); | |
142 | (void)iter4; | |
143 | ||
b32b8144 FG |
144 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
145 | ||
7c673cae FG |
146 | // buffer_size function overloads. |
147 | ||
148 | std::size_t size1 = buffer_size(mb1); | |
149 | (void)size1; | |
150 | std::size_t size2 = buffer_size(cb1); | |
151 | (void)size2; | |
b32b8144 | 152 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
153 | std::size_t size3 = buffer_size(mbc1); |
154 | (void)size3; | |
155 | std::size_t size4 = buffer_size(cbc1); | |
156 | (void)size4; | |
b32b8144 | 157 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
158 | std::size_t size5 = buffer_size(mutable_buffer_sequence); |
159 | (void)size5; | |
160 | std::size_t size6 = buffer_size(const_buffer_sequence); | |
161 | (void)size6; | |
162 | ||
163 | // buffer_cast function overloads. | |
164 | ||
b32b8144 FG |
165 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
166 | void* ptr3 = buffer_cast<void*>(mb1); | |
167 | (void)ptr3; | |
168 | const void* ptr4 = buffer_cast<const void*>(cb1); | |
169 | (void)ptr4; | |
170 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
7c673cae FG |
171 | |
172 | // buffer function overloads. | |
173 | ||
174 | mb1 = buffer(mb2); | |
175 | mb1 = buffer(mb2, 128); | |
176 | cb1 = buffer(cb2); | |
177 | cb1 = buffer(cb2, 128); | |
178 | mb1 = buffer(void_ptr_data, 1024); | |
179 | cb1 = buffer(const_void_ptr_data, 1024); | |
180 | mb1 = buffer(raw_data); | |
181 | mb1 = buffer(raw_data, 1024); | |
182 | cb1 = buffer(const_raw_data); | |
183 | cb1 = buffer(const_raw_data, 1024); | |
184 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
185 | mb1 = buffer(array_data); | |
186 | mb1 = buffer(array_data, 1024); | |
187 | cb1 = buffer(const_array_data_1); | |
188 | cb1 = buffer(const_array_data_1, 1024); | |
189 | cb1 = buffer(const_array_data_2); | |
190 | cb1 = buffer(const_array_data_2, 1024); | |
191 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
192 | #if defined(BOOST_ASIO_HAS_STD_ARRAY) | |
193 | mb1 = buffer(std_array_data); | |
194 | mb1 = buffer(std_array_data, 1024); | |
195 | cb1 = buffer(const_std_array_data_1); | |
196 | cb1 = buffer(const_std_array_data_1, 1024); | |
197 | cb1 = buffer(const_std_array_data_2); | |
198 | cb1 = buffer(const_std_array_data_2, 1024); | |
199 | #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) | |
200 | mb1 = buffer(vector_data); | |
201 | mb1 = buffer(vector_data, 1024); | |
202 | cb1 = buffer(const_vector_data); | |
203 | cb1 = buffer(const_vector_data, 1024); | |
b32b8144 FG |
204 | mb1 = buffer(string_data); |
205 | mb1 = buffer(string_data, 1024); | |
206 | cb1 = buffer(const_string_data); | |
207 | cb1 = buffer(const_string_data, 1024); | |
11fdf7f2 | 208 | #if defined(BOOST_ASIO_HAS_STRING_VIEW) |
b32b8144 FG |
209 | cb1 = buffer(string_view_data); |
210 | cb1 = buffer(string_view_data, 1024); | |
11fdf7f2 | 211 | #endif // defined(BOOST_ASIO_HAS_STRING_VIEW) |
7c673cae FG |
212 | |
213 | // buffer_copy function overloads. | |
214 | ||
215 | std::size_t size7 = buffer_copy(mb1, cb2); | |
216 | (void)size7; | |
b32b8144 | 217 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
218 | std::size_t size8 = buffer_copy(mb1, cbc2); |
219 | (void)size8; | |
b32b8144 | 220 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
221 | std::size_t size9 = buffer_copy(mb1, mb2); |
222 | (void)size9; | |
b32b8144 | 223 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
224 | std::size_t size10 = buffer_copy(mb1, mbc2); |
225 | (void)size10; | |
b32b8144 | 226 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
227 | std::size_t size11 = buffer_copy(mb1, const_buffer_sequence); |
228 | (void)size11; | |
b32b8144 | 229 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
230 | std::size_t size12 = buffer_copy(mbc1, cb2); |
231 | (void)size12; | |
232 | std::size_t size13 = buffer_copy(mbc1, cbc2); | |
233 | (void)size13; | |
234 | std::size_t size14 = buffer_copy(mbc1, mb2); | |
235 | (void)size14; | |
236 | std::size_t size15 = buffer_copy(mbc1, mbc2); | |
237 | (void)size15; | |
238 | std::size_t size16 = buffer_copy(mbc1, const_buffer_sequence); | |
239 | (void)size16; | |
b32b8144 | 240 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
241 | std::size_t size17 = buffer_copy(mutable_buffer_sequence, cb2); |
242 | (void)size17; | |
b32b8144 | 243 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
244 | std::size_t size18 = buffer_copy(mutable_buffer_sequence, cbc2); |
245 | (void)size18; | |
b32b8144 | 246 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
247 | std::size_t size19 = buffer_copy(mutable_buffer_sequence, mb2); |
248 | (void)size19; | |
b32b8144 | 249 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
250 | std::size_t size20 = buffer_copy(mutable_buffer_sequence, mbc2); |
251 | (void)size20; | |
b32b8144 | 252 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
253 | std::size_t size21 = buffer_copy( |
254 | mutable_buffer_sequence, const_buffer_sequence); | |
255 | (void)size21; | |
256 | std::size_t size22 = buffer_copy(mb1, cb2, 128); | |
257 | (void)size22; | |
b32b8144 | 258 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
259 | std::size_t size23 = buffer_copy(mb1, cbc2, 128); |
260 | (void)size23; | |
b32b8144 | 261 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
262 | std::size_t size24 = buffer_copy(mb1, mb2, 128); |
263 | (void)size24; | |
b32b8144 | 264 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
265 | std::size_t size25 = buffer_copy(mb1, mbc2, 128); |
266 | (void)size25; | |
b32b8144 | 267 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
268 | std::size_t size26 = buffer_copy(mb1, const_buffer_sequence, 128); |
269 | (void)size26; | |
b32b8144 | 270 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
271 | std::size_t size27 = buffer_copy(mbc1, cb2, 128); |
272 | (void)size27; | |
273 | std::size_t size28 = buffer_copy(mbc1, cbc2, 128); | |
274 | (void)size28; | |
275 | std::size_t size29 = buffer_copy(mbc1, mb2, 128); | |
276 | (void)size29; | |
277 | std::size_t size30 = buffer_copy(mbc1, mbc2, 128); | |
278 | (void)size30; | |
279 | std::size_t size31 = buffer_copy(mbc1, const_buffer_sequence, 128); | |
280 | (void)size31; | |
b32b8144 | 281 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
282 | std::size_t size32 = buffer_copy(mutable_buffer_sequence, cb2, 128); |
283 | (void)size32; | |
b32b8144 | 284 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
285 | std::size_t size33 = buffer_copy(mutable_buffer_sequence, cbc2, 128); |
286 | (void)size33; | |
b32b8144 | 287 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
288 | std::size_t size34 = buffer_copy(mutable_buffer_sequence, mb2, 128); |
289 | (void)size34; | |
b32b8144 | 290 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
291 | std::size_t size35 = buffer_copy(mutable_buffer_sequence, mbc2, 128); |
292 | (void)size35; | |
b32b8144 | 293 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
294 | std::size_t size36 = buffer_copy( |
295 | mutable_buffer_sequence, const_buffer_sequence, 128); | |
296 | (void)size36; | |
b32b8144 FG |
297 | |
298 | // dynamic_buffer function overloads. | |
299 | ||
300 | dynamic_string_buffer<char, std::string::traits_type, | |
301 | std::string::allocator_type> db1 = dynamic_buffer(string_data); | |
302 | (void)db1; | |
303 | dynamic_string_buffer<char, std::string::traits_type, | |
304 | std::string::allocator_type> db2 = dynamic_buffer(string_data, 1024); | |
305 | (void)db2; | |
306 | dynamic_vector_buffer<char, std::allocator<char> > | |
307 | db3 = dynamic_buffer(vector_data); | |
308 | (void)db3; | |
309 | dynamic_vector_buffer<char, std::allocator<char> > | |
310 | db4 = dynamic_buffer(vector_data, 1024); | |
311 | (void)db4; | |
312 | ||
313 | // dynamic_buffer member functions. | |
314 | ||
315 | std::size_t size37 = db1.size(); | |
316 | (void)size37; | |
317 | std::size_t size38 = db3.size(); | |
318 | (void)size38; | |
319 | ||
320 | std::size_t size39 = db1.max_size(); | |
321 | (void)size39; | |
322 | std::size_t size40 = db3.max_size(); | |
323 | (void)size40; | |
324 | ||
92f5a8d4 | 325 | #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1) |
b32b8144 FG |
326 | dynamic_string_buffer<char, std::string::traits_type, |
327 | std::string::allocator_type>::const_buffers_type | |
328 | cb5 = db1.data(); | |
329 | (void)cb5; | |
330 | dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type | |
331 | cb6 = db3.data(); | |
332 | (void)cb6; | |
333 | ||
334 | dynamic_string_buffer<char, std::string::traits_type, | |
335 | std::string::allocator_type>::mutable_buffers_type mb5 | |
336 | = db1.prepare(1024); | |
337 | (void)mb5; | |
338 | dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type | |
339 | mb6 = db3.prepare(1024); | |
340 | (void)mb6; | |
341 | ||
342 | db1.commit(1024); | |
343 | db3.commit(1024); | |
92f5a8d4 | 344 | #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1) |
b32b8144 | 345 | |
92f5a8d4 TL |
346 | dynamic_string_buffer<char, std::string::traits_type, |
347 | std::string::allocator_type>::mutable_buffers_type | |
348 | mb7 = db1.data(0, 1); | |
349 | (void)mb7; | |
350 | dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type | |
351 | mb8 = db3.data(0, 1); | |
352 | (void)mb8; | |
353 | ||
354 | dynamic_string_buffer<char, std::string::traits_type, | |
355 | std::string::allocator_type>::const_buffers_type | |
356 | cb7 = static_cast<const dynamic_string_buffer<char, | |
357 | std::string::traits_type, | |
358 | std::string::allocator_type>&>(db1).data(0, 1); | |
359 | (void)cb7; | |
360 | dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type | |
361 | cb8 = static_cast<const dynamic_vector_buffer<char, | |
362 | std::allocator<char> >&>(db3).data(0, 1); | |
363 | (void)cb8; | |
364 | ||
365 | db1.grow(1024); | |
366 | db3.grow(1024); | |
367 | ||
368 | db1.shrink(1024); | |
369 | db3.shrink(1024); | |
370 | ||
371 | db1.consume(0); | |
372 | db3.consume(0); | |
7c673cae FG |
373 | } |
374 | catch (std::exception&) | |
375 | { | |
376 | } | |
377 | } | |
378 | ||
379 | } // namespace buffer_compile | |
380 | ||
381 | //------------------------------------------------------------------------------ | |
382 | ||
b32b8144 FG |
383 | namespace buffer_copy_runtime { |
384 | ||
385 | using namespace boost::asio; | |
386 | using namespace std; | |
387 | ||
388 | void test() | |
389 | { | |
390 | char dest_data[256]; | |
391 | char source_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; | |
392 | ||
393 | memset(dest_data, 0, sizeof(dest_data)); | |
394 | mutable_buffer mb1 = boost::asio::buffer(dest_data); | |
395 | mutable_buffer mb2 = boost::asio::buffer(source_data); | |
396 | std::size_t n = buffer_copy(mb1, mb2); | |
397 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
398 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
399 | ||
400 | memset(dest_data, 0, sizeof(dest_data)); | |
401 | mb1 = boost::asio::buffer(dest_data); | |
402 | const_buffer cb1 = boost::asio::buffer(source_data); | |
403 | n = buffer_copy(mb1, cb1); | |
404 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
405 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
406 | ||
407 | #if !defined(BOOST_ASIO_NO_DEPRECATED) | |
408 | memset(dest_data, 0, sizeof(dest_data)); | |
409 | mb1 = boost::asio::buffer(dest_data); | |
410 | mutable_buffers_1 mbc1 = boost::asio::buffer(source_data); | |
411 | n = buffer_copy(mb1, mbc1); | |
412 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
413 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
414 | ||
415 | memset(dest_data, 0, sizeof(dest_data)); | |
416 | mb1 = boost::asio::buffer(dest_data); | |
417 | const_buffers_1 cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
418 | n = buffer_copy(mb1, cbc1); | |
419 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
420 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
421 | ||
422 | memset(dest_data, 0, sizeof(dest_data)); | |
423 | mbc1 = boost::asio::buffer(dest_data); | |
424 | mb1 = boost::asio::buffer(source_data); | |
425 | n = buffer_copy(mbc1, mb1); | |
426 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
427 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
428 | ||
429 | memset(dest_data, 0, sizeof(dest_data)); | |
430 | mbc1 = boost::asio::buffer(dest_data); | |
431 | cb1 = boost::asio::buffer(source_data); | |
432 | n = buffer_copy(mbc1, cb1); | |
433 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
434 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
435 | ||
436 | memset(dest_data, 0, sizeof(dest_data)); | |
437 | mbc1 = boost::asio::buffer(dest_data); | |
438 | mutable_buffers_1 mbc2 = boost::asio::buffer(source_data); | |
439 | n = buffer_copy(mbc1, mbc2); | |
440 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
441 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
442 | ||
443 | memset(dest_data, 0, sizeof(dest_data)); | |
444 | mbc1 = boost::asio::buffer(dest_data); | |
445 | cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
446 | n = buffer_copy(mbc1, cbc1); | |
447 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
448 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
449 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
450 | ||
451 | memset(dest_data, 0, sizeof(dest_data)); | |
452 | mb1 = boost::asio::buffer(dest_data); | |
453 | std::vector<mutable_buffer> mv1; | |
454 | mv1.push_back(boost::asio::buffer(source_data, 5)); | |
455 | mv1.push_back(boost::asio::buffer(source_data) + 5); | |
456 | n = buffer_copy(mb1, mv1); | |
457 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
458 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
459 | ||
460 | memset(dest_data, 0, sizeof(dest_data)); | |
461 | mb1 = boost::asio::buffer(dest_data); | |
462 | std::vector<const_buffer> cv1; | |
463 | cv1.push_back(boost::asio::buffer(source_data, 6)); | |
464 | cv1.push_back(boost::asio::buffer(source_data) + 6); | |
465 | n = buffer_copy(mb1, cv1); | |
466 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
467 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
468 | ||
469 | memset(dest_data, 0, sizeof(dest_data)); | |
470 | mv1.clear(); | |
471 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
472 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
473 | cb1 = boost::asio::buffer(source_data); | |
474 | n = buffer_copy(mv1, cb1); | |
475 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
476 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
477 | ||
478 | memset(dest_data, 0, sizeof(dest_data)); | |
479 | mv1.clear(); | |
480 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
481 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
482 | cv1.clear(); | |
483 | cv1.push_back(boost::asio::buffer(source_data, 8)); | |
484 | cv1.push_back(boost::asio::buffer(source_data) + 8); | |
485 | n = buffer_copy(mv1, cv1); | |
486 | BOOST_ASIO_CHECK(n == sizeof(source_data)); | |
487 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
488 | ||
489 | memset(dest_data, 0, sizeof(dest_data)); | |
490 | mb1 = boost::asio::buffer(dest_data); | |
491 | mb2 = boost::asio::buffer(source_data); | |
492 | n = buffer_copy(mb1, mb2, 10); | |
493 | BOOST_ASIO_CHECK(n == 10); | |
494 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
495 | ||
496 | memset(dest_data, 0, sizeof(dest_data)); | |
497 | mb1 = boost::asio::buffer(dest_data); | |
498 | cb1 = boost::asio::buffer(source_data); | |
499 | n = buffer_copy(mb1, cb1, 10); | |
500 | BOOST_ASIO_CHECK(n == 10); | |
501 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
502 | ||
503 | #if !defined(BOOST_ASIO_NO_DEPRECATED) | |
504 | memset(dest_data, 0, sizeof(dest_data)); | |
505 | mb1 = boost::asio::buffer(dest_data); | |
506 | mbc1 = boost::asio::buffer(source_data); | |
507 | n = buffer_copy(mb1, mbc1, 10); | |
508 | BOOST_ASIO_CHECK(n == 10); | |
509 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
510 | ||
511 | memset(dest_data, 0, sizeof(dest_data)); | |
512 | mb1 = boost::asio::buffer(dest_data); | |
513 | cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
514 | n = buffer_copy(mb1, cbc1, 10); | |
515 | BOOST_ASIO_CHECK(n == 10); | |
516 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
517 | ||
518 | memset(dest_data, 0, sizeof(dest_data)); | |
519 | mbc1 = boost::asio::buffer(dest_data); | |
520 | mb1 = boost::asio::buffer(source_data); | |
521 | n = buffer_copy(mbc1, mb1, 10); | |
522 | BOOST_ASIO_CHECK(n == 10); | |
523 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
524 | ||
525 | memset(dest_data, 0, sizeof(dest_data)); | |
526 | mbc1 = boost::asio::buffer(dest_data); | |
527 | cb1 = boost::asio::buffer(source_data); | |
528 | n = buffer_copy(mbc1, cb1, 10); | |
529 | BOOST_ASIO_CHECK(n == 10); | |
530 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
531 | ||
532 | memset(dest_data, 0, sizeof(dest_data)); | |
533 | mbc1 = boost::asio::buffer(dest_data); | |
534 | mbc2 = boost::asio::buffer(source_data); | |
535 | n = buffer_copy(mbc1, mbc2, 10); | |
536 | BOOST_ASIO_CHECK(n == 10); | |
537 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
538 | ||
539 | memset(dest_data, 0, sizeof(dest_data)); | |
540 | mbc1 = boost::asio::buffer(dest_data); | |
541 | cbc1 = const_buffers_1(boost::asio::buffer(source_data)); | |
542 | n = buffer_copy(mbc1, cbc1, 10); | |
543 | BOOST_ASIO_CHECK(n == 10); | |
544 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
545 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
546 | ||
547 | memset(dest_data, 0, sizeof(dest_data)); | |
548 | mb1 = boost::asio::buffer(dest_data); | |
549 | mv1.clear(); | |
550 | mv1.push_back(boost::asio::buffer(source_data, 5)); | |
551 | mv1.push_back(boost::asio::buffer(source_data) + 5); | |
552 | n = buffer_copy(mb1, mv1, 10); | |
553 | BOOST_ASIO_CHECK(n == 10); | |
554 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
555 | ||
556 | memset(dest_data, 0, sizeof(dest_data)); | |
557 | mb1 = boost::asio::buffer(dest_data); | |
558 | cv1.clear(); | |
559 | cv1.push_back(boost::asio::buffer(source_data, 6)); | |
560 | cv1.push_back(boost::asio::buffer(source_data) + 6); | |
561 | n = buffer_copy(mb1, cv1, 10); | |
562 | BOOST_ASIO_CHECK(n == 10); | |
563 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
564 | ||
565 | memset(dest_data, 0, sizeof(dest_data)); | |
566 | mv1.clear(); | |
567 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
568 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
569 | cb1 = boost::asio::buffer(source_data); | |
570 | n = buffer_copy(mv1, cb1, 10); | |
571 | BOOST_ASIO_CHECK(n == 10); | |
572 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
573 | ||
574 | memset(dest_data, 0, sizeof(dest_data)); | |
575 | mv1.clear(); | |
576 | mv1.push_back(boost::asio::buffer(dest_data, 7)); | |
577 | mv1.push_back(boost::asio::buffer(dest_data) + 7); | |
578 | cv1.clear(); | |
579 | cv1.push_back(boost::asio::buffer(source_data, 8)); | |
580 | cv1.push_back(boost::asio::buffer(source_data) + 8); | |
581 | n = buffer_copy(mv1, cv1, 10); | |
582 | BOOST_ASIO_CHECK(n == 10); | |
583 | BOOST_ASIO_CHECK(memcmp(dest_data, source_data, n) == 0); | |
584 | } | |
585 | ||
586 | } // namespace buffer_copy_runtime | |
587 | ||
588 | //------------------------------------------------------------------------------ | |
589 | ||
f67539c2 | 590 | namespace buffer_sequence { |
92f5a8d4 TL |
591 | |
592 | using namespace boost::asio; | |
593 | using namespace std; | |
594 | ||
595 | struct valid_const_a | |
596 | { | |
597 | typedef const_buffer* const_iterator; | |
598 | typedef const_buffer value_type; | |
599 | const_buffer* begin() const { return 0; } | |
600 | const_buffer* end() const { return 0; } | |
601 | }; | |
602 | ||
603 | #if defined(BOOST_ASIO_HAS_DECLTYPE) | |
604 | struct valid_const_b | |
605 | { | |
606 | const_buffer* begin() const { return 0; } | |
607 | const_buffer* end() const { return 0; } | |
608 | }; | |
609 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) | |
610 | ||
611 | struct valid_mutable_a | |
612 | { | |
613 | typedef mutable_buffer* const_iterator; | |
614 | typedef mutable_buffer value_type; | |
f67539c2 TL |
615 | mutable_buffer* begin() const { return 0; } |
616 | mutable_buffer* end() const { return 0; } | |
92f5a8d4 TL |
617 | }; |
618 | ||
619 | #if defined(BOOST_ASIO_HAS_DECLTYPE) | |
620 | struct valid_mutable_b | |
621 | { | |
622 | mutable_buffer* begin() const { return 0; } | |
623 | mutable_buffer* end() const { return 0; } | |
624 | }; | |
625 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) | |
626 | ||
627 | struct invalid_const_a | |
628 | { | |
629 | typedef int value_type; | |
630 | int* begin() const { return 0; } | |
631 | const_buffer* end() const { return 0; } | |
632 | }; | |
633 | ||
634 | struct invalid_const_b | |
635 | { | |
636 | typedef const_buffer value_type; | |
637 | const_buffer* begin() const { return 0; } | |
638 | }; | |
639 | ||
640 | struct invalid_const_c | |
641 | { | |
642 | typedef const_buffer value_type; | |
643 | const_buffer* end() const { return 0; } | |
644 | }; | |
645 | ||
646 | #if defined(BOOST_ASIO_HAS_DECLTYPE) | |
647 | struct invalid_const_d | |
648 | { | |
649 | int* begin() const { return 0; } | |
650 | const_buffer* end() const { return 0; } | |
651 | }; | |
652 | ||
653 | struct invalid_const_e | |
654 | { | |
655 | const_buffer* begin() const { return 0; } | |
656 | }; | |
657 | ||
658 | struct invalid_const_f | |
659 | { | |
660 | const_buffer* end() const { return 0; } | |
661 | }; | |
662 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) | |
663 | ||
664 | struct invalid_mutable_a | |
665 | { | |
666 | typedef int value_type; | |
667 | int* begin() const { return 0; } | |
668 | mutable_buffer* end() const { return 0; } | |
669 | }; | |
670 | ||
671 | struct invalid_mutable_b | |
672 | { | |
673 | typedef mutable_buffer value_type; | |
674 | mutable_buffer* begin() const { return 0; } | |
675 | }; | |
676 | ||
677 | struct invalid_mutable_c | |
678 | { | |
679 | typedef mutable_buffer value_type; | |
680 | mutable_buffer* end() const { return 0; } | |
681 | }; | |
682 | ||
683 | #if defined(BOOST_ASIO_HAS_DECLTYPE) | |
684 | struct invalid_mutable_d | |
685 | { | |
686 | int* begin() const { return 0; } | |
687 | mutable_buffer* end() const { return 0; } | |
688 | }; | |
689 | ||
690 | struct invalid_mutable_e | |
691 | { | |
692 | mutable_buffer* begin() const { return 0; } | |
693 | }; | |
694 | ||
695 | struct invalid_mutable_f | |
696 | { | |
697 | mutable_buffer* end() const { return 0; } | |
698 | }; | |
699 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) | |
700 | ||
701 | void test() | |
702 | { | |
703 | BOOST_ASIO_CHECK(is_const_buffer_sequence<const_buffer>::value); | |
704 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<const_buffer>::value); | |
705 | ||
f67539c2 TL |
706 | const_buffer b1; |
707 | BOOST_ASIO_CHECK(buffer_sequence_begin(b1) == &b1); | |
708 | BOOST_ASIO_CHECK(buffer_sequence_end(b1) == &b1 + 1); | |
709 | ||
92f5a8d4 TL |
710 | BOOST_ASIO_CHECK(is_const_buffer_sequence<mutable_buffer>::value); |
711 | BOOST_ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffer>::value); | |
712 | ||
f67539c2 TL |
713 | mutable_buffer b2; |
714 | BOOST_ASIO_CHECK(buffer_sequence_begin(b2) == &b2); | |
715 | BOOST_ASIO_CHECK(buffer_sequence_end(b2) == &b2 + 1); | |
716 | ||
92f5a8d4 TL |
717 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
718 | BOOST_ASIO_CHECK(is_const_buffer_sequence<const_buffers_1>::value); | |
719 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<const_buffers_1>::value); | |
720 | ||
f67539c2 TL |
721 | const_buffers_1 b3(0, 0); |
722 | BOOST_ASIO_CHECK(buffer_sequence_begin(b3) == &b3); | |
723 | BOOST_ASIO_CHECK(buffer_sequence_end(b3) == &b3 + 1); | |
724 | ||
92f5a8d4 TL |
725 | BOOST_ASIO_CHECK(is_const_buffer_sequence<mutable_buffers_1>::value); |
726 | BOOST_ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffers_1>::value); | |
f67539c2 TL |
727 | |
728 | mutable_buffers_1 b4(0, 0); | |
729 | BOOST_ASIO_CHECK(buffer_sequence_begin(b4) == &b4); | |
730 | BOOST_ASIO_CHECK(buffer_sequence_end(b4) == &b4 + 1); | |
92f5a8d4 TL |
731 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
732 | ||
733 | BOOST_ASIO_CHECK(is_const_buffer_sequence<vector<const_buffer> >::value); | |
734 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<vector<const_buffer> >::value); | |
735 | ||
f67539c2 TL |
736 | vector<const_buffer> b5; |
737 | BOOST_ASIO_CHECK(buffer_sequence_begin(b5) == b5.begin()); | |
738 | BOOST_ASIO_CHECK(buffer_sequence_end(b5) == b5.end()); | |
739 | ||
92f5a8d4 TL |
740 | BOOST_ASIO_CHECK(is_const_buffer_sequence<vector<mutable_buffer> >::value); |
741 | BOOST_ASIO_CHECK(is_mutable_buffer_sequence<vector<mutable_buffer> >::value); | |
742 | ||
f67539c2 TL |
743 | vector<mutable_buffer> b6; |
744 | BOOST_ASIO_CHECK(buffer_sequence_begin(b6) == b6.begin()); | |
745 | BOOST_ASIO_CHECK(buffer_sequence_end(b6) == b6.end()); | |
746 | ||
92f5a8d4 TL |
747 | BOOST_ASIO_CHECK(is_const_buffer_sequence<valid_const_a>::value); |
748 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_a>::value); | |
749 | ||
f67539c2 TL |
750 | valid_const_a b7; |
751 | BOOST_ASIO_CHECK(buffer_sequence_begin(b7) == b7.begin()); | |
752 | BOOST_ASIO_CHECK(buffer_sequence_end(b7) == b7.end()); | |
753 | ||
92f5a8d4 TL |
754 | #if defined(BOOST_ASIO_HAS_DECLTYPE) |
755 | BOOST_ASIO_CHECK(is_const_buffer_sequence<valid_const_b>::value); | |
756 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_b>::value); | |
f67539c2 TL |
757 | |
758 | valid_const_b b8; | |
759 | BOOST_ASIO_CHECK(buffer_sequence_begin(b8) == b8.begin()); | |
760 | BOOST_ASIO_CHECK(buffer_sequence_end(b8) == b8.end()); | |
92f5a8d4 TL |
761 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) |
762 | ||
763 | BOOST_ASIO_CHECK(is_const_buffer_sequence<valid_mutable_a>::value); | |
764 | BOOST_ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_a>::value); | |
765 | ||
f67539c2 TL |
766 | valid_mutable_a b9; |
767 | BOOST_ASIO_CHECK(buffer_sequence_begin(b9) == b9.begin()); | |
768 | BOOST_ASIO_CHECK(buffer_sequence_end(b9) == b9.end()); | |
769 | ||
92f5a8d4 TL |
770 | #if defined(BOOST_ASIO_HAS_DECLTYPE) |
771 | BOOST_ASIO_CHECK(is_const_buffer_sequence<valid_mutable_b>::value); | |
772 | BOOST_ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_b>::value); | |
f67539c2 TL |
773 | |
774 | valid_mutable_b b10; | |
775 | BOOST_ASIO_CHECK(buffer_sequence_begin(b10) == b10.begin()); | |
776 | BOOST_ASIO_CHECK(buffer_sequence_end(b10) == b10.end()); | |
92f5a8d4 TL |
777 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) |
778 | ||
779 | BOOST_ASIO_CHECK(!is_const_buffer_sequence<invalid_const_a>::value); | |
780 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_a>::value); | |
781 | ||
782 | BOOST_ASIO_CHECK(!is_const_buffer_sequence<invalid_const_b>::value); | |
783 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_b>::value); | |
784 | ||
785 | BOOST_ASIO_CHECK(!is_const_buffer_sequence<invalid_const_c>::value); | |
786 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_c>::value); | |
787 | ||
788 | #if defined(BOOST_ASIO_HAS_DECLTYPE) | |
789 | BOOST_ASIO_CHECK(!is_const_buffer_sequence<invalid_const_d>::value); | |
790 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_d>::value); | |
791 | ||
792 | BOOST_ASIO_CHECK(!is_const_buffer_sequence<invalid_const_e>::value); | |
793 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_e>::value); | |
794 | ||
795 | BOOST_ASIO_CHECK(!is_const_buffer_sequence<invalid_const_f>::value); | |
796 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_f>::value); | |
797 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) | |
798 | ||
799 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value); | |
800 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value); | |
801 | ||
802 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value); | |
803 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value); | |
804 | ||
805 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value); | |
806 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value); | |
807 | ||
808 | #if defined(BOOST_ASIO_HAS_DECLTYPE) | |
809 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value); | |
810 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value); | |
811 | ||
812 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value); | |
813 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value); | |
814 | ||
815 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value); | |
816 | BOOST_ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value); | |
817 | #endif // defined(BOOST_ASIO_HAS_DECLTYPE) | |
818 | } | |
819 | ||
f67539c2 | 820 | } // namespace buffer_sequence |
92f5a8d4 TL |
821 | |
822 | //------------------------------------------------------------------------------ | |
823 | ||
7c673cae FG |
824 | BOOST_ASIO_TEST_SUITE |
825 | ( | |
826 | "buffer", | |
827 | BOOST_ASIO_COMPILE_TEST_CASE(buffer_compile::test) | |
b32b8144 | 828 | BOOST_ASIO_TEST_CASE(buffer_copy_runtime::test) |
f67539c2 | 829 | BOOST_ASIO_TEST_CASE(buffer_sequence::test) |
7c673cae | 830 | ) |