5 // Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
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)
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)
16 // Test that header file is self-contained.
17 #include <boost/asio/socket_base.hpp>
19 #include <boost/asio/io_context.hpp>
20 #include <boost/asio/ip/tcp.hpp>
21 #include <boost/asio/ip/udp.hpp>
22 #include "unit_test.hpp"
24 //------------------------------------------------------------------------------
26 // socket_base_compile test
27 // ~~~~~~~~~~~~~~~~~~~~~~~~
28 // The following test checks that all nested classes, enums and constants in
29 // socket_base compile and link correctly. Runtime failures are ignored.
31 namespace socket_base_compile
{
35 using namespace boost::asio
;
36 namespace ip
= boost::asio::ip
;
41 ip::tcp::socket
sock(ioc
);
44 // shutdown_type enumeration.
46 sock
.shutdown(socket_base::shutdown_receive
);
47 sock
.shutdown(socket_base::shutdown_send
);
48 sock
.shutdown(socket_base::shutdown_both
);
50 // message_flags constants.
52 sock
.receive(buffer(buf
), socket_base::message_peek
);
53 sock
.receive(buffer(buf
), socket_base::message_out_of_band
);
54 sock
.send(buffer(buf
), socket_base::message_do_not_route
);
58 socket_base::broadcast
broadcast1(true);
59 sock
.set_option(broadcast1
);
60 socket_base::broadcast broadcast2
;
61 sock
.get_option(broadcast2
);
63 (void)static_cast<bool>(broadcast1
);
64 (void)static_cast<bool>(!broadcast1
);
65 (void)static_cast<bool>(broadcast1
.value());
69 socket_base::debug
debug1(true);
70 sock
.set_option(debug1
);
71 socket_base::debug debug2
;
72 sock
.get_option(debug2
);
74 (void)static_cast<bool>(debug1
);
75 (void)static_cast<bool>(!debug1
);
76 (void)static_cast<bool>(debug1
.value());
78 // do_not_route class.
80 socket_base::do_not_route
do_not_route1(true);
81 sock
.set_option(do_not_route1
);
82 socket_base::do_not_route do_not_route2
;
83 sock
.get_option(do_not_route2
);
85 (void)static_cast<bool>(do_not_route1
);
86 (void)static_cast<bool>(!do_not_route1
);
87 (void)static_cast<bool>(do_not_route1
.value());
91 socket_base::keep_alive
keep_alive1(true);
92 sock
.set_option(keep_alive1
);
93 socket_base::keep_alive keep_alive2
;
94 sock
.get_option(keep_alive2
);
96 (void)static_cast<bool>(keep_alive1
);
97 (void)static_cast<bool>(!keep_alive1
);
98 (void)static_cast<bool>(keep_alive1
.value());
100 // send_buffer_size class.
102 socket_base::send_buffer_size
send_buffer_size1(1024);
103 sock
.set_option(send_buffer_size1
);
104 socket_base::send_buffer_size send_buffer_size2
;
105 sock
.get_option(send_buffer_size2
);
106 send_buffer_size1
= 1;
107 (void)static_cast<int>(send_buffer_size1
.value());
109 // send_low_watermark class.
111 socket_base::send_low_watermark
send_low_watermark1(128);
112 sock
.set_option(send_low_watermark1
);
113 socket_base::send_low_watermark send_low_watermark2
;
114 sock
.get_option(send_low_watermark2
);
115 send_low_watermark1
= 1;
116 (void)static_cast<int>(send_low_watermark1
.value());
118 // receive_buffer_size class.
120 socket_base::receive_buffer_size
receive_buffer_size1(1024);
121 sock
.set_option(receive_buffer_size1
);
122 socket_base::receive_buffer_size receive_buffer_size2
;
123 sock
.get_option(receive_buffer_size2
);
124 receive_buffer_size1
= 1;
125 (void)static_cast<int>(receive_buffer_size1
.value());
127 // receive_low_watermark class.
129 socket_base::receive_low_watermark
receive_low_watermark1(128);
130 sock
.set_option(receive_low_watermark1
);
131 socket_base::receive_low_watermark receive_low_watermark2
;
132 sock
.get_option(receive_low_watermark2
);
133 receive_low_watermark1
= 1;
134 (void)static_cast<int>(receive_low_watermark1
.value());
136 // reuse_address class.
138 socket_base::reuse_address
reuse_address1(true);
139 sock
.set_option(reuse_address1
);
140 socket_base::reuse_address reuse_address2
;
141 sock
.get_option(reuse_address2
);
142 reuse_address1
= true;
143 (void)static_cast<bool>(reuse_address1
);
144 (void)static_cast<bool>(!reuse_address1
);
145 (void)static_cast<bool>(reuse_address1
.value());
149 socket_base::linger
linger1(true, 30);
150 sock
.set_option(linger1
);
151 socket_base::linger linger2
;
152 sock
.get_option(linger2
);
153 linger1
.enabled(true);
154 (void)static_cast<bool>(linger1
.enabled());
156 (void)static_cast<int>(linger1
.timeout());
158 // out_of_band_inline class.
160 socket_base::out_of_band_inline
out_of_band_inline1(true);
161 sock
.set_option(out_of_band_inline1
);
162 socket_base::out_of_band_inline out_of_band_inline2
;
163 sock
.get_option(out_of_band_inline2
);
164 out_of_band_inline1
= true;
165 (void)static_cast<bool>(out_of_band_inline1
);
166 (void)static_cast<bool>(!out_of_band_inline1
);
167 (void)static_cast<bool>(out_of_band_inline1
.value());
169 // enable_connection_aborted class.
171 socket_base::enable_connection_aborted
enable_connection_aborted1(true);
172 sock
.set_option(enable_connection_aborted1
);
173 socket_base::enable_connection_aborted enable_connection_aborted2
;
174 sock
.get_option(enable_connection_aborted2
);
175 enable_connection_aborted1
= true;
176 (void)static_cast<bool>(enable_connection_aborted1
);
177 (void)static_cast<bool>(!enable_connection_aborted1
);
178 (void)static_cast<bool>(enable_connection_aborted1
.value());
180 // bytes_readable class.
182 socket_base::bytes_readable bytes_readable
;
183 sock
.io_control(bytes_readable
);
184 std::size_t bytes
= bytes_readable
.get();
187 catch (std::exception
&)
192 } // namespace socket_base_compile
194 //------------------------------------------------------------------------------
196 // socket_base_runtime test
197 // ~~~~~~~~~~~~~~~~~~~~~~~~
198 // The following test checks the runtime operation of the socket options and I/O
199 // control commands defined in socket_base.
201 namespace socket_base_runtime
{
205 using namespace boost::asio
;
206 namespace ip
= boost::asio::ip
;
209 ip::udp::socket
udp_sock(ioc
, ip::udp::v4());
210 ip::tcp::socket
tcp_sock(ioc
, ip::tcp::v4());
211 ip::tcp::acceptor
tcp_acceptor(ioc
, ip::tcp::v4());
212 boost::system::error_code ec
;
216 socket_base::broadcast
broadcast1(true);
217 BOOST_ASIO_CHECK(broadcast1
.value());
218 BOOST_ASIO_CHECK(static_cast<bool>(broadcast1
));
219 BOOST_ASIO_CHECK(!!broadcast1
);
220 udp_sock
.set_option(broadcast1
, ec
);
221 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
223 socket_base::broadcast broadcast2
;
224 udp_sock
.get_option(broadcast2
, ec
);
225 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
226 BOOST_ASIO_CHECK(broadcast2
.value());
227 BOOST_ASIO_CHECK(static_cast<bool>(broadcast2
));
228 BOOST_ASIO_CHECK(!!broadcast2
);
230 socket_base::broadcast
broadcast3(false);
231 BOOST_ASIO_CHECK(!broadcast3
.value());
232 BOOST_ASIO_CHECK(!static_cast<bool>(broadcast3
));
233 BOOST_ASIO_CHECK(!broadcast3
);
234 udp_sock
.set_option(broadcast3
, ec
);
235 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
237 socket_base::broadcast broadcast4
;
238 udp_sock
.get_option(broadcast4
, ec
);
239 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
240 BOOST_ASIO_CHECK(!broadcast4
.value());
241 BOOST_ASIO_CHECK(!static_cast<bool>(broadcast4
));
242 BOOST_ASIO_CHECK(!broadcast4
);
246 socket_base::debug
debug1(true);
247 BOOST_ASIO_CHECK(debug1
.value());
248 BOOST_ASIO_CHECK(static_cast<bool>(debug1
));
249 BOOST_ASIO_CHECK(!!debug1
);
250 udp_sock
.set_option(debug1
, ec
);
251 #if defined(__linux__)
252 // On Linux, only root can set SO_DEBUG.
253 bool not_root
= (ec
== boost::asio::error::access_denied
);
254 BOOST_ASIO_CHECK(!ec
|| not_root
);
255 BOOST_ASIO_WARN_MESSAGE(!ec
, "Must be root to set debug socket option");
256 #else // defined(__linux__)
257 # if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
258 // Option is not supported under Windows CE.
259 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
260 ec
.value() << ", " << ec
.message());
261 # else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
262 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
263 # endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
264 #endif // defined(__linux__)
266 socket_base::debug debug2
;
267 udp_sock
.get_option(debug2
, ec
);
268 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
269 // Option is not supported under Windows CE.
270 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
271 ec
.value() << ", " << ec
.message());
272 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
273 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
274 # if defined(__linux__)
275 BOOST_ASIO_CHECK(debug2
.value() || not_root
);
276 BOOST_ASIO_CHECK(static_cast<bool>(debug2
) || not_root
);
277 BOOST_ASIO_CHECK(!!debug2
|| not_root
);
278 # else // defined(__linux__)
279 BOOST_ASIO_CHECK(debug2
.value());
280 BOOST_ASIO_CHECK(static_cast<bool>(debug2
));
281 BOOST_ASIO_CHECK(!!debug2
);
282 # endif // defined(__linux__)
283 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
285 socket_base::debug
debug3(false);
286 BOOST_ASIO_CHECK(!debug3
.value());
287 BOOST_ASIO_CHECK(!static_cast<bool>(debug3
));
288 BOOST_ASIO_CHECK(!debug3
);
289 udp_sock
.set_option(debug3
, ec
);
290 #if defined(__linux__)
291 BOOST_ASIO_CHECK(!ec
|| not_root
);
292 #else // defined(__linux__)
293 # if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
294 // Option is not supported under Windows CE.
295 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
296 ec
.value() << ", " << ec
.message());
297 # else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
298 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
299 # endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
300 #endif // defined(__linux__)
302 socket_base::debug debug4
;
303 udp_sock
.get_option(debug4
, ec
);
304 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
305 // Option is not supported under Windows CE.
306 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
307 ec
.value() << ", " << ec
.message());
308 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
309 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
310 # if defined(__linux__)
311 BOOST_ASIO_CHECK(!debug4
.value() || not_root
);
312 BOOST_ASIO_CHECK(!static_cast<bool>(debug4
) || not_root
);
313 BOOST_ASIO_CHECK(!debug4
|| not_root
);
314 # else // defined(__linux__)
315 BOOST_ASIO_CHECK(!debug4
.value());
316 BOOST_ASIO_CHECK(!static_cast<bool>(debug4
));
317 BOOST_ASIO_CHECK(!debug4
);
318 # endif // defined(__linux__)
319 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
321 // do_not_route class.
323 socket_base::do_not_route
do_not_route1(true);
324 BOOST_ASIO_CHECK(do_not_route1
.value());
325 BOOST_ASIO_CHECK(static_cast<bool>(do_not_route1
));
326 BOOST_ASIO_CHECK(!!do_not_route1
);
327 udp_sock
.set_option(do_not_route1
, ec
);
328 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
329 // Option is not supported under Windows CE.
330 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
331 ec
.value() << ", " << ec
.message());
332 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
333 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
334 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
336 socket_base::do_not_route do_not_route2
;
337 udp_sock
.get_option(do_not_route2
, ec
);
338 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
339 // Option is not supported under Windows CE.
340 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
341 ec
.value() << ", " << ec
.message());
342 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
343 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
344 BOOST_ASIO_CHECK(do_not_route2
.value());
345 BOOST_ASIO_CHECK(static_cast<bool>(do_not_route2
));
346 BOOST_ASIO_CHECK(!!do_not_route2
);
347 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
349 socket_base::do_not_route
do_not_route3(false);
350 BOOST_ASIO_CHECK(!do_not_route3
.value());
351 BOOST_ASIO_CHECK(!static_cast<bool>(do_not_route3
));
352 BOOST_ASIO_CHECK(!do_not_route3
);
353 udp_sock
.set_option(do_not_route3
, ec
);
354 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
355 // Option is not supported under Windows CE.
356 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
357 ec
.value() << ", " << ec
.message());
358 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
359 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
360 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
362 socket_base::do_not_route do_not_route4
;
363 udp_sock
.get_option(do_not_route4
, ec
);
364 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
365 // Option is not supported under Windows CE.
366 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
367 ec
.value() << ", " << ec
.message());
368 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
369 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
370 BOOST_ASIO_CHECK(!do_not_route4
.value());
371 BOOST_ASIO_CHECK(!static_cast<bool>(do_not_route4
));
372 BOOST_ASIO_CHECK(!do_not_route4
);
373 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
377 socket_base::keep_alive
keep_alive1(true);
378 BOOST_ASIO_CHECK(keep_alive1
.value());
379 BOOST_ASIO_CHECK(static_cast<bool>(keep_alive1
));
380 BOOST_ASIO_CHECK(!!keep_alive1
);
381 tcp_sock
.set_option(keep_alive1
, ec
);
382 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
384 socket_base::keep_alive keep_alive2
;
385 tcp_sock
.get_option(keep_alive2
, ec
);
386 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
387 BOOST_ASIO_CHECK(keep_alive2
.value());
388 BOOST_ASIO_CHECK(static_cast<bool>(keep_alive2
));
389 BOOST_ASIO_CHECK(!!keep_alive2
);
391 socket_base::keep_alive
keep_alive3(false);
392 BOOST_ASIO_CHECK(!keep_alive3
.value());
393 BOOST_ASIO_CHECK(!static_cast<bool>(keep_alive3
));
394 BOOST_ASIO_CHECK(!keep_alive3
);
395 tcp_sock
.set_option(keep_alive3
, ec
);
396 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
398 socket_base::keep_alive keep_alive4
;
399 tcp_sock
.get_option(keep_alive4
, ec
);
400 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
401 BOOST_ASIO_CHECK(!keep_alive4
.value());
402 BOOST_ASIO_CHECK(!static_cast<bool>(keep_alive4
));
403 BOOST_ASIO_CHECK(!keep_alive4
);
405 // send_buffer_size class.
407 socket_base::send_buffer_size
send_buffer_size1(4096);
408 BOOST_ASIO_CHECK(send_buffer_size1
.value() == 4096);
409 tcp_sock
.set_option(send_buffer_size1
, ec
);
410 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
412 socket_base::send_buffer_size send_buffer_size2
;
413 tcp_sock
.get_option(send_buffer_size2
, ec
);
414 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
415 BOOST_ASIO_CHECK(send_buffer_size2
.value() == 4096);
417 socket_base::send_buffer_size
send_buffer_size3(16384);
418 BOOST_ASIO_CHECK(send_buffer_size3
.value() == 16384);
419 tcp_sock
.set_option(send_buffer_size3
, ec
);
420 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
422 socket_base::send_buffer_size send_buffer_size4
;
423 tcp_sock
.get_option(send_buffer_size4
, ec
);
424 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
425 BOOST_ASIO_CHECK(send_buffer_size4
.value() == 16384);
427 // send_low_watermark class.
429 socket_base::send_low_watermark
send_low_watermark1(4096);
430 BOOST_ASIO_CHECK(send_low_watermark1
.value() == 4096);
431 tcp_sock
.set_option(send_low_watermark1
, ec
);
432 #if defined(WIN32) || defined(__linux__) || defined(__sun)
433 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows, Linux or Solaris.
435 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
438 socket_base::send_low_watermark send_low_watermark2
;
439 tcp_sock
.get_option(send_low_watermark2
, ec
);
440 #if defined(WIN32) || defined(__sun)
441 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows or Solaris.
442 #elif defined(__linux__)
443 BOOST_ASIO_CHECK(!ec
); // Not supported on Linux but can get value.
445 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
446 BOOST_ASIO_CHECK(send_low_watermark2
.value() == 4096);
449 socket_base::send_low_watermark
send_low_watermark3(8192);
450 BOOST_ASIO_CHECK(send_low_watermark3
.value() == 8192);
451 tcp_sock
.set_option(send_low_watermark3
, ec
);
452 #if defined(WIN32) || defined(__linux__) || defined(__sun)
453 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows, Linux or Solaris.
455 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
458 socket_base::send_low_watermark send_low_watermark4
;
459 tcp_sock
.get_option(send_low_watermark4
, ec
);
460 #if defined(WIN32) || defined(__sun)
461 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows or Solaris.
462 #elif defined(__linux__)
463 BOOST_ASIO_CHECK(!ec
); // Not supported on Linux but can get value.
465 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
466 BOOST_ASIO_CHECK(send_low_watermark4
.value() == 8192);
469 // receive_buffer_size class.
471 socket_base::receive_buffer_size
receive_buffer_size1(4096);
472 BOOST_ASIO_CHECK(receive_buffer_size1
.value() == 4096);
473 tcp_sock
.set_option(receive_buffer_size1
, ec
);
474 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
475 // Option is not supported under Windows CE.
476 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
477 ec
.value() << ", " << ec
.message());
478 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
479 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
480 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
482 socket_base::receive_buffer_size receive_buffer_size2
;
483 tcp_sock
.get_option(receive_buffer_size2
, ec
);
484 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
485 BOOST_ASIO_CHECK(!ec
); // Not supported under Windows CE but can get value.
486 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
487 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
488 BOOST_ASIO_CHECK(receive_buffer_size2
.value() == 4096);
489 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
491 socket_base::receive_buffer_size
receive_buffer_size3(16384);
492 BOOST_ASIO_CHECK(receive_buffer_size3
.value() == 16384);
493 tcp_sock
.set_option(receive_buffer_size3
, ec
);
494 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
495 // Option is not supported under Windows CE.
496 BOOST_ASIO_CHECK_MESSAGE(ec
== boost::asio::error::no_protocol_option
,
497 ec
.value() << ", " << ec
.message());
498 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
499 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
500 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
502 socket_base::receive_buffer_size receive_buffer_size4
;
503 tcp_sock
.get_option(receive_buffer_size4
, ec
);
504 #if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
505 BOOST_ASIO_CHECK(!ec
); // Not supported under Windows CE but can get value.
506 #else // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
507 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
508 BOOST_ASIO_CHECK(receive_buffer_size4
.value() == 16384);
509 #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
511 // receive_low_watermark class.
513 socket_base::receive_low_watermark
receive_low_watermark1(4096);
514 BOOST_ASIO_CHECK(receive_low_watermark1
.value() == 4096);
515 tcp_sock
.set_option(receive_low_watermark1
, ec
);
516 #if defined(WIN32) || defined(__sun)
517 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows or Solaris.
519 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
522 socket_base::receive_low_watermark receive_low_watermark2
;
523 tcp_sock
.get_option(receive_low_watermark2
, ec
);
524 #if defined(WIN32) || defined(__sun)
525 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows or Solaris.
527 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
528 BOOST_ASIO_CHECK(receive_low_watermark2
.value() == 4096);
531 socket_base::receive_low_watermark
receive_low_watermark3(8192);
532 BOOST_ASIO_CHECK(receive_low_watermark3
.value() == 8192);
533 tcp_sock
.set_option(receive_low_watermark3
, ec
);
534 #if defined(WIN32) || defined(__sun)
535 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows or Solaris.
537 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
540 socket_base::receive_low_watermark receive_low_watermark4
;
541 tcp_sock
.get_option(receive_low_watermark4
, ec
);
542 #if defined(WIN32) || defined(__sun)
543 BOOST_ASIO_CHECK(!!ec
); // Not supported on Windows or Solaris.
545 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
546 BOOST_ASIO_CHECK(receive_low_watermark4
.value() == 8192);
549 // reuse_address class.
551 socket_base::reuse_address
reuse_address1(true);
552 BOOST_ASIO_CHECK(reuse_address1
.value());
553 BOOST_ASIO_CHECK(static_cast<bool>(reuse_address1
));
554 BOOST_ASIO_CHECK(!!reuse_address1
);
555 udp_sock
.set_option(reuse_address1
, ec
);
556 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
558 socket_base::reuse_address reuse_address2
;
559 udp_sock
.get_option(reuse_address2
, ec
);
560 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
561 BOOST_ASIO_CHECK(reuse_address2
.value());
562 BOOST_ASIO_CHECK(static_cast<bool>(reuse_address2
));
563 BOOST_ASIO_CHECK(!!reuse_address2
);
565 socket_base::reuse_address
reuse_address3(false);
566 BOOST_ASIO_CHECK(!reuse_address3
.value());
567 BOOST_ASIO_CHECK(!static_cast<bool>(reuse_address3
));
568 BOOST_ASIO_CHECK(!reuse_address3
);
569 udp_sock
.set_option(reuse_address3
, ec
);
570 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
572 socket_base::reuse_address reuse_address4
;
573 udp_sock
.get_option(reuse_address4
, ec
);
574 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
575 BOOST_ASIO_CHECK(!reuse_address4
.value());
576 BOOST_ASIO_CHECK(!static_cast<bool>(reuse_address4
));
577 BOOST_ASIO_CHECK(!reuse_address4
);
581 socket_base::linger
linger1(true, 60);
582 BOOST_ASIO_CHECK(linger1
.enabled());
583 BOOST_ASIO_CHECK(linger1
.timeout() == 60);
584 tcp_sock
.set_option(linger1
, ec
);
585 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
587 socket_base::linger linger2
;
588 tcp_sock
.get_option(linger2
, ec
);
589 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
590 BOOST_ASIO_CHECK(linger2
.enabled());
591 BOOST_ASIO_CHECK(linger2
.timeout() == 60);
593 socket_base::linger
linger3(false, 0);
594 BOOST_ASIO_CHECK(!linger3
.enabled());
595 BOOST_ASIO_CHECK(linger3
.timeout() == 0);
596 tcp_sock
.set_option(linger3
, ec
);
597 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
599 socket_base::linger linger4
;
600 tcp_sock
.get_option(linger4
, ec
);
601 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
602 BOOST_ASIO_CHECK(!linger4
.enabled());
604 // enable_connection_aborted class.
606 socket_base::enable_connection_aborted
enable_connection_aborted1(true);
607 BOOST_ASIO_CHECK(enable_connection_aborted1
.value());
608 BOOST_ASIO_CHECK(static_cast<bool>(enable_connection_aborted1
));
609 BOOST_ASIO_CHECK(!!enable_connection_aborted1
);
610 tcp_acceptor
.set_option(enable_connection_aborted1
, ec
);
611 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
613 socket_base::enable_connection_aborted enable_connection_aborted2
;
614 tcp_acceptor
.get_option(enable_connection_aborted2
, ec
);
615 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
616 BOOST_ASIO_CHECK(enable_connection_aborted2
.value());
617 BOOST_ASIO_CHECK(static_cast<bool>(enable_connection_aborted2
));
618 BOOST_ASIO_CHECK(!!enable_connection_aborted2
);
620 socket_base::enable_connection_aborted
enable_connection_aborted3(false);
621 BOOST_ASIO_CHECK(!enable_connection_aborted3
.value());
622 BOOST_ASIO_CHECK(!static_cast<bool>(enable_connection_aborted3
));
623 BOOST_ASIO_CHECK(!enable_connection_aborted3
);
624 tcp_acceptor
.set_option(enable_connection_aborted3
, ec
);
625 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
627 socket_base::enable_connection_aborted enable_connection_aborted4
;
628 tcp_acceptor
.get_option(enable_connection_aborted4
, ec
);
629 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
630 BOOST_ASIO_CHECK(!enable_connection_aborted4
.value());
631 BOOST_ASIO_CHECK(!static_cast<bool>(enable_connection_aborted4
));
632 BOOST_ASIO_CHECK(!enable_connection_aborted4
);
634 // bytes_readable class.
636 socket_base::bytes_readable bytes_readable
;
637 udp_sock
.io_control(bytes_readable
, ec
);
638 BOOST_ASIO_CHECK_MESSAGE(!ec
, ec
.value() << ", " << ec
.message());
641 } // namespace socket_base_runtime
643 //------------------------------------------------------------------------------
645 BOOST_ASIO_TEST_SUITE
648 BOOST_ASIO_TEST_CASE(socket_base_compile::test
)
649 BOOST_ASIO_TEST_CASE(socket_base_runtime::test
)