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