diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 18:24:20 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 18:24:20 +0000 |
commit | 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 (patch) | |
tree | e5d88d25d870d5dedacb6bbdbe2a966086a0a5cf /src/boost/libs/asio/test/generic | |
parent | Initial commit. (diff) | |
download | ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.tar.xz ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.zip |
Adding upstream version 14.2.21.upstream/14.2.21upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/boost/libs/asio/test/generic')
-rw-r--r-- | src/boost/libs/asio/test/generic/basic_endpoint.cpp | 25 | ||||
-rw-r--r-- | src/boost/libs/asio/test/generic/datagram_protocol.cpp | 263 | ||||
-rw-r--r-- | src/boost/libs/asio/test/generic/raw_protocol.cpp | 263 | ||||
-rw-r--r-- | src/boost/libs/asio/test/generic/seq_packet_protocol.cpp | 205 | ||||
-rw-r--r-- | src/boost/libs/asio/test/generic/stream_protocol.cpp | 248 |
5 files changed, 1004 insertions, 0 deletions
diff --git a/src/boost/libs/asio/test/generic/basic_endpoint.cpp b/src/boost/libs/asio/test/generic/basic_endpoint.cpp new file mode 100644 index 00000000..01f2c8fa --- /dev/null +++ b/src/boost/libs/asio/test/generic/basic_endpoint.cpp @@ -0,0 +1,25 @@ +// +// generic/basic_endpoint.cpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2019 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/generic/basic_endpoint.hpp> + +#include "../unit_test.hpp" + +BOOST_ASIO_TEST_SUITE +( + "generic/basic_endpoint", + BOOST_ASIO_TEST_CASE(null_test) +) diff --git a/src/boost/libs/asio/test/generic/datagram_protocol.cpp b/src/boost/libs/asio/test/generic/datagram_protocol.cpp new file mode 100644 index 00000000..3191c8f2 --- /dev/null +++ b/src/boost/libs/asio/test/generic/datagram_protocol.cpp @@ -0,0 +1,263 @@ +// +// generic/datagram_protocol.cpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2019 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/generic/datagram_protocol.hpp> + +#include <cstring> +#include <boost/asio/io_context.hpp> +#include <boost/asio/ip/udp.hpp> +#include "../unit_test.hpp" + +#if defined(__cplusplus_cli) || defined(__cplusplus_winrt) +# define generic cpp_generic +#endif + +//------------------------------------------------------------------------------ + +// generic_datagram_protocol_socket_compile test +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// The following test checks that all public member functions on the class +// generic::datagram_socket::socket compile and link correctly. Runtime +// failures are ignored. + +namespace generic_datagram_protocol_socket_compile { + +void connect_handler(const boost::system::error_code&) +{ +} + +void send_handler(const boost::system::error_code&, std::size_t) +{ +} + +void receive_handler(const boost::system::error_code&, std::size_t) +{ +} + +void test() +{ + using namespace boost::asio; + namespace generic = boost::asio::generic; + typedef generic::datagram_protocol dp; + + const int af_inet = BOOST_ASIO_OS_DEF(AF_INET); + const int ipproto_udp = BOOST_ASIO_OS_DEF(IPPROTO_UDP); + const int sock_dgram = BOOST_ASIO_OS_DEF(SOCK_DGRAM); + + try + { + io_context ioc; + char mutable_char_buffer[128] = ""; + const char const_char_buffer[128] = ""; + socket_base::message_flags in_flags = 0; + socket_base::send_buffer_size socket_option; + socket_base::bytes_readable io_control_command; + boost::system::error_code ec; + + // basic_datagram_socket constructors. + + dp::socket socket1(ioc); + dp::socket socket2(ioc, dp(af_inet, ipproto_udp)); + dp::socket socket3(ioc, dp::endpoint()); +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + dp::socket::native_handle_type native_socket1 + = ::socket(af_inet, sock_dgram, 0); + dp::socket socket4(ioc, dp(af_inet, ipproto_udp), native_socket1); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_HAS_MOVE) + dp::socket socket5(std::move(socket4)); + boost::asio::ip::udp::socket udp_socket(ioc); + dp::socket socket6(std::move(udp_socket)); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_datagram_socket operators. + +#if defined(BOOST_ASIO_HAS_MOVE) + socket1 = dp::socket(ioc); + socket1 = std::move(socket2); + socket1 = boost::asio::ip::udp::socket(ioc); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_io_object functions. + + dp::socket::executor_type ex = socket1.get_executor(); + (void)ex; + + // basic_socket functions. + + dp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer(); + (void)lowest_layer; + + socket1.open(dp(af_inet, ipproto_udp)); + socket1.open(dp(af_inet, ipproto_udp), ec); + +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + dp::socket::native_handle_type native_socket2 + = ::socket(af_inet, sock_dgram, 0); + socket1.assign(dp(af_inet, ipproto_udp), native_socket2); + dp::socket::native_handle_type native_socket3 + = ::socket(af_inet, sock_dgram, 0); + socket1.assign(dp(af_inet, ipproto_udp), native_socket3, ec); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + + bool is_open = socket1.is_open(); + (void)is_open; + + socket1.close(); + socket1.close(ec); + + dp::socket::native_handle_type native_socket4 = socket1.native_handle(); + (void)native_socket4; + + socket1.cancel(); + socket1.cancel(ec); + + bool at_mark1 = socket1.at_mark(); + (void)at_mark1; + bool at_mark2 = socket1.at_mark(ec); + (void)at_mark2; + + std::size_t available1 = socket1.available(); + (void)available1; + std::size_t available2 = socket1.available(ec); + (void)available2; + + socket1.bind(dp::endpoint()); + socket1.bind(dp::endpoint(), ec); + + socket1.connect(dp::endpoint()); + socket1.connect(dp::endpoint(), ec); + + socket1.async_connect(dp::endpoint(), connect_handler); + + socket1.set_option(socket_option); + socket1.set_option(socket_option, ec); + + socket1.get_option(socket_option); + socket1.get_option(socket_option, ec); + + socket1.io_control(io_control_command); + socket1.io_control(io_control_command, ec); + + dp::endpoint endpoint1 = socket1.local_endpoint(); + (void)endpoint1; + dp::endpoint endpoint2 = socket1.local_endpoint(ec); + (void)endpoint2; + + dp::endpoint endpoint3 = socket1.remote_endpoint(); + (void)endpoint3; + dp::endpoint endpoint4 = socket1.remote_endpoint(ec); + (void)endpoint4; + + socket1.shutdown(socket_base::shutdown_both); + socket1.shutdown(socket_base::shutdown_both, ec); + + // basic_datagram_socket functions. + + socket1.send(buffer(mutable_char_buffer)); + socket1.send(buffer(const_char_buffer)); + socket1.send(null_buffers()); + socket1.send(buffer(mutable_char_buffer), in_flags); + socket1.send(buffer(const_char_buffer), in_flags); + socket1.send(null_buffers(), in_flags); + socket1.send(buffer(mutable_char_buffer), in_flags, ec); + socket1.send(buffer(const_char_buffer), in_flags, ec); + socket1.send(null_buffers(), in_flags, ec); + + socket1.async_send(buffer(mutable_char_buffer), send_handler); + socket1.async_send(buffer(const_char_buffer), send_handler); + socket1.async_send(null_buffers(), send_handler); + socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler); + socket1.async_send(buffer(const_char_buffer), in_flags, send_handler); + socket1.async_send(null_buffers(), in_flags, send_handler); + + socket1.send_to(buffer(mutable_char_buffer), + dp::endpoint()); + socket1.send_to(buffer(const_char_buffer), + dp::endpoint()); + socket1.send_to(null_buffers(), + dp::endpoint()); + socket1.send_to(buffer(mutable_char_buffer), + dp::endpoint(), in_flags); + socket1.send_to(buffer(const_char_buffer), + dp::endpoint(), in_flags); + socket1.send_to(null_buffers(), + dp::endpoint(), in_flags); + socket1.send_to(buffer(mutable_char_buffer), + dp::endpoint(), in_flags, ec); + socket1.send_to(buffer(const_char_buffer), + dp::endpoint(), in_flags, ec); + socket1.send_to(null_buffers(), + dp::endpoint(), in_flags, ec); + + socket1.async_send_to(buffer(mutable_char_buffer), + dp::endpoint(), send_handler); + socket1.async_send_to(buffer(const_char_buffer), + dp::endpoint(), send_handler); + socket1.async_send_to(null_buffers(), + dp::endpoint(), send_handler); + socket1.async_send_to(buffer(mutable_char_buffer), + dp::endpoint(), in_flags, send_handler); + socket1.async_send_to(buffer(const_char_buffer), + dp::endpoint(), in_flags, send_handler); + socket1.async_send_to(null_buffers(), + dp::endpoint(), in_flags, send_handler); + + socket1.receive(buffer(mutable_char_buffer)); + socket1.receive(null_buffers()); + socket1.receive(buffer(mutable_char_buffer), in_flags); + socket1.receive(null_buffers(), in_flags); + socket1.receive(buffer(mutable_char_buffer), in_flags, ec); + socket1.receive(null_buffers(), in_flags, ec); + + socket1.async_receive(buffer(mutable_char_buffer), receive_handler); + socket1.async_receive(null_buffers(), receive_handler); + socket1.async_receive(buffer(mutable_char_buffer), in_flags, + receive_handler); + socket1.async_receive(null_buffers(), in_flags, receive_handler); + + dp::endpoint endpoint; + socket1.receive_from(buffer(mutable_char_buffer), endpoint); + socket1.receive_from(null_buffers(), endpoint); + socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags); + socket1.receive_from(null_buffers(), endpoint, in_flags); + socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec); + socket1.receive_from(null_buffers(), endpoint, in_flags, ec); + + socket1.async_receive_from(buffer(mutable_char_buffer), + endpoint, receive_handler); + socket1.async_receive_from(null_buffers(), + endpoint, receive_handler); + socket1.async_receive_from(buffer(mutable_char_buffer), + endpoint, in_flags, receive_handler); + socket1.async_receive_from(null_buffers(), + endpoint, in_flags, receive_handler); + } + catch (std::exception&) + { + } +} + +} // namespace generic_datagram_protocol_socket_compile + +//------------------------------------------------------------------------------ + +BOOST_ASIO_TEST_SUITE +( + "generic/datagram_protocol", + BOOST_ASIO_TEST_CASE(generic_datagram_protocol_socket_compile::test) +) diff --git a/src/boost/libs/asio/test/generic/raw_protocol.cpp b/src/boost/libs/asio/test/generic/raw_protocol.cpp new file mode 100644 index 00000000..9dc67732 --- /dev/null +++ b/src/boost/libs/asio/test/generic/raw_protocol.cpp @@ -0,0 +1,263 @@ +// +// generic/raw_protocol.cpp +// ~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2019 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/generic/raw_protocol.hpp> + +#include <cstring> +#include <boost/asio/io_context.hpp> +#include <boost/asio/ip/icmp.hpp> +#include "../unit_test.hpp" + +#if defined(__cplusplus_cli) || defined(__cplusplus_winrt) +# define generic cpp_generic +#endif + +//------------------------------------------------------------------------------ + +// generic_raw_protocol_socket_compile test +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// The following test checks that all public member functions on the class +// generic::raw_socket::socket compile and link correctly. Runtime failures +// are ignored. + +namespace generic_raw_protocol_socket_compile { + +void connect_handler(const boost::system::error_code&) +{ +} + +void send_handler(const boost::system::error_code&, std::size_t) +{ +} + +void receive_handler(const boost::system::error_code&, std::size_t) +{ +} + +void test() +{ + using namespace boost::asio; + namespace generic = boost::asio::generic; + typedef generic::raw_protocol rp; + + const int af_inet = BOOST_ASIO_OS_DEF(AF_INET); + const int ipproto_icmp = BOOST_ASIO_OS_DEF(IPPROTO_ICMP); + const int sock_raw = BOOST_ASIO_OS_DEF(SOCK_RAW); + + try + { + io_context ioc; + char mutable_char_buffer[128] = ""; + const char const_char_buffer[128] = ""; + socket_base::message_flags in_flags = 0; + socket_base::send_buffer_size socket_option; + socket_base::bytes_readable io_control_command; + boost::system::error_code ec; + + // basic_raw_socket constructors. + + rp::socket socket1(ioc); + rp::socket socket2(ioc, rp(af_inet, ipproto_icmp)); + rp::socket socket3(ioc, rp::endpoint()); +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + rp::socket::native_handle_type native_socket1 + = ::socket(af_inet, sock_raw, 0); + rp::socket socket4(ioc, rp(af_inet, ipproto_icmp), native_socket1); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_HAS_MOVE) + rp::socket socket5(std::move(socket4)); + boost::asio::ip::icmp::socket icmp_socket(ioc); + rp::socket socket6(std::move(icmp_socket)); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_datagram_socket operators. + +#if defined(BOOST_ASIO_HAS_MOVE) + socket1 = rp::socket(ioc); + socket1 = std::move(socket2); + socket1 = boost::asio::ip::icmp::socket(ioc); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_io_object functions. + + rp::socket::executor_type ex = socket1.get_executor(); + (void)ex; + + // basic_socket functions. + + rp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer(); + (void)lowest_layer; + + socket1.open(rp(af_inet, ipproto_icmp)); + socket1.open(rp(af_inet, ipproto_icmp), ec); + +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + rp::socket::native_handle_type native_socket2 + = ::socket(af_inet, sock_raw, 0); + socket1.assign(rp(af_inet, ipproto_icmp), native_socket2); + rp::socket::native_handle_type native_socket3 + = ::socket(af_inet, sock_raw, 0); + socket1.assign(rp(af_inet, ipproto_icmp), native_socket3, ec); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + + bool is_open = socket1.is_open(); + (void)is_open; + + socket1.close(); + socket1.close(ec); + + rp::socket::native_handle_type native_socket4 = socket1.native_handle(); + (void)native_socket4; + + socket1.cancel(); + socket1.cancel(ec); + + bool at_mark1 = socket1.at_mark(); + (void)at_mark1; + bool at_mark2 = socket1.at_mark(ec); + (void)at_mark2; + + std::size_t available1 = socket1.available(); + (void)available1; + std::size_t available2 = socket1.available(ec); + (void)available2; + + socket1.bind(rp::endpoint()); + socket1.bind(rp::endpoint(), ec); + + socket1.connect(rp::endpoint()); + socket1.connect(rp::endpoint(), ec); + + socket1.async_connect(rp::endpoint(), connect_handler); + + socket1.set_option(socket_option); + socket1.set_option(socket_option, ec); + + socket1.get_option(socket_option); + socket1.get_option(socket_option, ec); + + socket1.io_control(io_control_command); + socket1.io_control(io_control_command, ec); + + rp::endpoint endpoint1 = socket1.local_endpoint(); + (void)endpoint1; + rp::endpoint endpoint2 = socket1.local_endpoint(ec); + (void)endpoint2; + + rp::endpoint endpoint3 = socket1.remote_endpoint(); + (void)endpoint3; + rp::endpoint endpoint4 = socket1.remote_endpoint(ec); + (void)endpoint4; + + socket1.shutdown(socket_base::shutdown_both); + socket1.shutdown(socket_base::shutdown_both, ec); + + // basic_raw_socket functions. + + socket1.send(buffer(mutable_char_buffer)); + socket1.send(buffer(const_char_buffer)); + socket1.send(null_buffers()); + socket1.send(buffer(mutable_char_buffer), in_flags); + socket1.send(buffer(const_char_buffer), in_flags); + socket1.send(null_buffers(), in_flags); + socket1.send(buffer(mutable_char_buffer), in_flags, ec); + socket1.send(buffer(const_char_buffer), in_flags, ec); + socket1.send(null_buffers(), in_flags, ec); + + socket1.async_send(buffer(mutable_char_buffer), send_handler); + socket1.async_send(buffer(const_char_buffer), send_handler); + socket1.async_send(null_buffers(), send_handler); + socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler); + socket1.async_send(buffer(const_char_buffer), in_flags, send_handler); + socket1.async_send(null_buffers(), in_flags, send_handler); + + socket1.send_to(buffer(mutable_char_buffer), + rp::endpoint()); + socket1.send_to(buffer(const_char_buffer), + rp::endpoint()); + socket1.send_to(null_buffers(), + rp::endpoint()); + socket1.send_to(buffer(mutable_char_buffer), + rp::endpoint(), in_flags); + socket1.send_to(buffer(const_char_buffer), + rp::endpoint(), in_flags); + socket1.send_to(null_buffers(), + rp::endpoint(), in_flags); + socket1.send_to(buffer(mutable_char_buffer), + rp::endpoint(), in_flags, ec); + socket1.send_to(buffer(const_char_buffer), + rp::endpoint(), in_flags, ec); + socket1.send_to(null_buffers(), + rp::endpoint(), in_flags, ec); + + socket1.async_send_to(buffer(mutable_char_buffer), + rp::endpoint(), send_handler); + socket1.async_send_to(buffer(const_char_buffer), + rp::endpoint(), send_handler); + socket1.async_send_to(null_buffers(), + rp::endpoint(), send_handler); + socket1.async_send_to(buffer(mutable_char_buffer), + rp::endpoint(), in_flags, send_handler); + socket1.async_send_to(buffer(const_char_buffer), + rp::endpoint(), in_flags, send_handler); + socket1.async_send_to(null_buffers(), + rp::endpoint(), in_flags, send_handler); + + socket1.receive(buffer(mutable_char_buffer)); + socket1.receive(null_buffers()); + socket1.receive(buffer(mutable_char_buffer), in_flags); + socket1.receive(null_buffers(), in_flags); + socket1.receive(buffer(mutable_char_buffer), in_flags, ec); + socket1.receive(null_buffers(), in_flags, ec); + + socket1.async_receive(buffer(mutable_char_buffer), receive_handler); + socket1.async_receive(null_buffers(), receive_handler); + socket1.async_receive(buffer(mutable_char_buffer), in_flags, + receive_handler); + socket1.async_receive(null_buffers(), in_flags, receive_handler); + + rp::endpoint endpoint; + socket1.receive_from(buffer(mutable_char_buffer), endpoint); + socket1.receive_from(null_buffers(), endpoint); + socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags); + socket1.receive_from(null_buffers(), endpoint, in_flags); + socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec); + socket1.receive_from(null_buffers(), endpoint, in_flags, ec); + + socket1.async_receive_from(buffer(mutable_char_buffer), + endpoint, receive_handler); + socket1.async_receive_from(null_buffers(), + endpoint, receive_handler); + socket1.async_receive_from(buffer(mutable_char_buffer), + endpoint, in_flags, receive_handler); + socket1.async_receive_from(null_buffers(), + endpoint, in_flags, receive_handler); + } + catch (std::exception&) + { + } +} + +} // namespace generic_raw_protocol_socket_compile + +//------------------------------------------------------------------------------ + +BOOST_ASIO_TEST_SUITE +( + "generic/raw_protocol", + BOOST_ASIO_TEST_CASE(generic_raw_protocol_socket_compile::test) +) diff --git a/src/boost/libs/asio/test/generic/seq_packet_protocol.cpp b/src/boost/libs/asio/test/generic/seq_packet_protocol.cpp new file mode 100644 index 00000000..c5860633 --- /dev/null +++ b/src/boost/libs/asio/test/generic/seq_packet_protocol.cpp @@ -0,0 +1,205 @@ +// +// generic/seq_packet_protocol.cpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2019 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/generic/seq_packet_protocol.hpp> + +#include <cstring> +#include <boost/asio/io_context.hpp> +#include "../unit_test.hpp" + +#if defined(__cplusplus_cli) || defined(__cplusplus_winrt) +# define generic cpp_generic +#endif + +//------------------------------------------------------------------------------ + +// generic_seq_packet_protocol_socket_compile test +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// The following test checks that all public member functions on the class +// generic::seq_packet_socket::socket compile and link correctly. Runtime +// failures are ignored. + +namespace generic_seq_packet_protocol_socket_compile { + +void connect_handler(const boost::system::error_code&) +{ +} + +void send_handler(const boost::system::error_code&, std::size_t) +{ +} + +void receive_handler(const boost::system::error_code&, std::size_t) +{ +} + +void test() +{ + using namespace boost::asio; + namespace generic = boost::asio::generic; + typedef generic::seq_packet_protocol spp; + + const int af_inet = BOOST_ASIO_OS_DEF(AF_INET); + const int sock_seqpacket = BOOST_ASIO_OS_DEF(SOCK_SEQPACKET); + + try + { + io_context ioc; + char mutable_char_buffer[128] = ""; + const char const_char_buffer[128] = ""; + const socket_base::message_flags in_flags = 0; + socket_base::message_flags out_flags = 0; + socket_base::send_buffer_size socket_option; + socket_base::bytes_readable io_control_command; + boost::system::error_code ec; + + // basic_seq_packet_socket constructors. + + spp::socket socket1(ioc); + spp::socket socket2(ioc, spp(af_inet, 0)); + spp::socket socket3(ioc, spp::endpoint()); +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + spp::socket::native_handle_type native_socket1 + = ::socket(af_inet, sock_seqpacket, 0); + spp::socket socket4(ioc, spp(af_inet, 0), native_socket1); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_HAS_MOVE) + spp::socket socket5(std::move(socket4)); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_seq_packet_socket operators. + +#if defined(BOOST_ASIO_HAS_MOVE) + socket1 = spp::socket(ioc); + socket1 = std::move(socket2); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_io_object functions. + + spp::socket::executor_type ex = socket1.get_executor(); + (void)ex; + + // basic_socket functions. + + spp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer(); + (void)lowest_layer; + + socket1.open(spp(af_inet, 0)); + socket1.open(spp(af_inet, 0), ec); + +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + spp::socket::native_handle_type native_socket2 + = ::socket(af_inet, sock_seqpacket, 0); + socket1.assign(spp(af_inet, 0), native_socket2); + spp::socket::native_handle_type native_socket3 + = ::socket(af_inet, sock_seqpacket, 0); + socket1.assign(spp(af_inet, 0), native_socket3, ec); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + + bool is_open = socket1.is_open(); + (void)is_open; + + socket1.close(); + socket1.close(ec); + + spp::socket::native_handle_type native_socket4 = socket1.native_handle(); + (void)native_socket4; + + socket1.cancel(); + socket1.cancel(ec); + + bool at_mark1 = socket1.at_mark(); + (void)at_mark1; + bool at_mark2 = socket1.at_mark(ec); + (void)at_mark2; + + std::size_t available1 = socket1.available(); + (void)available1; + std::size_t available2 = socket1.available(ec); + (void)available2; + + socket1.bind(spp::endpoint()); + socket1.bind(spp::endpoint(), ec); + + socket1.connect(spp::endpoint()); + socket1.connect(spp::endpoint(), ec); + + socket1.async_connect(spp::endpoint(), connect_handler); + + socket1.set_option(socket_option); + socket1.set_option(socket_option, ec); + + socket1.get_option(socket_option); + socket1.get_option(socket_option, ec); + + socket1.io_control(io_control_command); + socket1.io_control(io_control_command, ec); + + spp::endpoint endpoint1 = socket1.local_endpoint(); + (void)endpoint1; + spp::endpoint endpoint2 = socket1.local_endpoint(ec); + (void)endpoint2; + + spp::endpoint endpoint3 = socket1.remote_endpoint(); + (void)endpoint3; + spp::endpoint endpoint4 = socket1.remote_endpoint(ec); + (void)endpoint4; + + socket1.shutdown(socket_base::shutdown_both); + socket1.shutdown(socket_base::shutdown_both, ec); + + // basic_seq_packet_socket functions. + + socket1.send(buffer(mutable_char_buffer), in_flags); + socket1.send(buffer(const_char_buffer), in_flags); + socket1.send(null_buffers(), in_flags); + socket1.send(buffer(mutable_char_buffer), in_flags, ec); + socket1.send(buffer(const_char_buffer), in_flags, ec); + socket1.send(null_buffers(), in_flags, ec); + + socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler); + socket1.async_send(buffer(const_char_buffer), in_flags, send_handler); + socket1.async_send(null_buffers(), in_flags, send_handler); + + socket1.receive(buffer(mutable_char_buffer), out_flags); + socket1.receive(null_buffers(), out_flags); + socket1.receive(buffer(mutable_char_buffer), in_flags, out_flags); + socket1.receive(null_buffers(), in_flags, out_flags); + socket1.receive(buffer(mutable_char_buffer), in_flags, out_flags, ec); + socket1.receive(null_buffers(), in_flags, out_flags, ec); + + socket1.async_receive(buffer(mutable_char_buffer), out_flags, + receive_handler); + socket1.async_receive(null_buffers(), out_flags, receive_handler); + socket1.async_receive(buffer(mutable_char_buffer), in_flags, + out_flags, receive_handler); + socket1.async_receive(null_buffers(), in_flags, out_flags, receive_handler); + } + catch (std::exception&) + { + } +} + +} // namespace generic_seq_packet_protocol_socket_compile + +//------------------------------------------------------------------------------ + +BOOST_ASIO_TEST_SUITE +( + "generic/seq_packet_protocol", + BOOST_ASIO_TEST_CASE(generic_seq_packet_protocol_socket_compile::test) +) diff --git a/src/boost/libs/asio/test/generic/stream_protocol.cpp b/src/boost/libs/asio/test/generic/stream_protocol.cpp new file mode 100644 index 00000000..ad8a66c1 --- /dev/null +++ b/src/boost/libs/asio/test/generic/stream_protocol.cpp @@ -0,0 +1,248 @@ +// +// generic/stream_protocol.cpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2019 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/generic/stream_protocol.hpp> + +#include <cstring> +#include <boost/asio/io_context.hpp> +#include <boost/asio/ip/tcp.hpp> +#include "../unit_test.hpp" + +#if defined(__cplusplus_cli) || defined(__cplusplus_winrt) +# define generic cpp_generic +#endif + +//------------------------------------------------------------------------------ + +// generic_stream_protocol_socket_compile test +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// The following test checks that all public member functions on the class +// generic::stream_protocol::socket compile and link correctly. Runtime +// failures are ignored. + +namespace generic_stream_protocol_socket_compile { + +void connect_handler(const boost::system::error_code&) +{ +} + +void send_handler(const boost::system::error_code&, std::size_t) +{ +} + +void receive_handler(const boost::system::error_code&, std::size_t) +{ +} + +void write_some_handler(const boost::system::error_code&, std::size_t) +{ +} + +void read_some_handler(const boost::system::error_code&, std::size_t) +{ +} + +void test() +{ + using namespace boost::asio; + namespace generic = boost::asio::generic; + typedef generic::stream_protocol sp; + + const int af_inet = BOOST_ASIO_OS_DEF(AF_INET); + const int ipproto_tcp = BOOST_ASIO_OS_DEF(IPPROTO_TCP); + const int sock_stream = BOOST_ASIO_OS_DEF(SOCK_STREAM); + + try + { + io_context ioc; + char mutable_char_buffer[128] = ""; + const char const_char_buffer[128] = ""; + socket_base::message_flags in_flags = 0; + socket_base::keep_alive socket_option; + socket_base::bytes_readable io_control_command; + boost::system::error_code ec; + + // basic_stream_socket constructors. + + sp::socket socket1(ioc); + sp::socket socket2(ioc, sp(af_inet, ipproto_tcp)); + sp::socket socket3(ioc, sp::endpoint()); +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + Windows::Networking::Sockets::StreamSocket^ native_socket1 = nullptr; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) + sp::socket::native_handle_type native_socket1 + = ::socket(af_inet, sock_stream, 0); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + sp::socket socket4(ioc, sp(af_inet, ipproto_tcp), native_socket1); + +#if defined(BOOST_ASIO_HAS_MOVE) + sp::socket socket5(std::move(socket4)); + boost::asio::ip::tcp::socket tcp_socket(ioc); + sp::socket socket6(std::move(tcp_socket)); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_stream_socket operators. + +#if defined(BOOST_ASIO_HAS_MOVE) + socket1 = sp::socket(ioc); + socket1 = std::move(socket2); + socket1 = boost::asio::ip::tcp::socket(ioc); +#endif // defined(BOOST_ASIO_HAS_MOVE) + + // basic_io_object functions. + + sp::socket::executor_type ex = socket1.get_executor(); + (void)ex; + + // basic_socket functions. + + sp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer(); + (void)lowest_layer; + + socket1.open(sp(af_inet, ipproto_tcp)); + socket1.open(sp(af_inet, ipproto_tcp), ec); + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + Windows::Networking::Sockets::StreamSocket^ native_socket2 = nullptr; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) + sp::socket::native_handle_type native_socket2 + = ::socket(af_inet, sock_stream, 0); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + socket1.assign(sp(af_inet, ipproto_tcp), native_socket2); +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + Windows::Networking::Sockets::StreamSocket^ native_socket3 = nullptr; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) + sp::socket::native_handle_type native_socket3 + = ::socket(af_inet, sock_stream, 0); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + socket1.assign(sp(af_inet, ipproto_tcp), native_socket3, ec); + + bool is_open = socket1.is_open(); + (void)is_open; + + socket1.close(); + socket1.close(ec); + + sp::socket::native_handle_type native_socket4 = socket1.native_handle(); + (void)native_socket4; + + socket1.cancel(); + socket1.cancel(ec); + + bool at_mark1 = socket1.at_mark(); + (void)at_mark1; + bool at_mark2 = socket1.at_mark(ec); + (void)at_mark2; + + std::size_t available1 = socket1.available(); + (void)available1; + std::size_t available2 = socket1.available(ec); + (void)available2; + + socket1.bind(sp::endpoint()); + socket1.bind(sp::endpoint(), ec); + + socket1.connect(sp::endpoint()); + socket1.connect(sp::endpoint(), ec); + + socket1.async_connect(sp::endpoint(), connect_handler); + + socket1.set_option(socket_option); + socket1.set_option(socket_option, ec); + + socket1.get_option(socket_option); + socket1.get_option(socket_option, ec); + + socket1.io_control(io_control_command); + socket1.io_control(io_control_command, ec); + + sp::endpoint endpoint1 = socket1.local_endpoint(); + (void)endpoint1; + sp::endpoint endpoint2 = socket1.local_endpoint(ec); + (void)endpoint2; + + sp::endpoint endpoint3 = socket1.remote_endpoint(); + (void)endpoint3; + sp::endpoint endpoint4 = socket1.remote_endpoint(ec); + (void)endpoint4; + + socket1.shutdown(socket_base::shutdown_both); + socket1.shutdown(socket_base::shutdown_both, ec); + + // basic_stream_socket functions. + + socket1.send(buffer(mutable_char_buffer)); + socket1.send(buffer(const_char_buffer)); + socket1.send(null_buffers()); + socket1.send(buffer(mutable_char_buffer), in_flags); + socket1.send(buffer(const_char_buffer), in_flags); + socket1.send(null_buffers(), in_flags); + socket1.send(buffer(mutable_char_buffer), in_flags, ec); + socket1.send(buffer(const_char_buffer), in_flags, ec); + socket1.send(null_buffers(), in_flags, ec); + + socket1.async_send(buffer(mutable_char_buffer), send_handler); + socket1.async_send(buffer(const_char_buffer), send_handler); + socket1.async_send(null_buffers(), send_handler); + socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler); + socket1.async_send(buffer(const_char_buffer), in_flags, send_handler); + socket1.async_send(null_buffers(), in_flags, send_handler); + + socket1.receive(buffer(mutable_char_buffer)); + socket1.receive(null_buffers()); + socket1.receive(buffer(mutable_char_buffer), in_flags); + socket1.receive(null_buffers(), in_flags); + socket1.receive(buffer(mutable_char_buffer), in_flags, ec); + socket1.receive(null_buffers(), in_flags, ec); + + socket1.async_receive(buffer(mutable_char_buffer), receive_handler); + socket1.async_receive(null_buffers(), receive_handler); + socket1.async_receive(buffer(mutable_char_buffer), in_flags, + receive_handler); + socket1.async_receive(null_buffers(), in_flags, receive_handler); + + socket1.write_some(buffer(mutable_char_buffer)); + socket1.write_some(buffer(const_char_buffer)); + socket1.write_some(null_buffers()); + socket1.write_some(buffer(mutable_char_buffer), ec); + socket1.write_some(buffer(const_char_buffer), ec); + socket1.write_some(null_buffers(), ec); + + socket1.async_write_some(buffer(mutable_char_buffer), write_some_handler); + socket1.async_write_some(buffer(const_char_buffer), write_some_handler); + socket1.async_write_some(null_buffers(), write_some_handler); + + socket1.read_some(buffer(mutable_char_buffer)); + socket1.read_some(buffer(mutable_char_buffer), ec); + socket1.read_some(null_buffers(), ec); + + socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler); + socket1.async_read_some(null_buffers(), read_some_handler); + } + catch (std::exception&) + { + } +} + +} // namespace generic_stream_protocol_socket_compile + +//------------------------------------------------------------------------------ + +BOOST_ASIO_TEST_SUITE +( + "generic/stream_protocol", + BOOST_ASIO_TEST_CASE(generic_stream_protocol_socket_compile::test) +) |