]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // tcp.cpp | |
3 | // ~~~~~~~ | |
4 | // | |
f67539c2 | 5 | // Copyright (c) 2003-2020 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 | // Enable cancel() support on Windows. | |
17 | #define BOOST_ASIO_ENABLE_CANCELIO 1 | |
18 | ||
19 | // Test that header file is self-contained. | |
20 | #include <boost/asio/ip/tcp.hpp> | |
21 | ||
22 | #include <cstring> | |
b32b8144 | 23 | #include <boost/asio/io_context.hpp> |
7c673cae FG |
24 | #include <boost/asio/read.hpp> |
25 | #include <boost/asio/write.hpp> | |
26 | #include "../unit_test.hpp" | |
7c673cae | 27 | #include "../archetypes/async_result.hpp" |
b32b8144 | 28 | #include "../archetypes/gettable_socket_option.hpp" |
7c673cae FG |
29 | #include "../archetypes/io_control_command.hpp" |
30 | #include "../archetypes/settable_socket_option.hpp" | |
31 | ||
32 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
33 | # include <boost/array.hpp> | |
34 | #else // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
35 | # include <array> | |
36 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
37 | ||
38 | #if defined(BOOST_ASIO_HAS_BOOST_BIND) | |
f67539c2 | 39 | # include <boost/bind/bind.hpp> |
7c673cae FG |
40 | #else // defined(BOOST_ASIO_HAS_BOOST_BIND) |
41 | # include <functional> | |
42 | #endif // defined(BOOST_ASIO_HAS_BOOST_BIND) | |
43 | ||
44 | //------------------------------------------------------------------------------ | |
45 | ||
46 | // ip_tcp_compile test | |
47 | // ~~~~~~~~~~~~~~~~~~~ | |
48 | // The following test checks that all nested classes, enums and constants in | |
49 | // ip::tcp compile and link correctly. Runtime failures are ignored. | |
50 | ||
51 | namespace ip_tcp_compile { | |
52 | ||
53 | void test() | |
54 | { | |
55 | using namespace boost::asio; | |
56 | namespace ip = boost::asio::ip; | |
57 | ||
58 | try | |
59 | { | |
b32b8144 FG |
60 | io_context ioc; |
61 | ip::tcp::socket sock(ioc); | |
7c673cae FG |
62 | |
63 | // no_delay class. | |
64 | ||
65 | ip::tcp::no_delay no_delay1(true); | |
66 | sock.set_option(no_delay1); | |
67 | ip::tcp::no_delay no_delay2; | |
68 | sock.get_option(no_delay2); | |
69 | no_delay1 = true; | |
70 | (void)static_cast<bool>(no_delay1); | |
71 | (void)static_cast<bool>(!no_delay1); | |
72 | (void)static_cast<bool>(no_delay1.value()); | |
73 | } | |
74 | catch (std::exception&) | |
75 | { | |
76 | } | |
77 | } | |
78 | ||
79 | } // namespace ip_tcp_compile | |
80 | ||
81 | //------------------------------------------------------------------------------ | |
82 | ||
83 | // ip_tcp_runtime test | |
84 | // ~~~~~~~~~~~~~~~~~~~ | |
85 | // The following test checks the runtime operation of the ip::tcp class. | |
86 | ||
87 | namespace ip_tcp_runtime { | |
88 | ||
89 | void test() | |
90 | { | |
91 | using namespace boost::asio; | |
92 | namespace ip = boost::asio::ip; | |
93 | ||
b32b8144 FG |
94 | io_context ioc; |
95 | ip::tcp::socket sock(ioc, ip::tcp::v4()); | |
7c673cae FG |
96 | boost::system::error_code ec; |
97 | ||
98 | // no_delay class. | |
99 | ||
100 | ip::tcp::no_delay no_delay1(true); | |
101 | BOOST_ASIO_CHECK(no_delay1.value()); | |
102 | BOOST_ASIO_CHECK(static_cast<bool>(no_delay1)); | |
103 | BOOST_ASIO_CHECK(!!no_delay1); | |
104 | sock.set_option(no_delay1, ec); | |
105 | BOOST_ASIO_CHECK(!ec); | |
106 | ||
107 | ip::tcp::no_delay no_delay2; | |
108 | sock.get_option(no_delay2, ec); | |
109 | BOOST_ASIO_CHECK(!ec); | |
110 | BOOST_ASIO_CHECK(no_delay2.value()); | |
111 | BOOST_ASIO_CHECK(static_cast<bool>(no_delay2)); | |
112 | BOOST_ASIO_CHECK(!!no_delay2); | |
113 | ||
114 | ip::tcp::no_delay no_delay3(false); | |
115 | BOOST_ASIO_CHECK(!no_delay3.value()); | |
116 | BOOST_ASIO_CHECK(!static_cast<bool>(no_delay3)); | |
117 | BOOST_ASIO_CHECK(!no_delay3); | |
118 | sock.set_option(no_delay3, ec); | |
119 | BOOST_ASIO_CHECK(!ec); | |
120 | ||
121 | ip::tcp::no_delay no_delay4; | |
122 | sock.get_option(no_delay4, ec); | |
123 | BOOST_ASIO_CHECK(!ec); | |
124 | BOOST_ASIO_CHECK(!no_delay4.value()); | |
125 | BOOST_ASIO_CHECK(!static_cast<bool>(no_delay4)); | |
126 | BOOST_ASIO_CHECK(!no_delay4); | |
127 | } | |
128 | ||
129 | } // namespace ip_tcp_runtime | |
130 | ||
131 | //------------------------------------------------------------------------------ | |
132 | ||
133 | // ip_tcp_socket_compile test | |
134 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
135 | // The following test checks that all public member functions on the class | |
136 | // ip::tcp::socket compile and link correctly. Runtime failures are ignored. | |
137 | ||
138 | namespace ip_tcp_socket_compile { | |
139 | ||
b32b8144 | 140 | struct connect_handler |
7c673cae | 141 | { |
b32b8144 FG |
142 | connect_handler() {} |
143 | void operator()(const boost::system::error_code&) {} | |
144 | #if defined(BOOST_ASIO_HAS_MOVE) | |
145 | connect_handler(connect_handler&&) {} | |
146 | private: | |
147 | connect_handler(const connect_handler&); | |
148 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
149 | }; | |
7c673cae | 150 | |
b32b8144 | 151 | struct wait_handler |
7c673cae | 152 | { |
b32b8144 FG |
153 | wait_handler() {} |
154 | void operator()(const boost::system::error_code&) {} | |
155 | #if defined(BOOST_ASIO_HAS_MOVE) | |
156 | wait_handler(wait_handler&&) {} | |
157 | private: | |
158 | wait_handler(const wait_handler&); | |
159 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
160 | }; | |
7c673cae | 161 | |
b32b8144 | 162 | struct send_handler |
7c673cae | 163 | { |
b32b8144 FG |
164 | send_handler() {} |
165 | void operator()(const boost::system::error_code&, std::size_t) {} | |
166 | #if defined(BOOST_ASIO_HAS_MOVE) | |
167 | send_handler(send_handler&&) {} | |
168 | private: | |
169 | send_handler(const send_handler&); | |
170 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
171 | }; | |
7c673cae | 172 | |
b32b8144 | 173 | struct receive_handler |
7c673cae | 174 | { |
b32b8144 FG |
175 | receive_handler() {} |
176 | void operator()(const boost::system::error_code&, std::size_t) {} | |
177 | #if defined(BOOST_ASIO_HAS_MOVE) | |
178 | receive_handler(receive_handler&&) {} | |
179 | private: | |
180 | receive_handler(const receive_handler&); | |
181 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
182 | }; | |
7c673cae | 183 | |
b32b8144 | 184 | struct write_some_handler |
7c673cae | 185 | { |
b32b8144 FG |
186 | write_some_handler() {} |
187 | void operator()(const boost::system::error_code&, std::size_t) {} | |
188 | #if defined(BOOST_ASIO_HAS_MOVE) | |
189 | write_some_handler(write_some_handler&&) {} | |
190 | private: | |
191 | write_some_handler(const write_some_handler&); | |
192 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
193 | }; | |
194 | ||
195 | struct read_some_handler | |
196 | { | |
197 | read_some_handler() {} | |
198 | void operator()(const boost::system::error_code&, std::size_t) {} | |
199 | #if defined(BOOST_ASIO_HAS_MOVE) | |
200 | read_some_handler(read_some_handler&&) {} | |
201 | private: | |
202 | read_some_handler(const read_some_handler&); | |
203 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
204 | }; | |
7c673cae FG |
205 | |
206 | void test() | |
207 | { | |
208 | #if defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
209 | using boost::array; | |
210 | #else // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
211 | using std::array; | |
212 | #endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY) | |
213 | ||
214 | using namespace boost::asio; | |
215 | namespace ip = boost::asio::ip; | |
216 | ||
217 | try | |
218 | { | |
b32b8144 | 219 | io_context ioc; |
92f5a8d4 | 220 | const io_context::executor_type ioc_ex = ioc.get_executor(); |
7c673cae FG |
221 | char mutable_char_buffer[128] = ""; |
222 | const char const_char_buffer[128] = ""; | |
223 | array<boost::asio::mutable_buffer, 2> mutable_buffers = {{ | |
224 | boost::asio::buffer(mutable_char_buffer, 10), | |
225 | boost::asio::buffer(mutable_char_buffer + 10, 10) }}; | |
226 | array<boost::asio::const_buffer, 2> const_buffers = {{ | |
227 | boost::asio::buffer(const_char_buffer, 10), | |
228 | boost::asio::buffer(const_char_buffer + 10, 10) }}; | |
229 | socket_base::message_flags in_flags = 0; | |
230 | archetypes::settable_socket_option<void> settable_socket_option1; | |
231 | archetypes::settable_socket_option<int> settable_socket_option2; | |
232 | archetypes::settable_socket_option<double> settable_socket_option3; | |
233 | archetypes::gettable_socket_option<void> gettable_socket_option1; | |
234 | archetypes::gettable_socket_option<int> gettable_socket_option2; | |
235 | archetypes::gettable_socket_option<double> gettable_socket_option3; | |
236 | archetypes::io_control_command io_control_command; | |
237 | archetypes::lazy_handler lazy; | |
238 | boost::system::error_code ec; | |
239 | ||
240 | // basic_stream_socket constructors. | |
241 | ||
b32b8144 FG |
242 | ip::tcp::socket socket1(ioc); |
243 | ip::tcp::socket socket2(ioc, ip::tcp::v4()); | |
244 | ip::tcp::socket socket3(ioc, ip::tcp::v6()); | |
245 | ip::tcp::socket socket4(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
246 | ip::tcp::socket socket5(ioc, ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
7c673cae FG |
247 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) |
248 | ip::tcp::socket::native_handle_type native_socket1 | |
249 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
b32b8144 | 250 | ip::tcp::socket socket6(ioc, ip::tcp::v4(), native_socket1); |
7c673cae FG |
251 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) |
252 | ||
92f5a8d4 TL |
253 | ip::tcp::socket socket7(ioc_ex); |
254 | ip::tcp::socket socket8(ioc_ex, ip::tcp::v4()); | |
255 | ip::tcp::socket socket9(ioc_ex, ip::tcp::v6()); | |
256 | ip::tcp::socket socket10(ioc_ex, ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
257 | ip::tcp::socket socket11(ioc_ex, ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
258 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
259 | ip::tcp::socket::native_handle_type native_socket2 | |
260 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
261 | ip::tcp::socket socket12(ioc_ex, ip::tcp::v4(), native_socket2); | |
262 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
263 | ||
7c673cae | 264 | #if defined(BOOST_ASIO_HAS_MOVE) |
92f5a8d4 | 265 | ip::tcp::socket socket13(std::move(socket5)); |
7c673cae FG |
266 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
267 | ||
268 | // basic_stream_socket operators. | |
269 | ||
270 | #if defined(BOOST_ASIO_HAS_MOVE) | |
b32b8144 | 271 | socket1 = ip::tcp::socket(ioc); |
7c673cae FG |
272 | socket1 = std::move(socket2); |
273 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
274 | ||
275 | // basic_io_object functions. | |
276 | ||
b32b8144 FG |
277 | ip::tcp::socket::executor_type ex = socket1.get_executor(); |
278 | (void)ex; | |
7c673cae FG |
279 | |
280 | // basic_socket functions. | |
281 | ||
282 | ip::tcp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer(); | |
283 | (void)lowest_layer; | |
284 | ||
92f5a8d4 | 285 | const ip::tcp::socket& socket14 = socket1; |
7c673cae | 286 | const ip::tcp::socket::lowest_layer_type& lowest_layer2 |
92f5a8d4 | 287 | = socket14.lowest_layer(); |
7c673cae FG |
288 | (void)lowest_layer2; |
289 | ||
290 | socket1.open(ip::tcp::v4()); | |
291 | socket1.open(ip::tcp::v6()); | |
292 | socket1.open(ip::tcp::v4(), ec); | |
293 | socket1.open(ip::tcp::v6(), ec); | |
294 | ||
295 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
7c673cae FG |
296 | ip::tcp::socket::native_handle_type native_socket3 |
297 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
92f5a8d4 TL |
298 | socket1.assign(ip::tcp::v4(), native_socket3); |
299 | ip::tcp::socket::native_handle_type native_socket4 | |
300 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
301 | socket1.assign(ip::tcp::v4(), native_socket4, ec); | |
7c673cae FG |
302 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) |
303 | ||
304 | bool is_open = socket1.is_open(); | |
305 | (void)is_open; | |
306 | ||
307 | socket1.close(); | |
308 | socket1.close(ec); | |
309 | ||
b32b8144 FG |
310 | socket1.release(); |
311 | socket1.release(ec); | |
7c673cae | 312 | |
92f5a8d4 | 313 | ip::tcp::socket::native_handle_type native_socket5 |
7c673cae | 314 | = socket1.native_handle(); |
92f5a8d4 | 315 | (void)native_socket5; |
7c673cae FG |
316 | |
317 | socket1.cancel(); | |
318 | socket1.cancel(ec); | |
319 | ||
320 | bool at_mark1 = socket1.at_mark(); | |
321 | (void)at_mark1; | |
322 | bool at_mark2 = socket1.at_mark(ec); | |
323 | (void)at_mark2; | |
324 | ||
325 | std::size_t available1 = socket1.available(); | |
326 | (void)available1; | |
327 | std::size_t available2 = socket1.available(ec); | |
328 | (void)available2; | |
329 | ||
330 | socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
331 | socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
332 | socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), ec); | |
333 | socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), ec); | |
334 | ||
335 | socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
336 | socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
337 | socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0), ec); | |
338 | socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0), ec); | |
339 | ||
340 | socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), | |
b32b8144 | 341 | connect_handler()); |
7c673cae | 342 | socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), |
b32b8144 | 343 | connect_handler()); |
7c673cae FG |
344 | int i1 = socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), lazy); |
345 | (void)i1; | |
346 | int i2 = socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), lazy); | |
347 | (void)i2; | |
348 | ||
349 | socket1.set_option(settable_socket_option1); | |
350 | socket1.set_option(settable_socket_option1, ec); | |
351 | socket1.set_option(settable_socket_option2); | |
352 | socket1.set_option(settable_socket_option2, ec); | |
353 | socket1.set_option(settable_socket_option3); | |
354 | socket1.set_option(settable_socket_option3, ec); | |
355 | ||
356 | socket1.get_option(gettable_socket_option1); | |
357 | socket1.get_option(gettable_socket_option1, ec); | |
358 | socket1.get_option(gettable_socket_option2); | |
359 | socket1.get_option(gettable_socket_option2, ec); | |
360 | socket1.get_option(gettable_socket_option3); | |
361 | socket1.get_option(gettable_socket_option3, ec); | |
362 | ||
363 | socket1.io_control(io_control_command); | |
364 | socket1.io_control(io_control_command, ec); | |
365 | ||
366 | bool non_blocking1 = socket1.non_blocking(); | |
367 | (void)non_blocking1; | |
368 | socket1.non_blocking(true); | |
369 | socket1.non_blocking(false, ec); | |
370 | ||
371 | bool non_blocking2 = socket1.native_non_blocking(); | |
372 | (void)non_blocking2; | |
373 | socket1.native_non_blocking(true); | |
374 | socket1.native_non_blocking(false, ec); | |
375 | ||
376 | ip::tcp::endpoint endpoint1 = socket1.local_endpoint(); | |
92f5a8d4 | 377 | (void)endpoint1; |
7c673cae | 378 | ip::tcp::endpoint endpoint2 = socket1.local_endpoint(ec); |
92f5a8d4 | 379 | (void)endpoint2; |
7c673cae FG |
380 | |
381 | ip::tcp::endpoint endpoint3 = socket1.remote_endpoint(); | |
92f5a8d4 | 382 | (void)endpoint3; |
7c673cae | 383 | ip::tcp::endpoint endpoint4 = socket1.remote_endpoint(ec); |
92f5a8d4 | 384 | (void)endpoint4; |
7c673cae FG |
385 | |
386 | socket1.shutdown(socket_base::shutdown_both); | |
387 | socket1.shutdown(socket_base::shutdown_both, ec); | |
388 | ||
b32b8144 FG |
389 | socket1.wait(socket_base::wait_read); |
390 | socket1.wait(socket_base::wait_write, ec); | |
391 | ||
392 | socket1.async_wait(socket_base::wait_read, wait_handler()); | |
393 | int i3 = socket1.async_wait(socket_base::wait_write, lazy); | |
394 | (void)i3; | |
b32b8144 | 395 | |
7c673cae FG |
396 | // basic_stream_socket functions. |
397 | ||
398 | socket1.send(buffer(mutable_char_buffer)); | |
399 | socket1.send(buffer(const_char_buffer)); | |
400 | socket1.send(mutable_buffers); | |
401 | socket1.send(const_buffers); | |
402 | socket1.send(null_buffers()); | |
403 | socket1.send(buffer(mutable_char_buffer), in_flags); | |
404 | socket1.send(buffer(const_char_buffer), in_flags); | |
405 | socket1.send(mutable_buffers, in_flags); | |
406 | socket1.send(const_buffers, in_flags); | |
407 | socket1.send(null_buffers(), in_flags); | |
408 | socket1.send(buffer(mutable_char_buffer), in_flags, ec); | |
409 | socket1.send(buffer(const_char_buffer), in_flags, ec); | |
410 | socket1.send(mutable_buffers, in_flags, ec); | |
411 | socket1.send(const_buffers, in_flags, ec); | |
412 | socket1.send(null_buffers(), in_flags, ec); | |
413 | ||
b32b8144 FG |
414 | socket1.async_send(buffer(mutable_char_buffer), send_handler()); |
415 | socket1.async_send(buffer(const_char_buffer), send_handler()); | |
416 | socket1.async_send(mutable_buffers, send_handler()); | |
417 | socket1.async_send(const_buffers, send_handler()); | |
418 | socket1.async_send(null_buffers(), send_handler()); | |
419 | socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler()); | |
420 | socket1.async_send(buffer(const_char_buffer), in_flags, send_handler()); | |
421 | socket1.async_send(mutable_buffers, in_flags, send_handler()); | |
422 | socket1.async_send(const_buffers, in_flags, send_handler()); | |
423 | socket1.async_send(null_buffers(), in_flags, send_handler()); | |
424 | int i4 = socket1.async_send(buffer(mutable_char_buffer), lazy); | |
7c673cae | 425 | (void)i4; |
b32b8144 | 426 | int i5 = socket1.async_send(buffer(const_char_buffer), lazy); |
7c673cae | 427 | (void)i5; |
b32b8144 | 428 | int i6 = socket1.async_send(mutable_buffers, lazy); |
7c673cae | 429 | (void)i6; |
b32b8144 | 430 | int i7 = socket1.async_send(const_buffers, lazy); |
7c673cae | 431 | (void)i7; |
b32b8144 | 432 | int i8 = socket1.async_send(null_buffers(), lazy); |
7c673cae | 433 | (void)i8; |
b32b8144 | 434 | int i9 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy); |
7c673cae | 435 | (void)i9; |
b32b8144 | 436 | int i10 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy); |
7c673cae | 437 | (void)i10; |
b32b8144 | 438 | int i11 = socket1.async_send(mutable_buffers, in_flags, lazy); |
7c673cae | 439 | (void)i11; |
b32b8144 | 440 | int i12 = socket1.async_send(const_buffers, in_flags, lazy); |
7c673cae | 441 | (void)i12; |
b32b8144 FG |
442 | int i13 = socket1.async_send(null_buffers(), in_flags, lazy); |
443 | (void)i13; | |
7c673cae FG |
444 | |
445 | socket1.receive(buffer(mutable_char_buffer)); | |
446 | socket1.receive(mutable_buffers); | |
447 | socket1.receive(null_buffers()); | |
448 | socket1.receive(buffer(mutable_char_buffer), in_flags); | |
449 | socket1.receive(mutable_buffers, in_flags); | |
450 | socket1.receive(null_buffers(), in_flags); | |
451 | socket1.receive(buffer(mutable_char_buffer), in_flags, ec); | |
452 | socket1.receive(mutable_buffers, in_flags, ec); | |
453 | socket1.receive(null_buffers(), in_flags, ec); | |
454 | ||
b32b8144 FG |
455 | socket1.async_receive(buffer(mutable_char_buffer), receive_handler()); |
456 | socket1.async_receive(mutable_buffers, receive_handler()); | |
457 | socket1.async_receive(null_buffers(), receive_handler()); | |
7c673cae | 458 | socket1.async_receive(buffer(mutable_char_buffer), in_flags, |
b32b8144 FG |
459 | receive_handler()); |
460 | socket1.async_receive(mutable_buffers, in_flags, receive_handler()); | |
461 | socket1.async_receive(null_buffers(), in_flags, receive_handler()); | |
462 | int i14 = socket1.async_receive(buffer(mutable_char_buffer), lazy); | |
7c673cae | 463 | (void)i14; |
b32b8144 | 464 | int i15 = socket1.async_receive(mutable_buffers, lazy); |
7c673cae | 465 | (void)i15; |
b32b8144 | 466 | int i16 = socket1.async_receive(null_buffers(), lazy); |
7c673cae | 467 | (void)i16; |
b32b8144 FG |
468 | int i17 = socket1.async_receive(buffer(mutable_char_buffer), in_flags, |
469 | lazy); | |
7c673cae | 470 | (void)i17; |
b32b8144 | 471 | int i18 = socket1.async_receive(mutable_buffers, in_flags, lazy); |
7c673cae | 472 | (void)i18; |
b32b8144 FG |
473 | int i19 = socket1.async_receive(null_buffers(), in_flags, lazy); |
474 | (void)i19; | |
7c673cae FG |
475 | |
476 | socket1.write_some(buffer(mutable_char_buffer)); | |
477 | socket1.write_some(buffer(const_char_buffer)); | |
478 | socket1.write_some(mutable_buffers); | |
479 | socket1.write_some(const_buffers); | |
480 | socket1.write_some(null_buffers()); | |
481 | socket1.write_some(buffer(mutable_char_buffer), ec); | |
482 | socket1.write_some(buffer(const_char_buffer), ec); | |
483 | socket1.write_some(mutable_buffers, ec); | |
484 | socket1.write_some(const_buffers, ec); | |
485 | socket1.write_some(null_buffers(), ec); | |
486 | ||
b32b8144 FG |
487 | socket1.async_write_some(buffer(mutable_char_buffer), write_some_handler()); |
488 | socket1.async_write_some(buffer(const_char_buffer), write_some_handler()); | |
489 | socket1.async_write_some(mutable_buffers, write_some_handler()); | |
490 | socket1.async_write_some(const_buffers, write_some_handler()); | |
491 | socket1.async_write_some(null_buffers(), write_some_handler()); | |
492 | int i20 = socket1.async_write_some(buffer(mutable_char_buffer), lazy); | |
7c673cae | 493 | (void)i20; |
b32b8144 | 494 | int i21 = socket1.async_write_some(buffer(const_char_buffer), lazy); |
7c673cae | 495 | (void)i21; |
b32b8144 | 496 | int i22 = socket1.async_write_some(mutable_buffers, lazy); |
7c673cae | 497 | (void)i22; |
b32b8144 | 498 | int i23 = socket1.async_write_some(const_buffers, lazy); |
7c673cae | 499 | (void)i23; |
b32b8144 FG |
500 | int i24 = socket1.async_write_some(null_buffers(), lazy); |
501 | (void)i24; | |
7c673cae FG |
502 | |
503 | socket1.read_some(buffer(mutable_char_buffer)); | |
504 | socket1.read_some(mutable_buffers); | |
505 | socket1.read_some(null_buffers()); | |
506 | socket1.read_some(buffer(mutable_char_buffer), ec); | |
507 | socket1.read_some(mutable_buffers, ec); | |
508 | socket1.read_some(null_buffers(), ec); | |
509 | ||
b32b8144 FG |
510 | socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler()); |
511 | socket1.async_read_some(mutable_buffers, read_some_handler()); | |
512 | socket1.async_read_some(null_buffers(), read_some_handler()); | |
513 | int i25 = socket1.async_read_some(buffer(mutable_char_buffer), lazy); | |
7c673cae | 514 | (void)i25; |
b32b8144 | 515 | int i26 = socket1.async_read_some(mutable_buffers, lazy); |
7c673cae | 516 | (void)i26; |
b32b8144 FG |
517 | int i27 = socket1.async_read_some(null_buffers(), lazy); |
518 | (void)i27; | |
7c673cae FG |
519 | } |
520 | catch (std::exception&) | |
521 | { | |
522 | } | |
523 | } | |
524 | ||
525 | } // namespace ip_tcp_socket_compile | |
526 | ||
527 | //------------------------------------------------------------------------------ | |
528 | ||
529 | // ip_tcp_socket_runtime test | |
530 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
531 | // The following test checks the runtime operation of the ip::tcp::socket class. | |
532 | ||
533 | namespace ip_tcp_socket_runtime { | |
534 | ||
535 | static const char write_data[] | |
536 | = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; | |
537 | ||
538 | void handle_read_noop(const boost::system::error_code& err, | |
539 | size_t bytes_transferred, bool* called) | |
540 | { | |
541 | *called = true; | |
542 | BOOST_ASIO_CHECK(!err); | |
543 | BOOST_ASIO_CHECK(bytes_transferred == 0); | |
544 | } | |
545 | ||
546 | void handle_write_noop(const boost::system::error_code& err, | |
547 | size_t bytes_transferred, bool* called) | |
548 | { | |
549 | *called = true; | |
550 | BOOST_ASIO_CHECK(!err); | |
551 | BOOST_ASIO_CHECK(bytes_transferred == 0); | |
552 | } | |
553 | ||
554 | void handle_read(const boost::system::error_code& err, | |
555 | size_t bytes_transferred, bool* called) | |
556 | { | |
557 | *called = true; | |
558 | BOOST_ASIO_CHECK(!err); | |
559 | BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data)); | |
560 | } | |
561 | ||
562 | void handle_write(const boost::system::error_code& err, | |
563 | size_t bytes_transferred, bool* called) | |
564 | { | |
565 | *called = true; | |
566 | BOOST_ASIO_CHECK(!err); | |
567 | BOOST_ASIO_CHECK(bytes_transferred == sizeof(write_data)); | |
568 | } | |
569 | ||
570 | void handle_read_cancel(const boost::system::error_code& err, | |
571 | size_t bytes_transferred, bool* called) | |
572 | { | |
573 | *called = true; | |
574 | BOOST_ASIO_CHECK(err == boost::asio::error::operation_aborted); | |
575 | BOOST_ASIO_CHECK(bytes_transferred == 0); | |
576 | } | |
577 | ||
578 | void handle_read_eof(const boost::system::error_code& err, | |
579 | size_t bytes_transferred, bool* called) | |
580 | { | |
581 | *called = true; | |
582 | BOOST_ASIO_CHECK(err == boost::asio::error::eof); | |
583 | BOOST_ASIO_CHECK(bytes_transferred == 0); | |
584 | } | |
585 | ||
586 | void test() | |
587 | { | |
588 | using namespace std; // For memcmp. | |
589 | using namespace boost::asio; | |
590 | namespace ip = boost::asio::ip; | |
591 | ||
592 | #if defined(BOOST_ASIO_HAS_BOOST_BIND) | |
593 | namespace bindns = boost; | |
594 | #else // defined(BOOST_ASIO_HAS_BOOST_BIND) | |
595 | namespace bindns = std; | |
7c673cae | 596 | #endif // defined(BOOST_ASIO_HAS_BOOST_BIND) |
f67539c2 TL |
597 | using bindns::placeholders::_1; |
598 | using bindns::placeholders::_2; | |
7c673cae | 599 | |
b32b8144 | 600 | io_context ioc; |
7c673cae | 601 | |
b32b8144 | 602 | ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0)); |
7c673cae FG |
603 | ip::tcp::endpoint server_endpoint = acceptor.local_endpoint(); |
604 | server_endpoint.address(ip::address_v4::loopback()); | |
605 | ||
b32b8144 FG |
606 | ip::tcp::socket client_side_socket(ioc); |
607 | ip::tcp::socket server_side_socket(ioc); | |
7c673cae FG |
608 | |
609 | client_side_socket.connect(server_endpoint); | |
610 | acceptor.accept(server_side_socket); | |
611 | ||
612 | // No-op read. | |
613 | ||
614 | bool read_noop_completed = false; | |
615 | client_side_socket.async_read_some( | |
b32b8144 | 616 | boost::asio::mutable_buffer(0, 0), |
7c673cae FG |
617 | bindns::bind(handle_read_noop, |
618 | _1, _2, &read_noop_completed)); | |
619 | ||
b32b8144 | 620 | ioc.run(); |
7c673cae FG |
621 | BOOST_ASIO_CHECK(read_noop_completed); |
622 | ||
623 | // No-op write. | |
624 | ||
625 | bool write_noop_completed = false; | |
626 | client_side_socket.async_write_some( | |
b32b8144 | 627 | boost::asio::const_buffer(0, 0), |
7c673cae FG |
628 | bindns::bind(handle_write_noop, |
629 | _1, _2, &write_noop_completed)); | |
630 | ||
b32b8144 FG |
631 | ioc.restart(); |
632 | ioc.run(); | |
7c673cae FG |
633 | BOOST_ASIO_CHECK(write_noop_completed); |
634 | ||
635 | // Read and write to transfer data. | |
636 | ||
637 | char read_buffer[sizeof(write_data)]; | |
638 | bool read_completed = false; | |
639 | boost::asio::async_read(client_side_socket, | |
640 | boost::asio::buffer(read_buffer), | |
641 | bindns::bind(handle_read, | |
642 | _1, _2, &read_completed)); | |
643 | ||
644 | bool write_completed = false; | |
645 | boost::asio::async_write(server_side_socket, | |
646 | boost::asio::buffer(write_data), | |
647 | bindns::bind(handle_write, | |
648 | _1, _2, &write_completed)); | |
649 | ||
b32b8144 FG |
650 | ioc.restart(); |
651 | ioc.run(); | |
7c673cae FG |
652 | BOOST_ASIO_CHECK(read_completed); |
653 | BOOST_ASIO_CHECK(write_completed); | |
654 | BOOST_ASIO_CHECK(memcmp(read_buffer, write_data, sizeof(write_data)) == 0); | |
655 | ||
656 | // Cancelled read. | |
657 | ||
658 | bool read_cancel_completed = false; | |
659 | boost::asio::async_read(server_side_socket, | |
660 | boost::asio::buffer(read_buffer), | |
661 | bindns::bind(handle_read_cancel, | |
662 | _1, _2, &read_cancel_completed)); | |
663 | ||
b32b8144 FG |
664 | ioc.restart(); |
665 | ioc.poll(); | |
7c673cae FG |
666 | BOOST_ASIO_CHECK(!read_cancel_completed); |
667 | ||
668 | server_side_socket.cancel(); | |
669 | ||
b32b8144 FG |
670 | ioc.restart(); |
671 | ioc.run(); | |
7c673cae FG |
672 | BOOST_ASIO_CHECK(read_cancel_completed); |
673 | ||
674 | // A read when the peer closes socket should fail with eof. | |
675 | ||
676 | bool read_eof_completed = false; | |
677 | boost::asio::async_read(client_side_socket, | |
678 | boost::asio::buffer(read_buffer), | |
679 | bindns::bind(handle_read_eof, | |
680 | _1, _2, &read_eof_completed)); | |
681 | ||
682 | server_side_socket.close(); | |
683 | ||
b32b8144 FG |
684 | ioc.restart(); |
685 | ioc.run(); | |
7c673cae FG |
686 | BOOST_ASIO_CHECK(read_eof_completed); |
687 | } | |
688 | ||
689 | } // namespace ip_tcp_socket_runtime | |
690 | ||
691 | //------------------------------------------------------------------------------ | |
692 | ||
693 | // ip_tcp_acceptor_compile test | |
694 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
695 | // The following test checks that all public member functions on the class | |
696 | // ip::tcp::acceptor compile and link correctly. Runtime failures are ignored. | |
697 | ||
698 | namespace ip_tcp_acceptor_compile { | |
699 | ||
b32b8144 | 700 | struct wait_handler |
7c673cae | 701 | { |
b32b8144 FG |
702 | wait_handler() {} |
703 | void operator()(const boost::system::error_code&) {} | |
704 | #if defined(BOOST_ASIO_HAS_MOVE) | |
705 | wait_handler(wait_handler&&) {} | |
706 | private: | |
707 | wait_handler(const wait_handler&); | |
708 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
709 | }; | |
710 | ||
711 | struct accept_handler | |
712 | { | |
713 | accept_handler() {} | |
714 | void operator()(const boost::system::error_code&) {} | |
715 | #if defined(BOOST_ASIO_HAS_MOVE) | |
716 | accept_handler(accept_handler&&) {} | |
717 | private: | |
718 | accept_handler(const accept_handler&); | |
719 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
720 | }; | |
721 | ||
722 | #if defined(BOOST_ASIO_HAS_MOVE) | |
723 | struct move_accept_handler | |
724 | { | |
725 | move_accept_handler() {} | |
726 | void operator()( | |
727 | const boost::system::error_code&, boost::asio::ip::tcp::socket) {} | |
728 | move_accept_handler(move_accept_handler&&) {} | |
729 | private: | |
730 | move_accept_handler(const move_accept_handler&) {} | |
731 | }; | |
92f5a8d4 TL |
732 | |
733 | struct move_accept_ioc_handler | |
734 | { | |
735 | move_accept_ioc_handler() {} | |
736 | void operator()(const boost::system::error_code&, | |
737 | boost::asio::basic_stream_socket<boost::asio::ip::tcp, | |
738 | boost::asio::io_context::executor_type>) {} | |
739 | move_accept_ioc_handler(move_accept_handler&&) {} | |
740 | private: | |
741 | move_accept_ioc_handler(const move_accept_handler&) {} | |
742 | }; | |
b32b8144 | 743 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
7c673cae FG |
744 | |
745 | void test() | |
746 | { | |
747 | using namespace boost::asio; | |
748 | namespace ip = boost::asio::ip; | |
749 | ||
750 | try | |
751 | { | |
b32b8144 | 752 | io_context ioc; |
92f5a8d4 TL |
753 | const io_context::executor_type ioc_ex = ioc.get_executor(); |
754 | ip::tcp::socket peer_socket1(ioc); | |
755 | boost::asio::basic_stream_socket<ip::tcp, | |
756 | io_context::executor_type> peer_socket2(ioc); | |
7c673cae FG |
757 | ip::tcp::endpoint peer_endpoint; |
758 | archetypes::settable_socket_option<void> settable_socket_option1; | |
759 | archetypes::settable_socket_option<int> settable_socket_option2; | |
760 | archetypes::settable_socket_option<double> settable_socket_option3; | |
761 | archetypes::gettable_socket_option<void> gettable_socket_option1; | |
762 | archetypes::gettable_socket_option<int> gettable_socket_option2; | |
763 | archetypes::gettable_socket_option<double> gettable_socket_option3; | |
764 | archetypes::io_control_command io_control_command; | |
765 | archetypes::lazy_handler lazy; | |
766 | boost::system::error_code ec; | |
767 | ||
768 | // basic_socket_acceptor constructors. | |
769 | ||
b32b8144 FG |
770 | ip::tcp::acceptor acceptor1(ioc); |
771 | ip::tcp::acceptor acceptor2(ioc, ip::tcp::v4()); | |
772 | ip::tcp::acceptor acceptor3(ioc, ip::tcp::v6()); | |
773 | ip::tcp::acceptor acceptor4(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
774 | ip::tcp::acceptor acceptor5(ioc, ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
7c673cae FG |
775 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) |
776 | ip::tcp::acceptor::native_handle_type native_acceptor1 | |
777 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
b32b8144 | 778 | ip::tcp::acceptor acceptor6(ioc, ip::tcp::v4(), native_acceptor1); |
7c673cae FG |
779 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) |
780 | ||
92f5a8d4 TL |
781 | ip::tcp::acceptor acceptor7(ioc_ex); |
782 | ip::tcp::acceptor acceptor8(ioc_ex, ip::tcp::v4()); | |
783 | ip::tcp::acceptor acceptor9(ioc_ex, ip::tcp::v6()); | |
784 | ip::tcp::acceptor acceptor10(ioc_ex, ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
785 | ip::tcp::acceptor acceptor11(ioc_ex, ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
786 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
787 | ip::tcp::acceptor::native_handle_type native_acceptor2 | |
788 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
789 | ip::tcp::acceptor acceptor12(ioc_ex, ip::tcp::v4(), native_acceptor2); | |
790 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
791 | ||
7c673cae | 792 | #if defined(BOOST_ASIO_HAS_MOVE) |
92f5a8d4 | 793 | ip::tcp::acceptor acceptor13(std::move(acceptor5)); |
7c673cae FG |
794 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
795 | ||
796 | // basic_socket_acceptor operators. | |
797 | ||
798 | #if defined(BOOST_ASIO_HAS_MOVE) | |
b32b8144 | 799 | acceptor1 = ip::tcp::acceptor(ioc); |
7c673cae FG |
800 | acceptor1 = std::move(acceptor2); |
801 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
802 | ||
803 | // basic_io_object functions. | |
804 | ||
b32b8144 FG |
805 | ip::tcp::acceptor::executor_type ex = acceptor1.get_executor(); |
806 | (void)ex; | |
7c673cae FG |
807 | |
808 | // basic_socket_acceptor functions. | |
809 | ||
810 | acceptor1.open(ip::tcp::v4()); | |
811 | acceptor1.open(ip::tcp::v6()); | |
812 | acceptor1.open(ip::tcp::v4(), ec); | |
813 | acceptor1.open(ip::tcp::v6(), ec); | |
814 | ||
815 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
7c673cae FG |
816 | ip::tcp::acceptor::native_handle_type native_acceptor3 |
817 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
92f5a8d4 TL |
818 | acceptor1.assign(ip::tcp::v4(), native_acceptor3); |
819 | ip::tcp::acceptor::native_handle_type native_acceptor4 | |
820 | = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
821 | acceptor1.assign(ip::tcp::v4(), native_acceptor4, ec); | |
7c673cae FG |
822 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) |
823 | ||
824 | bool is_open = acceptor1.is_open(); | |
825 | (void)is_open; | |
826 | ||
827 | acceptor1.close(); | |
828 | acceptor1.close(ec); | |
829 | ||
b32b8144 FG |
830 | acceptor1.release(); |
831 | acceptor1.release(ec); | |
7c673cae | 832 | |
92f5a8d4 | 833 | ip::tcp::acceptor::native_handle_type native_acceptor5 |
7c673cae | 834 | = acceptor1.native_handle(); |
92f5a8d4 | 835 | (void)native_acceptor5; |
7c673cae FG |
836 | |
837 | acceptor1.cancel(); | |
838 | acceptor1.cancel(ec); | |
839 | ||
840 | acceptor1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0)); | |
841 | acceptor1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0)); | |
842 | acceptor1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), ec); | |
843 | acceptor1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), ec); | |
844 | ||
845 | acceptor1.set_option(settable_socket_option1); | |
846 | acceptor1.set_option(settable_socket_option1, ec); | |
847 | acceptor1.set_option(settable_socket_option2); | |
848 | acceptor1.set_option(settable_socket_option2, ec); | |
849 | acceptor1.set_option(settable_socket_option3); | |
850 | acceptor1.set_option(settable_socket_option3, ec); | |
851 | ||
852 | acceptor1.get_option(gettable_socket_option1); | |
853 | acceptor1.get_option(gettable_socket_option1, ec); | |
854 | acceptor1.get_option(gettable_socket_option2); | |
855 | acceptor1.get_option(gettable_socket_option2, ec); | |
856 | acceptor1.get_option(gettable_socket_option3); | |
857 | acceptor1.get_option(gettable_socket_option3, ec); | |
858 | ||
859 | acceptor1.io_control(io_control_command); | |
860 | acceptor1.io_control(io_control_command, ec); | |
861 | ||
862 | bool non_blocking1 = acceptor1.non_blocking(); | |
863 | (void)non_blocking1; | |
864 | acceptor1.non_blocking(true); | |
865 | acceptor1.non_blocking(false, ec); | |
866 | ||
867 | bool non_blocking2 = acceptor1.native_non_blocking(); | |
868 | (void)non_blocking2; | |
869 | acceptor1.native_non_blocking(true); | |
870 | acceptor1.native_non_blocking(false, ec); | |
871 | ||
872 | ip::tcp::endpoint endpoint1 = acceptor1.local_endpoint(); | |
92f5a8d4 | 873 | (void)endpoint1; |
7c673cae | 874 | ip::tcp::endpoint endpoint2 = acceptor1.local_endpoint(ec); |
92f5a8d4 | 875 | (void)endpoint2; |
7c673cae | 876 | |
b32b8144 FG |
877 | acceptor1.wait(socket_base::wait_read); |
878 | acceptor1.wait(socket_base::wait_write, ec); | |
879 | ||
880 | acceptor1.async_wait(socket_base::wait_read, wait_handler()); | |
881 | int i1 = acceptor1.async_wait(socket_base::wait_write, lazy); | |
882 | (void)i1; | |
b32b8144 | 883 | |
92f5a8d4 TL |
884 | acceptor1.accept(peer_socket1); |
885 | acceptor1.accept(peer_socket1, ec); | |
886 | acceptor1.accept(peer_socket1, peer_endpoint); | |
887 | acceptor1.accept(peer_socket1, peer_endpoint, ec); | |
888 | ||
889 | acceptor1.accept(peer_socket2); | |
890 | acceptor1.accept(peer_socket2, ec); | |
891 | acceptor1.accept(peer_socket2, peer_endpoint); | |
892 | acceptor1.accept(peer_socket2, peer_endpoint, ec); | |
7c673cae | 893 | |
b32b8144 | 894 | #if defined(BOOST_ASIO_HAS_MOVE) |
92f5a8d4 TL |
895 | peer_socket1 = acceptor1.accept(); |
896 | peer_socket1 = acceptor1.accept(ioc); | |
897 | peer_socket1 = acceptor1.accept(ioc_ex); | |
898 | peer_socket1 = acceptor1.accept(peer_endpoint); | |
899 | peer_socket1 = acceptor1.accept(ioc, peer_endpoint); | |
900 | peer_socket1 = acceptor1.accept(ioc_ex, peer_endpoint); | |
901 | (void)peer_socket1; | |
902 | ||
903 | peer_socket2 = acceptor1.accept(ioc); | |
904 | peer_socket2 = acceptor1.accept(ioc_ex); | |
905 | peer_socket2 = acceptor1.accept(ioc, peer_endpoint); | |
906 | peer_socket2 = acceptor1.accept(ioc_ex, peer_endpoint); | |
907 | (void)peer_socket2; | |
b32b8144 FG |
908 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
909 | ||
92f5a8d4 TL |
910 | acceptor1.async_accept(peer_socket1, accept_handler()); |
911 | acceptor1.async_accept(peer_socket1, peer_endpoint, accept_handler()); | |
912 | int i2 = acceptor1.async_accept(peer_socket1, lazy); | |
7c673cae | 913 | (void)i2; |
92f5a8d4 | 914 | int i3 = acceptor1.async_accept(peer_socket1, peer_endpoint, lazy); |
b32b8144 | 915 | (void)i3; |
92f5a8d4 TL |
916 | |
917 | acceptor1.async_accept(peer_socket2, accept_handler()); | |
918 | acceptor1.async_accept(peer_socket2, peer_endpoint, accept_handler()); | |
919 | int i4 = acceptor1.async_accept(peer_socket2, lazy); | |
920 | (void)i4; | |
921 | int i5 = acceptor1.async_accept(peer_socket2, peer_endpoint, lazy); | |
922 | (void)i5; | |
b32b8144 FG |
923 | |
924 | #if defined(BOOST_ASIO_HAS_MOVE) | |
925 | acceptor1.async_accept(move_accept_handler()); | |
926 | acceptor1.async_accept(ioc, move_accept_handler()); | |
92f5a8d4 TL |
927 | acceptor1.async_accept(ioc_ex, move_accept_handler()); |
928 | acceptor1.async_accept(ioc_ex, move_accept_ioc_handler()); | |
b32b8144 FG |
929 | acceptor1.async_accept(peer_endpoint, move_accept_handler()); |
930 | acceptor1.async_accept(ioc, peer_endpoint, move_accept_handler()); | |
92f5a8d4 TL |
931 | acceptor1.async_accept(ioc_ex, peer_endpoint, move_accept_handler()); |
932 | acceptor1.async_accept(ioc_ex, peer_endpoint, move_accept_ioc_handler()); | |
b32b8144 | 933 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
7c673cae FG |
934 | } |
935 | catch (std::exception&) | |
936 | { | |
937 | } | |
938 | } | |
939 | ||
940 | } // namespace ip_tcp_acceptor_compile | |
941 | ||
942 | //------------------------------------------------------------------------------ | |
943 | ||
944 | // ip_tcp_acceptor_runtime test | |
945 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
946 | // The following test checks the runtime operation of the ip::tcp::acceptor | |
947 | // class. | |
948 | ||
949 | namespace ip_tcp_acceptor_runtime { | |
950 | ||
951 | void handle_accept(const boost::system::error_code& err) | |
952 | { | |
953 | BOOST_ASIO_CHECK(!err); | |
954 | } | |
955 | ||
956 | void handle_connect(const boost::system::error_code& err) | |
957 | { | |
958 | BOOST_ASIO_CHECK(!err); | |
959 | } | |
960 | ||
961 | void test() | |
962 | { | |
963 | using namespace boost::asio; | |
964 | namespace ip = boost::asio::ip; | |
965 | ||
b32b8144 | 966 | io_context ioc; |
7c673cae | 967 | |
b32b8144 | 968 | ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0)); |
7c673cae FG |
969 | ip::tcp::endpoint server_endpoint = acceptor.local_endpoint(); |
970 | server_endpoint.address(ip::address_v4::loopback()); | |
971 | ||
b32b8144 FG |
972 | ip::tcp::socket client_side_socket(ioc); |
973 | ip::tcp::socket server_side_socket(ioc); | |
7c673cae FG |
974 | |
975 | client_side_socket.connect(server_endpoint); | |
976 | acceptor.accept(server_side_socket); | |
977 | ||
978 | client_side_socket.close(); | |
979 | server_side_socket.close(); | |
980 | ||
981 | client_side_socket.connect(server_endpoint); | |
982 | ip::tcp::endpoint client_endpoint; | |
983 | acceptor.accept(server_side_socket, client_endpoint); | |
984 | ||
7c673cae FG |
985 | ip::tcp::endpoint client_side_local_endpoint |
986 | = client_side_socket.local_endpoint(); | |
987 | BOOST_ASIO_CHECK(client_side_local_endpoint.port() == client_endpoint.port()); | |
988 | ||
989 | ip::tcp::endpoint server_side_remote_endpoint | |
990 | = server_side_socket.remote_endpoint(); | |
991 | BOOST_ASIO_CHECK(server_side_remote_endpoint.port() | |
992 | == client_endpoint.port()); | |
993 | ||
994 | client_side_socket.close(); | |
995 | server_side_socket.close(); | |
996 | ||
997 | acceptor.async_accept(server_side_socket, &handle_accept); | |
998 | client_side_socket.async_connect(server_endpoint, &handle_connect); | |
999 | ||
b32b8144 | 1000 | ioc.run(); |
7c673cae FG |
1001 | |
1002 | client_side_socket.close(); | |
1003 | server_side_socket.close(); | |
1004 | ||
1005 | acceptor.async_accept(server_side_socket, client_endpoint, &handle_accept); | |
1006 | client_side_socket.async_connect(server_endpoint, &handle_connect); | |
1007 | ||
b32b8144 FG |
1008 | ioc.restart(); |
1009 | ioc.run(); | |
7c673cae FG |
1010 | |
1011 | client_side_local_endpoint = client_side_socket.local_endpoint(); | |
1012 | BOOST_ASIO_CHECK(client_side_local_endpoint.port() == client_endpoint.port()); | |
1013 | ||
1014 | server_side_remote_endpoint = server_side_socket.remote_endpoint(); | |
1015 | BOOST_ASIO_CHECK(server_side_remote_endpoint.port() | |
1016 | == client_endpoint.port()); | |
1017 | } | |
1018 | ||
1019 | } // namespace ip_tcp_acceptor_runtime | |
1020 | ||
1021 | //------------------------------------------------------------------------------ | |
1022 | ||
1023 | // ip_tcp_resolver_compile test | |
1024 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
1025 | // The following test checks that all public member functions on the class | |
1026 | // ip::tcp::resolver compile and link correctly. Runtime failures are ignored. | |
1027 | ||
1028 | namespace ip_tcp_resolver_compile { | |
1029 | ||
b32b8144 | 1030 | struct resolve_handler |
7c673cae | 1031 | { |
b32b8144 FG |
1032 | resolve_handler() {} |
1033 | void operator()(const boost::system::error_code&, | |
1034 | boost::asio::ip::tcp::resolver::results_type) {} | |
1035 | #if defined(BOOST_ASIO_HAS_MOVE) | |
1036 | resolve_handler(resolve_handler&&) {} | |
1037 | private: | |
1038 | resolve_handler(const resolve_handler&); | |
1039 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
1040 | }; | |
1041 | ||
11fdf7f2 | 1042 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1043 | struct legacy_resolve_handler |
1044 | { | |
1045 | legacy_resolve_handler() {} | |
1046 | void operator()(const boost::system::error_code&, | |
1047 | boost::asio::ip::tcp::resolver::iterator) {} | |
1048 | #if defined(BOOST_ASIO_HAS_MOVE) | |
1049 | legacy_resolve_handler(legacy_resolve_handler&&) {} | |
1050 | private: | |
1051 | legacy_resolve_handler(const legacy_resolve_handler&); | |
1052 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
1053 | }; | |
11fdf7f2 | 1054 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
1055 | |
1056 | void test() | |
1057 | { | |
1058 | using namespace boost::asio; | |
1059 | namespace ip = boost::asio::ip; | |
1060 | ||
1061 | try | |
1062 | { | |
b32b8144 | 1063 | io_context ioc; |
92f5a8d4 | 1064 | const io_context::executor_type ioc_ex = ioc.get_executor(); |
7c673cae FG |
1065 | archetypes::lazy_handler lazy; |
1066 | boost::system::error_code ec; | |
b32b8144 | 1067 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae | 1068 | ip::tcp::resolver::query q(ip::tcp::v4(), "localhost", "0"); |
b32b8144 | 1069 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae FG |
1070 | ip::tcp::endpoint e(ip::address_v4::loopback(), 0); |
1071 | ||
1072 | // basic_resolver constructors. | |
1073 | ||
b32b8144 | 1074 | ip::tcp::resolver resolver(ioc); |
92f5a8d4 | 1075 | ip::tcp::resolver resolver2(ioc_ex); |
b32b8144 FG |
1076 | |
1077 | #if defined(BOOST_ASIO_HAS_MOVE) | |
92f5a8d4 | 1078 | ip::tcp::resolver resolver3(std::move(resolver)); |
b32b8144 FG |
1079 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
1080 | ||
1081 | // basic_resolver operators. | |
1082 | ||
1083 | #if defined(BOOST_ASIO_HAS_MOVE) | |
1084 | resolver = ip::tcp::resolver(ioc); | |
92f5a8d4 | 1085 | resolver = std::move(resolver3); |
b32b8144 | 1086 | #endif // defined(BOOST_ASIO_HAS_MOVE) |
7c673cae FG |
1087 | |
1088 | // basic_io_object functions. | |
1089 | ||
b32b8144 FG |
1090 | ip::tcp::resolver::executor_type ex = resolver.get_executor(); |
1091 | (void)ex; | |
7c673cae FG |
1092 | |
1093 | // basic_resolver functions. | |
1094 | ||
1095 | resolver.cancel(); | |
1096 | ||
b32b8144 FG |
1097 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
1098 | ip::tcp::resolver::results_type results1 = resolver.resolve(q); | |
1099 | (void)results1; | |
1100 | ||
1101 | ip::tcp::resolver::results_type results2 = resolver.resolve(q, ec); | |
1102 | (void)results2; | |
1103 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) | |
1104 | ||
1105 | ip::tcp::resolver::results_type results3 = resolver.resolve("", ""); | |
1106 | (void)results3; | |
1107 | ||
1108 | ip::tcp::resolver::results_type results4 = resolver.resolve("", "", ec); | |
1109 | (void)results4; | |
1110 | ||
1111 | ip::tcp::resolver::results_type results5 = | |
1112 | resolver.resolve("", "", ip::tcp::resolver::flags()); | |
1113 | (void)results5; | |
7c673cae | 1114 | |
b32b8144 FG |
1115 | ip::tcp::resolver::results_type results6 = |
1116 | resolver.resolve("", "", ip::tcp::resolver::flags(), ec); | |
1117 | (void)results6; | |
7c673cae | 1118 | |
b32b8144 FG |
1119 | ip::tcp::resolver::results_type results7 = |
1120 | resolver.resolve(ip::tcp::v4(), "", ""); | |
1121 | (void)results7; | |
7c673cae | 1122 | |
b32b8144 FG |
1123 | ip::tcp::resolver::results_type results8 = |
1124 | resolver.resolve(ip::tcp::v4(), "", "", ec); | |
1125 | (void)results8; | |
7c673cae | 1126 | |
b32b8144 FG |
1127 | ip::tcp::resolver::results_type results9 = |
1128 | resolver.resolve(ip::tcp::v4(), "", "", ip::tcp::resolver::flags()); | |
1129 | (void)results9; | |
1130 | ||
1131 | ip::tcp::resolver::results_type results10 = | |
1132 | resolver.resolve(ip::tcp::v4(), "", "", ip::tcp::resolver::flags(), ec); | |
1133 | (void)results10; | |
1134 | ||
1135 | ip::tcp::resolver::results_type results11 = resolver.resolve(e); | |
1136 | (void)results11; | |
1137 | ||
1138 | ip::tcp::resolver::results_type results12 = resolver.resolve(e, ec); | |
1139 | (void)results12; | |
1140 | ||
1141 | #if !defined(BOOST_ASIO_NO_DEPRECATED) | |
1142 | resolver.async_resolve(q, resolve_handler()); | |
1143 | resolver.async_resolve(q, legacy_resolve_handler()); | |
7c673cae FG |
1144 | int i1 = resolver.async_resolve(q, lazy); |
1145 | (void)i1; | |
b32b8144 | 1146 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
7c673cae | 1147 | |
b32b8144 | 1148 | resolver.async_resolve("", "", resolve_handler()); |
11fdf7f2 | 1149 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 | 1150 | resolver.async_resolve("", "", legacy_resolve_handler()); |
11fdf7f2 | 1151 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 | 1152 | int i2 = resolver.async_resolve("", "", lazy); |
7c673cae | 1153 | (void)i2; |
b32b8144 FG |
1154 | |
1155 | resolver.async_resolve("", "", | |
1156 | ip::tcp::resolver::flags(), resolve_handler()); | |
11fdf7f2 | 1157 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1158 | resolver.async_resolve("", "", |
1159 | ip::tcp::resolver::flags(), legacy_resolve_handler()); | |
11fdf7f2 | 1160 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1161 | int i3 = resolver.async_resolve("", "", |
1162 | ip::tcp::resolver::flags(), lazy); | |
1163 | (void)i3; | |
b32b8144 FG |
1164 | |
1165 | resolver.async_resolve(ip::tcp::v4(), "", "", resolve_handler()); | |
11fdf7f2 | 1166 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 | 1167 | resolver.async_resolve(ip::tcp::v4(), "", "", legacy_resolve_handler()); |
11fdf7f2 | 1168 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1169 | int i4 = resolver.async_resolve(ip::tcp::v4(), "", "", lazy); |
1170 | (void)i4; | |
b32b8144 FG |
1171 | |
1172 | resolver.async_resolve(ip::tcp::v4(), | |
1173 | "", "", ip::tcp::resolver::flags(), resolve_handler()); | |
11fdf7f2 | 1174 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1175 | resolver.async_resolve(ip::tcp::v4(), |
1176 | "", "", ip::tcp::resolver::flags(), legacy_resolve_handler()); | |
11fdf7f2 | 1177 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1178 | int i5 = resolver.async_resolve(ip::tcp::v4(), |
1179 | "", "", ip::tcp::resolver::flags(), lazy); | |
1180 | (void)i5; | |
b32b8144 FG |
1181 | |
1182 | resolver.async_resolve(e, resolve_handler()); | |
11fdf7f2 | 1183 | #if !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 | 1184 | resolver.async_resolve(e, legacy_resolve_handler()); |
11fdf7f2 | 1185 | #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
b32b8144 FG |
1186 | int i6 = resolver.async_resolve(e, lazy); |
1187 | (void)i6; | |
7c673cae FG |
1188 | } |
1189 | catch (std::exception&) | |
1190 | { | |
1191 | } | |
1192 | } | |
1193 | ||
1194 | } // namespace ip_tcp_resolver_compile | |
1195 | ||
1196 | //------------------------------------------------------------------------------ | |
1197 | ||
b32b8144 FG |
1198 | // ip_tcp_resolver_entry_compile test |
1199 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
1200 | // The following test checks that all public member functions on the class | |
1201 | // ip::tcp::resolver::entry compile and link correctly. Runtime failures are | |
1202 | // ignored. | |
1203 | ||
1204 | namespace ip_tcp_resolver_entry_compile { | |
1205 | ||
1206 | void test() | |
1207 | { | |
1208 | using namespace boost::asio; | |
1209 | namespace ip = boost::asio::ip; | |
1210 | const ip::tcp::endpoint endpoint; | |
1211 | const std::string host_name; | |
1212 | const std::string service_name; | |
1213 | const std::allocator<char> alloc; | |
1214 | ||
1215 | try | |
1216 | { | |
1217 | // basic_resolver_entry constructors. | |
1218 | ||
1219 | const ip::basic_resolver_entry<ip::tcp> entry1; | |
1220 | ip::basic_resolver_entry<ip::tcp> entry2(endpoint, host_name, service_name); | |
1221 | ip::basic_resolver_entry<ip::tcp> entry3(entry1); | |
1222 | #if defined(BOOST_ASIO_HAS_MOVE) | |
1223 | ip::basic_resolver_entry<ip::tcp> entry4(std::move(entry2)); | |
1224 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
1225 | ||
1226 | // basic_resolver_entry functions. | |
1227 | ||
1228 | ip::tcp::endpoint e1 = entry1.endpoint(); | |
1229 | (void)e1; | |
1230 | ||
1231 | ip::tcp::endpoint e2 = entry1; | |
1232 | (void)e2; | |
1233 | ||
1234 | std::string s1 = entry1.host_name(); | |
1235 | (void)s1; | |
1236 | ||
1237 | std::string s2 = entry1.host_name(alloc); | |
1238 | (void)s2; | |
1239 | ||
1240 | std::string s3 = entry1.service_name(); | |
1241 | (void)s3; | |
1242 | ||
1243 | std::string s4 = entry1.service_name(alloc); | |
1244 | (void)s4; | |
1245 | } | |
1246 | catch (std::exception&) | |
1247 | { | |
1248 | } | |
1249 | } | |
1250 | ||
1251 | } // namespace ip_tcp_resolver_entry_compile | |
1252 | ||
1253 | //------------------------------------------------------------------------------ | |
1254 | ||
1255 | // ip_tcp_iostream_compile test | |
1256 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
1257 | // The following test checks that all public types and member functions on the | |
1258 | // class ip::tcp::iostream compile and link correctly. Runtime failures are | |
1259 | // ignored. | |
1260 | ||
1261 | namespace ip_tcp_iostream_compile { | |
1262 | ||
1263 | void test() | |
1264 | { | |
1265 | #if !defined(BOOST_ASIO_NO_IOSTREAM) | |
1266 | using namespace boost::asio; | |
1267 | namespace ip = boost::asio::ip; | |
1268 | ||
1269 | boost::asio::io_context ioc; | |
1270 | boost::asio::ip::tcp::socket sock(ioc); | |
1271 | ||
1272 | // basic_socket_iostream typedefs. | |
1273 | ||
1274 | (void)static_cast<ip::tcp::iostream::protocol_type*>(0); | |
1275 | (void)static_cast<ip::tcp::iostream::endpoint_type*>(0); | |
1276 | (void)static_cast<ip::tcp::iostream::clock_type*>(0); | |
1277 | (void)static_cast<ip::tcp::iostream::time_point*>(0); | |
1278 | (void)static_cast<ip::tcp::iostream::duration*>(0); | |
1279 | (void)static_cast<ip::tcp::iostream::traits_type*>(0); | |
1280 | ||
1281 | // basic_socket_iostream constructors. | |
1282 | ||
1283 | ip::tcp::iostream ios1; | |
1284 | ||
1285 | #if defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE) | |
1286 | ip::tcp::iostream ios2(std::move(sock)); | |
1287 | #endif // defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE) | |
1288 | ||
1289 | ip::tcp::iostream ios3("hostname", "service"); | |
1290 | ||
1291 | // basic_socket_iostream operators. | |
1292 | ||
1293 | #if defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE) | |
1294 | ios1 = ip::tcp::iostream(); | |
1295 | ||
1296 | ios2 = std::move(ios1); | |
1297 | #endif // defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE) | |
1298 | ||
1299 | // basic_socket_iostream members. | |
1300 | ||
1301 | ios1.connect("hostname", "service"); | |
1302 | ||
1303 | ios1.close(); | |
1304 | ||
1305 | (void)static_cast<std::streambuf*>(ios1.rdbuf()); | |
1306 | ||
b32b8144 | 1307 | basic_socket<ip::tcp>& sref = ios1.socket(); |
b32b8144 FG |
1308 | (void)sref; |
1309 | ||
1310 | boost::system::error_code ec = ios1.error(); | |
1311 | (void)ec; | |
1312 | ||
1313 | ip::tcp::iostream::time_point tp = ios1.expiry(); | |
1314 | (void)tp; | |
1315 | ||
1316 | ios1.expires_at(tp); | |
1317 | ||
1318 | ip::tcp::iostream::duration d; | |
1319 | ios1.expires_after(d); | |
1320 | ||
1321 | // iostream operators. | |
1322 | ||
1323 | int i = 0; | |
1324 | ios1 >> i; | |
1325 | ios1 << i; | |
1326 | #endif // !defined(BOOST_ASIO_NO_IOSTREAM) | |
1327 | } | |
1328 | ||
1329 | } // namespace ip_tcp_iostream_compile | |
1330 | ||
1331 | //------------------------------------------------------------------------------ | |
1332 | ||
7c673cae FG |
1333 | BOOST_ASIO_TEST_SUITE |
1334 | ( | |
1335 | "ip/tcp", | |
1336 | BOOST_ASIO_TEST_CASE(ip_tcp_compile::test) | |
1337 | BOOST_ASIO_TEST_CASE(ip_tcp_runtime::test) | |
1338 | BOOST_ASIO_TEST_CASE(ip_tcp_socket_compile::test) | |
1339 | BOOST_ASIO_TEST_CASE(ip_tcp_socket_runtime::test) | |
1340 | BOOST_ASIO_TEST_CASE(ip_tcp_acceptor_compile::test) | |
1341 | BOOST_ASIO_TEST_CASE(ip_tcp_acceptor_runtime::test) | |
1342 | BOOST_ASIO_TEST_CASE(ip_tcp_resolver_compile::test) | |
b32b8144 FG |
1343 | BOOST_ASIO_TEST_CASE(ip_tcp_resolver_entry_compile::test) |
1344 | BOOST_ASIO_TEST_CASE(ip_tcp_resolver_entry_compile::test) | |
1345 | BOOST_ASIO_COMPILE_TEST_CASE(ip_tcp_iostream_compile::test) | |
7c673cae | 1346 | ) |