socket_base.cpp

来自「Boost provides free peer-reviewed portab」· C++ 代码 · 共 654 行 · 第 1/2 页

//
// socket_base.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)

// Test that header file is self-contained.
#include <boost/asio/socket_base.hpp>

#include <boost/asio.hpp>
#include "unit_test.hpp"

//------------------------------------------------------------------------------

// socket_base_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all nested classes, enums and constants in
// socket_base compile and link correctly. Runtime failures are ignored.

namespace socket_base_compile {

void test()
{
  using namespace boost::asio;
  namespace ip = boost::asio::ip;

  try
  {
    io_service ios;
    ip::tcp::socket sock(ios);
    char buf[1024];

    // shutdown_type enumeration.

    sock.shutdown(socket_base::shutdown_receive);
    sock.shutdown(socket_base::shutdown_send);
    sock.shutdown(socket_base::shutdown_both);

    // message_flags constants.

    sock.receive(buffer(buf), socket_base::message_peek);
    sock.receive(buffer(buf), socket_base::message_out_of_band);
    sock.send(buffer(buf), socket_base::message_do_not_route);

    // broadcast class.

    socket_base::broadcast broadcast1(true);
    sock.set_option(broadcast1);
    socket_base::broadcast broadcast2;
    sock.get_option(broadcast2);
    broadcast1 = true;
    static_cast<bool>(broadcast1);
    static_cast<bool>(!broadcast1);
    static_cast<bool>(broadcast1.value());

    // debug class.

    socket_base::debug debug1(true);
    sock.set_option(debug1);
    socket_base::debug debug2;
    sock.get_option(debug2);
    debug1 = true;
    static_cast<bool>(debug1);
    static_cast<bool>(!debug1);
    static_cast<bool>(debug1.value());

    // do_not_route class.

    socket_base::do_not_route do_not_route1(true);
    sock.set_option(do_not_route1);
    socket_base::do_not_route do_not_route2;
    sock.get_option(do_not_route2);
    do_not_route1 = true;
    static_cast<bool>(do_not_route1);
    static_cast<bool>(!do_not_route1);
    static_cast<bool>(do_not_route1.value());

    // keep_alive class.

    socket_base::keep_alive keep_alive1(true);
    sock.set_option(keep_alive1);
    socket_base::keep_alive keep_alive2;
    sock.get_option(keep_alive2);
    keep_alive1 = true;
    static_cast<bool>(keep_alive1);
    static_cast<bool>(!keep_alive1);
    static_cast<bool>(keep_alive1.value());

    // send_buffer_size class.

    socket_base::send_buffer_size send_buffer_size1(1024);
    sock.set_option(send_buffer_size1);
    socket_base::send_buffer_size send_buffer_size2;
    sock.get_option(send_buffer_size2);
    send_buffer_size1 = 1;
    static_cast<int>(send_buffer_size1.value());

    // send_low_watermark class.

    socket_base::send_low_watermark send_low_watermark1(128);
    sock.set_option(send_low_watermark1);
    socket_base::send_low_watermark send_low_watermark2;
    sock.get_option(send_low_watermark2);
    send_low_watermark1 = 1;
    static_cast<int>(send_low_watermark1.value());

    // receive_buffer_size class.

    socket_base::receive_buffer_size receive_buffer_size1(1024);
    sock.set_option(receive_buffer_size1);
    socket_base::receive_buffer_size receive_buffer_size2;
    sock.get_option(receive_buffer_size2);
    receive_buffer_size1 = 1;
    static_cast<int>(receive_buffer_size1.value());

    // receive_low_watermark class.

    socket_base::receive_low_watermark receive_low_watermark1(128);
    sock.set_option(receive_low_watermark1);
    socket_base::receive_low_watermark receive_low_watermark2;
    sock.get_option(receive_low_watermark2);
    receive_low_watermark1 = 1;
    static_cast<int>(receive_low_watermark1.value());

    // reuse_address class.

    socket_base::reuse_address reuse_address1(true);
    sock.set_option(reuse_address1);
    socket_base::reuse_address reuse_address2;
    sock.get_option(reuse_address2);
    reuse_address1 = true;
    static_cast<bool>(reuse_address1);
    static_cast<bool>(!reuse_address1);
    static_cast<bool>(reuse_address1.value());

    // linger class.

    socket_base::linger linger1(true, 30);
    sock.set_option(linger1);
    socket_base::linger linger2;
    sock.get_option(linger2);
    linger1.enabled(true);
    static_cast<bool>(linger1.enabled());
    linger1.timeout(1);
    static_cast<int>(linger1.timeout());

    // enable_connection_aborted class.

    socket_base::enable_connection_aborted enable_connection_aborted1(true);
    sock.set_option(enable_connection_aborted1);
    socket_base::enable_connection_aborted enable_connection_aborted2;
    sock.get_option(enable_connection_aborted2);
    enable_connection_aborted1 = true;
    static_cast<bool>(enable_connection_aborted1);
    static_cast<bool>(!enable_connection_aborted1);
    static_cast<bool>(enable_connection_aborted1.value());

    // non_blocking_io class.

    socket_base::non_blocking_io non_blocking_io(true);
    sock.io_control(non_blocking_io);

    // bytes_readable class.

    socket_base::bytes_readable bytes_readable;
    sock.io_control(bytes_readable);
    std::size_t bytes = bytes_readable.get();
    (void)bytes;
  }
  catch (std::exception&)
  {
  }
}

} // namespace socket_base_compile

//------------------------------------------------------------------------------

// socket_base_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the socket options and I/O
// control commands defined in socket_base.

namespace socket_base_runtime {

void test()
{
  using namespace boost::asio;
  namespace ip = boost::asio::ip;

  io_service ios;
  ip::udp::socket udp_sock(ios, ip::udp::v4());
  ip::tcp::socket tcp_sock(ios, ip::tcp::v4());
  ip::tcp::acceptor tcp_acceptor(ios, ip::tcp::v4());
  boost::system::error_code ec;

  // broadcast class.

  socket_base::broadcast broadcast1(true);
  BOOST_CHECK(broadcast1.value());
  BOOST_CHECK(static_cast<bool>(broadcast1));
  BOOST_CHECK(!!broadcast1);
  udp_sock.set_option(broadcast1, ec);
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());

  socket_base::broadcast broadcast2;
  udp_sock.get_option(broadcast2, ec);
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
  BOOST_CHECK(broadcast2.value());
  BOOST_CHECK(static_cast<bool>(broadcast2));
  BOOST_CHECK(!!broadcast2);

  socket_base::broadcast broadcast3(false);
  BOOST_CHECK(!broadcast3.value());
  BOOST_CHECK(!static_cast<bool>(broadcast3));
  BOOST_CHECK(!broadcast3);
  udp_sock.set_option(broadcast3, ec);
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());

  socket_base::broadcast broadcast4;
  udp_sock.get_option(broadcast4, ec);
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
  BOOST_CHECK(!broadcast4.value());
  BOOST_CHECK(!static_cast<bool>(broadcast4));
  BOOST_CHECK(!broadcast4);

  // debug class.

  socket_base::debug debug1(true);
  BOOST_CHECK(debug1.value());
  BOOST_CHECK(static_cast<bool>(debug1));
  BOOST_CHECK(!!debug1);
  udp_sock.set_option(debug1, ec);
#if defined(__linux__)
  // On Linux, only root can set SO_DEBUG.
  bool not_root = (ec == boost::asio::error::access_denied);
  BOOST_CHECK(!ec || not_root);
  BOOST_WARN_MESSAGE(!ec, "Must be root to set debug socket option");
#else // defined(__linux__)
# if defined(BOOST_WINDOWS) && defined(UNDER_CE)
  // Option is not supported under Windows CE.
  BOOST_CHECK_MESSAGE(ec == boost::asio::error::no_protocol_option,
      ec.value() << ", " << ec.message());
# else // defined(BOOST_WINDOWS) && defined(UNDER_CE)
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# endif // defined(BOOST_WINDOWS) && defined(UNDER_CE)
#endif // defined(__linux__)

  socket_base::debug debug2;
  udp_sock.get_option(debug2, ec);
#if defined(BOOST_WINDOWS) && defined(UNDER_CE)
  // Option is not supported under Windows CE.
  BOOST_CHECK_MESSAGE(ec == boost::asio::error::no_protocol_option,
      ec.value() << ", " << ec.message());
#else // defined(BOOST_WINDOWS) && defined(UNDER_CE)
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# if defined(__linux__)
  BOOST_CHECK(debug2.value() || not_root);
  BOOST_CHECK(static_cast<bool>(debug2) || not_root);
  BOOST_CHECK(!!debug2 || not_root);
# else // defined(__linux__)
  BOOST_CHECK(debug2.value());
  BOOST_CHECK(static_cast<bool>(debug2));
  BOOST_CHECK(!!debug2);
# endif // defined(__linux__)
#endif // defined(BOOST_WINDOWS) && defined(UNDER_CE)

  socket_base::debug debug3(false);
  BOOST_CHECK(!debug3.value());
  BOOST_CHECK(!static_cast<bool>(debug3));
  BOOST_CHECK(!debug3);
  udp_sock.set_option(debug3, ec);
#if defined(__linux__)
  BOOST_CHECK(!ec || not_root);
#else // defined(__linux__)
# if defined(BOOST_WINDOWS) && defined(UNDER_CE)
  // Option is not supported under Windows CE.
  BOOST_CHECK_MESSAGE(ec == boost::asio::error::no_protocol_option,
      ec.value() << ", " << ec.message());
# else // defined(BOOST_WINDOWS) && defined(UNDER_CE)
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# endif // defined(BOOST_WINDOWS) && defined(UNDER_CE)
#endif // defined(__linux__)

  socket_base::debug debug4;
  udp_sock.get_option(debug4, ec);
#if defined(BOOST_WINDOWS) && defined(UNDER_CE)
  // Option is not supported under Windows CE.
  BOOST_CHECK_MESSAGE(ec == boost::asio::error::no_protocol_option,
      ec.value() << ", " << ec.message());
#else // defined(BOOST_WINDOWS) && defined(UNDER_CE)
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# if defined(__linux__)
  BOOST_CHECK(!debug4.value() || not_root);
  BOOST_CHECK(!static_cast<bool>(debug4) || not_root);
  BOOST_CHECK(!debug4 || not_root);
# else // defined(__linux__)
  BOOST_CHECK(!debug4.value());
  BOOST_CHECK(!static_cast<bool>(debug4));
  BOOST_CHECK(!debug4);
# endif // defined(__linux__)
#endif // defined(BOOST_WINDOWS) && defined(UNDER_CE)

  // do_not_route class.

  socket_base::do_not_route do_not_route1(true);
  BOOST_CHECK(do_not_route1.value());
  BOOST_CHECK(static_cast<bool>(do_not_route1));
  BOOST_CHECK(!!do_not_route1);
  udp_sock.set_option(do_not_route1, ec);
#if defined(BOOST_WINDOWS) && defined(UNDER_CE)
  // Option is not supported under Windows CE.
  BOOST_CHECK_MESSAGE(ec == boost::asio::error::no_protocol_option,
      ec.value() << ", " << ec.message());
#else // defined(BOOST_WINDOWS) && defined(UNDER_CE)
  BOOST_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(BOOST_WINDOWS) && defined(UNDER_CE)