1 | // |
2 | // buffer.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/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 = { .elems: { 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 = { ._M_elems: { 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; |
60 | const std::string string_data(1024, ' '); |
61 | std::vector<mutable_buffer> mutable_buffer_sequence; |
62 | std::vector<const_buffer> const_buffer_sequence; |
63 | |
64 | // mutable_buffer constructors. |
65 | |
66 | mutable_buffer mb1; |
67 | mutable_buffer mb2(void_ptr_data, 1024); |
68 | mutable_buffer mb3(mb1); |
69 | |
70 | // mutable_buffer operators. |
71 | |
72 | mb1 = mb2 + 128; |
73 | mb1 = 128 + mb2; |
74 | |
75 | // mutable_buffers_1 constructors. |
76 | |
77 | mutable_buffers_1 mbc1(mb1); |
78 | mutable_buffers_1 mbc2(mbc1); |
79 | |
80 | // mutable_buffers_1 functions. |
81 | |
82 | mutable_buffers_1::const_iterator iter1 = mbc1.begin(); |
83 | (void)iter1; |
84 | mutable_buffers_1::const_iterator iter2 = mbc1.end(); |
85 | (void)iter2; |
86 | |
87 | // const_buffer constructors. |
88 | |
89 | const_buffer cb1; |
90 | const_buffer cb2(const_void_ptr_data, 1024); |
91 | const_buffer cb3(cb1); |
92 | const_buffer cb4(mb1); |
93 | |
94 | // const_buffer operators. |
95 | |
96 | cb1 = cb2 + 128; |
97 | cb1 = 128 + cb2; |
98 | |
99 | // const_buffers_1 constructors. |
100 | |
101 | const_buffers_1 cbc1(cb1); |
102 | const_buffers_1 cbc2(cbc1); |
103 | |
104 | // const_buffers_1 functions. |
105 | |
106 | const_buffers_1::const_iterator iter3 = cbc1.begin(); |
107 | (void)iter3; |
108 | const_buffers_1::const_iterator iter4 = cbc1.end(); |
109 | (void)iter4; |
110 | |
111 | // buffer_size function overloads. |
112 | |
113 | std::size_t size1 = buffer_size(b: mb1); |
114 | (void)size1; |
115 | std::size_t size2 = buffer_size(b: cb1); |
116 | (void)size2; |
117 | std::size_t size3 = buffer_size(b: mbc1); |
118 | (void)size3; |
119 | std::size_t size4 = buffer_size(b: cbc1); |
120 | (void)size4; |
121 | std::size_t size5 = buffer_size(b: mutable_buffer_sequence); |
122 | (void)size5; |
123 | std::size_t size6 = buffer_size(b: const_buffer_sequence); |
124 | (void)size6; |
125 | |
126 | // buffer_cast function overloads. |
127 | |
128 | void* ptr1 = buffer_cast<void*>(b: mb1); |
129 | (void)ptr1; |
130 | const void* ptr2 = buffer_cast<const void*>(b: cb1); |
131 | (void)ptr2; |
132 | |
133 | // buffer function overloads. |
134 | |
135 | mb1 = buffer(b: mb2); |
136 | mb1 = buffer(b: mb2, max_size_in_bytes: 128); |
137 | cb1 = buffer(b: cb2); |
138 | cb1 = buffer(b: cb2, max_size_in_bytes: 128); |
139 | mb1 = buffer(data: void_ptr_data, size_in_bytes: 1024); |
140 | cb1 = buffer(data: const_void_ptr_data, size_in_bytes: 1024); |
141 | mb1 = buffer(data&: raw_data); |
142 | mb1 = buffer(data&: raw_data, max_size_in_bytes: 1024); |
143 | cb1 = buffer(data: const_raw_data); |
144 | cb1 = buffer(data: const_raw_data, max_size_in_bytes: 1024); |
145 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) |
146 | mb1 = buffer(data&: array_data); |
147 | mb1 = buffer(data&: array_data, max_size_in_bytes: 1024); |
148 | cb1 = buffer(data: const_array_data_1); |
149 | cb1 = buffer(data: const_array_data_1, max_size_in_bytes: 1024); |
150 | cb1 = buffer(data&: const_array_data_2); |
151 | cb1 = buffer(data&: const_array_data_2, max_size_in_bytes: 1024); |
152 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) |
153 | #if defined(BOOST_ASIO_HAS_STD_ARRAY) |
154 | mb1 = buffer(data&: std_array_data); |
155 | mb1 = buffer(data&: std_array_data, max_size_in_bytes: 1024); |
156 | cb1 = buffer(data: const_std_array_data_1); |
157 | cb1 = buffer(data: const_std_array_data_1, max_size_in_bytes: 1024); |
158 | cb1 = buffer(data&: const_std_array_data_2); |
159 | cb1 = buffer(data&: const_std_array_data_2, max_size_in_bytes: 1024); |
160 | #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) |
161 | mb1 = buffer(data&: vector_data); |
162 | mb1 = buffer(data&: vector_data, max_size_in_bytes: 1024); |
163 | cb1 = buffer(data: const_vector_data); |
164 | cb1 = buffer(data: const_vector_data, max_size_in_bytes: 1024); |
165 | cb1 = buffer(data: string_data); |
166 | cb1 = buffer(data: string_data, max_size_in_bytes: 1024); |
167 | |
168 | // buffer_copy function overloads. |
169 | |
170 | std::size_t size7 = buffer_copy(target: mb1, source: cb2); |
171 | (void)size7; |
172 | std::size_t size8 = buffer_copy(target: mb1, source: cbc2); |
173 | (void)size8; |
174 | std::size_t size9 = buffer_copy(target: mb1, source: mb2); |
175 | (void)size9; |
176 | std::size_t size10 = buffer_copy(target: mb1, source: mbc2); |
177 | (void)size10; |
178 | std::size_t size11 = buffer_copy(target: mb1, source: const_buffer_sequence); |
179 | (void)size11; |
180 | std::size_t size12 = buffer_copy(target: mbc1, source: cb2); |
181 | (void)size12; |
182 | std::size_t size13 = buffer_copy(target: mbc1, source: cbc2); |
183 | (void)size13; |
184 | std::size_t size14 = buffer_copy(target: mbc1, source: mb2); |
185 | (void)size14; |
186 | std::size_t size15 = buffer_copy(target: mbc1, source: mbc2); |
187 | (void)size15; |
188 | std::size_t size16 = buffer_copy(target: mbc1, source: const_buffer_sequence); |
189 | (void)size16; |
190 | std::size_t size17 = buffer_copy(target: mutable_buffer_sequence, source: cb2); |
191 | (void)size17; |
192 | std::size_t size18 = buffer_copy(target: mutable_buffer_sequence, source: cbc2); |
193 | (void)size18; |
194 | std::size_t size19 = buffer_copy(target: mutable_buffer_sequence, source: mb2); |
195 | (void)size19; |
196 | std::size_t size20 = buffer_copy(target: mutable_buffer_sequence, source: mbc2); |
197 | (void)size20; |
198 | std::size_t size21 = buffer_copy( |
199 | target: mutable_buffer_sequence, source: const_buffer_sequence); |
200 | (void)size21; |
201 | std::size_t size22 = buffer_copy(target: mb1, source: cb2, max_bytes_to_copy: 128); |
202 | (void)size22; |
203 | std::size_t size23 = buffer_copy(target: mb1, source: cbc2, max_bytes_to_copy: 128); |
204 | (void)size23; |
205 | std::size_t size24 = buffer_copy(target: mb1, source: mb2, max_bytes_to_copy: 128); |
206 | (void)size24; |
207 | std::size_t size25 = buffer_copy(target: mb1, source: mbc2, max_bytes_to_copy: 128); |
208 | (void)size25; |
209 | std::size_t size26 = buffer_copy(target: mb1, source: const_buffer_sequence, max_bytes_to_copy: 128); |
210 | (void)size26; |
211 | std::size_t size27 = buffer_copy(target: mbc1, source: cb2, max_bytes_to_copy: 128); |
212 | (void)size27; |
213 | std::size_t size28 = buffer_copy(target: mbc1, source: cbc2, max_bytes_to_copy: 128); |
214 | (void)size28; |
215 | std::size_t size29 = buffer_copy(target: mbc1, source: mb2, max_bytes_to_copy: 128); |
216 | (void)size29; |
217 | std::size_t size30 = buffer_copy(target: mbc1, source: mbc2, max_bytes_to_copy: 128); |
218 | (void)size30; |
219 | std::size_t size31 = buffer_copy(target: mbc1, source: const_buffer_sequence, max_bytes_to_copy: 128); |
220 | (void)size31; |
221 | std::size_t size32 = buffer_copy(target: mutable_buffer_sequence, source: cb2, max_bytes_to_copy: 128); |
222 | (void)size32; |
223 | std::size_t size33 = buffer_copy(target: mutable_buffer_sequence, source: cbc2, max_bytes_to_copy: 128); |
224 | (void)size33; |
225 | std::size_t size34 = buffer_copy(target: mutable_buffer_sequence, source: mb2, max_bytes_to_copy: 128); |
226 | (void)size34; |
227 | std::size_t size35 = buffer_copy(target: mutable_buffer_sequence, source: mbc2, max_bytes_to_copy: 128); |
228 | (void)size35; |
229 | std::size_t size36 = buffer_copy( |
230 | target: mutable_buffer_sequence, source: const_buffer_sequence, max_bytes_to_copy: 128); |
231 | (void)size36; |
232 | } |
233 | catch (std::exception&) |
234 | { |
235 | } |
236 | } |
237 | |
238 | } // namespace buffer_compile |
239 | |
240 | //------------------------------------------------------------------------------ |
241 | |
242 | BOOST_ASIO_TEST_SUITE |
243 | ( |
244 | "buffer" , |
245 | BOOST_ASIO_COMPILE_TEST_CASE(buffer_compile::test) |
246 | ) |
247 | |