boost/asio
2
0
Fork 0
mirror of https://github.com/boostorg/asio.git synced 2026-01-24 17:42:08 +00:00
Code Issues Projects Releases Wiki Activity
Files
a2000c8a38b7d626da7ed538c36c9f044ffb01fa
asio/test/ip/address_v4.cpp
Christopher Kohlhoff 7139b456d2 Changes for asio version 1.5.0: 
* Added support for timeouts on socket iostreams, such as
  ip::tcp::iostream. A timeout is set by calling expires_at() or
  expires_from_now() to establish a deadline. Any socket operations
  which occur past the deadline will put the iostream into a bad state.

* Added a new error() member function to socket iostreams, for
  retrieving the error code from the most recent system call.

* Added a new basic_deadline_timer::cancel_one() function. This function
  lets you cancel a single waiting handler on a timer. Handlers are
  cancelled in FIFO order.

* Added a new transfer_exactly() completion condition. This can be used
  to send or receive a specified number of bytes even if the total size
  of the buffer (or buffer sequence) is larger.

* Added new free functions connect() and async_connect(). These
  operations try each endpoint in a list until the socket is
  successfully connected.

* Extended the buffer_size() function so that it works for buffer
  sequences in addition to individual buffers.

* Added a new buffer_copy() function that can be used to copy the raw
  bytes between individual buffers and buffer sequences.

* Added new non-throwing overloads of read(), read_at(), write() and
  write_at() that do not require a completion condition.

* Added friendlier compiler errors for when a completion handler does
  not meet the necessary type requirements. When C++0x is available
  (currently supported for g++ 4.5 or later, and MSVC 10), static_assert
  is also used to generate an informative error message. Checking may be
  disabled by defining BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS.

* Made the is_loopback(), is_unspecified() and is_multicast() functions
  consistently available across the ip::address, ip::address_v4 and
  ip::address_v6 classes. Refs #3939.

* Added new non_blocking() functions for managing the non-blocking
  behaviour of a socket or descriptor. The io_control() commands named
  non_blocking_io are now deprecated in favour of these new functions.

* Added new native_non_blocking() functions for managing the
  non-blocking mode of the underlying socket or descriptor. These
  functions are intended to allow the encapsulation of arbitrary
  non-blocking system calls as asynchronous operations, in a way that is
  transparent to the user of the socket object. The functions have no
  effect on the behaviour of the synchronous operations of the socket or
  descriptor. Refs #3307.

* Added the io_control() member function for socket acceptors.
  Refs #3297.

* For consistency with the C++0x standard library, deprecated the
  native_type typedefs in favour of native_handle_type, and the native()
  member functions in favour of native_handle().

* Added a release() member function to posix descriptors. This function
  releases ownership of the underlying native descriptor to the caller.
  Refs #3900.

* Added support for sequenced packet sockets (SOCK_SEQPACKET).

* Added a new io_service::stopped() function that can be used to
  determine whether the io_service has stopped (i.e. a reset() call is
  needed prior to any further calls to run(), run_one(), poll() or
  poll_one()).

* Reduced the copying of handler function objects.

* Added support for C++0x move construction to further reduce copying of
  handler objects. Move support is enabled when compiling in -std=c++0x
  mode on g++ 4.5 or higher, or when using MSVC10.

* Removed the dependency on OS-provided macros for the well-known IPv4
  and IPv6 addresses. This should eliminate the annoying "missing braces
  around initializer" warnings. Refs #3741.

* Reduced the size of ip::basic_endpoint<> objects (such as
  ip::tcp::endpoint and ip::udp::endpoint).

* Changed the reactor backends to assume that any descriptors or sockets
  added using assign() may have been dup()-ed, and so require explicit
  deregistration from the reactor. Refs #4971.

* Changed the SSL error category to return error strings from the
  OpenSSL library.

* Changed the separate compilation support such that, to use Asio's SSL
  capabilities, you should also include 'asio/ssl/impl/src.hpp in one
  source file in your program.

* Removed the deprecated member functions named io_service(). The
  get_io_service() member functions should be used instead.

* Removed the deprecated typedefs resolver_query and resolver_iterator
  from the ip::tcp, ip::udp and ip::icmp classes.

* Fixed a compile error on some versions of g++ due to anonymous enums.
  Refs #4883.

* Added an explicit cast to the FIONBIO constant to int to suppress a
  compiler warning on some platforms. Refs #5128.

* Fixed warnings reported by g++'s -Wshadow compiler option. Refs #3905.


[SVN r69194]
2011-02-23 01:04:16 +00:00

270 lines
8.4 KiB
C++
Raw Blame History

//
// address_v4.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2011 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/ip/address_v4.hpp>
#include "../unit_test.hpp"
#include <sstream>
//------------------------------------------------------------------------------
// ip_address_v4_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::address_v4 compile and link correctly. Runtime failures are ignored.
namespace ip_address_v4_compile {
void test()
{
using namespace boost::asio;
namespace ip = boost::asio::ip;
try
{
boost::system::error_code ec;
// address_v4 constructors.
ip::address_v4 addr1;
const ip::address_v4::bytes_type const_bytes_value = { { 127, 0, 0, 1 } };
ip::address_v4 addr2(const_bytes_value);
const unsigned long const_ulong_value = 0x7F000001;
ip::address_v4 addr3(const_ulong_value);
// address_v4 functions.
bool b = addr1.is_loopback();
(void)b;
b = addr1.is_unspecified();
(void)b;
b = addr1.is_class_a();
(void)b;
b = addr1.is_class_b();
(void)b;
b = addr1.is_class_c();
(void)b;
b = addr1.is_multicast();
(void)b;
ip::address_v4::bytes_type bytes_value = addr1.to_bytes();
(void)bytes_value;
unsigned long ulong_value = addr1.to_ulong();
(void)ulong_value;
std::string string_value = addr1.to_string();
string_value = addr1.to_string(ec);
// address_v4 static functions.
addr1 = ip::address_v4::from_string("127.0.0.1");
addr1 = ip::address_v4::from_string("127.0.0.1", ec);
addr1 = ip::address_v4::from_string(string_value);
addr1 = ip::address_v4::from_string(string_value, ec);
addr1 = ip::address_v4::any();
addr1 = ip::address_v4::loopback();
addr1 = ip::address_v4::broadcast();
addr1 = ip::address_v4::broadcast(addr2, addr3);
addr1 = ip::address_v4::netmask(addr2);
// address_v4 comparisons.
b = (addr1 == addr2);
(void)b;
b = (addr1 != addr2);
(void)b;
b = (addr1 < addr2);
(void)b;
b = (addr1 > addr2);
(void)b;
b = (addr1 <= addr2);
(void)b;
b = (addr1 >= addr2);
(void)b;
// address_v4 I/O.
std::ostringstream os;
os << addr1;
#if !defined(BOOST_NO_STD_WSTREAMBUF)
std::wostringstream wos;
wos << addr1;
#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
}
catch (std::exception&)
{
}
}
} // namespace ip_address_v4_compile
//------------------------------------------------------------------------------
// ip_address_v4_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that the various public member functions meet the
// necessary postconditions.
namespace ip_address_v4_runtime {
void test()
{
using boost::asio::ip::address_v4;
address_v4 a1;
BOOST_CHECK(a1.to_bytes()[0] == 0);
BOOST_CHECK(a1.to_bytes()[1] == 0);
BOOST_CHECK(a1.to_bytes()[2] == 0);
BOOST_CHECK(a1.to_bytes()[3] == 0);
BOOST_CHECK(a1.to_ulong() == 0);
address_v4::bytes_type b1 = {{ 1, 2, 3, 4 }};
address_v4 a2(b1);
BOOST_CHECK(a2.to_bytes()[0] == 1);
BOOST_CHECK(a2.to_bytes()[1] == 2);
BOOST_CHECK(a2.to_bytes()[2] == 3);
BOOST_CHECK(a2.to_bytes()[3] == 4);
BOOST_CHECK(((a2.to_ulong() >> 24) & 0xFF) == b1[0]);
BOOST_CHECK(((a2.to_ulong() >> 16) & 0xFF) == b1[1]);
BOOST_CHECK(((a2.to_ulong() >> 8) & 0xFF) == b1[2]);
BOOST_CHECK((a2.to_ulong() & 0xFF) == b1[3]);
address_v4 a3(0x01020304);
BOOST_CHECK(a3.to_bytes()[0] == 1);
BOOST_CHECK(a3.to_bytes()[1] == 2);
BOOST_CHECK(a3.to_bytes()[2] == 3);
BOOST_CHECK(a3.to_bytes()[3] == 4);
BOOST_CHECK(a3.to_ulong() == 0x01020304);
BOOST_CHECK(address_v4(0x7F000001).is_loopback());
BOOST_CHECK(address_v4(0x7F000002).is_loopback());
BOOST_CHECK(!address_v4(0x00000000).is_loopback());
BOOST_CHECK(!address_v4(0x01020304).is_loopback());
BOOST_CHECK(address_v4(0x00000000).is_unspecified());
BOOST_CHECK(!address_v4(0x7F000001).is_unspecified());
BOOST_CHECK(!address_v4(0x01020304).is_unspecified());
BOOST_CHECK(address_v4(0x01000000).is_class_a());
BOOST_CHECK(address_v4(0x7F000000).is_class_a());
BOOST_CHECK(!address_v4(0x80000000).is_class_a());
BOOST_CHECK(!address_v4(0xBFFF0000).is_class_a());
BOOST_CHECK(!address_v4(0xC0000000).is_class_a());
BOOST_CHECK(!address_v4(0xDFFFFF00).is_class_a());
BOOST_CHECK(!address_v4(0xE0000000).is_class_a());
BOOST_CHECK(!address_v4(0xEFFFFFFF).is_class_a());
BOOST_CHECK(!address_v4(0xF0000000).is_class_a());
BOOST_CHECK(!address_v4(0xFFFFFFFF).is_class_a());
BOOST_CHECK(!address_v4(0x01000000).is_class_b());
BOOST_CHECK(!address_v4(0x7F000000).is_class_b());
BOOST_CHECK(address_v4(0x80000000).is_class_b());
BOOST_CHECK(address_v4(0xBFFF0000).is_class_b());
BOOST_CHECK(!address_v4(0xC0000000).is_class_b());
BOOST_CHECK(!address_v4(0xDFFFFF00).is_class_b());
BOOST_CHECK(!address_v4(0xE0000000).is_class_b());
BOOST_CHECK(!address_v4(0xEFFFFFFF).is_class_b());
BOOST_CHECK(!address_v4(0xF0000000).is_class_b());
BOOST_CHECK(!address_v4(0xFFFFFFFF).is_class_b());
BOOST_CHECK(!address_v4(0x01000000).is_class_c());
BOOST_CHECK(!address_v4(0x7F000000).is_class_c());
BOOST_CHECK(!address_v4(0x80000000).is_class_c());
BOOST_CHECK(!address_v4(0xBFFF0000).is_class_c());
BOOST_CHECK(address_v4(0xC0000000).is_class_c());
BOOST_CHECK(address_v4(0xDFFFFF00).is_class_c());
BOOST_CHECK(!address_v4(0xE0000000).is_class_c());
BOOST_CHECK(!address_v4(0xEFFFFFFF).is_class_c());
BOOST_CHECK(!address_v4(0xF0000000).is_class_c());
BOOST_CHECK(!address_v4(0xFFFFFFFF).is_class_c());
BOOST_CHECK(!address_v4(0x01000000).is_multicast());
BOOST_CHECK(!address_v4(0x7F000000).is_multicast());
BOOST_CHECK(!address_v4(0x80000000).is_multicast());
BOOST_CHECK(!address_v4(0xBFFF0000).is_multicast());
BOOST_CHECK(!address_v4(0xC0000000).is_multicast());
BOOST_CHECK(!address_v4(0xDFFFFF00).is_multicast());
BOOST_CHECK(address_v4(0xE0000000).is_multicast());
BOOST_CHECK(address_v4(0xEFFFFFFF).is_multicast());
BOOST_CHECK(!address_v4(0xF0000000).is_multicast());
BOOST_CHECK(!address_v4(0xFFFFFFFF).is_multicast());
address_v4 a4 = address_v4::any();
BOOST_CHECK(a4.to_bytes()[0] == 0);
BOOST_CHECK(a4.to_bytes()[1] == 0);
BOOST_CHECK(a4.to_bytes()[2] == 0);
BOOST_CHECK(a4.to_bytes()[3] == 0);
BOOST_CHECK(a4.to_ulong() == 0);
address_v4 a5 = address_v4::loopback();
BOOST_CHECK(a5.to_bytes()[0] == 0x7F);
BOOST_CHECK(a5.to_bytes()[1] == 0);
BOOST_CHECK(a5.to_bytes()[2] == 0);
BOOST_CHECK(a5.to_bytes()[3] == 0x01);
BOOST_CHECK(a5.to_ulong() == 0x7F000001);
address_v4 a6 = address_v4::broadcast();
BOOST_CHECK(a6.to_bytes()[0] == 0xFF);
BOOST_CHECK(a6.to_bytes()[1] == 0xFF);
BOOST_CHECK(a6.to_bytes()[2] == 0xFF);
BOOST_CHECK(a6.to_bytes()[3] == 0xFF);
BOOST_CHECK(a6.to_ulong() == 0xFFFFFFFF);
address_v4 class_a_net(0xFF000000);
address_v4 class_b_net(0xFFFF0000);
address_v4 class_c_net(0xFFFFFF00);
address_v4 other_net(0xFFFFFFFF);
BOOST_CHECK(address_v4::netmask(address_v4(0x01000000)) == class_a_net);
BOOST_CHECK(address_v4::netmask(address_v4(0x7F000000)) == class_a_net);
BOOST_CHECK(address_v4::netmask(address_v4(0x80000000)) == class_b_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xBFFF0000)) == class_b_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xC0000000)) == class_c_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xDFFFFF00)) == class_c_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xE0000000)) == other_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xEFFFFFFF)) == other_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xF0000000)) == other_net);
BOOST_CHECK(address_v4::netmask(address_v4(0xFFFFFFFF)) == other_net);
}
} // namespace ip_address_v4_runtime
//------------------------------------------------------------------------------
test_suite* init_unit_test_suite(int, char*[])
{
test_suite* test = BOOST_TEST_SUITE("ip/address_v4");
test->add(BOOST_TEST_CASE(&ip_address_v4_compile::test));
test->add(BOOST_TEST_CASE(&ip_address_v4_runtime::test));
return test;
}
Reference in New Issue View Git Blame Copy Permalink