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