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