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
36namespace buffer_compile {
37
38using namespace boost::asio;
39
40void 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
242BOOST_ASIO_TEST_SUITE
243(
244 "buffer",
245 BOOST_ASIO_COMPILE_TEST_CASE(buffer_compile::test)
246)
247

source code of boost/libs/asio/test/buffer.cpp