ceph/src/boost/libs/asio/test/ip/tcp.cpp

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