Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/deferred.cpp | //
// deferred.cpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/deferred.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"experimental/deferred",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/cancel_after.cpp | //
// cancel_after.cpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/cancel_after.hpp"
#include <functional>
#include "asio/io_context.hpp"
#include "asio/steady_timer.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
namespace chronons = asio::chrono;
void increment_on_cancel(int* count, const asio::error_code& error)
{
if (error == asio::error::operation_aborted)
++(*count);
}
void cancel_after_function_object_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(
cancel_after(chronons::seconds(5),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
t.async_wait(
cancel_after(chronons::seconds(5),
cancel_after(chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::milliseconds(100),
cancel_after(chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::seconds(10),
cancel_after(chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void cancel_after_timer_function_object_test()
{
io_context ioc;
steady_timer cancellation_timer1(ioc);
steady_timer cancellation_timer2(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(5),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(5),
cancel_after(cancellation_timer2, chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::milliseconds(100),
cancel_after(cancellation_timer2, chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(10),
cancel_after(cancellation_timer2, chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
struct incrementer_token_v1
{
explicit incrementer_token_v1(int* c) : count(c) {}
int* count;
};
struct incrementer_handler_v1
{
explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
void operator()(asio::error_code error)
{
increment_on_cancel(count, error);
}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v1, void(asio::error_code)>
{
public:
typedef incrementer_handler_v1 completion_handler_type;
typedef void return_type;
explicit async_result(completion_handler_type&) {}
return_type get() {}
};
} // namespace asio
void cancel_after_completion_token_v1_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(
cancel_after(chronons::seconds(5),
incrementer_token_v1(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
t.async_wait(
cancel_after(chronons::seconds(5),
cancel_after(chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::milliseconds(100),
cancel_after(chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::seconds(10),
cancel_after(chronons::milliseconds(100),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void cancel_after_timer_completion_token_v1_test()
{
io_context ioc;
steady_timer cancellation_timer1(ioc);
steady_timer cancellation_timer2(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(5),
incrementer_token_v1(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(5),
cancel_after(cancellation_timer2, chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::milliseconds(100),
cancel_after(cancellation_timer2, chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(10),
cancel_after(cancellation_timer2, chronons::milliseconds(100),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
struct incrementer_token_v2
{
explicit incrementer_token_v2(int* c) : count(c) {}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v2, void(asio::error_code)>
{
public:
template <typename Initiation, typename... Args>
static void initiate(Initiation initiation,
incrementer_token_v2 token, Args&&... args)
{
initiation(
bindns::bind(&increment_on_cancel,
token.count, bindns::placeholders::_1),
static_cast<Args&&>(args)...);
}
};
} // namespace asio
void cancel_after_completion_token_v2_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(
cancel_after(chronons::seconds(5),
incrementer_token_v2(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::milliseconds(100),
incrementer_token_v2(&count)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
t.async_wait(
cancel_after(chronons::seconds(5),
cancel_after(chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::milliseconds(100),
cancel_after(chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(chronons::seconds(10),
cancel_after(chronons::milliseconds(100),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void cancel_after_timer_completion_token_v2_test()
{
io_context ioc;
steady_timer cancellation_timer1(ioc);
steady_timer cancellation_timer2(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(5),
incrementer_token_v2(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::milliseconds(100),
incrementer_token_v2(&count)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(5),
cancel_after(cancellation_timer2, chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::milliseconds(100),
cancel_after(cancellation_timer2, chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
t.async_wait(
cancel_after(cancellation_timer1, chronons::seconds(10),
cancel_after(cancellation_timer2, chronons::milliseconds(100),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void partial_cancel_after_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(cancel_after(chronons::seconds(5)))(
incrementer_token_v2(&count));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(cancel_after(chronons::milliseconds(100)))(
incrementer_token_v2(&count));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
}
void partial_cancel_after_timer_test()
{
io_context ioc;
steady_timer cancellation_timer(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
t.async_wait(cancel_after(cancellation_timer, chronons::seconds(5)))(
incrementer_token_v2(&count));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
t.async_wait(cancel_after(cancellation_timer, chronons::milliseconds(100)))(
incrementer_token_v2(&count));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"cancel_after",
ASIO_TEST_CASE(cancel_after_function_object_test)
ASIO_TEST_CASE(cancel_after_timer_function_object_test)
ASIO_TEST_CASE(cancel_after_completion_token_v1_test)
ASIO_TEST_CASE(cancel_after_timer_completion_token_v1_test)
ASIO_TEST_CASE(cancel_after_completion_token_v2_test)
ASIO_TEST_CASE(cancel_after_timer_completion_token_v2_test)
ASIO_TEST_CASE(partial_cancel_after_test)
ASIO_TEST_CASE(partial_cancel_after_timer_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_seq_packet_socket.cpp | //
// basic_seq_packet_socket.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_seq_packet_socket.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_seq_packet_socket",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/socket_base.cpp | //
// socket_base.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/socket_base.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "asio/ip/udp.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 asio;
namespace ip = asio::ip;
try
{
io_context ioc;
ip::tcp::socket sock(ioc);
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;
(void)static_cast<bool>(broadcast1);
(void)static_cast<bool>(!broadcast1);
(void)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;
(void)static_cast<bool>(debug1);
(void)static_cast<bool>(!debug1);
(void)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;
(void)static_cast<bool>(do_not_route1);
(void)static_cast<bool>(!do_not_route1);
(void)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;
(void)static_cast<bool>(keep_alive1);
(void)static_cast<bool>(!keep_alive1);
(void)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;
(void)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;
(void)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;
(void)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;
(void)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;
(void)static_cast<bool>(reuse_address1);
(void)static_cast<bool>(!reuse_address1);
(void)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);
(void)static_cast<bool>(linger1.enabled());
linger1.timeout(1);
(void)static_cast<int>(linger1.timeout());
// out_of_band_inline class.
socket_base::out_of_band_inline out_of_band_inline1(true);
sock.set_option(out_of_band_inline1);
socket_base::out_of_band_inline out_of_band_inline2;
sock.get_option(out_of_band_inline2);
out_of_band_inline1 = true;
(void)static_cast<bool>(out_of_band_inline1);
(void)static_cast<bool>(!out_of_band_inline1);
(void)static_cast<bool>(out_of_band_inline1.value());
// 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;
(void)static_cast<bool>(enable_connection_aborted1);
(void)static_cast<bool>(!enable_connection_aborted1);
(void)static_cast<bool>(enable_connection_aborted1.value());
// 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 asio;
namespace ip = asio::ip;
io_context ioc;
ip::udp::socket udp_sock(ioc, ip::udp::v4());
ip::tcp::socket tcp_sock(ioc, ip::tcp::v4());
ip::tcp::acceptor tcp_acceptor(ioc, ip::tcp::v4());
asio::error_code ec;
// broadcast class.
socket_base::broadcast broadcast1(true);
ASIO_CHECK(broadcast1.value());
ASIO_CHECK(static_cast<bool>(broadcast1));
ASIO_CHECK(!!broadcast1);
udp_sock.set_option(broadcast1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::broadcast broadcast2;
udp_sock.get_option(broadcast2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(broadcast2.value());
ASIO_CHECK(static_cast<bool>(broadcast2));
ASIO_CHECK(!!broadcast2);
socket_base::broadcast broadcast3(false);
ASIO_CHECK(!broadcast3.value());
ASIO_CHECK(!static_cast<bool>(broadcast3));
ASIO_CHECK(!broadcast3);
udp_sock.set_option(broadcast3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::broadcast broadcast4;
udp_sock.get_option(broadcast4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!broadcast4.value());
ASIO_CHECK(!static_cast<bool>(broadcast4));
ASIO_CHECK(!broadcast4);
// debug class.
socket_base::debug debug1(true);
ASIO_CHECK(debug1.value());
ASIO_CHECK(static_cast<bool>(debug1));
ASIO_CHECK(!!debug1);
udp_sock.set_option(debug1, ec);
#if defined(__linux__)
// On Linux, only root can set SO_DEBUG.
bool not_root = (ec == asio::error::access_denied);
ASIO_CHECK(!ec || not_root);
ASIO_WARN_MESSAGE(!ec, "Must be root to set debug socket option");
#else // defined(__linux__)
# if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
# else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
#endif // defined(__linux__)
socket_base::debug debug2;
udp_sock.get_option(debug2, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# if defined(__linux__)
ASIO_CHECK(debug2.value() || not_root);
ASIO_CHECK(static_cast<bool>(debug2) || not_root);
ASIO_CHECK(!!debug2 || not_root);
# else // defined(__linux__)
ASIO_CHECK(debug2.value());
ASIO_CHECK(static_cast<bool>(debug2));
ASIO_CHECK(!!debug2);
# endif // defined(__linux__)
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::debug debug3(false);
ASIO_CHECK(!debug3.value());
ASIO_CHECK(!static_cast<bool>(debug3));
ASIO_CHECK(!debug3);
udp_sock.set_option(debug3, ec);
#if defined(__linux__)
ASIO_CHECK(!ec || not_root);
#else // defined(__linux__)
# if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
# else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
#endif // defined(__linux__)
socket_base::debug debug4;
udp_sock.get_option(debug4, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
# if defined(__linux__)
ASIO_CHECK(!debug4.value() || not_root);
ASIO_CHECK(!static_cast<bool>(debug4) || not_root);
ASIO_CHECK(!debug4 || not_root);
# else // defined(__linux__)
ASIO_CHECK(!debug4.value());
ASIO_CHECK(!static_cast<bool>(debug4));
ASIO_CHECK(!debug4);
# endif // defined(__linux__)
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
// do_not_route class.
socket_base::do_not_route do_not_route1(true);
ASIO_CHECK(do_not_route1.value());
ASIO_CHECK(static_cast<bool>(do_not_route1));
ASIO_CHECK(!!do_not_route1);
udp_sock.set_option(do_not_route1, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::do_not_route do_not_route2;
udp_sock.get_option(do_not_route2, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(do_not_route2.value());
ASIO_CHECK(static_cast<bool>(do_not_route2));
ASIO_CHECK(!!do_not_route2);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::do_not_route do_not_route3(false);
ASIO_CHECK(!do_not_route3.value());
ASIO_CHECK(!static_cast<bool>(do_not_route3));
ASIO_CHECK(!do_not_route3);
udp_sock.set_option(do_not_route3, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::do_not_route do_not_route4;
udp_sock.get_option(do_not_route4, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!do_not_route4.value());
ASIO_CHECK(!static_cast<bool>(do_not_route4));
ASIO_CHECK(!do_not_route4);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
// keep_alive class.
socket_base::keep_alive keep_alive1(true);
ASIO_CHECK(keep_alive1.value());
ASIO_CHECK(static_cast<bool>(keep_alive1));
ASIO_CHECK(!!keep_alive1);
tcp_sock.set_option(keep_alive1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::keep_alive keep_alive2;
tcp_sock.get_option(keep_alive2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(keep_alive2.value());
ASIO_CHECK(static_cast<bool>(keep_alive2));
ASIO_CHECK(!!keep_alive2);
socket_base::keep_alive keep_alive3(false);
ASIO_CHECK(!keep_alive3.value());
ASIO_CHECK(!static_cast<bool>(keep_alive3));
ASIO_CHECK(!keep_alive3);
tcp_sock.set_option(keep_alive3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::keep_alive keep_alive4;
tcp_sock.get_option(keep_alive4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!keep_alive4.value());
ASIO_CHECK(!static_cast<bool>(keep_alive4));
ASIO_CHECK(!keep_alive4);
// send_buffer_size class.
socket_base::send_buffer_size send_buffer_size1(4096);
ASIO_CHECK(send_buffer_size1.value() == 4096);
tcp_sock.set_option(send_buffer_size1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::send_buffer_size send_buffer_size2;
tcp_sock.get_option(send_buffer_size2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(send_buffer_size2.value() == 4096);
socket_base::send_buffer_size send_buffer_size3(16384);
ASIO_CHECK(send_buffer_size3.value() == 16384);
tcp_sock.set_option(send_buffer_size3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::send_buffer_size send_buffer_size4;
tcp_sock.get_option(send_buffer_size4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(send_buffer_size4.value() == 16384);
// send_low_watermark class.
socket_base::send_low_watermark send_low_watermark1(4096);
ASIO_CHECK(send_low_watermark1.value() == 4096);
tcp_sock.set_option(send_low_watermark1, ec);
#if defined(WIN32) || defined(__linux__) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows, Linux or Solaris.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif
socket_base::send_low_watermark send_low_watermark2;
tcp_sock.get_option(send_low_watermark2, ec);
#if defined(WIN32) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
#elif defined(__linux__)
ASIO_CHECK(!ec); // Not supported on Linux but can get value.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(send_low_watermark2.value() == 4096);
#endif
socket_base::send_low_watermark send_low_watermark3(8192);
ASIO_CHECK(send_low_watermark3.value() == 8192);
tcp_sock.set_option(send_low_watermark3, ec);
#if defined(WIN32) || defined(__linux__) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows, Linux or Solaris.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif
socket_base::send_low_watermark send_low_watermark4;
tcp_sock.get_option(send_low_watermark4, ec);
#if defined(WIN32) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
#elif defined(__linux__)
ASIO_CHECK(!ec); // Not supported on Linux but can get value.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(send_low_watermark4.value() == 8192);
#endif
// receive_buffer_size class.
socket_base::receive_buffer_size receive_buffer_size1(4096);
ASIO_CHECK(receive_buffer_size1.value() == 4096);
tcp_sock.set_option(receive_buffer_size1, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::receive_buffer_size receive_buffer_size2;
tcp_sock.get_option(receive_buffer_size2, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!ec); // Not supported under Windows CE but can get value.
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(receive_buffer_size2.value() == 4096);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::receive_buffer_size receive_buffer_size3(16384);
ASIO_CHECK(receive_buffer_size3.value() == 16384);
tcp_sock.set_option(receive_buffer_size3, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
socket_base::receive_buffer_size receive_buffer_size4;
tcp_sock.get_option(receive_buffer_size4, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!ec); // Not supported under Windows CE but can get value.
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(receive_buffer_size4.value() == 16384);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
// receive_low_watermark class.
socket_base::receive_low_watermark receive_low_watermark1(4096);
ASIO_CHECK(receive_low_watermark1.value() == 4096);
tcp_sock.set_option(receive_low_watermark1, ec);
#if defined(WIN32) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif
socket_base::receive_low_watermark receive_low_watermark2;
tcp_sock.get_option(receive_low_watermark2, ec);
#if defined(WIN32) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(receive_low_watermark2.value() == 4096);
#endif
socket_base::receive_low_watermark receive_low_watermark3(8192);
ASIO_CHECK(receive_low_watermark3.value() == 8192);
tcp_sock.set_option(receive_low_watermark3, ec);
#if defined(WIN32) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif
socket_base::receive_low_watermark receive_low_watermark4;
tcp_sock.get_option(receive_low_watermark4, ec);
#if defined(WIN32) || defined(__sun)
ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
#else
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(receive_low_watermark4.value() == 8192);
#endif
// reuse_address class.
socket_base::reuse_address reuse_address1(true);
ASIO_CHECK(reuse_address1.value());
ASIO_CHECK(static_cast<bool>(reuse_address1));
ASIO_CHECK(!!reuse_address1);
udp_sock.set_option(reuse_address1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::reuse_address reuse_address2;
udp_sock.get_option(reuse_address2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(reuse_address2.value());
ASIO_CHECK(static_cast<bool>(reuse_address2));
ASIO_CHECK(!!reuse_address2);
socket_base::reuse_address reuse_address3(false);
ASIO_CHECK(!reuse_address3.value());
ASIO_CHECK(!static_cast<bool>(reuse_address3));
ASIO_CHECK(!reuse_address3);
udp_sock.set_option(reuse_address3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::reuse_address reuse_address4;
udp_sock.get_option(reuse_address4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!reuse_address4.value());
ASIO_CHECK(!static_cast<bool>(reuse_address4));
ASIO_CHECK(!reuse_address4);
// linger class.
socket_base::linger linger1(true, 60);
ASIO_CHECK(linger1.enabled());
ASIO_CHECK(linger1.timeout() == 60);
tcp_sock.set_option(linger1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::linger linger2;
tcp_sock.get_option(linger2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(linger2.enabled());
ASIO_CHECK(linger2.timeout() == 60);
socket_base::linger linger3(false, 0);
ASIO_CHECK(!linger3.enabled());
ASIO_CHECK(linger3.timeout() == 0);
tcp_sock.set_option(linger3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::linger linger4;
tcp_sock.get_option(linger4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!linger4.enabled());
// enable_connection_aborted class.
socket_base::enable_connection_aborted enable_connection_aborted1(true);
ASIO_CHECK(enable_connection_aborted1.value());
ASIO_CHECK(static_cast<bool>(enable_connection_aborted1));
ASIO_CHECK(!!enable_connection_aborted1);
tcp_acceptor.set_option(enable_connection_aborted1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::enable_connection_aborted enable_connection_aborted2;
tcp_acceptor.get_option(enable_connection_aborted2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(enable_connection_aborted2.value());
ASIO_CHECK(static_cast<bool>(enable_connection_aborted2));
ASIO_CHECK(!!enable_connection_aborted2);
socket_base::enable_connection_aborted enable_connection_aborted3(false);
ASIO_CHECK(!enable_connection_aborted3.value());
ASIO_CHECK(!static_cast<bool>(enable_connection_aborted3));
ASIO_CHECK(!enable_connection_aborted3);
tcp_acceptor.set_option(enable_connection_aborted3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
socket_base::enable_connection_aborted enable_connection_aborted4;
tcp_acceptor.get_option(enable_connection_aborted4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!enable_connection_aborted4.value());
ASIO_CHECK(!static_cast<bool>(enable_connection_aborted4));
ASIO_CHECK(!enable_connection_aborted4);
// bytes_readable class.
socket_base::bytes_readable bytes_readable;
udp_sock.io_control(bytes_readable, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
}
} // namespace socket_base_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"socket_base",
ASIO_COMPILE_TEST_CASE(socket_base_compile::test)
ASIO_TEST_CASE(socket_base_runtime::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/cancellation_type.cpp | //
// cancellation_type.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/cancellation_type.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"cancellation_type",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_serial_port.cpp | //
// basic_serial_port.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2008 Rep Invariant Systems, Inc. ([email protected])
//
// 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 "asio/basic_serial_port.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_serial_port",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/any_completion_handler.cpp | //
// any_completion_handler.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/any_completion_handler.hpp"
#include "unit_test.hpp"
#include <functional>
#include "asio/bind_allocator.hpp"
#include "asio/bind_cancellation_slot.hpp"
#include "asio/bind_executor.hpp"
#include "asio/bind_immediate_executor.hpp"
#include "asio/error.hpp"
#include "asio/thread_pool.hpp"
namespace bindns = std;
void increment(int* count)
{
++(*count);
}
void any_completion_handler_construction_test()
{
int count = 0;
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_completion_handler<void()> h1;
ASIO_CHECK(!h1);
ASIO_CHECK(h1 == null_ptr);
asio::any_completion_handler<void()> h2(null_ptr);
ASIO_CHECK(!h2);
ASIO_CHECK(h2 == null_ptr);
asio::any_completion_handler<void()> h3(
bindns::bind(&increment, &count));
ASIO_CHECK(!!h3);
ASIO_CHECK(h3 != null_ptr);
asio::any_completion_handler<void()> h4(std::move(h1));
ASIO_CHECK(!h4);
ASIO_CHECK(h4 == null_ptr);
ASIO_CHECK(!h1);
ASIO_CHECK(h1 == null_ptr);
asio::any_completion_handler<void()> h5(std::move(h3));
ASIO_CHECK(!!h5);
ASIO_CHECK(h5 != null_ptr);
ASIO_CHECK(!h3);
ASIO_CHECK(h3 == null_ptr);
asio::any_completion_handler<void()> h6(std::move(h5));
ASIO_CHECK(!!h6);
ASIO_CHECK(h6 != null_ptr);
ASIO_CHECK(!h5);
ASIO_CHECK(h5 == null_ptr);
}
void any_completion_handler_assignment_test()
{
int count = 0;
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_completion_handler<void()> h1;
asio::any_completion_handler<void()> h2;
h2 = null_ptr;
ASIO_CHECK(!h2);
asio::any_completion_handler<void()> h3;
h3 = bindns::bind(&increment, &count);
ASIO_CHECK(!!h3);
asio::any_completion_handler<void()> h4;
h4 = std::move(h1);
ASIO_CHECK(!h4);
ASIO_CHECK(!h1);
h4 = std::move(h3);
ASIO_CHECK(!!h4);
ASIO_CHECK(!h3);
}
template <typename T>
class handler_allocator
{
public:
using value_type = T;
explicit handler_allocator(int* count)
: count_(count)
{
}
template <typename U>
handler_allocator(const handler_allocator<U>& other) noexcept
: count_(other.count_)
{
}
bool operator==(const handler_allocator& other) const noexcept
{
return &count_ == &other.count_;
}
bool operator!=(const handler_allocator& other) const noexcept
{
return &count_ != &other.count_;
}
T* allocate(std::size_t n) const
{
++(*count_);
return static_cast<T*>(::operator new(sizeof(T) * n));
}
void deallocate(T* p, std::size_t /*n*/) const
{
::operator delete(p);
}
private:
template <typename> friend class handler_allocator;
int* count_;
};
class cancel_handler
{
public:
explicit cancel_handler(int* count)
: count_(count)
{
}
void operator()(asio::cancellation_type_t)
{
++(*count_);
}
private:
int* count_;
};
void any_completion_handler_associator_test()
{
typedef asio::any_completion_handler<void()> handler_type;
int count = 0;
int alloc_count = 0;
int cancel_count = 0;
asio::thread_pool pool(1);
asio::cancellation_signal sig;
asio::any_completion_handler<void()> h1(
asio::bind_allocator(handler_allocator<char>(&alloc_count),
asio::bind_cancellation_slot(sig.slot(),
asio::bind_executor(pool.get_executor(),
asio::bind_immediate_executor(asio::system_executor(),
bindns::bind(&increment, &count))))));
ASIO_CHECK(alloc_count == 1);
ASIO_REBIND_ALLOC(asio::associated_allocator<handler_type>::type,
char) alloc1(asio::get_associated_allocator(h1));
alloc1.deallocate(alloc1.allocate(1), 1);
ASIO_CHECK(alloc_count == 2);
asio::associated_cancellation_slot<handler_type>::type slot1
= asio::get_associated_cancellation_slot(h1);
ASIO_CHECK(slot1.is_connected());
slot1.emplace<cancel_handler>(&cancel_count);
ASIO_CHECK(cancel_count == 0);
sig.emit(asio::cancellation_type::terminal);
ASIO_CHECK(cancel_count == 1);
asio::associated_executor<handler_type>::type ex1
= asio::get_associated_executor(h1);
ASIO_CHECK(ex1 == pool.get_executor());
asio::associated_immediate_executor<
handler_type, asio::thread_pool::executor_type>::type ex2
= asio::get_associated_immediate_executor(h1, pool.get_executor());
ASIO_CHECK(ex2 == asio::system_executor());
}
void increment_with_error(asio::error_code ec,
asio::error_code* out_ec, int* count)
{
*out_ec = ec;
++(*count);
}
void any_completion_handler_invocation_test()
{
int count = 0;
asio::error_code ec;
asio::any_completion_handler<void()> h1(
bindns::bind(&increment, &count));
ASIO_CHECK(count == 0);
std::move(h1)();
ASIO_CHECK(count == 1);
asio::any_completion_handler<void(asio::error_code)> h2(
bindns::bind(&increment_with_error,
bindns::placeholders::_1, &ec, &count));
ASIO_CHECK(!ec);
ASIO_CHECK(count == 1);
std::move(h2)(asio::error::eof);
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 2);
}
ASIO_TEST_SUITE
(
"any_completion_handler",
ASIO_TEST_CASE(any_completion_handler_construction_test)
ASIO_TEST_CASE(any_completion_handler_assignment_test)
ASIO_TEST_CASE(any_completion_handler_associator_test)
ASIO_TEST_CASE(any_completion_handler_invocation_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/associated_executor.cpp | //
// associated_executor.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/associated_executor.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"associated_executor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/write.cpp | //
// write.cpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/write.hpp"
#include <array>
#include <cstring>
#include <functional>
#include <vector>
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/streambuf.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
#include <boost/array.hpp>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace std; // For memcmp, memcpy and memset.
class test_stream
{
public:
typedef asio::io_context::executor_type executor_type;
test_stream(asio::io_context& io_context)
: io_context_(io_context),
length_(max_length),
position_(0),
next_write_length_(max_length)
{
memset(data_, 0, max_length);
}
executor_type get_executor() noexcept
{
return io_context_.get_executor();
}
void reset(size_t length = max_length)
{
ASIO_CHECK(length <= max_length);
memset(data_, 0, max_length);
length_ = length;
position_ = 0;
next_write_length_ = length;
}
void next_write_length(size_t length)
{
next_write_length_ = length;
}
template <typename Iterator>
bool check_buffers(Iterator begin, Iterator end, size_t length)
{
if (length != position_)
return false;
Iterator iter = begin;
size_t checked_length = 0;
for (; iter != end && checked_length < length; ++iter)
{
size_t buffer_length = asio::buffer_size(*iter);
if (buffer_length > length - checked_length)
buffer_length = length - checked_length;
if (memcmp(data_ + checked_length, iter->data(), buffer_length) != 0)
return false;
checked_length += buffer_length;
}
return true;
}
template <typename Const_Buffers>
bool check_buffers(const Const_Buffers& buffers, size_t length)
{
return check_buffers(asio::buffer_sequence_begin(buffers),
asio::buffer_sequence_end(buffers), length);
}
template <typename Const_Buffers>
size_t write_some(const Const_Buffers& buffers)
{
size_t n = asio::buffer_copy(
asio::buffer(data_, length_) + position_,
buffers, next_write_length_);
position_ += n;
return n;
}
template <typename Const_Buffers>
size_t write_some(const Const_Buffers& buffers, asio::error_code& ec)
{
ec = asio::error_code();
return write_some(buffers);
}
template <typename Const_Buffers, typename Handler>
void async_write_some(const Const_Buffers& buffers,
Handler&& handler)
{
size_t bytes_transferred = write_some(buffers);
asio::post(get_executor(),
asio::detail::bind_handler(
static_cast<Handler&&>(handler),
asio::error_code(), bytes_transferred));
}
private:
asio::io_context& io_context_;
enum { max_length = 8192 };
char data_[max_length];
size_t length_;
size_t position_;
size_t next_write_length_;
};
static const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static char mutable_write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_2_arg_zero_buffers_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
size_t bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == 0);
}
void test_2_arg_const_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
size_t bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_2_arg_mutable_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
size_t bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
}
void test_2_arg_vector_buffers_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data, 39) + 32);
buffers.push_back(asio::buffer(write_data) + 39);
s.reset();
size_t bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_2_arg_dynamic_string_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(write_data));
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
data.assign(write_data, sizeof(write_data));
size_t bytes_transferred = asio::write(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_nothrow_zero_buffers_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == 0);
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_const_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_mutable_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_vector_buffers_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data, 39) + 32);
buffers.push_back(asio::buffer(write_data) + 39);
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_dynamic_string_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(write_data));
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
data.assign(write_data, sizeof(write_data));
asio::error_code error;
size_t bytes_transferred = asio::write(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
bool old_style_transfer_all(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec;
}
struct short_transfer
{
short_transfer() {}
short_transfer(short_transfer&&) {}
size_t operator()(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec ? 0 : 3;
}
};
void test_3_arg_const_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
size_t bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_mutable_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
size_t bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
}
void test_3_arg_vector_buffers_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data, 39) + 32);
buffers.push_back(asio::buffer(write_data) + 39);
s.reset();
size_t bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_dynamic_string_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(write_data));
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
data.assign(write_data, sizeof(write_data));
size_t bytes_transferred = asio::write(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
bytes_transferred = asio::write(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
bytes_transferred = asio::write(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_4_arg_const_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void test_4_arg_mutable_buffer_write()
{
asio::io_context ioc;
test_stream s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
}
void test_4_arg_vector_buffers_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data, 39) + 32);
buffers.push_back(asio::buffer(write_data) + 39);
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void test_4_arg_dynamic_string_write()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(write_data));
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
data.assign(write_data, sizeof(write_data));
asio::error_code error;
size_t bytes_transferred = asio::write(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
bytes_transferred = asio::write(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void async_write_handler(const asio::error_code& e,
size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!e);
ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
}
void test_3_arg_const_buffer_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
bool called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_mutable_buffer_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
bool called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
int i = asio::async_write(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write(s, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
}
void test_3_arg_boost_array_buffers_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_stream s(ioc);
boost::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_3_arg_std_array_buffers_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_vector_buffers_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data, 39) + 32);
buffers.push_back(asio::buffer(write_data) + 39);
s.reset();
bool called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_dynamic_string_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(write_data));
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
data.assign(write_data, sizeof(write_data));
bool called = false;
asio::async_write(s, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
int i = asio::async_write(s, sb, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_3_arg_streambuf_async_write()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb;
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
bool called = false;
asio::async_write(s, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
int i = asio::async_write(s, sb, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_4_arg_const_buffer_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
bool called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_4_arg_mutable_buffer_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
bool called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
s.reset();
int i = asio::async_write(s, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
}
void test_4_arg_boost_array_buffers_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_stream s(ioc);
boost::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_4_arg_std_array_buffers_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_4_arg_vector_buffers_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data, 39) + 32);
buffers.push_back(asio::buffer(write_data) + 39);
s.reset();
bool called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write(s, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write(s, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write(s, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_4_arg_dynamic_string_async_write()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(write_data));
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
data.assign(write_data, sizeof(write_data));
bool called = false;
asio::async_write(s, sb, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
int i = asio::async_write(s, sb, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
data.assign(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
}
void test_4_arg_streambuf_async_write()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb;
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
bool called = false;
asio::async_write(s, sb, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write(s, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write(s, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
int i = asio::async_write(s, sb, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write(s, sb, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
ASIO_TEST_SUITE
(
"write",
ASIO_TEST_CASE(test_2_arg_zero_buffers_write)
ASIO_TEST_CASE(test_2_arg_const_buffer_write)
ASIO_TEST_CASE(test_2_arg_mutable_buffer_write)
ASIO_TEST_CASE(test_2_arg_vector_buffers_write)
ASIO_TEST_CASE(test_2_arg_dynamic_string_write)
ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_write)
ASIO_TEST_CASE(test_3_arg_nothrow_const_buffer_write)
ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_write)
ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_write)
ASIO_TEST_CASE(test_3_arg_nothrow_dynamic_string_write)
ASIO_TEST_CASE(test_3_arg_const_buffer_write)
ASIO_TEST_CASE(test_3_arg_mutable_buffer_write)
ASIO_TEST_CASE(test_3_arg_vector_buffers_write)
ASIO_TEST_CASE(test_3_arg_dynamic_string_write)
ASIO_TEST_CASE(test_4_arg_const_buffer_write)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_write)
ASIO_TEST_CASE(test_4_arg_vector_buffers_write)
ASIO_TEST_CASE(test_4_arg_dynamic_string_write)
ASIO_TEST_CASE(test_3_arg_const_buffer_async_write)
ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_write)
ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_write)
ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_write)
ASIO_TEST_CASE(test_3_arg_vector_buffers_async_write)
ASIO_TEST_CASE(test_3_arg_dynamic_string_async_write)
ASIO_TEST_CASE(test_3_arg_streambuf_async_write)
ASIO_TEST_CASE(test_4_arg_const_buffer_async_write)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_write)
ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_write)
ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_write)
ASIO_TEST_CASE(test_4_arg_vector_buffers_async_write)
ASIO_TEST_CASE(test_4_arg_dynamic_string_async_write)
ASIO_TEST_CASE(test_4_arg_streambuf_async_write)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/static_thread_pool.cpp | //
// static_thread_pool.cpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/static_thread_pool.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"static_thread_pool",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/dispatch.cpp | //
// dispatch.cpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/dispatch.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"dispatch",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/deadline_timer.cpp | //
// deadline_timer.cpp
// ~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/deadline_timer.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_DATE_TIME)
#include <boost/bind/bind.hpp>
#include "archetypes/async_result.hpp"
#include "asio/executor_work_guard.hpp"
#include "asio/io_context.hpp"
#include "asio/placeholders.hpp"
#include "asio/thread.hpp"
using namespace boost::posix_time;
void increment(int* count)
{
++(*count);
}
void decrement_to_zero(asio::deadline_timer* t, int* count)
{
if (*count > 0)
{
--(*count);
int before_value = *count;
t->expires_at(t->expires_at() + seconds(1));
t->async_wait(boost::bind(decrement_to_zero, t, count));
// Completion cannot nest, so count value should remain unchanged.
ASIO_CHECK(*count == before_value);
}
}
void increment_if_not_cancelled(int* count,
const asio::error_code& ec)
{
if (!ec)
++(*count);
}
void cancel_timer(asio::deadline_timer* t)
{
std::size_t num_cancelled = t->cancel();
ASIO_CHECK(num_cancelled == 1);
}
void cancel_one_timer(asio::deadline_timer* t)
{
std::size_t num_cancelled = t->cancel_one();
ASIO_CHECK(num_cancelled == 1);
}
ptime now()
{
#if defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
return microsec_clock::universal_time();
#else // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
return second_clock::universal_time();
#endif // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
}
void deadline_timer_test()
{
asio::io_context ioc;
int count = 0;
ptime start = now();
asio::deadline_timer t1(ioc, seconds(1));
t1.wait();
// The timer must block until after its expiry time.
ptime end = now();
ptime expected_end = start + seconds(1);
ASIO_CHECK(expected_end < end || expected_end == end);
start = now();
asio::deadline_timer t2(ioc, seconds(1) + microseconds(500000));
t2.wait();
// The timer must block until after its expiry time.
end = now();
expected_end = start + seconds(1) + microseconds(500000);
ASIO_CHECK(expected_end < end || expected_end == end);
t2.expires_at(t2.expires_at() + seconds(1));
t2.wait();
// The timer must block until after its expiry time.
end = now();
expected_end += seconds(1);
ASIO_CHECK(expected_end < end || expected_end == end);
start = now();
t2.expires_from_now(seconds(1) + microseconds(200000));
t2.wait();
// The timer must block until after its expiry time.
end = now();
expected_end = start + seconds(1) + microseconds(200000);
ASIO_CHECK(expected_end < end || expected_end == end);
start = now();
asio::deadline_timer t3(ioc, seconds(5));
t3.async_wait(boost::bind(increment, &count));
// No completions can be delivered until run() is called.
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all operations have finished, and
// this should not be until after the timer's expiry time.
ASIO_CHECK(count == 1);
end = now();
expected_end = start + seconds(1);
ASIO_CHECK(expected_end < end || expected_end == end);
count = 3;
start = now();
asio::deadline_timer t4(ioc, seconds(1));
t4.async_wait(boost::bind(decrement_to_zero, &t4, &count));
// No completions can be delivered until run() is called.
ASIO_CHECK(count == 3);
ioc.restart();
ioc.run();
// The run() call will not return until all operations have finished, and
// this should not be until after the timer's final expiry time.
ASIO_CHECK(count == 0);
end = now();
expected_end = start + seconds(3);
ASIO_CHECK(expected_end < end || expected_end == end);
count = 0;
start = now();
asio::deadline_timer t5(ioc, seconds(10));
t5.async_wait(boost::bind(increment_if_not_cancelled, &count,
asio::placeholders::error));
asio::deadline_timer t6(ioc, seconds(1));
t6.async_wait(boost::bind(cancel_timer, &t5));
// No completions can be delivered until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The timer should have been cancelled, so count should not have changed.
// The total run time should not have been much more than 1 second (and
// certainly far less than 10 seconds).
ASIO_CHECK(count == 0);
end = now();
expected_end = start + seconds(2);
ASIO_CHECK(end < expected_end);
// Wait on the timer again without cancelling it. This time the asynchronous
// wait should run to completion and increment the counter.
t5.async_wait(boost::bind(increment_if_not_cancelled, &count,
asio::placeholders::error));
ioc.restart();
ioc.run();
// The timer should not have been cancelled, so count should have changed.
// The total time since the timer was created should be more than 10 seconds.
ASIO_CHECK(count == 1);
end = now();
expected_end = start + seconds(10);
ASIO_CHECK(expected_end < end || expected_end == end);
count = 0;
start = now();
// Start two waits on a timer, one of which will be cancelled. The one
// which is not cancelled should still run to completion and increment the
// counter.
asio::deadline_timer t7(ioc, seconds(3));
t7.async_wait(boost::bind(increment_if_not_cancelled, &count,
asio::placeholders::error));
t7.async_wait(boost::bind(increment_if_not_cancelled, &count,
asio::placeholders::error));
asio::deadline_timer t8(ioc, seconds(1));
t8.async_wait(boost::bind(cancel_one_timer, &t7));
ioc.restart();
ioc.run();
// One of the waits should not have been cancelled, so count should have
// changed. The total time since the timer was created should be more than 3
// seconds.
ASIO_CHECK(count == 1);
end = now();
expected_end = start + seconds(3);
ASIO_CHECK(expected_end < end || expected_end == end);
}
void timer_handler(const asio::error_code&)
{
}
void deadline_timer_cancel_test()
{
static asio::io_context io_context;
struct timer
{
asio::deadline_timer t;
timer() : t(io_context) { t.expires_at(boost::posix_time::pos_infin); }
} timers[50];
timers[2].t.async_wait(&timer_handler);
timers[41].t.async_wait(&timer_handler);
for (int i = 10; i < 20; ++i)
timers[i].t.async_wait(&timer_handler);
ASIO_CHECK(timers[2].t.cancel() == 1);
ASIO_CHECK(timers[41].t.cancel() == 1);
for (int i = 10; i < 20; ++i)
ASIO_CHECK(timers[i].t.cancel() == 1);
}
struct custom_allocation_timer_handler
{
custom_allocation_timer_handler(int* count) : count_(count) {}
void operator()(const asio::error_code&) {}
int* count_;
template <typename T>
struct allocator
{
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
template <typename U>
struct rebind
{
typedef allocator<U> other;
};
explicit allocator(int* count) noexcept
: count_(count)
{
}
allocator(const allocator& other) noexcept
: count_(other.count_)
{
}
template <typename U>
allocator(const allocator<U>& other) noexcept
: count_(other.count_)
{
}
pointer allocate(size_type n, const void* = 0)
{
++(*count_);
return static_cast<T*>(::operator new(sizeof(T) * n));
}
void deallocate(pointer p, size_type)
{
--(*count_);
::operator delete(p);
}
size_type max_size() const
{
return ~size_type(0);
}
void construct(pointer p, const T& v)
{
new (p) T(v);
}
void destroy(pointer p)
{
p->~T();
}
int* count_;
};
typedef allocator<int> allocator_type;
allocator_type get_allocator() const noexcept
{
return allocator_type(count_);
}
};
void deadline_timer_custom_allocation_test()
{
static asio::io_context io_context;
struct timer
{
asio::deadline_timer t;
timer() : t(io_context) {}
} timers[100];
int allocation_count = 0;
for (int i = 0; i < 50; ++i)
{
timers[i].t.expires_at(boost::posix_time::pos_infin);
timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
}
for (int i = 50; i < 100; ++i)
{
timers[i].t.expires_at(boost::posix_time::neg_infin);
timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
}
for (int i = 0; i < 50; ++i)
timers[i].t.cancel();
io_context.run();
ASIO_CHECK(allocation_count == 0);
}
void io_context_run(asio::io_context* ioc)
{
ioc->run();
}
void deadline_timer_thread_test()
{
asio::io_context ioc;
asio::executor_work_guard<asio::io_context::executor_type> work
= asio::make_work_guard(ioc);
asio::deadline_timer t1(ioc);
asio::deadline_timer t2(ioc);
int count = 0;
asio::thread th(boost::bind(io_context_run, &ioc));
t2.expires_from_now(boost::posix_time::seconds(2));
t2.wait();
t1.expires_from_now(boost::posix_time::seconds(2));
t1.async_wait(boost::bind(increment, &count));
t2.expires_from_now(boost::posix_time::seconds(4));
t2.wait();
ioc.stop();
th.join();
ASIO_CHECK(count == 1);
}
void deadline_timer_async_result_test()
{
asio::io_context ioc;
asio::deadline_timer t1(ioc);
t1.expires_from_now(boost::posix_time::seconds(1));
int i = t1.async_wait(archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.run();
}
asio::deadline_timer make_timer(asio::io_context& ioc, int* count)
{
asio::deadline_timer t(ioc);
t.expires_from_now(boost::posix_time::seconds(1));
t.async_wait(boost::bind(increment, count));
return t;
}
void deadline_timer_move_test()
{
asio::io_context io_context1;
asio::io_context io_context2;
int count = 0;
asio::deadline_timer t1 = make_timer(io_context1, &count);
asio::deadline_timer t2 = make_timer(io_context2, &count);
asio::deadline_timer t3 = std::move(t1);
t2 = std::move(t1);
io_context2.run();
ASIO_CHECK(count == 1);
io_context1.run();
ASIO_CHECK(count == 2);
}
ASIO_TEST_SUITE
(
"deadline_timer",
ASIO_TEST_CASE(deadline_timer_test)
ASIO_TEST_CASE(deadline_timer_cancel_test)
ASIO_TEST_CASE(deadline_timer_custom_allocation_test)
ASIO_TEST_CASE(deadline_timer_thread_test)
ASIO_TEST_CASE(deadline_timer_async_result_test)
ASIO_TEST_CASE(deadline_timer_move_test)
)
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
ASIO_TEST_SUITE
(
"deadline_timer",
ASIO_TEST_CASE(null_test)
)
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/serial_port.cpp | //
// serial_port.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2008 Rep Invariant Systems, Inc. ([email protected])
//
// 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 "asio/serial_port.hpp"
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
// serial_port_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// serial_port compile and link correctly. Runtime failures are ignored.
namespace serial_port_compile {
struct write_some_handler
{
write_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
write_some_handler(write_some_handler&&) {}
private:
write_some_handler(const write_some_handler&);
};
struct read_some_handler
{
read_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
read_some_handler(read_some_handler&&) {}
private:
read_some_handler(const read_some_handler&);
};
void test()
{
#if defined(ASIO_HAS_SERIAL_PORT)
using namespace asio;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
serial_port::baud_rate serial_port_option;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_serial_port constructors.
serial_port port1(ioc);
serial_port port2(ioc, "null");
serial_port::native_handle_type native_port1 = port1.native_handle();
#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
// Skip this on older MSVC due to mysterious ambiguous overload errors.
#else
serial_port port3(ioc, native_port1);
#endif
serial_port port4(ioc_ex);
serial_port port5(ioc_ex, "null");
serial_port::native_handle_type native_port2 = port1.native_handle();
serial_port port6(ioc_ex, native_port2);
serial_port port7(std::move(port6));
basic_serial_port<io_context::executor_type> port8(ioc);
serial_port port9(std::move(port8));
// basic_serial_port operators.
port1 = serial_port(ioc);
port1 = std::move(port2);
port1 = std::move(port8);
// basic_io_object functions.
serial_port::executor_type ex = port1.get_executor();
(void)ex;
// basic_serial_port functions.
serial_port::lowest_layer_type& lowest_layer = port1.lowest_layer();
(void)lowest_layer;
const serial_port& port10 = port1;
const serial_port::lowest_layer_type& lowest_layer2 = port10.lowest_layer();
(void)lowest_layer2;
port1.open("null");
port1.open("null", ec);
serial_port::native_handle_type native_port3 = port1.native_handle();
port1.assign(native_port3);
serial_port::native_handle_type native_port4 = port1.native_handle();
port1.assign(native_port4, ec);
bool is_open = port1.is_open();
(void)is_open;
port1.close();
port1.close(ec);
serial_port::native_handle_type native_port5 = port1.native_handle();
(void)native_port5;
port1.cancel();
port1.cancel(ec);
port1.set_option(serial_port_option);
port1.set_option(serial_port_option, ec);
port1.get_option(serial_port_option);
port1.get_option(serial_port_option, ec);
port1.send_break();
port1.send_break(ec);
port1.write_some(buffer(mutable_char_buffer));
port1.write_some(buffer(const_char_buffer));
port1.write_some(buffer(mutable_char_buffer), ec);
port1.write_some(buffer(const_char_buffer), ec);
port1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
port1.async_write_some(buffer(const_char_buffer), write_some_handler());
int i1 = port1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = port1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
port1.read_some(buffer(mutable_char_buffer));
port1.read_some(buffer(mutable_char_buffer), ec);
port1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
int i3 = port1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i3;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_SERIAL_PORT)
}
} // namespace serial_port_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"serial_port",
ASIO_COMPILE_TEST_CASE(serial_port_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/thread.cpp | //
// thread.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/thread.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"thread",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_signal_set.cpp | //
// basic_signal_set.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_signal_set.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_signal_set",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_socket_acceptor.cpp | //
// basic_socket_acceptor.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_socket_acceptor.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_socket_acceptor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/defer.cpp | //
// defer.cpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/defer.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"defer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/stream_file.cpp | //
// stream_file.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/stream_file.hpp"
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
// stream_file_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// stream_file compile and link correctly. Runtime failures are ignored.
namespace stream_file_compile {
struct write_some_handler
{
write_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
write_some_handler(write_some_handler&&) {}
private:
write_some_handler(const write_some_handler&);
};
struct read_some_handler
{
read_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
read_some_handler(read_some_handler&&) {}
private:
read_some_handler(const read_some_handler&);
};
void test()
{
#if defined(ASIO_HAS_FILE)
using namespace asio;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
archetypes::lazy_handler lazy;
asio::error_code ec;
const std::string path;
// basic_stream_file constructors.
stream_file file1(ioc);
stream_file file2(ioc, "", stream_file::read_only);
stream_file file3(ioc, path, stream_file::read_only);
stream_file::native_handle_type native_file1 = file1.native_handle();
stream_file file4(ioc, native_file1);
stream_file file5(ioc_ex);
stream_file file6(ioc_ex, "", stream_file::read_only);
stream_file file7(ioc_ex, path, stream_file::read_only);
stream_file::native_handle_type native_file2 = file1.native_handle();
stream_file file8(ioc_ex, native_file2);
stream_file file9(std::move(file8));
basic_stream_file<io_context::executor_type> file10(ioc);
stream_file file11(std::move(file10));
// basic_stream_file operators.
file1 = stream_file(ioc);
file1 = std::move(file2);
file1 = std::move(file10);
// basic_io_object functions.
stream_file::executor_type ex = file1.get_executor();
(void)ex;
// basic_stream_file functions.
file1.open("", stream_file::read_only);
file1.open("", stream_file::read_only, ec);
file1.open(path, stream_file::read_only);
file1.open(path, stream_file::read_only, ec);
stream_file::native_handle_type native_file3 = file1.native_handle();
file1.assign(native_file3);
stream_file::native_handle_type native_file4 = file1.native_handle();
file1.assign(native_file4, ec);
bool is_open = file1.is_open();
(void)is_open;
file1.close();
file1.close(ec);
stream_file::native_handle_type native_file5 = file1.native_handle();
(void)native_file5;
stream_file::native_handle_type native_file6 = file1.release();
(void)native_file6;
stream_file::native_handle_type native_file7 = file1.release(ec);
(void)native_file7;
file1.cancel();
file1.cancel(ec);
asio::uint64_t s1 = file1.size();
(void)s1;
asio::uint64_t s2 = file1.size(ec);
(void)s2;
file1.resize(asio::uint64_t(0));
file1.resize(asio::uint64_t(0), ec);
file1.sync_all();
file1.sync_all(ec);
file1.sync_data();
file1.sync_data(ec);
asio::uint64_t s3 = file1.seek(0, stream_file::seek_set);
(void)s3;
asio::uint64_t s4 = file1.seek(0, stream_file::seek_set, ec);
(void)s4;
file1.write_some(buffer(mutable_char_buffer));
file1.write_some(buffer(const_char_buffer));
file1.write_some(buffer(mutable_char_buffer), ec);
file1.write_some(buffer(const_char_buffer), ec);
file1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
file1.async_write_some(buffer(const_char_buffer), write_some_handler());
int i1 = file1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = file1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
file1.read_some(buffer(mutable_char_buffer));
file1.read_some(buffer(mutable_char_buffer), ec);
file1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
int i3 = file1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i3;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_FILE)
}
} // namespace stream_file_compile
ASIO_TEST_SUITE
(
"stream_file",
ASIO_COMPILE_TEST_CASE(stream_file_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/prepend.cpp | //
// prepend.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/prepend.hpp"
#include "asio/bind_executor.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "unit_test.hpp"
void prepend_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(
asio::prepend(
asio::bind_executor(io2.get_executor(),
[&count](int a, int b, asio::error_code)
{
++count;
ASIO_CHECK(a == 123);
ASIO_CHECK(b == 321);
}), 123, 321));
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"prepend",
ASIO_TEST_CASE(prepend_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_deadline_timer.cpp | //
// basic_deadline_timer.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_deadline_timer.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_deadline_timer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/completion_condition.cpp | //
// completion_condition.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/completion_condition.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"completion_condition",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/buffer.cpp | //
// buffer.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/buffer.hpp"
#include <array>
#include <cstring>
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
# include <boost/array.hpp>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
//------------------------------------------------------------------------------
// buffer_compile test
// ~~~~~~~~~~~~~~~~~~~
// The following test checks that all overloads of the buffer function compile
// and link correctly. Runtime failures are ignored.
namespace buffer_compile {
using namespace asio;
template <typename T>
class mutable_contiguous_container
{
public:
typedef T value_type;
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
mutable_contiguous_container() {}
std::size_t size() const { return 0; }
iterator begin() { return 0; }
const_iterator begin() const { return 0; }
iterator end() { return 0; }
const_iterator end() const { return 0; }
};
template <typename T>
class const_contiguous_container
{
public:
typedef const T value_type;
typedef const T* iterator;
typedef const T* const_iterator;
typedef const T& reference;
typedef const T& const_reference;
const_contiguous_container() {}
std::size_t size() const { return 0; }
iterator begin() { return 0; }
const_iterator begin() const { return 0; }
iterator end() { return 0; }
const_iterator end() const { return 0; }
};
void test()
{
try
{
char raw_data[1024];
const char const_raw_data[1024] = "";
void* void_ptr_data = raw_data;
const void* const_void_ptr_data = const_raw_data;
#if defined(ASIO_HAS_BOOST_ARRAY)
boost::array<char, 1024> array_data;
const boost::array<char, 1024>& const_array_data_1 = array_data;
boost::array<const char, 1024> const_array_data_2 = { { 0 } };
#endif // defined(ASIO_HAS_BOOST_ARRAY)
std::array<char, 1024> std_array_data;
const std::array<char, 1024>& const_std_array_data_1 = std_array_data;
std::array<const char, 1024> const_std_array_data_2 = { { 0 } };
std::vector<char> vector_data(1024);
const std::vector<char>& const_vector_data = vector_data;
std::string string_data(1024, ' ');
const std::string const_string_data(1024, ' ');
std::vector<mutable_buffer> mutable_buffer_sequence;
std::vector<const_buffer> const_buffer_sequence;
#if defined(ASIO_HAS_STD_STRING_VIEW)
std::string_view string_view_data(string_data);
#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_data(string_data);
#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
mutable_contiguous_container<char> mutable_contiguous_data;
const mutable_contiguous_container<char> const_mutable_contiguous_data;
const_contiguous_container<char> const_contiguous_data;
const const_contiguous_container<char> const_const_contiguous_data;
// mutable_buffer constructors.
mutable_buffer mb1;
mutable_buffer mb2(void_ptr_data, 1024);
mutable_buffer mb3(mb1);
(void)mb3;
// mutable_buffer functions.
void* ptr1 = mb1.data();
(void)ptr1;
std::size_t n1 = mb1.size();
(void)n1;
// mutable_buffer operators.
mb1 += 128;
mb1 = mb2 + 128;
mb1 = 128 + mb2;
#if !defined(ASIO_NO_DEPRECATED)
// mutable_buffers_1 constructors.
mutable_buffers_1 mbc1(mb1);
mutable_buffers_1 mbc2(mbc1);
// mutable_buffers_1 functions.
mutable_buffers_1::const_iterator iter1 = mbc1.begin();
(void)iter1;
mutable_buffers_1::const_iterator iter2 = mbc1.end();
(void)iter2;
#endif // !defined(ASIO_NO_DEPRECATED)
// const_buffer constructors.
const_buffer cb1;
const_buffer cb2(const_void_ptr_data, 1024);
const_buffer cb3(cb1);
(void)cb3;
const_buffer cb4(mb1);
(void)cb4;
// const_buffer functions.
const void* ptr2 = cb1.data();
(void)ptr2;
std::size_t n2 = cb1.size();
(void)n2;
// const_buffer operators.
cb1 += 128;
cb1 = cb2 + 128;
cb1 = 128 + cb2;
#if !defined(ASIO_NO_DEPRECATED)
// const_buffers_1 constructors.
const_buffers_1 cbc1(cb1);
const_buffers_1 cbc2(cbc1);
// const_buffers_1 functions.
const_buffers_1::const_iterator iter3 = cbc1.begin();
(void)iter3;
const_buffers_1::const_iterator iter4 = cbc1.end();
(void)iter4;
#endif // !defined(ASIO_NO_DEPRECATED)
// buffer_size function overloads.
std::size_t size1 = buffer_size(mb1);
(void)size1;
std::size_t size2 = buffer_size(cb1);
(void)size2;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size3 = buffer_size(mbc1);
(void)size3;
std::size_t size4 = buffer_size(cbc1);
(void)size4;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size5 = buffer_size(mutable_buffer_sequence);
(void)size5;
std::size_t size6 = buffer_size(const_buffer_sequence);
(void)size6;
// buffer_cast function overloads.
#if !defined(ASIO_NO_DEPRECATED)
void* ptr3 = buffer_cast<void*>(mb1);
(void)ptr3;
const void* ptr4 = buffer_cast<const void*>(cb1);
(void)ptr4;
#endif // !defined(ASIO_NO_DEPRECATED)
// buffer function overloads.
mb1 = buffer(mb2);
mb1 = buffer(mb2, 128);
cb1 = buffer(cb2);
cb1 = buffer(cb2, 128);
mb1 = buffer(void_ptr_data, 1024);
cb1 = buffer(const_void_ptr_data, 1024);
mb1 = buffer(raw_data);
mb1 = buffer(raw_data, 1024);
cb1 = buffer(const_raw_data);
cb1 = buffer(const_raw_data, 1024);
#if defined(ASIO_HAS_BOOST_ARRAY)
mb1 = buffer(array_data);
mb1 = buffer(array_data, 1024);
cb1 = buffer(const_array_data_1);
cb1 = buffer(const_array_data_1, 1024);
cb1 = buffer(const_array_data_2);
cb1 = buffer(const_array_data_2, 1024);
#endif // defined(ASIO_HAS_BOOST_ARRAY)
mb1 = buffer(std_array_data);
mb1 = buffer(std_array_data, 1024);
cb1 = buffer(const_std_array_data_1);
cb1 = buffer(const_std_array_data_1, 1024);
cb1 = buffer(const_std_array_data_2);
cb1 = buffer(const_std_array_data_2, 1024);
mb1 = buffer(vector_data);
mb1 = buffer(vector_data, 1024);
cb1 = buffer(const_vector_data);
cb1 = buffer(const_vector_data, 1024);
mb1 = buffer(string_data);
mb1 = buffer(string_data, 1024);
cb1 = buffer(const_string_data);
cb1 = buffer(const_string_data, 1024);
#if defined(ASIO_HAS_STRING_VIEW)
cb1 = buffer(string_view_data);
cb1 = buffer(string_view_data, 1024);
#endif // defined(ASIO_HAS_STRING_VIEW)
mb1 = buffer(mutable_contiguous_data);
mb1 = buffer(mutable_contiguous_data, 1024);
cb1 = buffer(const_mutable_contiguous_data);
cb1 = buffer(const_mutable_contiguous_data, 1024);
cb1 = buffer(const_contiguous_data);
cb1 = buffer(const_contiguous_data, 1024);
cb1 = buffer(const_const_contiguous_data);
cb1 = buffer(const_const_contiguous_data, 1024);
// buffer_copy function overloads.
std::size_t size7 = buffer_copy(mb1, cb2);
(void)size7;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size8 = buffer_copy(mb1, cbc2);
(void)size8;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size9 = buffer_copy(mb1, mb2);
(void)size9;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size10 = buffer_copy(mb1, mbc2);
(void)size10;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size11 = buffer_copy(mb1, const_buffer_sequence);
(void)size11;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size12 = buffer_copy(mbc1, cb2);
(void)size12;
std::size_t size13 = buffer_copy(mbc1, cbc2);
(void)size13;
std::size_t size14 = buffer_copy(mbc1, mb2);
(void)size14;
std::size_t size15 = buffer_copy(mbc1, mbc2);
(void)size15;
std::size_t size16 = buffer_copy(mbc1, const_buffer_sequence);
(void)size16;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size17 = buffer_copy(mutable_buffer_sequence, cb2);
(void)size17;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size18 = buffer_copy(mutable_buffer_sequence, cbc2);
(void)size18;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size19 = buffer_copy(mutable_buffer_sequence, mb2);
(void)size19;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size20 = buffer_copy(mutable_buffer_sequence, mbc2);
(void)size20;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size21 = buffer_copy(
mutable_buffer_sequence, const_buffer_sequence);
(void)size21;
std::size_t size22 = buffer_copy(mb1, cb2, 128);
(void)size22;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size23 = buffer_copy(mb1, cbc2, 128);
(void)size23;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size24 = buffer_copy(mb1, mb2, 128);
(void)size24;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size25 = buffer_copy(mb1, mbc2, 128);
(void)size25;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size26 = buffer_copy(mb1, const_buffer_sequence, 128);
(void)size26;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size27 = buffer_copy(mbc1, cb2, 128);
(void)size27;
std::size_t size28 = buffer_copy(mbc1, cbc2, 128);
(void)size28;
std::size_t size29 = buffer_copy(mbc1, mb2, 128);
(void)size29;
std::size_t size30 = buffer_copy(mbc1, mbc2, 128);
(void)size30;
std::size_t size31 = buffer_copy(mbc1, const_buffer_sequence, 128);
(void)size31;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size32 = buffer_copy(mutable_buffer_sequence, cb2, 128);
(void)size32;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size33 = buffer_copy(mutable_buffer_sequence, cbc2, 128);
(void)size33;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size34 = buffer_copy(mutable_buffer_sequence, mb2, 128);
(void)size34;
#if !defined(ASIO_NO_DEPRECATED)
std::size_t size35 = buffer_copy(mutable_buffer_sequence, mbc2, 128);
(void)size35;
#endif // !defined(ASIO_NO_DEPRECATED)
std::size_t size36 = buffer_copy(
mutable_buffer_sequence, const_buffer_sequence, 128);
(void)size36;
// dynamic_buffer function overloads.
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> db1 = dynamic_buffer(string_data);
(void)db1;
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> db2 = dynamic_buffer(string_data, 1024);
(void)db2;
dynamic_vector_buffer<char, std::allocator<char> >
db3 = dynamic_buffer(vector_data);
(void)db3;
dynamic_vector_buffer<char, std::allocator<char> >
db4 = dynamic_buffer(vector_data, 1024);
(void)db4;
// dynamic_buffer member functions.
std::size_t size37 = db1.size();
(void)size37;
std::size_t size38 = db3.size();
(void)size38;
std::size_t size39 = db1.max_size();
(void)size39;
std::size_t size40 = db3.max_size();
(void)size40;
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type>::const_buffers_type
cb5 = db1.data();
(void)cb5;
dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type
cb6 = db3.data();
(void)cb6;
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type>::mutable_buffers_type mb5
= db1.prepare(1024);
(void)mb5;
dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type
mb6 = db3.prepare(1024);
(void)mb6;
db1.commit(1024);
db3.commit(1024);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type>::mutable_buffers_type
mb7 = db1.data(0, 1);
(void)mb7;
dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type
mb8 = db3.data(0, 1);
(void)mb8;
dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type>::const_buffers_type
cb7 = static_cast<const dynamic_string_buffer<char,
std::string::traits_type,
std::string::allocator_type>&>(db1).data(0, 1);
(void)cb7;
dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type
cb8 = static_cast<const dynamic_vector_buffer<char,
std::allocator<char> >&>(db3).data(0, 1);
(void)cb8;
db1.grow(1024);
db3.grow(1024);
db1.shrink(1024);
db3.shrink(1024);
db1.consume(0);
db3.consume(0);
}
catch (std::exception&)
{
}
}
} // namespace buffer_compile
//------------------------------------------------------------------------------
namespace buffer_copy_runtime {
using namespace asio;
using namespace std;
void test()
{
char dest_data[256];
char source_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
memset(dest_data, 0, sizeof(dest_data));
mutable_buffer mb1 = asio::buffer(dest_data);
mutable_buffer mb2 = asio::buffer(source_data);
std::size_t n = buffer_copy(mb1, mb2);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
const_buffer cb1 = asio::buffer(source_data);
n = buffer_copy(mb1, cb1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#if !defined(ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
mutable_buffers_1 mbc1 = asio::buffer(source_data);
n = buffer_copy(mb1, mbc1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
const_buffers_1 cbc1 = const_buffers_1(asio::buffer(source_data));
n = buffer_copy(mb1, cbc1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
mb1 = asio::buffer(source_data);
n = buffer_copy(mbc1, mb1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
cb1 = asio::buffer(source_data);
n = buffer_copy(mbc1, cb1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
mutable_buffers_1 mbc2 = asio::buffer(source_data);
n = buffer_copy(mbc1, mbc2);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
cbc1 = const_buffers_1(asio::buffer(source_data));
n = buffer_copy(mbc1, cbc1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#endif // !defined(ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
std::vector<mutable_buffer> mv1;
mv1.push_back(asio::buffer(source_data, 5));
mv1.push_back(asio::buffer(source_data) + 5);
n = buffer_copy(mb1, mv1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
std::vector<const_buffer> cv1;
cv1.push_back(asio::buffer(source_data, 6));
cv1.push_back(asio::buffer(source_data) + 6);
n = buffer_copy(mb1, cv1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(asio::buffer(dest_data, 7));
mv1.push_back(asio::buffer(dest_data) + 7);
cb1 = asio::buffer(source_data);
n = buffer_copy(mv1, cb1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(asio::buffer(dest_data, 7));
mv1.push_back(asio::buffer(dest_data) + 7);
cv1.clear();
cv1.push_back(asio::buffer(source_data, 8));
cv1.push_back(asio::buffer(source_data) + 8);
n = buffer_copy(mv1, cv1);
ASIO_CHECK(n == sizeof(source_data));
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
mb2 = asio::buffer(source_data);
n = buffer_copy(mb1, mb2, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
cb1 = asio::buffer(source_data);
n = buffer_copy(mb1, cb1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#if !defined(ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
mbc1 = asio::buffer(source_data);
n = buffer_copy(mb1, mbc1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
cbc1 = const_buffers_1(asio::buffer(source_data));
n = buffer_copy(mb1, cbc1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
mb1 = asio::buffer(source_data);
n = buffer_copy(mbc1, mb1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
cb1 = asio::buffer(source_data);
n = buffer_copy(mbc1, cb1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
mbc2 = asio::buffer(source_data);
n = buffer_copy(mbc1, mbc2, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mbc1 = asio::buffer(dest_data);
cbc1 = const_buffers_1(asio::buffer(source_data));
n = buffer_copy(mbc1, cbc1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
#endif // !defined(ASIO_NO_DEPRECATED)
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
mv1.clear();
mv1.push_back(asio::buffer(source_data, 5));
mv1.push_back(asio::buffer(source_data) + 5);
n = buffer_copy(mb1, mv1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mb1 = asio::buffer(dest_data);
cv1.clear();
cv1.push_back(asio::buffer(source_data, 6));
cv1.push_back(asio::buffer(source_data) + 6);
n = buffer_copy(mb1, cv1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(asio::buffer(dest_data, 7));
mv1.push_back(asio::buffer(dest_data) + 7);
cb1 = asio::buffer(source_data);
n = buffer_copy(mv1, cb1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
memset(dest_data, 0, sizeof(dest_data));
mv1.clear();
mv1.push_back(asio::buffer(dest_data, 7));
mv1.push_back(asio::buffer(dest_data) + 7);
cv1.clear();
cv1.push_back(asio::buffer(source_data, 8));
cv1.push_back(asio::buffer(source_data) + 8);
n = buffer_copy(mv1, cv1, 10);
ASIO_CHECK(n == 10);
ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
}
} // namespace buffer_copy_runtime
//------------------------------------------------------------------------------
namespace buffer_sequence {
using namespace asio;
using namespace std;
struct valid_const_a
{
typedef const_buffer* const_iterator;
typedef const_buffer value_type;
const_buffer* begin() const { return 0; }
const_buffer* end() const { return 0; }
};
struct valid_const_b
{
const_buffer* begin() const { return 0; }
const_buffer* end() const { return 0; }
};
struct valid_mutable_a
{
typedef mutable_buffer* const_iterator;
typedef mutable_buffer value_type;
mutable_buffer* begin() const { return 0; }
mutable_buffer* end() const { return 0; }
};
struct valid_mutable_b
{
mutable_buffer* begin() const { return 0; }
mutable_buffer* end() const { return 0; }
};
struct invalid_const_a
{
typedef int value_type;
int* begin() const { return 0; }
const_buffer* end() const { return 0; }
};
struct invalid_const_b
{
typedef const_buffer value_type;
const_buffer* begin() const { return 0; }
};
struct invalid_const_c
{
typedef const_buffer value_type;
const_buffer* end() const { return 0; }
};
struct invalid_const_d
{
int* begin() const { return 0; }
const_buffer* end() const { return 0; }
};
struct invalid_const_e
{
const_buffer* begin() const { return 0; }
};
struct invalid_const_f
{
const_buffer* end() const { return 0; }
};
struct invalid_mutable_a
{
typedef int value_type;
int* begin() const { return 0; }
mutable_buffer* end() const { return 0; }
};
struct invalid_mutable_b
{
typedef mutable_buffer value_type;
mutable_buffer* begin() const { return 0; }
};
struct invalid_mutable_c
{
typedef mutable_buffer value_type;
mutable_buffer* end() const { return 0; }
};
struct invalid_mutable_d
{
int* begin() const { return 0; }
mutable_buffer* end() const { return 0; }
};
struct invalid_mutable_e
{
mutable_buffer* begin() const { return 0; }
};
struct invalid_mutable_f
{
mutable_buffer* end() const { return 0; }
};
void test()
{
ASIO_CHECK(is_const_buffer_sequence<const_buffer>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<const_buffer>::value);
const_buffer b1;
ASIO_CHECK(buffer_sequence_begin(b1) == &b1);
ASIO_CHECK(buffer_sequence_end(b1) == &b1 + 1);
ASIO_CHECK(is_const_buffer_sequence<mutable_buffer>::value);
ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffer>::value);
mutable_buffer b2;
ASIO_CHECK(buffer_sequence_begin(b2) == &b2);
ASIO_CHECK(buffer_sequence_end(b2) == &b2 + 1);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(is_const_buffer_sequence<const_buffers_1>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<const_buffers_1>::value);
const_buffers_1 b3(0, 0);
ASIO_CHECK(buffer_sequence_begin(b3) == &b3);
ASIO_CHECK(buffer_sequence_end(b3) == &b3 + 1);
ASIO_CHECK(is_const_buffer_sequence<mutable_buffers_1>::value);
ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffers_1>::value);
mutable_buffers_1 b4(0, 0);
ASIO_CHECK(buffer_sequence_begin(b4) == &b4);
ASIO_CHECK(buffer_sequence_end(b4) == &b4 + 1);
#endif // !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(is_const_buffer_sequence<vector<const_buffer> >::value);
ASIO_CHECK(!is_mutable_buffer_sequence<vector<const_buffer> >::value);
vector<const_buffer> b5;
ASIO_CHECK(buffer_sequence_begin(b5) == b5.begin());
ASIO_CHECK(buffer_sequence_end(b5) == b5.end());
ASIO_CHECK(is_const_buffer_sequence<vector<mutable_buffer> >::value);
ASIO_CHECK(is_mutable_buffer_sequence<vector<mutable_buffer> >::value);
vector<mutable_buffer> b6;
ASIO_CHECK(buffer_sequence_begin(b6) == b6.begin());
ASIO_CHECK(buffer_sequence_end(b6) == b6.end());
ASIO_CHECK(is_const_buffer_sequence<valid_const_a>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_a>::value);
valid_const_a b7;
ASIO_CHECK(buffer_sequence_begin(b7) == b7.begin());
ASIO_CHECK(buffer_sequence_end(b7) == b7.end());
ASIO_CHECK(is_const_buffer_sequence<valid_const_b>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_b>::value);
valid_const_b b8;
ASIO_CHECK(buffer_sequence_begin(b8) == b8.begin());
ASIO_CHECK(buffer_sequence_end(b8) == b8.end());
ASIO_CHECK(is_const_buffer_sequence<valid_mutable_a>::value);
ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_a>::value);
valid_mutable_a b9;
ASIO_CHECK(buffer_sequence_begin(b9) == b9.begin());
ASIO_CHECK(buffer_sequence_end(b9) == b9.end());
ASIO_CHECK(is_const_buffer_sequence<valid_mutable_b>::value);
ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_b>::value);
valid_mutable_b b10;
ASIO_CHECK(buffer_sequence_begin(b10) == b10.begin());
ASIO_CHECK(buffer_sequence_end(b10) == b10.end());
ASIO_CHECK(!is_const_buffer_sequence<invalid_const_a>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_a>::value);
ASIO_CHECK(!is_const_buffer_sequence<invalid_const_b>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_b>::value);
ASIO_CHECK(!is_const_buffer_sequence<invalid_const_c>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_c>::value);
ASIO_CHECK(!is_const_buffer_sequence<invalid_const_d>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_d>::value);
ASIO_CHECK(!is_const_buffer_sequence<invalid_const_e>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_e>::value);
ASIO_CHECK(!is_const_buffer_sequence<invalid_const_f>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_f>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value);
ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value);
}
} // namespace buffer_sequence
namespace buffer_literals {
void test()
{
#if defined(ASIO_HAS_USER_DEFINED_LITERALS)
using namespace asio::buffer_literals;
using namespace std; // For memcmp.
asio::const_buffer b1 = ""_buf;
ASIO_CHECK(b1.size() == 0);
asio::const_buffer b2 = "hello"_buf;
ASIO_CHECK(b2.size() == 5);
ASIO_CHECK(memcmp(b2.data(), "hello", 5) == 0);
asio::const_buffer b3 = 0x00_buf;
ASIO_CHECK(b3.size() == 1);
ASIO_CHECK(memcmp(b3.data(), "\x00", 1) == 0);
asio::const_buffer b4 = 0X01_buf;
ASIO_CHECK(b4.size() == 1);
ASIO_CHECK(memcmp(b4.data(), "\x01", 1) == 0);
asio::const_buffer b5 = 0xaB_buf;
ASIO_CHECK(b5.size() == 1);
ASIO_CHECK(memcmp(b5.data(), "\xab", 1) == 0);
asio::const_buffer b6 = 0xABcd_buf;
ASIO_CHECK(b6.size() == 2);
ASIO_CHECK(memcmp(b6.data(), "\xab\xcd", 2) == 0);
asio::const_buffer b7 = 0x01ab01cd01ef01ba01dc01fe_buf;
ASIO_CHECK(b7.size() == 12);
ASIO_CHECK(memcmp(b7.data(),
"\x01\xab\x01\xcd\x01\xef\x01\xba\x01\xdc\x01\xfe", 12) == 0);
asio::const_buffer b8 = 0b00000000_buf;
ASIO_CHECK(b8.size() == 1);
ASIO_CHECK(memcmp(b8.data(), "\x00", 1) == 0);
asio::const_buffer b9 = 0B00000001_buf;
ASIO_CHECK(b9.size() == 1);
ASIO_CHECK(memcmp(b9.data(), "\x01", 1) == 0);
asio::const_buffer b10 = 0B11111111_buf;
ASIO_CHECK(b10.size() == 1);
ASIO_CHECK(memcmp(b10.data(), "\xFF", 1) == 0);
asio::const_buffer b11 = 0b1111000000001111_buf;
ASIO_CHECK(b11.size() == 2);
ASIO_CHECK(memcmp(b11.data(), "\xF0\x0F", 2) == 0);
#endif // (defined(ASIO_HAS_USER_DEFINED_LITERALS)
}
} // namespace buffer_literals
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"buffer",
ASIO_COMPILE_TEST_CASE(buffer_compile::test)
ASIO_TEST_CASE(buffer_copy_runtime::test)
ASIO_TEST_CASE(buffer_sequence::test)
ASIO_TEST_CASE(buffer_literals::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/this_coro.cpp | //
// this_coro.cpp
// ~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/this_coro.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"this_coro",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/cancel_at.cpp | //
// cancel_at.cpp
// ~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/cancel_at.hpp"
#include <functional>
#include "asio/io_context.hpp"
#include "asio/steady_timer.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
namespace chronons = asio::chrono;
void increment_on_cancel(int* count, const asio::error_code& error)
{
if (error == asio::error::operation_aborted)
++(*count);
}
void cancel_at_function_object_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(5),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(5),
cancel_at(now + chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::milliseconds(100),
cancel_at(now + chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(10),
cancel_at(now + chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void cancel_at_timer_function_object_test()
{
io_context ioc;
steady_timer cancellation_timer1(ioc);
steady_timer cancellation_timer2(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(5),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(5),
cancel_at(cancellation_timer2, now + chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
cancel_at(cancellation_timer2, now + chronons::seconds(10),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(10),
cancel_at(cancellation_timer2, now + chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
struct incrementer_token_v1
{
explicit incrementer_token_v1(int* c) : count(c) {}
int* count;
};
struct incrementer_handler_v1
{
explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
void operator()(asio::error_code error)
{
increment_on_cancel(count, error);
}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v1, void(asio::error_code)>
{
public:
typedef incrementer_handler_v1 completion_handler_type;
typedef void return_type;
explicit async_result(completion_handler_type&) {}
return_type get() {}
};
} // namespace asio
void cancel_at_completion_token_v1_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(5),
incrementer_token_v1(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(5),
cancel_at(now + chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::milliseconds(100),
cancel_at(now + chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(10),
cancel_at(now + chronons::milliseconds(100),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void cancel_at_timer_completion_token_v1_test()
{
io_context ioc;
steady_timer cancellation_timer1(ioc);
steady_timer cancellation_timer2(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(5),
incrementer_token_v1(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(5),
cancel_at(cancellation_timer2, now + chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
cancel_at(cancellation_timer2, now + chronons::seconds(10),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(10),
cancel_at(cancellation_timer2, now + chronons::milliseconds(100),
incrementer_token_v1(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
struct incrementer_token_v2
{
explicit incrementer_token_v2(int* c) : count(c) {}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v2, void(asio::error_code)>
{
public:
template <typename Initiation, typename... Args>
static void initiate(Initiation initiation,
incrementer_token_v2 token, Args&&... args)
{
initiation(
bindns::bind(&increment_on_cancel,
token.count, bindns::placeholders::_1),
static_cast<Args&&>(args)...);
}
};
} // namespace asio
void cancel_at_completion_token_v2_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(5),
incrementer_token_v2(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::milliseconds(100),
incrementer_token_v2(&count)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(5),
cancel_at(now + chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::milliseconds(100),
cancel_at(now + chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(now + chronons::seconds(10),
cancel_at(now + chronons::milliseconds(100),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void cancel_at_timer_completion_token_v2_test()
{
io_context ioc;
steady_timer cancellation_timer1(ioc);
steady_timer cancellation_timer2(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(5),
incrementer_token_v2(&count)));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
incrementer_token_v2(&count)));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::milliseconds(100));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(5),
cancel_at(cancellation_timer2, now + chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
cancel_at(cancellation_timer2, now + chronons::seconds(10),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer1, now + chronons::seconds(10),
cancel_at(cancellation_timer2, now + chronons::milliseconds(100),
incrementer_token_v2(&count))));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 3);
}
void partial_cancel_at_test()
{
io_context ioc;
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(cancel_at(now + chronons::seconds(5)))(
incrementer_token_v2(&count));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(cancel_at(now + chronons::milliseconds(100)))(
incrementer_token_v2(&count));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
}
void partial_cancel_at_timer_test()
{
io_context ioc;
steady_timer cancellation_timer(ioc);
int count = 0;
steady_timer t(ioc, chronons::milliseconds(100));
auto now = steady_timer::clock_type::now();
t.async_wait(cancel_at(cancellation_timer, now + chronons::seconds(5)))(
incrementer_token_v2(&count));
ioc.run();
ASIO_CHECK(count == 0);
t.expires_after(chronons::seconds(5));
now = steady_timer::clock_type::now();
t.async_wait(
cancel_at(cancellation_timer, now + chronons::milliseconds(100)))(
incrementer_token_v2(&count));
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"cancel_at",
ASIO_TEST_CASE(cancel_at_function_object_test)
ASIO_TEST_CASE(cancel_at_timer_function_object_test)
ASIO_TEST_CASE(cancel_at_completion_token_v1_test)
ASIO_TEST_CASE(cancel_at_timer_completion_token_v1_test)
ASIO_TEST_CASE(cancel_at_completion_token_v2_test)
ASIO_TEST_CASE(cancel_at_timer_completion_token_v2_test)
ASIO_TEST_CASE(partial_cancel_at_test)
ASIO_TEST_CASE(partial_cancel_at_timer_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/cancellation_state.cpp | //
// cancellation_state.cpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/cancellation_state.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"cancellation_state",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/high_resolution_timer.cpp | //
// high_resolution_timer.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/high_resolution_timer.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"high_resolution_timer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/compose.cpp | //
// compose.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/compose.hpp"
#include <functional>
#include "asio/bind_cancellation_slot.hpp"
#include "asio/cancellation_signal.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
class impl_0_completion_args
{
public:
explicit impl_0_completion_args(asio::io_context& ioc)
: ioc_(ioc),
state_(starting)
{
}
template <typename Self>
void operator()(Self& self)
{
switch (state_)
{
case starting:
state_ = posting;
asio::post(ioc_, static_cast<Self&&>(self));
break;
case posting:
self.complete();
break;
default:
break;
}
}
private:
asio::io_context& ioc_;
enum { starting, posting } state_;
};
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void())
async_0_completion_args(asio::io_context& ioc,
CompletionToken&& token)
{
return asio::async_compose<CompletionToken, void()>(
impl_0_completion_args(ioc), token);
}
void compose_0_args_handler(int* count)
{
++(*count);
}
struct compose_0_args_lvalue_handler
{
int* count_;
void operator()()
{
++(*count_);
}
};
void compose_0_completion_args_test()
{
namespace bindns = std;
asio::io_context ioc;
int count = 0;
async_0_completion_args(ioc, bindns::bind(&compose_0_args_handler, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ioc.restart();
count = 0;
compose_0_args_lvalue_handler lvalue_handler = { &count };
async_0_completion_args(ioc, lvalue_handler);
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
}
//------------------------------------------------------------------------------
class impl_1_completion_arg
{
public:
explicit impl_1_completion_arg(asio::io_context& ioc)
: ioc_(ioc),
state_(starting)
{
}
template <typename Self>
void operator()(Self& self)
{
switch (state_)
{
case starting:
state_ = posting;
asio::post(ioc_, static_cast<Self&&>(self));
break;
case posting:
self.complete(42);
break;
default:
break;
}
}
private:
asio::io_context& ioc_;
enum { starting, posting } state_;
};
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void(int))
async_1_completion_arg(asio::io_context& ioc,
CompletionToken&& token)
{
return asio::async_compose<CompletionToken, void(int)>(
impl_1_completion_arg(ioc), token);
}
void compose_1_arg_handler(int* count, int* result_out, int result)
{
++(*count);
*result_out = result;
}
struct compose_1_arg_lvalue_handler
{
int* count_;
int* result_out_;
void operator()(int result)
{
++(*count_);
*result_out_ = result;
}
};
void compose_1_completion_arg_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
int count = 0;
int result = 0;
async_1_completion_arg(ioc,
bindns::bind(&compose_1_arg_handler, &count, &result, _1));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ASIO_CHECK(result == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == 42);
ioc.restart();
count = 0;
result = 0;
compose_1_arg_lvalue_handler lvalue_handler = { &count, &result };
async_1_completion_arg(ioc, lvalue_handler);
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ASIO_CHECK(result == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == 42);
}
//------------------------------------------------------------------------------
typedef asio::enable_terminal_cancellation default_filter;
template <typename CancellationFilter>
class impl_cancellable
{
public:
explicit impl_cancellable(CancellationFilter cancellation_filter,
asio::system_timer& timer)
: cancellation_filter_(cancellation_filter),
timer_(timer),
state_(starting)
{
}
template <typename Self>
void operator()(Self& self,
const asio::error_code& ec = asio::error_code())
{
switch (state_)
{
case starting:
if (!asio::is_same<CancellationFilter, default_filter>::value)
self.reset_cancellation_state(cancellation_filter_);
state_ = waiting;
timer_.expires_after(asio::chrono::milliseconds(100));
timer_.async_wait(static_cast<Self&&>(self));
break;
case waiting:
self.complete(!ec);
break;
default:
break;
}
}
private:
CancellationFilter cancellation_filter_;
asio::system_timer& timer_;
enum { starting, waiting } state_;
};
template <typename CancellationFilter, typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void(bool))
async_cancellable(CancellationFilter cancellation_filter,
asio::system_timer& timer,
CompletionToken&& token)
{
return asio::async_compose<CompletionToken, void(bool)>(
impl_cancellable<CancellationFilter>(cancellation_filter, timer), token);
}
void compose_partial_cancellation_handler(
int* count, bool* result_out, bool result)
{
++(*count);
*result_out = result;
}
void compose_default_cancellation_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
asio::system_timer timer(ioc);
asio::cancellation_signal signal;
int count = 0;
bool result = false;
async_cancellable(default_filter(), timer,
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1));
ioc.run();
// No cancellation, operation completes successfully.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(default_filter(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Total cancellation unsupported. Operation completes successfully.
signal.emit(asio::cancellation_type::total);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(default_filter(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Partial cancellation unsupported. Operation completes successfully.
signal.emit(asio::cancellation_type::partial);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(default_filter(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Terminal cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::terminal);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
}
void compose_partial_cancellation_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
asio::system_timer timer(ioc);
asio::cancellation_signal signal;
int count = 0;
bool result = false;
async_cancellable(asio::enable_partial_cancellation(), timer,
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1));
ioc.run();
// No cancellation, operation completes successfully.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_partial_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Total cancellation unsupported. Operation completes successfully.
signal.emit(asio::cancellation_type::total);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_partial_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Partial cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::partial);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_partial_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Terminal cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::terminal);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
}
void compose_total_cancellation_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
asio::system_timer timer(ioc);
asio::cancellation_signal signal;
int count = 0;
bool result = false;
async_cancellable(asio::enable_total_cancellation(), timer,
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1));
ioc.run();
// No cancellation, operation completes successfully.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_total_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Total cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::total);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_total_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Partial cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::partial);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_total_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Terminal cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::terminal);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
}
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"compose",
ASIO_TEST_CASE(compose_0_completion_args_test)
ASIO_TEST_CASE(compose_1_completion_arg_test)
ASIO_TEST_CASE(compose_default_cancellation_test)
ASIO_TEST_CASE(compose_partial_cancellation_test)
ASIO_TEST_CASE(compose_total_cancellation_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/associated_allocator.cpp | //
// associated_allocator.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/associated_allocator.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"associated_allocator",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_socket.cpp | //
// basic_socket.cpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_socket.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_socket",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_stream_socket.cpp | //
// basic_stream_socket.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_stream_socket.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_stream_socket",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/time_traits.cpp | //
// time_traits.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/time_traits.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"time_traits",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/buffers_iterator.cpp | //
// buffers_iterator.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/buffers_iterator.hpp"
#include <array>
#include "asio/buffer.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
// buffers_iterator_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all operations on the buffers_iterator compile
// and link correctly. Runtime failures are ignored.
namespace buffers_iterator_compile {
using std::array;
using std::vector;
using namespace asio;
void test()
{
try
{
char data1[16], data2[16];
const char cdata1[16] = "", cdata2[16] = "";
mutable_buffer mb1 = buffer(data1);
array<mutable_buffer, 2> mb2 = {{ buffer(data1), buffer(data2) }};
std::vector<mutable_buffer> mb3;
mb3.push_back(buffer(data1));
const_buffer cb1 = buffer(cdata1);
array<const_buffer, 2> cb2 = {{ buffer(cdata1), buffer(cdata2) }};
vector<const_buffer> cb3;
cb3.push_back(buffer(cdata1));
// buffers_iterator constructors.
buffers_iterator<mutable_buffer, char> bi1;
buffers_iterator<mutable_buffer, const char> bi2;
buffers_iterator<array<mutable_buffer, 2>, char> bi3;
buffers_iterator<array<mutable_buffer, 2>, const char> bi4;
buffers_iterator<vector<mutable_buffer>, char> bi5;
buffers_iterator<vector<mutable_buffer>, const char> bi6;
buffers_iterator<const_buffer, char> bi7;
buffers_iterator<const_buffer, const char> bi8;
buffers_iterator<array<const_buffer, 2>, char> bi9;
buffers_iterator<array<const_buffer, 2>, const char> bi10;
buffers_iterator<vector<const_buffer>, char> bi11;
buffers_iterator<vector<const_buffer>, const char> bi12;
buffers_iterator<mutable_buffer, char> bi13(
buffers_iterator<mutable_buffer, char>::begin(mb1));
buffers_iterator<mutable_buffer, const char> bi14(
buffers_iterator<mutable_buffer, const char>::begin(mb1));
buffers_iterator<array<mutable_buffer, 2>, char> bi15(
buffers_iterator<array<mutable_buffer, 2>, char>::begin(mb2));
buffers_iterator<array<mutable_buffer, 2>, const char> bi16(
buffers_iterator<array<mutable_buffer, 2>, const char>::begin(mb2));
buffers_iterator<vector<mutable_buffer>, char> bi17(
buffers_iterator<vector<mutable_buffer>, char>::begin(mb3));
buffers_iterator<vector<mutable_buffer>, const char> bi18(
buffers_iterator<vector<mutable_buffer>, const char>::begin(mb3));
buffers_iterator<const_buffer, char> bi19(
buffers_iterator<const_buffer, char>::begin(cb1));
buffers_iterator<const_buffer, const char> bi20(
buffers_iterator<const_buffer, const char>::begin(cb1));
buffers_iterator<array<const_buffer, 2>, char> bi21(
buffers_iterator<array<const_buffer, 2>, char>::begin(cb2));
buffers_iterator<array<const_buffer, 2>, const char> bi22(
buffers_iterator<array<const_buffer, 2>, const char>::begin(cb2));
buffers_iterator<vector<const_buffer>, char> bi23(
buffers_iterator<vector<const_buffer>, char>::begin(cb3));
buffers_iterator<vector<const_buffer>, const char> bi24(
buffers_iterator<vector<const_buffer>, const char>::begin(cb3));
// buffers_iterator member functions.
bi1 = buffers_iterator<mutable_buffer, char>::begin(mb1);
bi2 = buffers_iterator<mutable_buffer, const char>::begin(mb1);
bi3 = buffers_iterator<array<mutable_buffer, 2>, char>::begin(mb2);
bi4 = buffers_iterator<array<mutable_buffer, 2>, const char>::begin(mb2);
bi5 = buffers_iterator<vector<mutable_buffer>, char>::begin(mb3);
bi6 = buffers_iterator<vector<mutable_buffer>, const char>::begin(mb3);
bi7 = buffers_iterator<const_buffer, char>::begin(cb1);
bi8 = buffers_iterator<const_buffer, const char>::begin(cb1);
bi9 = buffers_iterator<array<const_buffer, 2>, char>::begin(cb2);
bi10 = buffers_iterator<array<const_buffer, 2>, const char>::begin(cb2);
bi11 = buffers_iterator<vector<const_buffer>, char>::begin(cb3);
bi12 = buffers_iterator<vector<const_buffer>, const char>::begin(cb3);
bi1 = buffers_iterator<mutable_buffer, char>::end(mb1);
bi2 = buffers_iterator<mutable_buffer, const char>::end(mb1);
bi3 = buffers_iterator<array<mutable_buffer, 2>, char>::end(mb2);
bi4 = buffers_iterator<array<mutable_buffer, 2>, const char>::end(mb2);
bi5 = buffers_iterator<vector<mutable_buffer>, char>::end(mb3);
bi6 = buffers_iterator<vector<mutable_buffer>, const char>::end(mb3);
bi7 = buffers_iterator<const_buffer, char>::end(cb1);
bi8 = buffers_iterator<const_buffer, const char>::end(cb1);
bi9 = buffers_iterator<array<const_buffer, 2>, char>::end(cb2);
bi10 = buffers_iterator<array<const_buffer, 2>, const char>::end(cb2);
bi11 = buffers_iterator<vector<const_buffer>, char>::end(cb3);
bi12 = buffers_iterator<vector<const_buffer>, const char>::end(cb3);
// buffers_iterator related functions.
bi1 = buffers_begin(mb1);
bi3 = buffers_begin(mb2);
bi5 = buffers_begin(mb3);
bi7 = buffers_begin(cb1);
bi9 = buffers_begin(cb2);
bi11 = buffers_begin(cb3);
bi1 = buffers_end(mb1);
bi3 = buffers_end(mb2);
bi5 = buffers_end(mb3);
bi7 = buffers_end(cb1);
bi9 = buffers_end(cb2);
bi11 = buffers_end(cb3);
// RandomAccessIterator operations.
--bi1;
--bi2;
--bi3;
--bi4;
--bi5;
--bi6;
--bi7;
--bi8;
--bi9;
--bi10;
--bi11;
--bi12;
++bi1;
++bi2;
++bi3;
++bi4;
++bi5;
++bi6;
++bi7;
++bi8;
++bi9;
++bi10;
++bi11;
++bi12;
bi1--;
bi2--;
bi3--;
bi4--;
bi5--;
bi6--;
bi7--;
bi8--;
bi9--;
bi10--;
bi11--;
bi12--;
bi1++;
bi2++;
bi3++;
bi4++;
bi5++;
bi6++;
bi7++;
bi8++;
bi9++;
bi10++;
bi11++;
bi12++;
bi1 -= 1;
bi2 -= 1;
bi3 -= 1;
bi4 -= 1;
bi5 -= 1;
bi6 -= 1;
bi7 -= 1;
bi8 -= 1;
bi9 -= 1;
bi10 -= 1;
bi11 -= 1;
bi12 -= 1;
bi1 += 1;
bi2 += 1;
bi3 += 1;
bi4 += 1;
bi5 += 1;
bi6 += 1;
bi7 += 1;
bi8 += 1;
bi9 += 1;
bi10 += 1;
bi11 += 1;
bi12 += 1;
bi1 = bi1 - 1;
bi2 = bi2 - 1;
bi3 = bi3 - 1;
bi4 = bi4 - 1;
bi5 = bi5 - 1;
bi6 = bi6 - 1;
bi7 = bi7 - 1;
bi8 = bi8 - 1;
bi9 = bi9 - 1;
bi10 = bi10 - 1;
bi11 = bi11 - 1;
bi12 = bi12 - 1;
bi1 = bi1 + 1;
bi2 = bi2 + 1;
bi3 = bi3 + 1;
bi4 = bi4 + 1;
bi5 = bi5 + 1;
bi6 = bi6 + 1;
bi7 = bi7 + 1;
bi8 = bi8 + 1;
bi9 = bi9 + 1;
bi10 = bi10 + 1;
bi11 = bi11 + 1;
bi12 = bi12 + 1;
bi1 = (-1) + bi1;
bi2 = (-1) + bi2;
bi3 = (-1) + bi3;
bi4 = (-1) + bi4;
bi5 = (-1) + bi5;
bi6 = (-1) + bi6;
bi7 = (-1) + bi7;
bi8 = (-1) + bi8;
bi9 = (-1) + bi9;
bi10 = (-1) + bi10;
bi11 = (-1) + bi11;
bi12 = (-1) + bi12;
(void)static_cast<std::ptrdiff_t>(bi13 - bi1);
(void)static_cast<std::ptrdiff_t>(bi14 - bi2);
(void)static_cast<std::ptrdiff_t>(bi15 - bi3);
(void)static_cast<std::ptrdiff_t>(bi16 - bi4);
(void)static_cast<std::ptrdiff_t>(bi17 - bi5);
(void)static_cast<std::ptrdiff_t>(bi18 - bi6);
(void)static_cast<std::ptrdiff_t>(bi19 - bi7);
(void)static_cast<std::ptrdiff_t>(bi20 - bi8);
(void)static_cast<std::ptrdiff_t>(bi21 - bi9);
(void)static_cast<std::ptrdiff_t>(bi22 - bi10);
(void)static_cast<std::ptrdiff_t>(bi23 - bi11);
(void)static_cast<std::ptrdiff_t>(bi24 - bi12);
}
catch (std::exception&)
{
}
}
} // namespace buffers_iterator_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"buffers_iterator",
ASIO_COMPILE_TEST_CASE(buffers_iterator_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_random_access_file.cpp | //
// basic_random_access_file.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_random_access_file.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_random_access_file",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/detached.cpp | //
// detached.cpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/detached.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"detached",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/file_base.cpp | //
// file_base.cpp
// ~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/post.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"file_base",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/recycling_allocator.cpp | //
// recycling_allocator.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/recycling_allocator.hpp"
#include "unit_test.hpp"
#include <vector>
#include "asio/detail/type_traits.hpp"
void recycling_allocator_test()
{
ASIO_CHECK((
asio::is_same<
asio::recycling_allocator<int>::value_type,
int
>::value));
ASIO_CHECK((
asio::is_same<
asio::recycling_allocator<void>::value_type,
void
>::value));
ASIO_CHECK((
asio::is_same<
asio::recycling_allocator<int>::rebind<char>::other,
asio::recycling_allocator<char>
>::value));
ASIO_CHECK((
asio::is_same<
asio::recycling_allocator<void>::rebind<char>::other,
asio::recycling_allocator<char>
>::value));
asio::recycling_allocator<int> a1;
asio::recycling_allocator<int> a2(a1);
ASIO_CHECK(a1 == a2);
ASIO_CHECK(!(a1 != a2));
asio::recycling_allocator<void> a3;
asio::recycling_allocator<void> a4(a3);
ASIO_CHECK(a3 == a4);
ASIO_CHECK(!(a3 != a4));
asio::recycling_allocator<int> a5(a4);
(void)a5;
asio::recycling_allocator<void> a6(a5);
(void)a6;
int* p = a1.allocate(42);
ASIO_CHECK(p != 0);
a1.deallocate(p, 42);
std::vector<int, asio::recycling_allocator<int> > v(42);
ASIO_CHECK(v.size() == 42);
}
ASIO_TEST_SUITE
(
"recycling_allocator",
ASIO_TEST_CASE(recycling_allocator_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/registered_buffer.cpp | //
// registered_buffer.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/registered_buffer.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
// registered_buffer_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all the mutable_registered_buffer and
// const_registered_buffer classes compile and link correctly. Runtime
// failures are ignored.
namespace registered_buffer_compile {
using namespace asio;
void test()
{
try
{
// mutable_registered_buffer constructors.
mutable_registered_buffer mb1;
mutable_registered_buffer mb2(mb1);
(void)mb2;
// mutable_registered_buffer functions.
mutable_buffer b1 = mb1.buffer();
(void)b1;
void* ptr1 = mb1.data();
(void)ptr1;
std::size_t n1 = mb1.size();
(void)n1;
registered_buffer_id id1 = mb1.id();
(void)id1;
// mutable_registered_buffer operators.
mb1 += 128;
mb1 = mb2 + 128;
mb1 = 128 + mb2;
// const_registered_buffer constructors.
const_registered_buffer cb1;
const_registered_buffer cb2(cb1);
(void)cb2;
const_registered_buffer cb3(mb1);
(void)cb3;
// const_registered_buffer functions.
const_buffer b2 = cb1.buffer();
(void)b2;
const void* ptr2 = cb1.data();
(void)ptr2;
std::size_t n2 = cb1.size();
(void)n2;
registered_buffer_id id2 = cb1.id();
(void)id2;
// const_registered_buffer operators.
cb1 += 128;
cb1 = cb2 + 128;
cb1 = 128 + cb2;
// buffer function overloads.
mb1 = buffer(mb2);
mb1 = buffer(mb2, 128);
cb1 = buffer(cb2);
cb1 = buffer(cb2, 128);
}
catch (std::exception&)
{
}
}
} // namespace buffer_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"registered_buffer",
ASIO_COMPILE_TEST_CASE(registered_buffer_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/io_context.cpp | //
// io_context.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/io_context.hpp"
#include <functional>
#include <sstream>
#include "asio/bind_executor.hpp"
#include "asio/dispatch.hpp"
#include "asio/post.hpp"
#include "asio/thread.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_DATE_TIME)
# include "asio/deadline_timer.hpp"
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
# include "asio/steady_timer.hpp"
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
using namespace asio;
namespace bindns = std;
#if defined(ASIO_HAS_BOOST_DATE_TIME)
typedef deadline_timer timer;
namespace chronons = boost::posix_time;
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
typedef steady_timer timer;
namespace chronons = asio::chrono;
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
void increment(int* count)
{
++(*count);
}
void decrement_to_zero(io_context* ioc, int* count)
{
if (*count > 0)
{
--(*count);
int before_value = *count;
asio::post(*ioc, bindns::bind(decrement_to_zero, ioc, count));
// Handler execution cannot nest, so count value should remain unchanged.
ASIO_CHECK(*count == before_value);
}
}
void nested_decrement_to_zero(io_context* ioc, int* count)
{
if (*count > 0)
{
--(*count);
asio::dispatch(*ioc,
bindns::bind(nested_decrement_to_zero, ioc, count));
// Handler execution is nested, so count value should now be zero.
ASIO_CHECK(*count == 0);
}
}
void sleep_increment(io_context* ioc, int* count)
{
timer t(*ioc, chronons::seconds(2));
t.wait();
if (++(*count) < 3)
asio::post(*ioc, bindns::bind(sleep_increment, ioc, count));
}
void start_sleep_increments(io_context* ioc, int* count)
{
// Give all threads a chance to start.
timer t(*ioc, chronons::seconds(2));
t.wait();
// Start the first of three increments.
asio::post(*ioc, bindns::bind(sleep_increment, ioc, count));
}
void throw_exception()
{
throw 1;
}
void io_context_run(io_context* ioc)
{
ioc->run();
}
void io_context_test()
{
io_context ioc;
int count = 0;
asio::post(ioc, bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::post(ioc, bindns::bind(increment, &count));
asio::post(ioc, bindns::bind(increment, &count));
asio::post(ioc, bindns::bind(increment, &count));
asio::post(ioc, bindns::bind(increment, &count));
asio::post(ioc, bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 5);
count = 0;
ioc.restart();
executor_work_guard<io_context::executor_type> w = make_work_guard(ioc);
asio::post(ioc, bindns::bind(&io_context::stop, &ioc));
ASIO_CHECK(!ioc.stopped());
ioc.run();
// The only operation executed should have been to stop run().
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 0);
ioc.restart();
asio::post(ioc, bindns::bind(increment, &count));
w.reset();
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 10;
ioc.restart();
asio::post(ioc, bindns::bind(decrement_to_zero, &ioc, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 10);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 0);
count = 10;
ioc.restart();
asio::post(ioc, bindns::bind(nested_decrement_to_zero, &ioc, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 10);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 0);
count = 10;
ioc.restart();
asio::dispatch(ioc,
bindns::bind(nested_decrement_to_zero, &ioc, &count));
// No handlers can be called until run() is called, even though nested
// delivery was specifically allowed in the previous call.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 10);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 0);
count = 0;
int count2 = 0;
ioc.restart();
ASIO_CHECK(!ioc.stopped());
asio::post(ioc, bindns::bind(start_sleep_increments, &ioc, &count));
asio::post(ioc, bindns::bind(start_sleep_increments, &ioc, &count2));
thread thread1(bindns::bind(io_context_run, &ioc));
thread thread2(bindns::bind(io_context_run, &ioc));
thread1.join();
thread2.join();
// The run() calls will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 3);
ASIO_CHECK(count2 == 3);
count = 10;
io_context ioc2;
asio::dispatch(ioc, asio::bind_executor(ioc2,
bindns::bind(decrement_to_zero, &ioc2, &count)));
ioc.restart();
ASIO_CHECK(!ioc.stopped());
ioc.run();
// No decrement_to_zero handlers can be called until run() is called on the
// second io_context object.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 10);
ioc2.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(count == 0);
count = 0;
int exception_count = 0;
ioc.restart();
asio::post(ioc, &throw_exception);
asio::post(ioc, bindns::bind(increment, &count));
asio::post(ioc, bindns::bind(increment, &count));
asio::post(ioc, &throw_exception);
asio::post(ioc, bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ASIO_CHECK(exception_count == 0);
for (;;)
{
try
{
ioc.run();
break;
}
catch (int)
{
++exception_count;
}
}
// The run() calls will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 3);
ASIO_CHECK(exception_count == 2);
}
class test_service : public asio::io_context::service
{
public:
static asio::io_context::id id;
test_service(asio::io_context& s)
: asio::io_context::service(s) {}
private:
virtual void shutdown_service() {}
};
asio::io_context::id test_service::id;
void io_context_service_test()
{
asio::io_context ioc1;
asio::io_context ioc2;
asio::io_context ioc3;
// Implicit service registration.
asio::use_service<test_service>(ioc1);
ASIO_CHECK(asio::has_service<test_service>(ioc1));
test_service* svc1 = new test_service(ioc1);
try
{
asio::add_service(ioc1, svc1);
ASIO_ERROR("add_service did not throw");
}
catch (asio::service_already_exists&)
{
}
delete svc1;
// Explicit service registration.
test_service* svc2 = new test_service(ioc2);
asio::add_service(ioc2, svc2);
ASIO_CHECK(asio::has_service<test_service>(ioc2));
ASIO_CHECK(&asio::use_service<test_service>(ioc2) == svc2);
test_service* svc3 = new test_service(ioc2);
try
{
asio::add_service(ioc2, svc3);
ASIO_ERROR("add_service did not throw");
}
catch (asio::service_already_exists&)
{
}
delete svc3;
// Explicit registration with invalid owner.
test_service* svc4 = new test_service(ioc2);
try
{
asio::add_service(ioc3, svc4);
ASIO_ERROR("add_service did not throw");
}
catch (asio::invalid_service_owner&)
{
}
delete svc4;
ASIO_CHECK(!asio::has_service<test_service>(ioc3));
}
void io_context_executor_query_test()
{
io_context ioc;
ASIO_CHECK(
&asio::query(ioc.get_executor(),
asio::execution::context)
== &ioc);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::blocking)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::blocking.possibly)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::outstanding_work)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::outstanding_work.untracked)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::relationship)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::relationship.fork)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::mapping)
== asio::execution::mapping.thread);
ASIO_CHECK(
asio::query(ioc.get_executor(),
asio::execution::allocator)
== std::allocator<void>());
}
void io_context_executor_execute_test()
{
io_context ioc;
int count = 0;
ioc.get_executor().execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(ioc.get_executor(),
asio::execution::blocking.possibly
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(ioc.get_executor(),
asio::execution::blocking.never
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
ASIO_CHECK(!ioc.stopped());
asio::require(ioc.get_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.tracked
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(ioc.get_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(ioc.get_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.fork
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(ioc.get_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::prefer(
asio::require(ioc.get_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator(std::allocator<void>())
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::prefer(
asio::require(ioc.get_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"io_context",
ASIO_TEST_CASE(io_context_test)
ASIO_TEST_CASE(io_context_service_test)
ASIO_TEST_CASE(io_context_executor_query_test)
ASIO_TEST_CASE(io_context_executor_execute_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/coroutine.cpp | //
// coroutine.cpp
// ~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/coroutine.hpp"
#include "unit_test.hpp"
// Must come after all other headers.
#include "asio/yield.hpp"
//------------------------------------------------------------------------------
// Coroutine completes via yield break.
void yield_break_coro(asio::coroutine& coro)
{
reenter (coro)
{
yield return;
yield break;
}
}
void yield_break_test()
{
asio::coroutine coro;
ASIO_CHECK(!coro.is_complete());
yield_break_coro(coro);
ASIO_CHECK(!coro.is_complete());
yield_break_coro(coro);
ASIO_CHECK(coro.is_complete());
}
//------------------------------------------------------------------------------
// Coroutine completes via return.
void return_coro(asio::coroutine& coro)
{
reenter (coro)
{
return;
}
}
void return_test()
{
asio::coroutine coro;
return_coro(coro);
ASIO_CHECK(coro.is_complete());
}
//------------------------------------------------------------------------------
// Coroutine completes via exception.
void exception_coro(asio::coroutine& coro)
{
reenter (coro)
{
throw 1;
}
}
void exception_test()
{
asio::coroutine coro;
try { exception_coro(coro); } catch (int) {}
ASIO_CHECK(coro.is_complete());
}
//------------------------------------------------------------------------------
// Coroutine completes by falling off the end.
void fall_off_end_coro(asio::coroutine& coro)
{
reenter (coro)
{
}
}
void fall_off_end_test()
{
asio::coroutine coro;
fall_off_end_coro(coro);
ASIO_CHECK(coro.is_complete());
}
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"coroutine",
ASIO_TEST_CASE(yield_break_test)
ASIO_TEST_CASE(return_test)
ASIO_TEST_CASE(exception_test)
ASIO_TEST_CASE(fall_off_end_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/signal_set.cpp | //
// signal_set.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/signal_set.hpp"
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
// signal_set_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// signal_set compile and link correctly. Runtime failures are ignored.
namespace signal_set_compile {
void signal_handler(const asio::error_code&, int)
{
}
void test()
{
using namespace asio;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_signal_set constructors.
signal_set set1(ioc);
signal_set set2(ioc, 1);
signal_set set3(ioc, 1, 2);
signal_set set4(ioc, 1, 2, 3);
signal_set set5(ioc_ex);
signal_set set6(ioc_ex, 1);
signal_set set7(ioc_ex, 1, 2);
signal_set set8(ioc_ex, 1, 2, 3);
// basic_io_object functions.
signal_set::executor_type ex = set1.get_executor();
(void)ex;
// basic_signal_set functions.
set1.add(1);
set1.add(1, ec);
set1.add(1, signal_set::flags::dont_care);
set1.add(1, signal_set::flags::dont_care, ec);
set1.remove(1);
set1.remove(1, ec);
set1.clear();
set1.clear(ec);
set1.cancel();
set1.cancel(ec);
set1.async_wait(&signal_handler);
int i = set1.async_wait(lazy);
(void)i;
}
catch (std::exception&)
{
}
}
} // namespace signal_set_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"signal_set",
ASIO_COMPILE_TEST_CASE(signal_set_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/composed.cpp | //
// composed.cpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/composed.hpp"
#include <functional>
#include "asio/bind_cancellation_slot.hpp"
#include "asio/cancellation_signal.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
class impl_0_completion_args
{
public:
explicit impl_0_completion_args(asio::io_context& ioc)
: ioc_(ioc),
state_(starting)
{
}
template <typename Self>
void operator()(Self& self)
{
switch (state_)
{
case starting:
state_ = posting;
asio::post(ioc_, static_cast<Self&&>(self));
break;
case posting:
self.complete();
break;
default:
break;
}
}
private:
asio::io_context& ioc_;
enum { starting, posting } state_;
};
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void())
async_0_completion_args(asio::io_context& ioc,
CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::composed(impl_0_completion_args(ioc)), token);
}
void compose_0_args_handler(int* count)
{
++(*count);
}
struct compose_0_args_lvalue_handler
{
int* count_;
void operator()()
{
++(*count_);
}
};
void compose_0_completion_args_test()
{
namespace bindns = std;
asio::io_context ioc;
int count = 0;
async_0_completion_args(ioc, bindns::bind(&compose_0_args_handler, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ioc.restart();
count = 0;
compose_0_args_lvalue_handler lvalue_handler = { &count };
async_0_completion_args(ioc, lvalue_handler);
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
}
//------------------------------------------------------------------------------
class impl_1_completion_arg
{
public:
explicit impl_1_completion_arg(asio::io_context& ioc)
: ioc_(ioc),
state_(starting)
{
}
template <typename Self>
void operator()(Self& self)
{
switch (state_)
{
case starting:
state_ = posting;
asio::post(ioc_, static_cast<Self&&>(self));
break;
case posting:
self.complete(42);
break;
default:
break;
}
}
private:
asio::io_context& ioc_;
enum { starting, posting } state_;
};
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void(int))
async_1_completion_arg(asio::io_context& ioc,
CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(int)>(
asio::composed(impl_1_completion_arg(ioc)), token);
}
void compose_1_arg_handler(int* count, int* result_out, int result)
{
++(*count);
*result_out = result;
}
struct compose_1_arg_lvalue_handler
{
int* count_;
int* result_out_;
void operator()(int result)
{
++(*count_);
*result_out_ = result;
}
};
void compose_1_completion_arg_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
int count = 0;
int result = 0;
async_1_completion_arg(ioc,
bindns::bind(&compose_1_arg_handler, &count, &result, _1));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ASIO_CHECK(result == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == 42);
ioc.restart();
count = 0;
result = 0;
compose_1_arg_lvalue_handler lvalue_handler = { &count, &result };
async_1_completion_arg(ioc, lvalue_handler);
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ASIO_CHECK(result == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == 42);
}
//------------------------------------------------------------------------------
typedef asio::enable_terminal_cancellation default_filter;
template <typename CancellationFilter>
class impl_cancellable
{
public:
explicit impl_cancellable(CancellationFilter cancellation_filter,
asio::system_timer& timer)
: cancellation_filter_(cancellation_filter),
timer_(timer),
state_(starting)
{
}
template <typename Self>
void operator()(Self& self,
const asio::error_code& ec = asio::error_code())
{
switch (state_)
{
case starting:
if (!asio::is_same<CancellationFilter, default_filter>::value)
self.reset_cancellation_state(cancellation_filter_);
state_ = waiting;
timer_.expires_after(asio::chrono::milliseconds(100));
timer_.async_wait(static_cast<Self&&>(self));
break;
case waiting:
self.complete(!ec);
break;
default:
break;
}
}
private:
CancellationFilter cancellation_filter_;
asio::system_timer& timer_;
enum { starting, waiting } state_;
};
template <typename CancellationFilter, typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void(bool))
async_cancellable(CancellationFilter cancellation_filter,
asio::system_timer& timer,
CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(bool)>(
asio::composed<void(bool)>(
impl_cancellable<CancellationFilter>(cancellation_filter, timer)),
token);
}
void compose_partial_cancellation_handler(
int* count, bool* result_out, bool result)
{
++(*count);
*result_out = result;
}
void compose_default_cancellation_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
asio::system_timer timer(ioc);
asio::cancellation_signal signal;
int count = 0;
bool result = false;
async_cancellable(default_filter(), timer,
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1));
ioc.run();
// No cancellation, operation completes successfully.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(default_filter(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Total cancellation unsupported. Operation completes successfully.
signal.emit(asio::cancellation_type::total);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(default_filter(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Partial cancellation unsupported. Operation completes successfully.
signal.emit(asio::cancellation_type::partial);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(default_filter(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Terminal cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::terminal);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
}
void compose_partial_cancellation_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
asio::system_timer timer(ioc);
asio::cancellation_signal signal;
int count = 0;
bool result = false;
async_cancellable(asio::enable_partial_cancellation(), timer,
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1));
ioc.run();
// No cancellation, operation completes successfully.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_partial_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Total cancellation unsupported. Operation completes successfully.
signal.emit(asio::cancellation_type::total);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_partial_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Partial cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::partial);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_partial_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Terminal cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::terminal);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
}
void compose_total_cancellation_test()
{
namespace bindns = std;
using bindns::placeholders::_1;
asio::io_context ioc;
asio::system_timer timer(ioc);
asio::cancellation_signal signal;
int count = 0;
bool result = false;
async_cancellable(asio::enable_total_cancellation(), timer,
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1));
ioc.run();
// No cancellation, operation completes successfully.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == true);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_total_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Total cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::total);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_total_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Partial cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::partial);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
ioc.restart();
count = 0;
result = 0;
async_cancellable(asio::enable_total_cancellation(), timer,
asio::bind_cancellation_slot(signal.slot(),
bindns::bind(&compose_partial_cancellation_handler,
&count, &result, _1)));
// Terminal cancellation works. Operation completes with failure.
signal.emit(asio::cancellation_type::terminal);
ioc.run();
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
ASIO_CHECK(result == false);
}
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"compose",
ASIO_TEST_CASE(compose_0_completion_args_test)
ASIO_TEST_CASE(compose_1_completion_arg_test)
ASIO_TEST_CASE(compose_default_cancellation_test)
ASIO_TEST_CASE(compose_partial_cancellation_test)
ASIO_TEST_CASE(compose_total_cancellation_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/readable_pipe.cpp | //
// readable_pipe.cpp
// ~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 pipe is self-contained.
#include "asio/readable_pipe.hpp"
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
// readable_pipe_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// readable_pipe compile and link correctly. Runtime failures are ignored.
namespace readable_pipe_compile {
struct write_some_handler
{
write_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
write_some_handler(write_some_handler&&) {}
private:
write_some_handler(const write_some_handler&);
};
struct read_some_handler
{
read_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
read_some_handler(read_some_handler&&) {}
private:
read_some_handler(const read_some_handler&);
};
void test()
{
#if defined(ASIO_HAS_PIPE)
using namespace asio;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
archetypes::lazy_handler lazy;
asio::error_code ec;
const std::string path;
// basic_readable_pipe constructors.
readable_pipe pipe1(ioc);
readable_pipe::native_handle_type native_pipe1 = pipe1.native_handle();
readable_pipe pipe2(ioc, native_pipe1);
readable_pipe pipe3(ioc_ex);
readable_pipe::native_handle_type native_pipe2 = pipe1.native_handle();
readable_pipe pipe4(ioc_ex, native_pipe2);
readable_pipe pipe5(std::move(pipe4));
basic_readable_pipe<io_context::executor_type> pipe6(ioc);
readable_pipe pipe7(std::move(pipe6));
// basic_readable_pipe operators.
pipe1 = readable_pipe(ioc);
pipe1 = std::move(pipe2);
pipe1 = std::move(pipe6);
// basic_io_object functions.
readable_pipe::executor_type ex = pipe1.get_executor();
(void)ex;
// basic_readable_pipe functions.
readable_pipe::native_handle_type native_pipe3 = pipe1.native_handle();
pipe1.assign(native_pipe3);
readable_pipe::native_handle_type native_pipe4 = pipe1.native_handle();
pipe1.assign(native_pipe4, ec);
bool is_open = pipe1.is_open();
(void)is_open;
pipe1.close();
pipe1.close(ec);
readable_pipe::native_handle_type native_pipe5 = pipe1.release();
(void)native_pipe5;
readable_pipe::native_handle_type native_pipe6 = pipe1.release(ec);
(void)native_pipe6;
readable_pipe::native_handle_type native_pipe7 = pipe1.native_handle();
(void)native_pipe7;
pipe1.cancel();
pipe1.cancel(ec);
pipe1.read_some(buffer(mutable_char_buffer));
pipe1.read_some(buffer(mutable_char_buffer), ec);
pipe1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
int i3 = pipe1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i3;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_PIPE)
}
} // namespace readable_pipe_compile
ASIO_TEST_SUITE
(
"readable_pipe",
ASIO_COMPILE_TEST_CASE(readable_pipe_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_streambuf.cpp | //
// basic_streambuf.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/basic_streambuf.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_streambuf",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/random_access_file.cpp | //
// random_access_file.cpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/random_access_file.hpp"
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
// random_access_file_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// random_access_file compile and link correctly. Runtime failures are ignored.
namespace random_access_file_compile {
struct write_some_at_handler
{
write_some_at_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
write_some_at_handler(write_some_at_handler&&) {}
private:
write_some_at_handler(const write_some_at_handler&);
};
struct read_some_at_handler
{
read_some_at_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
read_some_at_handler(read_some_at_handler&&) {}
private:
read_some_at_handler(const read_some_at_handler&);
};
void test()
{
#if defined(ASIO_HAS_FILE)
using namespace asio;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
archetypes::lazy_handler lazy;
asio::error_code ec;
const std::string path;
// basic_random_access_file constructors.
random_access_file file1(ioc);
random_access_file file2(ioc, "", random_access_file::read_only);
random_access_file file3(ioc, path, random_access_file::read_only);
random_access_file::native_handle_type native_file1 = file1.native_handle();
random_access_file file4(ioc, native_file1);
random_access_file file5(ioc_ex);
random_access_file file6(ioc_ex, "", random_access_file::read_only);
random_access_file file7(ioc_ex, path, random_access_file::read_only);
random_access_file::native_handle_type native_file2 = file1.native_handle();
random_access_file file8(ioc_ex, native_file2);
random_access_file file9(std::move(file8));
basic_random_access_file<io_context::executor_type> file10(ioc);
random_access_file file11(std::move(file10));
// basic_random_access_file operators.
file1 = random_access_file(ioc);
file1 = std::move(file2);
file1 = std::move(file10);
// basic_io_object functions.
random_access_file::executor_type ex = file1.get_executor();
(void)ex;
// basic_random_access_file functions.
file1.open("", random_access_file::read_only);
file1.open("", random_access_file::read_only, ec);
file1.open(path, random_access_file::read_only);
file1.open(path, random_access_file::read_only, ec);
random_access_file::native_handle_type native_file3 = file1.native_handle();
file1.assign(native_file3);
random_access_file::native_handle_type native_file4 = file1.native_handle();
file1.assign(native_file4, ec);
bool is_open = file1.is_open();
(void)is_open;
file1.close();
file1.close(ec);
random_access_file::native_handle_type native_file5 = file1.native_handle();
(void)native_file5;
random_access_file::native_handle_type native_file6 = file1.release();
(void)native_file6;
random_access_file::native_handle_type native_file7 = file1.release(ec);
(void)native_file7;
file1.cancel();
file1.cancel(ec);
asio::uint64_t s1 = file1.size();
(void)s1;
asio::uint64_t s2 = file1.size(ec);
(void)s2;
file1.resize(asio::uint64_t(0));
file1.resize(asio::uint64_t(0), ec);
file1.sync_all();
file1.sync_all(ec);
file1.sync_data();
file1.sync_data(ec);
file1.write_some_at(0, buffer(mutable_char_buffer));
file1.write_some_at(0, buffer(const_char_buffer));
file1.write_some_at(0, buffer(mutable_char_buffer), ec);
file1.write_some_at(0, buffer(const_char_buffer), ec);
file1.async_write_some_at(0, buffer(mutable_char_buffer),
write_some_at_handler());
file1.async_write_some_at(0, buffer(const_char_buffer),
write_some_at_handler());
int i1 = file1.async_write_some_at(0, buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = file1.async_write_some_at(0, buffer(const_char_buffer), lazy);
(void)i2;
file1.read_some_at(0, buffer(mutable_char_buffer));
file1.read_some_at(0, buffer(mutable_char_buffer), ec);
file1.async_read_some_at(0, buffer(mutable_char_buffer),
read_some_at_handler());
int i3 = file1.async_read_some_at(0, buffer(mutable_char_buffer), lazy);
(void)i3;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_FILE)
}
} // namespace random_access_file_compile
ASIO_TEST_SUITE
(
"random_access_file",
ASIO_COMPILE_TEST_CASE(random_access_file_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/error.cpp | //
// error.cpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/error.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ssl/error",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/stream_base.cpp | //
// stream_base.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/stream_base.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ssl/stream_base",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/host_name_verification.cpp | //
// host_name_verification.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/host_name_verification.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ssl/host_name_verification",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/stream.cpp | //
// stream.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/stream.hpp"
#include "asio.hpp"
#include "asio/ssl.hpp"
#include "../archetypes/async_result.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// ssl_stream_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ssl::stream::socket compile and link correctly. Runtime failures are ignored.
namespace ssl_stream_compile {
bool verify_callback(bool, asio::ssl::verify_context&)
{
return false;
}
void handshake_handler(const asio::error_code&)
{
}
void buffered_handshake_handler(const asio::error_code&, std::size_t)
{
}
void shutdown_handler(const asio::error_code&)
{
}
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
asio::ssl::context context(asio::ssl::context::sslv23);
archetypes::lazy_handler lazy;
asio::error_code ec;
// ssl::stream constructors.
ssl::stream<ip::tcp::socket> stream1(ioc, context);
ip::tcp::socket socket1(ioc, ip::tcp::v4());
ssl::stream<ip::tcp::socket&> stream2(socket1, context);
ssl::stream<ip::tcp::socket> stream3
= ssl::stream<ip::tcp::socket>(ioc, context);
ssl::stream<ip::tcp::socket> stream4(std::move(stream3));
// ssl::stream assignment.
stream3 = std::move(stream4);
// basic_io_object functions.
ssl::stream<ip::tcp::socket>::executor_type ex = stream1.get_executor();
(void)ex;
// ssl::stream functions.
SSL* ssl1 = stream1.native_handle();
(void)ssl1;
ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer
= stream1.lowest_layer();
(void)lowest_layer;
const ssl::stream<ip::tcp::socket>& stream5 = stream1;
const ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer2
= stream5.lowest_layer();
(void)lowest_layer2;
stream1.set_verify_mode(ssl::verify_none);
stream1.set_verify_mode(ssl::verify_none, ec);
stream1.set_verify_depth(1);
stream1.set_verify_depth(1, ec);
stream1.set_verify_callback(verify_callback);
stream1.set_verify_callback(verify_callback, ec);
stream1.handshake(ssl::stream_base::client);
stream1.handshake(ssl::stream_base::server);
stream1.handshake(ssl::stream_base::client, ec);
stream1.handshake(ssl::stream_base::server, ec);
stream1.handshake(ssl::stream_base::client, buffer(mutable_char_buffer));
stream1.handshake(ssl::stream_base::server, buffer(mutable_char_buffer));
stream1.handshake(ssl::stream_base::client, buffer(const_char_buffer));
stream1.handshake(ssl::stream_base::server, buffer(const_char_buffer));
stream1.handshake(ssl::stream_base::client,
buffer(mutable_char_buffer), ec);
stream1.handshake(ssl::stream_base::server,
buffer(mutable_char_buffer), ec);
stream1.handshake(ssl::stream_base::client,
buffer(const_char_buffer), ec);
stream1.handshake(ssl::stream_base::server,
buffer(const_char_buffer), ec);
stream1.async_handshake(ssl::stream_base::client, handshake_handler);
stream1.async_handshake(ssl::stream_base::server, handshake_handler);
int i1 = stream1.async_handshake(ssl::stream_base::client, lazy);
(void)i1;
int i2 = stream1.async_handshake(ssl::stream_base::server, lazy);
(void)i2;
stream1.async_handshake(ssl::stream_base::client,
buffer(mutable_char_buffer), buffered_handshake_handler);
stream1.async_handshake(ssl::stream_base::server,
buffer(mutable_char_buffer), buffered_handshake_handler);
stream1.async_handshake(ssl::stream_base::client,
buffer(const_char_buffer), buffered_handshake_handler);
stream1.async_handshake(ssl::stream_base::server,
buffer(const_char_buffer), buffered_handshake_handler);
int i3 = stream1.async_handshake(ssl::stream_base::client,
buffer(mutable_char_buffer), lazy);
(void)i3;
int i4 = stream1.async_handshake(ssl::stream_base::server,
buffer(mutable_char_buffer), lazy);
(void)i4;
int i5 = stream1.async_handshake(ssl::stream_base::client,
buffer(const_char_buffer), lazy);
(void)i5;
int i6 = stream1.async_handshake(ssl::stream_base::server,
buffer(const_char_buffer), lazy);
(void)i6;
stream1.shutdown();
stream1.shutdown(ec);
stream1.async_shutdown(shutdown_handler);
int i7 = stream1.async_shutdown(lazy);
(void)i7;
stream1.write_some(buffer(mutable_char_buffer));
stream1.write_some(buffer(const_char_buffer));
stream1.write_some(buffer(mutable_char_buffer), ec);
stream1.write_some(buffer(const_char_buffer), ec);
stream1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
stream1.async_write_some(buffer(const_char_buffer), write_some_handler);
int i8 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i8;
int i9 = stream1.async_write_some(buffer(const_char_buffer), lazy);
(void)i9;
stream1.read_some(buffer(mutable_char_buffer));
stream1.read_some(buffer(mutable_char_buffer), ec);
stream1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
int i10 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i10;
}
catch (std::exception&)
{
}
}
} // namespace ssl_stream_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ssl/stream",
ASIO_COMPILE_TEST_CASE(ssl_stream_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/context.cpp | //
// context.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/context.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ssl/context",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/rfc2818_verification.cpp | //
// rfc2818_verification.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/rfc2818_verification.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ssl/rfc2818_verification",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ssl/context_base.cpp | //
// context_base.cpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ssl/context_base.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ssl/context_base",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/posix/basic_stream_descriptor.cpp | //
// basic_stream_descriptor.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/posix/basic_stream_descriptor.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"posix/basic_stream_descriptor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/posix/descriptor.cpp | //
// descriptor.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/posix/descriptor.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"posix/descriptor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/posix/descriptor_base.cpp | //
// descriptor_base.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/posix/descriptor_base.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"posix/descriptor_base",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/posix/stream_descriptor.cpp | //
// stream_descriptor.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/posix/stream_descriptor.hpp"
#include "asio/io_context.hpp"
#include "../archetypes/async_result.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// posix_stream_descriptor_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// posix::stream_descriptor compile and link correctly. Runtime failures are
// ignored.
namespace posix_stream_descriptor_compile {
void wait_handler(const asio::error_code&)
{
}
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
using namespace asio;
namespace posix = asio::posix;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
posix::descriptor_base::bytes_readable io_control_command;
archetypes::immediate_handler immediate;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_stream_descriptor constructors.
posix::stream_descriptor descriptor1(ioc);
posix::stream_descriptor descriptor2(ioc_ex);
int native_descriptor1 = -1;
posix::stream_descriptor descriptor3(ioc, native_descriptor1);
posix::stream_descriptor descriptor4(ioc_ex, native_descriptor1);
posix::stream_descriptor descriptor5(std::move(descriptor2));
posix::basic_stream_descriptor<io_context::executor_type> descriptor6(ioc);
posix::stream_descriptor descriptor7(std::move(descriptor6));
// basic_stream_descriptor operators.
descriptor1 = posix::stream_descriptor(ioc);
descriptor1 = std::move(descriptor2);
descriptor1 = std::move(descriptor6);
// basic_io_object functions.
posix::stream_descriptor::executor_type ex = descriptor1.get_executor();
(void)ex;
// basic_descriptor functions.
posix::stream_descriptor::lowest_layer_type& lowest_layer
= descriptor1.lowest_layer();
(void)lowest_layer;
const posix::stream_descriptor& descriptor8 = descriptor1;
const posix::stream_descriptor::lowest_layer_type& lowest_layer2
= descriptor8.lowest_layer();
(void)lowest_layer2;
int native_descriptor2 = -1;
descriptor1.assign(native_descriptor2);
bool is_open = descriptor1.is_open();
(void)is_open;
descriptor1.close();
descriptor1.close(ec);
posix::stream_descriptor::native_handle_type native_descriptor3
= descriptor1.native_handle();
(void)native_descriptor3;
posix::stream_descriptor::native_handle_type native_descriptor4
= descriptor1.release();
(void)native_descriptor4;
descriptor1.cancel();
descriptor1.cancel(ec);
descriptor1.io_control(io_control_command);
descriptor1.io_control(io_control_command, ec);
bool non_blocking1 = descriptor1.non_blocking();
(void)non_blocking1;
descriptor1.non_blocking(true);
descriptor1.non_blocking(false, ec);
bool non_blocking2 = descriptor1.native_non_blocking();
(void)non_blocking2;
descriptor1.native_non_blocking(true);
descriptor1.native_non_blocking(false, ec);
descriptor1.wait(posix::descriptor_base::wait_read);
descriptor1.wait(posix::descriptor_base::wait_write, ec);
descriptor1.async_wait(posix::descriptor_base::wait_read, &wait_handler);
descriptor1.async_wait(posix::descriptor_base::wait_read, immediate);
int i1 = descriptor1.async_wait(posix::descriptor_base::wait_write, lazy);
(void)i1;
// basic_stream_descriptor functions.
descriptor1.write_some(buffer(mutable_char_buffer));
descriptor1.write_some(buffer(const_char_buffer));
descriptor1.write_some(null_buffers());
descriptor1.write_some(buffer(mutable_char_buffer), ec);
descriptor1.write_some(buffer(const_char_buffer), ec);
descriptor1.write_some(null_buffers(), ec);
descriptor1.async_write_some(buffer(mutable_char_buffer),
write_some_handler);
descriptor1.async_write_some(buffer(const_char_buffer),
write_some_handler);
descriptor1.async_write_some(null_buffers(),
write_some_handler);
descriptor1.async_write_some(buffer(mutable_char_buffer), immediate);
descriptor1.async_write_some(buffer(const_char_buffer), immediate);
descriptor1.async_write_some(null_buffers(), immediate);
int i2 = descriptor1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i2;
int i3 = descriptor1.async_write_some(buffer(const_char_buffer), lazy);
(void)i3;
int i4 = descriptor1.async_write_some(null_buffers(), lazy);
(void)i4;
descriptor1.read_some(buffer(mutable_char_buffer));
descriptor1.read_some(buffer(mutable_char_buffer), ec);
descriptor1.read_some(null_buffers(), ec);
descriptor1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
descriptor1.async_read_some(null_buffers(), read_some_handler);
descriptor1.async_read_some(buffer(mutable_char_buffer), immediate);
descriptor1.async_read_some(null_buffers(), immediate);
int i5 = descriptor1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i5;
int i6 = descriptor1.async_read_some(null_buffers(), lazy);
(void)i6;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
}
} // namespace posix_stream_descriptor_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"posix/stream_descriptor",
ASIO_COMPILE_TEST_CASE(posix_stream_descriptor_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/posix/basic_descriptor.cpp | //
// basic_descriptor.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/posix/basic_descriptor.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"posix/basic_descriptor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/netfwd.cpp | //
// netfwd.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/netfwd.hpp"
// Test that forward declarations don't conflict with full declarations.
#include "asio/ts/net.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/netfwd",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/executor.cpp | //
// executor.cpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/executor.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/executor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/internet.cpp | //
// internet.cpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/internet.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/internet",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/socket.cpp | //
// socket.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/socket.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/socket",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/buffer.cpp | //
// buffer.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/buffer.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/buffer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/net.cpp | //
// net.cpp
// ~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/net.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/net",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/timer.cpp | //
// timer.cpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/timer.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/timer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ts/io_context.cpp | //
// io_context.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/ts/io_context.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ts/io_context",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/overlapped_handle.cpp | //
// overlapped_handle.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/overlapped_handle.hpp"
#include "asio.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"windows/overlapped_handle",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/random_access_handle.cpp | //
// random_access_handle.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/random_access_handle.hpp"
#include "asio/io_context.hpp"
#include "../archetypes/async_result.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// windows_random_access_handle_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// windows::random_access_handle compile and link correctly. Runtime failures
// are ignored.
namespace windows_random_access_handle_compile {
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
using namespace asio;
namespace win = asio::windows;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
asio::uint64_t offset = 0;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_random_access_handle constructors.
win::random_access_handle handle1(ioc);
HANDLE native_handle1 = INVALID_HANDLE_VALUE;
#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
// Skip this on older MSVC due to mysterious ambiguous overload errors.
#else
win::random_access_handle handle2(ioc, native_handle1);
#endif
win::random_access_handle handle3(ioc_ex);
HANDLE native_handle2 = INVALID_HANDLE_VALUE;
win::random_access_handle handle4(ioc_ex, native_handle2);
win::random_access_handle handle5(std::move(handle4));
win::basic_random_access_handle<io_context::executor_type> handle6(ioc);
win::random_access_handle handle7(std::move(handle6));
// basic_random_access_handle operators.
handle1 = win::random_access_handle(ioc);
handle1 = std::move(handle4);
handle1 = std::move(handle6);
// basic_io_object functions.
windows::random_access_handle::executor_type ex = handle1.get_executor();
(void)ex;
// basic_overlapped_handle functions.
win::random_access_handle::lowest_layer_type& lowest_layer
= handle1.lowest_layer();
(void)lowest_layer;
const win::random_access_handle& handle8 = handle1;
const win::random_access_handle::lowest_layer_type& lowest_layer2
= handle8.lowest_layer();
(void)lowest_layer2;
HANDLE native_handle3 = INVALID_HANDLE_VALUE;
handle1.assign(native_handle3);
bool is_open = handle1.is_open();
(void)is_open;
handle1.close();
handle1.close(ec);
win::random_access_handle::native_handle_type native_handle4
= handle1.release();
(void)native_handle4;
win::random_access_handle::native_handle_type native_handle5
= handle1.release(ec);
(void)native_handle5;
win::random_access_handle::native_handle_type native_handle6
= handle1.native_handle();
(void)native_handle6;
handle1.cancel();
handle1.cancel(ec);
// basic_random_access_handle functions.
handle1.write_some_at(offset, buffer(mutable_char_buffer));
handle1.write_some_at(offset, buffer(const_char_buffer));
handle1.write_some_at(offset, buffer(mutable_char_buffer), ec);
handle1.write_some_at(offset, buffer(const_char_buffer), ec);
handle1.async_write_some_at(offset,
buffer(mutable_char_buffer), &write_some_handler);
handle1.async_write_some_at(offset,
buffer(const_char_buffer), &write_some_handler);
int i1 = handle1.async_write_some_at(offset,
buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = handle1.async_write_some_at(offset,
buffer(const_char_buffer), lazy);
(void)i2;
handle1.read_some_at(offset, buffer(mutable_char_buffer));
handle1.read_some_at(offset, buffer(mutable_char_buffer), ec);
handle1.async_read_some_at(offset,
buffer(mutable_char_buffer), &read_some_handler);
int i3 = handle1.async_read_some_at(offset,
buffer(mutable_char_buffer), lazy);
(void)i3;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
}
} // namespace windows_random_access_handle_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"windows/random_access_handle",
ASIO_COMPILE_TEST_CASE(windows_random_access_handle_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/basic_overlapped_handle.cpp | //
// basic_overlapped_handle.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/basic_overlapped_handle.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_overlapped_handle",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/basic_stream_handle.cpp | //
// basic_stream_handle.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/basic_stream_handle.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_stream_handle",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/overlapped_ptr.cpp | //
// overlapped_ptr.cpp
// ~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/overlapped_ptr.hpp"
#include "asio/any_io_executor.hpp"
#include "asio/executor.hpp"
#include "asio/io_context.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// windows_overlapped_ptr_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// windows::overlapped_ptr compile and link correctly. Runtime failures are
// ignored.
namespace windows_overlapped_ptr_compile {
void overlapped_handler_1(const asio::error_code&, std::size_t)
{
}
struct overlapped_handler_2
{
void operator()(const asio::error_code&, std::size_t)
{
}
};
void test()
{
#if defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
using namespace asio;
namespace win = asio::windows;
try
{
io_context ioc;
asio::any_io_executor ex1(ioc.get_executor());
#if !defined(ASIO_NO_TS_EXECUTORS)
asio::executor ex2(ioc.get_executor());
#endif // !defined(ASIO_NO_TS_EXECUTORS)
// basic_overlapped_ptr constructors.
win::overlapped_ptr ptr1;
win::overlapped_ptr ptr2(ioc, &overlapped_handler_1);
win::overlapped_ptr ptr3(ioc, overlapped_handler_2());
win::overlapped_ptr ptr4(ioc.get_executor(), &overlapped_handler_1);
win::overlapped_ptr ptr5(ioc.get_executor(), overlapped_handler_2());
win::overlapped_ptr ptr6(ex1, &overlapped_handler_1);
win::overlapped_ptr ptr7(ex1, overlapped_handler_2());
#if !defined(ASIO_NO_TS_EXECUTORS)
win::overlapped_ptr ptr8(ex2, &overlapped_handler_1);
win::overlapped_ptr ptr9(ex2, overlapped_handler_2());
#endif // !defined(ASIO_NO_TS_EXECUTORS)
// overlapped_ptr functions.
ptr1.reset();
ptr2.reset(ioc, &overlapped_handler_1);
ptr3.reset(ioc, overlapped_handler_2());
ptr2.reset(ioc.get_executor(), &overlapped_handler_1);
ptr3.reset(ioc.get_executor(), overlapped_handler_2());
ptr2.reset(ex1, &overlapped_handler_1);
ptr3.reset(ex1, overlapped_handler_2());
#if !defined(ASIO_NO_TS_EXECUTORS)
ptr3.reset(ex2, &overlapped_handler_1);
ptr3.reset(ex2, overlapped_handler_2());
#endif // !defined(ASIO_NO_TS_EXECUTORS)
OVERLAPPED* ov1 = ptr1.get();
(void)ov1;
const win::overlapped_ptr& ptr10(ptr1);
const OVERLAPPED* ov2 = ptr10.get();
(void)ov2;
OVERLAPPED* ov3 = ptr1.release();
(void)ov3;
asio::error_code ec;
std::size_t bytes_transferred = 0;
ptr1.complete(ec, bytes_transferred);
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
}
} // namespace windows_overlapped_ptr_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"windows/overlapped_ptr",
ASIO_COMPILE_TEST_CASE(windows_overlapped_ptr_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/basic_random_access_handle.cpp | //
// basic_random_access_handle.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/basic_random_access_handle.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_random_access_handle",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/object_handle.cpp | //
// object_handle.cpp
// ~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/object_handle.hpp"
#include "asio/io_context.hpp"
#include "../archetypes/async_result.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// windows_object_handle_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// windows::object_handle compile and link correctly. Runtime failures are
// ignored.
namespace windows_object_handle_compile {
void wait_handler(const asio::error_code&)
{
}
void test()
{
#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
using namespace asio;
namespace win = asio::windows;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_object_handle constructors.
win::object_handle handle1(ioc);
HANDLE native_handle1 = INVALID_HANDLE_VALUE;
#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
// Skip this on older MSVC due to mysterious ambiguous overload errors.
#else
win::object_handle handle2(ioc, native_handle1);
#endif
win::object_handle handle3(ioc_ex);
HANDLE native_handle2 = INVALID_HANDLE_VALUE;
win::object_handle handle4(ioc_ex, native_handle2);
win::object_handle handle5(std::move(handle4));
win::basic_object_handle<io_context::executor_type> handle6(ioc);
win::object_handle handle7(std::move(handle6));
// basic_object_handle operators.
handle1 = win::object_handle(ioc);
handle1 = std::move(handle3);
handle1 = std::move(handle6);
// basic_io_object functions.
win::object_handle::executor_type ex = handle1.get_executor();
(void)ex;
// basic_handle functions.
win::object_handle::lowest_layer_type& lowest_layer
= handle1.lowest_layer();
(void)lowest_layer;
const win::object_handle& handle8 = handle1;
const win::object_handle::lowest_layer_type& lowest_layer3
= handle8.lowest_layer();
(void)lowest_layer3;
HANDLE native_handle4 = INVALID_HANDLE_VALUE;
handle1.assign(native_handle4);
bool is_open = handle1.is_open();
(void)is_open;
handle1.close();
handle1.close(ec);
win::object_handle::native_handle_type native_handle3
= handle1.native_handle();
(void)native_handle3;
handle1.cancel();
handle1.cancel(ec);
// basic_object_handle functions.
handle1.wait();
handle1.wait(ec);
handle1.async_wait(&wait_handler);
int i1 = handle1.async_wait(lazy);
(void)i1;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
}
} // namespace windows_object_handle_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"windows/object_handle",
ASIO_COMPILE_TEST_CASE(windows_object_handle_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/stream_handle.cpp | //
// stream_handle.cpp
// ~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/stream_handle.hpp"
#include "asio/io_context.hpp"
#include "../archetypes/async_result.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// windows_stream_handle_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// windows::stream_handle compile and link correctly. Runtime failures are
// ignored.
namespace windows_stream_handle_compile {
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
#if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
using namespace asio;
namespace win = asio::windows;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_stream_handle constructors.
win::stream_handle handle1(ioc);
HANDLE native_handle1 = INVALID_HANDLE_VALUE;
#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
// Skip this on older MSVC due to mysterious ambiguous overload errors.
#else
win::stream_handle handle2(ioc, native_handle1);
#endif
win::stream_handle handle3(ioc_ex);
HANDLE native_handle2 = INVALID_HANDLE_VALUE;
win::stream_handle handle4(ioc_ex, native_handle2);
win::stream_handle handle5(std::move(handle4));
win::basic_stream_handle<io_context::executor_type> handle6(ioc);
win::stream_handle handle7(std::move(handle6));
// basic_stream_handle operators.
handle1 = win::stream_handle(ioc);
handle1 = std::move(handle4);
handle1 = std::move(handle6);
// basic_io_object functions.
windows::stream_handle::executor_type ex = handle1.get_executor();
(void)ex;
// basic_overlapped_handle functions.
win::stream_handle::lowest_layer_type& lowest_layer
= handle1.lowest_layer();
(void)lowest_layer;
const win::stream_handle& handle8 = handle1;
const win::stream_handle::lowest_layer_type& lowest_layer2
= handle8.lowest_layer();
(void)lowest_layer2;
HANDLE native_handle3 = INVALID_HANDLE_VALUE;
handle1.assign(native_handle3);
bool is_open = handle1.is_open();
(void)is_open;
handle1.close();
handle1.close(ec);
win::stream_handle::native_handle_type native_handle4
= handle1.release();
(void)native_handle4;
win::stream_handle::native_handle_type native_handle5
= handle1.release(ec);
(void)native_handle5;
win::stream_handle::native_handle_type native_handle6
= handle1.native_handle();
(void)native_handle6;
handle1.cancel();
handle1.cancel(ec);
// basic_stream_handle functions.
handle1.write_some(buffer(mutable_char_buffer));
handle1.write_some(buffer(const_char_buffer));
handle1.write_some(buffer(mutable_char_buffer), ec);
handle1.write_some(buffer(const_char_buffer), ec);
handle1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
handle1.async_write_some(buffer(const_char_buffer), &write_some_handler);
int i1 = handle1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = handle1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
handle1.read_some(buffer(mutable_char_buffer));
handle1.read_some(buffer(mutable_char_buffer), ec);
handle1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
int i3 = handle1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i3;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
}
} // namespace windows_stream_handle_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"windows/stream_handle",
ASIO_COMPILE_TEST_CASE(windows_stream_handle_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/windows/basic_object_handle.cpp | //
// basic_object_handle.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/windows/basic_object_handle.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_object_handle",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/generic/datagram_protocol.cpp | //
// generic/datagram_protocol.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/generic/datagram_protocol.hpp"
#include <cstring>
#include "asio/io_context.hpp"
#include "asio/ip/udp.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.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 asio::error_code&)
{
}
void send_handler(const asio::error_code&, std::size_t)
{
}
void receive_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
using namespace asio;
namespace generic = asio::generic;
typedef generic::datagram_protocol dp;
const int af_inet = ASIO_OS_DEF(AF_INET);
const int ipproto_udp = ASIO_OS_DEF(IPPROTO_UDP);
const int sock_dgram = 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;
archetypes::immediate_handler immediate;
asio::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(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(ASIO_WINDOWS_RUNTIME)
dp::socket socket5(std::move(socket4));
asio::ip::udp::socket udp_socket(ioc);
dp::socket socket6(std::move(udp_socket));
// basic_datagram_socket operators.
socket1 = dp::socket(ioc);
socket1 = std::move(socket2);
socket1 = asio::ip::udp::socket(ioc);
// 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(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(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.async_connect(dp::endpoint(), immediate);
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.async_send(buffer(mutable_char_buffer), immediate);
socket1.async_send(buffer(const_char_buffer), immediate);
socket1.async_send(null_buffers(), immediate);
socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
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.async_send_to(buffer(mutable_char_buffer),
dp::endpoint(), immediate);
socket1.async_send_to(buffer(const_char_buffer),
dp::endpoint(), immediate);
socket1.async_send_to(null_buffers(),
dp::endpoint(), immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
dp::endpoint(), in_flags, immediate);
socket1.async_send_to(buffer(const_char_buffer),
dp::endpoint(), in_flags, immediate);
socket1.async_send_to(null_buffers(),
dp::endpoint(), in_flags, immediate);
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.async_receive(buffer(mutable_char_buffer), immediate);
socket1.async_receive(null_buffers(), immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_receive(null_buffers(), in_flags, immediate);
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);
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, immediate);
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, in_flags, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, in_flags, immediate);
}
catch (std::exception&)
{
}
}
} // namespace generic_datagram_protocol_socket_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"generic/datagram_protocol",
ASIO_COMPILE_TEST_CASE(generic_datagram_protocol_socket_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/generic/seq_packet_protocol.cpp | //
// generic/seq_packet_protocol.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/generic/seq_packet_protocol.hpp"
#include <cstring>
#include "asio/io_context.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.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 asio::error_code&)
{
}
void send_handler(const asio::error_code&, std::size_t)
{
}
void receive_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
using namespace asio;
namespace generic = asio::generic;
typedef generic::seq_packet_protocol spp;
const int af_inet = ASIO_OS_DEF(AF_INET);
const int sock_seqpacket = 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;
archetypes::immediate_handler immediate;
asio::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(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(ASIO_WINDOWS_RUNTIME)
spp::socket socket5(std::move(socket4));
// basic_seq_packet_socket operators.
socket1 = spp::socket(ioc);
socket1 = std::move(socket2);
// 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(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(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.async_connect(spp::endpoint(), immediate);
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.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
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);
socket1.async_receive(buffer(mutable_char_buffer), out_flags, immediate);
socket1.async_receive(null_buffers(), out_flags, immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
out_flags, immediate);
socket1.async_receive(null_buffers(), in_flags, out_flags, immediate);
}
catch (std::exception&)
{
}
}
} // namespace generic_seq_packet_protocol_socket_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"generic/seq_packet_protocol",
ASIO_COMPILE_TEST_CASE(generic_seq_packet_protocol_socket_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/generic/basic_endpoint.cpp | //
// generic/basic_endpoint.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/generic/basic_endpoint.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"generic/basic_endpoint",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/generic/raw_protocol.cpp | //
// generic/raw_protocol.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/generic/raw_protocol.hpp"
#include <cstring>
#include "asio/io_context.hpp"
#include "asio/ip/icmp.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.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 asio::error_code&)
{
}
void send_handler(const asio::error_code&, std::size_t)
{
}
void receive_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
using namespace asio;
namespace generic = asio::generic;
typedef generic::raw_protocol rp;
const int af_inet = ASIO_OS_DEF(AF_INET);
const int ipproto_icmp = ASIO_OS_DEF(IPPROTO_ICMP);
const int sock_raw = 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;
archetypes::immediate_handler immediate;
asio::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(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(ASIO_WINDOWS_RUNTIME)
rp::socket socket5(std::move(socket4));
asio::ip::icmp::socket icmp_socket(ioc);
rp::socket socket6(std::move(icmp_socket));
// basic_datagram_socket operators.
socket1 = rp::socket(ioc);
socket1 = std::move(socket2);
socket1 = asio::ip::icmp::socket(ioc);
// 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(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(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.async_connect(rp::endpoint(), immediate);
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.async_send(buffer(mutable_char_buffer), immediate);
socket1.async_send(buffer(const_char_buffer), immediate);
socket1.async_send(null_buffers(), immediate);
socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
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.async_send_to(buffer(mutable_char_buffer),
rp::endpoint(), immediate);
socket1.async_send_to(buffer(const_char_buffer),
rp::endpoint(), immediate);
socket1.async_send_to(null_buffers(),
rp::endpoint(), immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
rp::endpoint(), in_flags, immediate);
socket1.async_send_to(buffer(const_char_buffer),
rp::endpoint(), in_flags, immediate);
socket1.async_send_to(null_buffers(),
rp::endpoint(), in_flags, immediate);
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.async_receive(buffer(mutable_char_buffer), immediate);
socket1.async_receive(null_buffers(), immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
immediate);
socket1.async_receive(null_buffers(), in_flags, immediate);
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);
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, immediate);
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, in_flags, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, in_flags, immediate);
}
catch (std::exception&)
{
}
}
} // namespace generic_raw_protocol_socket_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"generic/raw_protocol",
ASIO_COMPILE_TEST_CASE(generic_raw_protocol_socket_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/generic/stream_protocol.cpp | //
// generic/stream_protocol.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/generic/stream_protocol.hpp"
#include <cstring>
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.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 asio::error_code&)
{
}
void send_handler(const asio::error_code&, std::size_t)
{
}
void receive_handler(const asio::error_code&, std::size_t)
{
}
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test()
{
using namespace asio;
namespace generic = asio::generic;
typedef generic::stream_protocol sp;
const int af_inet = ASIO_OS_DEF(AF_INET);
const int ipproto_tcp = ASIO_OS_DEF(IPPROTO_TCP);
const int sock_stream = 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;
archetypes::immediate_handler immediate;
asio::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(ASIO_WINDOWS_RUNTIME)
Windows::Networking::Sockets::StreamSocket^ native_socket1 = nullptr;
#else // defined(ASIO_WINDOWS_RUNTIME)
sp::socket::native_handle_type native_socket1
= ::socket(af_inet, sock_stream, 0);
#endif // defined(ASIO_WINDOWS_RUNTIME)
sp::socket socket4(ioc, sp(af_inet, ipproto_tcp), native_socket1);
sp::socket socket5(std::move(socket4));
asio::ip::tcp::socket tcp_socket(ioc);
sp::socket socket6(std::move(tcp_socket));
// basic_stream_socket operators.
socket1 = sp::socket(ioc);
socket1 = std::move(socket2);
socket1 = asio::ip::tcp::socket(ioc);
// 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(ASIO_WINDOWS_RUNTIME)
Windows::Networking::Sockets::StreamSocket^ native_socket2 = nullptr;
#else // defined(ASIO_WINDOWS_RUNTIME)
sp::socket::native_handle_type native_socket2
= ::socket(af_inet, sock_stream, 0);
#endif // defined(ASIO_WINDOWS_RUNTIME)
socket1.assign(sp(af_inet, ipproto_tcp), native_socket2);
#if defined(ASIO_WINDOWS_RUNTIME)
Windows::Networking::Sockets::StreamSocket^ native_socket3 = nullptr;
#else // defined(ASIO_WINDOWS_RUNTIME)
sp::socket::native_handle_type native_socket3
= ::socket(af_inet, sock_stream, 0);
#endif // defined(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.async_connect(sp::endpoint(), immediate);
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.async_send(buffer(mutable_char_buffer), immediate);
socket1.async_send(buffer(const_char_buffer), immediate);
socket1.async_send(null_buffers(), immediate);
socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
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.async_receive(buffer(mutable_char_buffer), immediate);
socket1.async_receive(null_buffers(), immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
immediate);
socket1.async_receive(null_buffers(), in_flags, immediate);
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.async_write_some(buffer(mutable_char_buffer), immediate);
socket1.async_write_some(buffer(const_char_buffer), immediate);
socket1.async_write_some(null_buffers(), immediate);
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);
socket1.async_read_some(buffer(mutable_char_buffer), immediate);
socket1.async_read_some(null_buffers(), immediate);
}
catch (std::exception&)
{
}
}
} // namespace generic_stream_protocol_socket_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"generic/stream_protocol",
ASIO_COMPILE_TEST_CASE(generic_stream_protocol_socket_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/basic_resolver_iterator.cpp | //
// basic_resolver_iterator.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/basic_resolver_iterator.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ip/basic_resolver_iterator",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/network_v6.cpp | //
// network_v6.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail 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 "asio/ip/network_v6.hpp"
#include "../unit_test.hpp"
#include <sstream>
//------------------------------------------------------------------------------
// ip_network_v6_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::network_v6 compile and link correctly. Runtime failures are ignored.
namespace ip_network_v6_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
asio::error_code ec;
// network_v6 constructors.
ip::network_v6 net1(ip::make_address_v6("2001:370::10:7344"), 64);
ip::network_v6 net2(ip::make_address_v6("2001:370::10:7345"), 96);
// network_v6 functions.
ip::address_v6 addr1 = net1.address();
(void)addr1;
unsigned short prefix_len = net1.prefix_length();
(void)prefix_len;
ip::address_v6 addr3 = net1.network();
(void)addr3;
ip::address_v6_range hosts = net1.hosts();
(void)hosts;
ip::network_v6 net3 = net1.canonical();
(void)net3;
bool b1 = net1.is_host();
(void)b1;
bool b2 = net1.is_subnet_of(net2);
(void)b2;
std::string s1 = net1.to_string();
(void)s1;
std::string s2 = net1.to_string(ec);
(void)s2;
// network_v6 comparisons.
bool b3 = (net1 == net2);
(void)b3;
bool b4 = (net1 != net2);
(void)b4;
// network_v6 creation functions.
net1 = ip::make_network_v6(ip::address_v6(), 24);
net1 = ip::make_network_v6("10.0.0.0/8");
net1 = ip::make_network_v6("10.0.0.0/8", ec);
net1 = ip::make_network_v6(s1);
net1 = ip::make_network_v6(s1, ec);
#if defined(ASIO_HAS_STRING_VIEW)
# if defined(ASIO_HAS_STD_STRING_VIEW)
std::string_view string_view_value("0::0/8");
# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_value("0::0/8");
# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
net1 = ip::make_network_v6(string_view_value);
net1 = ip::make_network_v6(string_view_value, ec);
#endif // defined(ASIO_STD_STRING_VIEW)
// network_v6 I/O.
std::ostringstream os;
os << net1;
#if !defined(BOOST_NO_STD_WSTREAMBUF)
std::wostringstream wos;
wos << net1;
#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
}
catch (std::exception&)
{
}
}
} // namespace ip_network_v6_compile
//------------------------------------------------------------------------------
// ip_network_v6_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that the various public member functions meet the
// necessary postconditions.
namespace ip_network_v6_runtime {
void test()
{
using asio::ip::address_v6;
using asio::ip::make_address_v6;
using asio::ip::network_v6;
using asio::ip::make_network_v6;
address_v6 addr = make_address_v6("2001:370::10:7344");
std::string msg;
try
{
make_network_v6(addr, 129);
}
catch(std::out_of_range& ex)
{
msg = ex.what();
}
ASIO_CHECK(msg == std::string("prefix length too large"));
// construct address range from address and prefix length
ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 128).network() == make_address_v6("2001:370::10:7344"));
ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 64).network() == make_address_v6("2001:370::"));
ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 27).network() == make_address_v6("2001:360::"));
// construct address range from string in CIDR notation
ASIO_CHECK(make_network_v6("2001:370::10:7344/128").network() == make_address_v6("2001:370::10:7344"));
ASIO_CHECK(make_network_v6("2001:370::10:7344/64").network() == make_address_v6("2001:370::"));
ASIO_CHECK(make_network_v6("2001:370::10:7344/27").network() == make_address_v6("2001:360::"));
// construct network from invalid string
asio::error_code ec;
make_network_v6("a:b/24", ec);
ASIO_CHECK(!!ec);
make_network_v6("2001:370::10:7344/129", ec);
ASIO_CHECK(!!ec);
make_network_v6("2001:370::10:7344/-1", ec);
ASIO_CHECK(!!ec);
make_network_v6("2001:370::10:7344/", ec);
ASIO_CHECK(!!ec);
make_network_v6("2001:370::10:7344", ec);
ASIO_CHECK(!!ec);
// prefix length
ASIO_CHECK(make_network_v6("2001:370::10:7344/128").prefix_length() == 128);
ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 27).prefix_length() == 27);
// to string
std::string a("2001:370::10:7344/64");
ASIO_CHECK(make_network_v6(a.c_str()).to_string() == a);
ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 27).to_string() == std::string("2001:370::10:7344/27"));
// return host part
ASIO_CHECK(make_network_v6("2001:370::10:7344/64").address() == make_address_v6("2001:370::10:7344"));
ASIO_CHECK(make_network_v6("2001:370::10:7344/27").address().to_string() == "2001:370::10:7344");
// return network in CIDR notation
ASIO_CHECK(make_network_v6("2001:370::10:7344/27").canonical().to_string() == "2001:360::/27");
// is host
ASIO_CHECK(make_network_v6("2001:370::10:7344/128").is_host());
ASIO_CHECK(!make_network_v6("2001:370::10:7344/127").is_host());
// is real subnet of
ASIO_CHECK(make_network_v6("2001:370::10:3744/64").is_subnet_of(make_network_v6("2001:370::/16")));
ASIO_CHECK(make_network_v6("2001:370::/64").is_subnet_of(make_network_v6("2001:370::/16")));
ASIO_CHECK(make_network_v6("2001:0db8:85a3::/64").is_subnet_of(make_network_v6("2001:0d00::/24")));
ASIO_CHECK(!make_network_v6("2001:370::10:3744/128").is_subnet_of(make_network_v6("2001:370::10:3744/128")));
ASIO_CHECK(make_network_v6("2001:0db8:85a3::/64").is_subnet_of(make_network_v6("2001:0dc0::/24")));
network_v6 r(make_network_v6("2001:370::/64"));
ASIO_CHECK(!r.is_subnet_of(r));
network_v6 net12(make_network_v6("2001:370::10:7344/64"));
network_v6 net13(make_network_v6("2001:0db8::/127"));
network_v6 net14(make_network_v6("2001:0db8::/125"));
network_v6 net15(make_network_v6("2001:0db8::/119"));
// network
ASIO_CHECK(net12.network() == make_address_v6("2001:370::"));
ASIO_CHECK(net13.network() == make_address_v6("2001:0db8::"));
ASIO_CHECK(net14.network() == make_address_v6("2001:0db8::"));
ASIO_CHECK(net15.network() == make_address_v6("2001:0db8::"));
// iterator
//ASIO_CHECK(std::distance(net12.hosts().begin(),net12.hosts().end()) == 18446744073709552000);
ASIO_CHECK(std::distance(net13.hosts().begin(),net13.hosts().end()) == 2);
ASIO_CHECK(std::distance(net14.hosts().begin(),net14.hosts().end()) == 8);
ASIO_CHECK(std::distance(net15.hosts().begin(),net15.hosts().end()) == 512);
ASIO_CHECK(*net12.hosts().begin() == make_address_v6("2001:0370::"));
ASIO_CHECK(net12.hosts().end() != net12.hosts().find(make_address_v6("2001:0370::ffff:ffff:ffff:ffff")));
ASIO_CHECK(*net13.hosts().begin() == make_address_v6("2001:0db8::"));
ASIO_CHECK(net13.hosts().end() != net13.hosts().find(make_address_v6("2001:0db8::1")));
ASIO_CHECK(net13.hosts().end() == net13.hosts().find(make_address_v6("2001:0db8::2")));
ASIO_CHECK(*net14.hosts().begin() == make_address_v6("2001:0db8::"));
ASIO_CHECK(net14.hosts().end() != net14.hosts().find(make_address_v6("2001:0db8::7")));
ASIO_CHECK(net14.hosts().end() == net14.hosts().find(make_address_v6("2001:0db8::8")));
ASIO_CHECK(*net15.hosts().begin() == make_address_v6("2001:0db8::"));
ASIO_CHECK(net15.hosts().end() != net15.hosts().find(make_address_v6("2001:0db8::01ff")));
ASIO_CHECK(net15.hosts().end() == net15.hosts().find(make_address_v6("2001:0db8::0200")));
}
} // namespace ip_network_v6_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/network_v6",
ASIO_COMPILE_TEST_CASE(ip_network_v6_compile::test)
ASIO_TEST_CASE(ip_network_v6_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/tcp.cpp | //
// tcp.cpp
// ~~~~~~~
//
// Copyright (c) 2003-2024 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)
// Enable cancel() support on Windows.
#define ASIO_ENABLE_CANCELIO 1
// Test that header file is self-contained.
#include "asio/ip/tcp.hpp"
#include <cstring>
#include <functional>
#include "asio/io_context.hpp"
#include "asio/read.hpp"
#include "asio/write.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.hpp"
#include "../archetypes/gettable_socket_option.hpp"
#include "../archetypes/io_control_command.hpp"
#include "../archetypes/settable_socket_option.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
# include <boost/array.hpp>
#else // defined(ASIO_HAS_BOOST_ARRAY)
# include <array>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
//------------------------------------------------------------------------------
// ip_tcp_compile test
// ~~~~~~~~~~~~~~~~~~~
// The following test checks that all nested classes, enums and constants in
// ip::tcp compile and link correctly. Runtime failures are ignored.
namespace ip_tcp_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
ip::tcp::socket sock(ioc);
// no_delay class.
ip::tcp::no_delay no_delay1(true);
sock.set_option(no_delay1);
ip::tcp::no_delay no_delay2;
sock.get_option(no_delay2);
no_delay1 = true;
(void)static_cast<bool>(no_delay1);
(void)static_cast<bool>(!no_delay1);
(void)static_cast<bool>(no_delay1.value());
ip::tcp::endpoint ep;
(void)static_cast<std::size_t>(std::hash<ip::tcp::endpoint>()(ep));
}
catch (std::exception&)
{
}
}
} // namespace ip_tcp_compile
//------------------------------------------------------------------------------
// ip_tcp_runtime test
// ~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the ip::tcp class.
namespace ip_tcp_runtime {
void test()
{
using namespace asio;
namespace ip = asio::ip;
io_context ioc;
ip::tcp::socket sock(ioc, ip::tcp::v4());
asio::error_code ec;
// no_delay class.
ip::tcp::no_delay no_delay1(true);
ASIO_CHECK(no_delay1.value());
ASIO_CHECK(static_cast<bool>(no_delay1));
ASIO_CHECK(!!no_delay1);
sock.set_option(no_delay1, ec);
ASIO_CHECK(!ec);
ip::tcp::no_delay no_delay2;
sock.get_option(no_delay2, ec);
ASIO_CHECK(!ec);
ASIO_CHECK(no_delay2.value());
ASIO_CHECK(static_cast<bool>(no_delay2));
ASIO_CHECK(!!no_delay2);
ip::tcp::no_delay no_delay3(false);
ASIO_CHECK(!no_delay3.value());
ASIO_CHECK(!static_cast<bool>(no_delay3));
ASIO_CHECK(!no_delay3);
sock.set_option(no_delay3, ec);
ASIO_CHECK(!ec);
ip::tcp::no_delay no_delay4;
sock.get_option(no_delay4, ec);
ASIO_CHECK(!ec);
ASIO_CHECK(!no_delay4.value());
ASIO_CHECK(!static_cast<bool>(no_delay4));
ASIO_CHECK(!no_delay4);
}
} // namespace ip_tcp_runtime
//------------------------------------------------------------------------------
// ip_tcp_socket_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::tcp::socket compile and link correctly. Runtime failures are ignored.
namespace ip_tcp_socket_compile {
struct connect_handler
{
connect_handler() {}
void operator()(const asio::error_code&) {}
connect_handler(connect_handler&&) {}
private:
connect_handler(const connect_handler&);
};
struct wait_handler
{
wait_handler() {}
void operator()(const asio::error_code&) {}
wait_handler(wait_handler&&) {}
private:
wait_handler(const wait_handler&);
};
struct send_handler
{
send_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
send_handler(send_handler&&) {}
private:
send_handler(const send_handler&);
};
struct receive_handler
{
receive_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
receive_handler(receive_handler&&) {}
private:
receive_handler(const receive_handler&);
};
struct write_some_handler
{
write_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
write_some_handler(write_some_handler&&) {}
private:
write_some_handler(const write_some_handler&);
};
struct read_some_handler
{
read_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
read_some_handler(read_some_handler&&) {}
private:
read_some_handler(const read_some_handler&);
};
void test()
{
#if defined(ASIO_HAS_BOOST_ARRAY)
using boost::array;
#else // defined(ASIO_HAS_BOOST_ARRAY)
using std::array;
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
array<asio::mutable_buffer, 2> mutable_buffers = {{
asio::buffer(mutable_char_buffer, 10),
asio::buffer(mutable_char_buffer + 10, 10) }};
array<asio::const_buffer, 2> const_buffers = {{
asio::buffer(const_char_buffer, 10),
asio::buffer(const_char_buffer + 10, 10) }};
socket_base::message_flags in_flags = 0;
archetypes::settable_socket_option<void> settable_socket_option1;
archetypes::settable_socket_option<int> settable_socket_option2;
archetypes::settable_socket_option<double> settable_socket_option3;
archetypes::gettable_socket_option<void> gettable_socket_option1;
archetypes::gettable_socket_option<int> gettable_socket_option2;
archetypes::gettable_socket_option<double> gettable_socket_option3;
archetypes::io_control_command io_control_command;
archetypes::immediate_handler immediate;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_stream_socket constructors.
ip::tcp::socket socket1(ioc);
ip::tcp::socket socket2(ioc, ip::tcp::v4());
ip::tcp::socket socket3(ioc, ip::tcp::v6());
ip::tcp::socket socket4(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
ip::tcp::socket socket5(ioc, ip::tcp::endpoint(ip::tcp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::socket::native_handle_type native_socket1
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
ip::tcp::socket socket6(ioc, ip::tcp::v4(), native_socket1);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::socket socket7(ioc_ex);
ip::tcp::socket socket8(ioc_ex, ip::tcp::v4());
ip::tcp::socket socket9(ioc_ex, ip::tcp::v6());
ip::tcp::socket socket10(ioc_ex, ip::tcp::endpoint(ip::tcp::v4(), 0));
ip::tcp::socket socket11(ioc_ex, ip::tcp::endpoint(ip::tcp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::socket::native_handle_type native_socket2
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
ip::tcp::socket socket12(ioc_ex, ip::tcp::v4(), native_socket2);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::socket socket13(std::move(socket5));
// basic_stream_socket operators.
socket1 = ip::tcp::socket(ioc);
socket1 = std::move(socket2);
// basic_io_object functions.
ip::tcp::socket::executor_type ex = socket1.get_executor();
(void)ex;
// basic_socket functions.
ip::tcp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
(void)lowest_layer;
const ip::tcp::socket& socket14 = socket1;
const ip::tcp::socket::lowest_layer_type& lowest_layer2
= socket14.lowest_layer();
(void)lowest_layer2;
socket1.open(ip::tcp::v4());
socket1.open(ip::tcp::v6());
socket1.open(ip::tcp::v4(), ec);
socket1.open(ip::tcp::v6(), ec);
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::socket::native_handle_type native_socket3
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
socket1.assign(ip::tcp::v4(), native_socket3);
ip::tcp::socket::native_handle_type native_socket4
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
socket1.assign(ip::tcp::v4(), native_socket4, ec);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
bool is_open = socket1.is_open();
(void)is_open;
socket1.close();
socket1.close(ec);
socket1.release();
socket1.release(ec);
ip::tcp::socket::native_handle_type native_socket5
= socket1.native_handle();
(void)native_socket5;
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(ip::tcp::endpoint(ip::tcp::v4(), 0));
socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0));
socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), ec);
socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), ec);
socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0));
socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0));
socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0), ec);
socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0), ec);
socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0),
connect_handler());
socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0),
connect_handler());
socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), immediate);
socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), immediate);
int i1 = socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), lazy);
(void)i1;
int i2 = socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), lazy);
(void)i2;
socket1.set_option(settable_socket_option1);
socket1.set_option(settable_socket_option1, ec);
socket1.set_option(settable_socket_option2);
socket1.set_option(settable_socket_option2, ec);
socket1.set_option(settable_socket_option3);
socket1.set_option(settable_socket_option3, ec);
socket1.get_option(gettable_socket_option1);
socket1.get_option(gettable_socket_option1, ec);
socket1.get_option(gettable_socket_option2);
socket1.get_option(gettable_socket_option2, ec);
socket1.get_option(gettable_socket_option3);
socket1.get_option(gettable_socket_option3, ec);
socket1.io_control(io_control_command);
socket1.io_control(io_control_command, ec);
bool non_blocking1 = socket1.non_blocking();
(void)non_blocking1;
socket1.non_blocking(true);
socket1.non_blocking(false, ec);
bool non_blocking2 = socket1.native_non_blocking();
(void)non_blocking2;
socket1.native_non_blocking(true);
socket1.native_non_blocking(false, ec);
ip::tcp::endpoint endpoint1 = socket1.local_endpoint();
(void)endpoint1;
ip::tcp::endpoint endpoint2 = socket1.local_endpoint(ec);
(void)endpoint2;
ip::tcp::endpoint endpoint3 = socket1.remote_endpoint();
(void)endpoint3;
ip::tcp::endpoint endpoint4 = socket1.remote_endpoint(ec);
(void)endpoint4;
socket1.shutdown(socket_base::shutdown_both);
socket1.shutdown(socket_base::shutdown_both, ec);
socket1.wait(socket_base::wait_read);
socket1.wait(socket_base::wait_write, ec);
socket1.async_wait(socket_base::wait_read, wait_handler());
socket1.async_wait(socket_base::wait_read, immediate);
int i3 = socket1.async_wait(socket_base::wait_write, lazy);
(void)i3;
// basic_stream_socket functions.
socket1.send(buffer(mutable_char_buffer));
socket1.send(buffer(const_char_buffer));
socket1.send(mutable_buffers);
socket1.send(const_buffers);
socket1.send(null_buffers());
socket1.send(buffer(mutable_char_buffer), in_flags);
socket1.send(buffer(const_char_buffer), in_flags);
socket1.send(mutable_buffers, in_flags);
socket1.send(const_buffers, 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(mutable_buffers, in_flags, ec);
socket1.send(const_buffers, 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(mutable_buffers, send_handler());
socket1.async_send(const_buffers, 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(mutable_buffers, in_flags, send_handler());
socket1.async_send(const_buffers, in_flags, send_handler());
socket1.async_send(null_buffers(), in_flags, send_handler());
socket1.async_send(buffer(mutable_char_buffer), immediate);
socket1.async_send(buffer(const_char_buffer), immediate);
socket1.async_send(mutable_buffers, immediate);
socket1.async_send(const_buffers, immediate);
socket1.async_send(null_buffers(), immediate);
socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(mutable_buffers, in_flags, immediate);
socket1.async_send(const_buffers, in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
int i4 = socket1.async_send(buffer(mutable_char_buffer), lazy);
(void)i4;
int i5 = socket1.async_send(buffer(const_char_buffer), lazy);
(void)i5;
int i6 = socket1.async_send(mutable_buffers, lazy);
(void)i6;
int i7 = socket1.async_send(const_buffers, lazy);
(void)i7;
int i8 = socket1.async_send(null_buffers(), lazy);
(void)i8;
int i9 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
(void)i9;
int i10 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
(void)i10;
int i11 = socket1.async_send(mutable_buffers, in_flags, lazy);
(void)i11;
int i12 = socket1.async_send(const_buffers, in_flags, lazy);
(void)i12;
int i13 = socket1.async_send(null_buffers(), in_flags, lazy);
(void)i13;
socket1.receive(buffer(mutable_char_buffer));
socket1.receive(mutable_buffers);
socket1.receive(null_buffers());
socket1.receive(buffer(mutable_char_buffer), in_flags);
socket1.receive(mutable_buffers, in_flags);
socket1.receive(null_buffers(), in_flags);
socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
socket1.receive(mutable_buffers, in_flags, ec);
socket1.receive(null_buffers(), in_flags, ec);
socket1.async_receive(buffer(mutable_char_buffer), receive_handler());
socket1.async_receive(mutable_buffers, receive_handler());
socket1.async_receive(null_buffers(), receive_handler());
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
receive_handler());
socket1.async_receive(mutable_buffers, in_flags, receive_handler());
socket1.async_receive(null_buffers(), in_flags, receive_handler());
socket1.async_receive(buffer(mutable_char_buffer), immediate);
socket1.async_receive(mutable_buffers, immediate);
socket1.async_receive(null_buffers(), immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_receive(mutable_buffers, in_flags, immediate);
socket1.async_receive(null_buffers(), in_flags, immediate);
int i14 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
(void)i14;
int i15 = socket1.async_receive(mutable_buffers, lazy);
(void)i15;
int i16 = socket1.async_receive(null_buffers(), lazy);
(void)i16;
int i17 = socket1.async_receive(buffer(mutable_char_buffer), in_flags,
lazy);
(void)i17;
int i18 = socket1.async_receive(mutable_buffers, in_flags, lazy);
(void)i18;
int i19 = socket1.async_receive(null_buffers(), in_flags, lazy);
(void)i19;
socket1.write_some(buffer(mutable_char_buffer));
socket1.write_some(buffer(const_char_buffer));
socket1.write_some(mutable_buffers);
socket1.write_some(const_buffers);
socket1.write_some(null_buffers());
socket1.write_some(buffer(mutable_char_buffer), ec);
socket1.write_some(buffer(const_char_buffer), ec);
socket1.write_some(mutable_buffers, ec);
socket1.write_some(const_buffers, 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(mutable_buffers, write_some_handler());
socket1.async_write_some(const_buffers, write_some_handler());
socket1.async_write_some(null_buffers(), write_some_handler());
socket1.async_write_some(buffer(mutable_char_buffer), immediate);
socket1.async_write_some(buffer(const_char_buffer), immediate);
socket1.async_write_some(mutable_buffers, immediate);
socket1.async_write_some(const_buffers, immediate);
socket1.async_write_some(null_buffers(), immediate);
int i20 = socket1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i20;
int i21 = socket1.async_write_some(buffer(const_char_buffer), lazy);
(void)i21;
int i22 = socket1.async_write_some(mutable_buffers, lazy);
(void)i22;
int i23 = socket1.async_write_some(const_buffers, lazy);
(void)i23;
int i24 = socket1.async_write_some(null_buffers(), lazy);
(void)i24;
socket1.read_some(buffer(mutable_char_buffer));
socket1.read_some(mutable_buffers);
socket1.read_some(null_buffers());
socket1.read_some(buffer(mutable_char_buffer), ec);
socket1.read_some(mutable_buffers, ec);
socket1.read_some(null_buffers(), ec);
socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
socket1.async_read_some(mutable_buffers, read_some_handler());
socket1.async_read_some(null_buffers(), read_some_handler());
socket1.async_read_some(buffer(mutable_char_buffer), immediate);
socket1.async_read_some(mutable_buffers, immediate);
socket1.async_read_some(null_buffers(), immediate);
int i25 = socket1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i25;
int i26 = socket1.async_read_some(mutable_buffers, lazy);
(void)i26;
int i27 = socket1.async_read_some(null_buffers(), lazy);
(void)i27;
}
catch (std::exception&)
{
}
}
} // namespace ip_tcp_socket_compile
//------------------------------------------------------------------------------
// ip_tcp_socket_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the ip::tcp::socket class.
namespace ip_tcp_socket_runtime {
static const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void handle_read_noop(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!err);
ASIO_CHECK(bytes_transferred == 0);
}
void handle_write_noop(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!err);
ASIO_CHECK(bytes_transferred == 0);
}
void handle_read(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!err);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
}
void handle_write(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!err);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
}
void handle_read_cancel(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(err == asio::error::operation_aborted);
ASIO_CHECK(bytes_transferred == 0);
}
void handle_read_eof(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(err == asio::error::eof);
ASIO_CHECK(bytes_transferred == 0);
}
void test()
{
using namespace std; // For memcmp.
using namespace asio;
namespace ip = asio::ip;
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
io_context ioc;
ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(ip::address_v4::loopback());
ip::tcp::socket client_side_socket(ioc);
ip::tcp::socket server_side_socket(ioc);
client_side_socket.connect(server_endpoint);
acceptor.accept(server_side_socket);
// No-op read.
bool read_noop_completed = false;
client_side_socket.async_read_some(
asio::mutable_buffer(0, 0),
bindns::bind(handle_read_noop,
_1, _2, &read_noop_completed));
ioc.run();
ASIO_CHECK(read_noop_completed);
// No-op write.
bool write_noop_completed = false;
client_side_socket.async_write_some(
asio::const_buffer(0, 0),
bindns::bind(handle_write_noop,
_1, _2, &write_noop_completed));
ioc.restart();
ioc.run();
ASIO_CHECK(write_noop_completed);
// Read and write to transfer data.
char read_buffer[sizeof(write_data)];
bool read_completed = false;
asio::async_read(client_side_socket,
asio::buffer(read_buffer),
bindns::bind(handle_read,
_1, _2, &read_completed));
bool write_completed = false;
asio::async_write(server_side_socket,
asio::buffer(write_data),
bindns::bind(handle_write,
_1, _2, &write_completed));
ioc.restart();
ioc.run();
ASIO_CHECK(read_completed);
ASIO_CHECK(write_completed);
ASIO_CHECK(memcmp(read_buffer, write_data, sizeof(write_data)) == 0);
// Cancelled read.
bool read_cancel_completed = false;
asio::async_read(server_side_socket,
asio::buffer(read_buffer),
bindns::bind(handle_read_cancel,
_1, _2, &read_cancel_completed));
ioc.restart();
ioc.poll();
ASIO_CHECK(!read_cancel_completed);
server_side_socket.cancel();
ioc.restart();
ioc.run();
ASIO_CHECK(read_cancel_completed);
// A read when the peer closes socket should fail with eof.
bool read_eof_completed = false;
asio::async_read(client_side_socket,
asio::buffer(read_buffer),
bindns::bind(handle_read_eof,
_1, _2, &read_eof_completed));
server_side_socket.close();
ioc.restart();
ioc.run();
ASIO_CHECK(read_eof_completed);
}
} // namespace ip_tcp_socket_runtime
//------------------------------------------------------------------------------
// ip_tcp_acceptor_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::tcp::acceptor compile and link correctly. Runtime failures are ignored.
namespace ip_tcp_acceptor_compile {
struct wait_handler
{
wait_handler() {}
void operator()(const asio::error_code&) {}
wait_handler(wait_handler&&) {}
private:
wait_handler(const wait_handler&);
};
struct accept_handler
{
accept_handler() {}
void operator()(const asio::error_code&) {}
accept_handler(accept_handler&&) {}
private:
accept_handler(const accept_handler&);
};
struct move_accept_handler
{
move_accept_handler() {}
void operator()(
const asio::error_code&, asio::ip::tcp::socket) {}
move_accept_handler(move_accept_handler&&) {}
private:
move_accept_handler(const move_accept_handler&) {}
};
struct move_accept_ioc_handler
{
move_accept_ioc_handler() {}
void operator()(const asio::error_code&,
asio::basic_stream_socket<asio::ip::tcp,
asio::io_context::executor_type>) {}
move_accept_ioc_handler(move_accept_handler&&) {}
private:
move_accept_ioc_handler(const move_accept_handler&) {}
};
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
ip::tcp::socket peer_socket1(ioc);
asio::basic_stream_socket<ip::tcp,
io_context::executor_type> peer_socket2(ioc);
ip::tcp::endpoint peer_endpoint;
archetypes::settable_socket_option<void> settable_socket_option1;
archetypes::settable_socket_option<int> settable_socket_option2;
archetypes::settable_socket_option<double> settable_socket_option3;
archetypes::gettable_socket_option<void> gettable_socket_option1;
archetypes::gettable_socket_option<int> gettable_socket_option2;
archetypes::gettable_socket_option<double> gettable_socket_option3;
archetypes::io_control_command io_control_command;
archetypes::immediate_handler immediate;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_socket_acceptor constructors.
ip::tcp::acceptor acceptor1(ioc);
ip::tcp::acceptor acceptor2(ioc, ip::tcp::v4());
ip::tcp::acceptor acceptor3(ioc, ip::tcp::v6());
ip::tcp::acceptor acceptor4(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
ip::tcp::acceptor acceptor5(ioc, ip::tcp::endpoint(ip::tcp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::acceptor::native_handle_type native_acceptor1
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
ip::tcp::acceptor acceptor6(ioc, ip::tcp::v4(), native_acceptor1);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::acceptor acceptor7(ioc_ex);
ip::tcp::acceptor acceptor8(ioc_ex, ip::tcp::v4());
ip::tcp::acceptor acceptor9(ioc_ex, ip::tcp::v6());
ip::tcp::acceptor acceptor10(ioc_ex, ip::tcp::endpoint(ip::tcp::v4(), 0));
ip::tcp::acceptor acceptor11(ioc_ex, ip::tcp::endpoint(ip::tcp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::acceptor::native_handle_type native_acceptor2
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
ip::tcp::acceptor acceptor12(ioc_ex, ip::tcp::v4(), native_acceptor2);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::acceptor acceptor13(std::move(acceptor5));
// basic_socket_acceptor operators.
acceptor1 = ip::tcp::acceptor(ioc);
acceptor1 = std::move(acceptor2);
// basic_io_object functions.
ip::tcp::acceptor::executor_type ex = acceptor1.get_executor();
(void)ex;
// basic_socket_acceptor functions.
acceptor1.open(ip::tcp::v4());
acceptor1.open(ip::tcp::v6());
acceptor1.open(ip::tcp::v4(), ec);
acceptor1.open(ip::tcp::v6(), ec);
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::tcp::acceptor::native_handle_type native_acceptor3
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
acceptor1.assign(ip::tcp::v4(), native_acceptor3);
ip::tcp::acceptor::native_handle_type native_acceptor4
= ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
acceptor1.assign(ip::tcp::v4(), native_acceptor4, ec);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
bool is_open = acceptor1.is_open();
(void)is_open;
acceptor1.close();
acceptor1.close(ec);
acceptor1.release();
acceptor1.release(ec);
ip::tcp::acceptor::native_handle_type native_acceptor5
= acceptor1.native_handle();
(void)native_acceptor5;
acceptor1.cancel();
acceptor1.cancel(ec);
acceptor1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0));
acceptor1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0));
acceptor1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), ec);
acceptor1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), ec);
acceptor1.set_option(settable_socket_option1);
acceptor1.set_option(settable_socket_option1, ec);
acceptor1.set_option(settable_socket_option2);
acceptor1.set_option(settable_socket_option2, ec);
acceptor1.set_option(settable_socket_option3);
acceptor1.set_option(settable_socket_option3, ec);
acceptor1.get_option(gettable_socket_option1);
acceptor1.get_option(gettable_socket_option1, ec);
acceptor1.get_option(gettable_socket_option2);
acceptor1.get_option(gettable_socket_option2, ec);
acceptor1.get_option(gettable_socket_option3);
acceptor1.get_option(gettable_socket_option3, ec);
acceptor1.io_control(io_control_command);
acceptor1.io_control(io_control_command, ec);
bool non_blocking1 = acceptor1.non_blocking();
(void)non_blocking1;
acceptor1.non_blocking(true);
acceptor1.non_blocking(false, ec);
bool non_blocking2 = acceptor1.native_non_blocking();
(void)non_blocking2;
acceptor1.native_non_blocking(true);
acceptor1.native_non_blocking(false, ec);
ip::tcp::endpoint endpoint1 = acceptor1.local_endpoint();
(void)endpoint1;
ip::tcp::endpoint endpoint2 = acceptor1.local_endpoint(ec);
(void)endpoint2;
acceptor1.wait(socket_base::wait_read);
acceptor1.wait(socket_base::wait_write, ec);
acceptor1.async_wait(socket_base::wait_read, wait_handler());
acceptor1.async_wait(socket_base::wait_read, immediate);
int i1 = acceptor1.async_wait(socket_base::wait_write, lazy);
(void)i1;
acceptor1.accept(peer_socket1);
acceptor1.accept(peer_socket1, ec);
acceptor1.accept(peer_socket1, peer_endpoint);
acceptor1.accept(peer_socket1, peer_endpoint, ec);
acceptor1.accept(peer_socket2);
acceptor1.accept(peer_socket2, ec);
acceptor1.accept(peer_socket2, peer_endpoint);
acceptor1.accept(peer_socket2, peer_endpoint, ec);
peer_socket1 = acceptor1.accept();
peer_socket1 = acceptor1.accept(ioc);
peer_socket1 = acceptor1.accept(ioc_ex);
peer_socket1 = acceptor1.accept(peer_endpoint);
peer_socket1 = acceptor1.accept(ioc, peer_endpoint);
peer_socket1 = acceptor1.accept(ioc_ex, peer_endpoint);
(void)peer_socket1;
peer_socket2 = acceptor1.accept(ioc);
peer_socket2 = acceptor1.accept(ioc_ex);
peer_socket2 = acceptor1.accept(ioc, peer_endpoint);
peer_socket2 = acceptor1.accept(ioc_ex, peer_endpoint);
(void)peer_socket2;
acceptor1.async_accept(peer_socket1, accept_handler());
acceptor1.async_accept(peer_socket1, peer_endpoint, accept_handler());
acceptor1.async_accept(peer_socket1, immediate);
acceptor1.async_accept(peer_socket1, peer_endpoint, immediate);
int i2 = acceptor1.async_accept(peer_socket1, lazy);
(void)i2;
int i3 = acceptor1.async_accept(peer_socket1, peer_endpoint, lazy);
(void)i3;
acceptor1.async_accept(peer_socket2, accept_handler());
acceptor1.async_accept(peer_socket2, peer_endpoint, accept_handler());
acceptor1.async_accept(peer_socket2, immediate);
acceptor1.async_accept(peer_socket2, peer_endpoint, immediate);
int i4 = acceptor1.async_accept(peer_socket2, lazy);
(void)i4;
int i5 = acceptor1.async_accept(peer_socket2, peer_endpoint, lazy);
(void)i5;
acceptor1.async_accept(move_accept_handler());
acceptor1.async_accept(ioc, move_accept_handler());
acceptor1.async_accept(ioc_ex, move_accept_handler());
acceptor1.async_accept(ioc_ex, move_accept_ioc_handler());
acceptor1.async_accept(peer_endpoint, move_accept_handler());
acceptor1.async_accept(ioc, peer_endpoint, move_accept_handler());
acceptor1.async_accept(ioc_ex, peer_endpoint, move_accept_handler());
acceptor1.async_accept(ioc_ex, peer_endpoint, move_accept_ioc_handler());
acceptor1.async_accept(immediate);
acceptor1.async_accept(ioc, immediate);
acceptor1.async_accept(ioc_ex, immediate);
acceptor1.async_accept(peer_endpoint, immediate);
acceptor1.async_accept(ioc, peer_endpoint, immediate);
acceptor1.async_accept(ioc_ex, peer_endpoint, immediate);
}
catch (std::exception&)
{
}
}
} // namespace ip_tcp_acceptor_compile
//------------------------------------------------------------------------------
// ip_tcp_acceptor_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the ip::tcp::acceptor
// class.
namespace ip_tcp_acceptor_runtime {
void handle_accept(const asio::error_code& err)
{
ASIO_CHECK(!err);
}
void handle_connect(const asio::error_code& err)
{
ASIO_CHECK(!err);
}
void test()
{
using namespace asio;
namespace ip = asio::ip;
io_context ioc;
ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(ip::address_v4::loopback());
ip::tcp::socket client_side_socket(ioc);
ip::tcp::socket server_side_socket(ioc);
client_side_socket.connect(server_endpoint);
acceptor.accept(server_side_socket);
client_side_socket.close();
server_side_socket.close();
client_side_socket.connect(server_endpoint);
ip::tcp::endpoint client_endpoint;
acceptor.accept(server_side_socket, client_endpoint);
ip::tcp::endpoint client_side_local_endpoint
= client_side_socket.local_endpoint();
ASIO_CHECK(client_side_local_endpoint.port() == client_endpoint.port());
ip::tcp::endpoint server_side_remote_endpoint
= server_side_socket.remote_endpoint();
ASIO_CHECK(server_side_remote_endpoint.port()
== client_endpoint.port());
client_side_socket.close();
server_side_socket.close();
acceptor.async_accept(server_side_socket, &handle_accept);
client_side_socket.async_connect(server_endpoint, &handle_connect);
ioc.run();
client_side_socket.close();
server_side_socket.close();
acceptor.async_accept(server_side_socket, client_endpoint, &handle_accept);
client_side_socket.async_connect(server_endpoint, &handle_connect);
ioc.restart();
ioc.run();
client_side_local_endpoint = client_side_socket.local_endpoint();
ASIO_CHECK(client_side_local_endpoint.port() == client_endpoint.port());
server_side_remote_endpoint = server_side_socket.remote_endpoint();
ASIO_CHECK(server_side_remote_endpoint.port()
== client_endpoint.port());
}
} // namespace ip_tcp_acceptor_runtime
//------------------------------------------------------------------------------
// ip_tcp_resolver_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::tcp::resolver compile and link correctly. Runtime failures are ignored.
namespace ip_tcp_resolver_compile {
struct resolve_handler
{
resolve_handler() {}
void operator()(const asio::error_code&,
asio::ip::tcp::resolver::results_type) {}
resolve_handler(resolve_handler&&) {}
private:
resolve_handler(const resolve_handler&);
};
#if !defined(ASIO_NO_DEPRECATED)
struct legacy_resolve_handler
{
legacy_resolve_handler() {}
void operator()(const asio::error_code&,
asio::ip::tcp::resolver::iterator) {}
legacy_resolve_handler(legacy_resolve_handler&&) {}
private:
legacy_resolve_handler(const legacy_resolve_handler&);
};
#endif // !defined(ASIO_NO_DEPRECATED)
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
archetypes::lazy_handler lazy;
asio::error_code ec;
#if !defined(ASIO_NO_DEPRECATED)
ip::tcp::resolver::query q(ip::tcp::v4(), "localhost", "0");
#endif // !defined(ASIO_NO_DEPRECATED)
ip::tcp::endpoint e(ip::address_v4::loopback(), 0);
// basic_resolver constructors.
ip::tcp::resolver resolver(ioc);
ip::tcp::resolver resolver2(ioc_ex);
ip::tcp::resolver resolver3(std::move(resolver));
// basic_resolver operators.
resolver = ip::tcp::resolver(ioc);
resolver = std::move(resolver3);
// basic_io_object functions.
ip::tcp::resolver::executor_type ex = resolver.get_executor();
(void)ex;
// basic_resolver functions.
resolver.cancel();
#if !defined(ASIO_NO_DEPRECATED)
ip::tcp::resolver::results_type results1 = resolver.resolve(q);
(void)results1;
ip::tcp::resolver::results_type results2 = resolver.resolve(q, ec);
(void)results2;
#endif // !defined(ASIO_NO_DEPRECATED)
ip::tcp::resolver::results_type results3 = resolver.resolve("", "");
(void)results3;
ip::tcp::resolver::results_type results4 = resolver.resolve("", "", ec);
(void)results4;
ip::tcp::resolver::results_type results5 =
resolver.resolve("", "", ip::tcp::resolver::flags());
(void)results5;
ip::tcp::resolver::results_type results6 =
resolver.resolve("", "", ip::tcp::resolver::flags(), ec);
(void)results6;
ip::tcp::resolver::results_type results7 =
resolver.resolve(ip::tcp::v4(), "", "");
(void)results7;
ip::tcp::resolver::results_type results8 =
resolver.resolve(ip::tcp::v4(), "", "", ec);
(void)results8;
ip::tcp::resolver::results_type results9 =
resolver.resolve(ip::tcp::v4(), "", "", ip::tcp::resolver::flags());
(void)results9;
ip::tcp::resolver::results_type results10 =
resolver.resolve(ip::tcp::v4(), "", "", ip::tcp::resolver::flags(), ec);
(void)results10;
ip::tcp::resolver::results_type results11 = resolver.resolve(e);
(void)results11;
ip::tcp::resolver::results_type results12 = resolver.resolve(e, ec);
(void)results12;
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve(q, resolve_handler());
resolver.async_resolve(q, legacy_resolve_handler());
int i1 = resolver.async_resolve(q, lazy);
(void)i1;
#endif // !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve("", "", resolve_handler());
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve("", "", legacy_resolve_handler());
#endif // !defined(ASIO_NO_DEPRECATED)
int i2 = resolver.async_resolve("", "", lazy);
(void)i2;
resolver.async_resolve("", "",
ip::tcp::resolver::flags(), resolve_handler());
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve("", "",
ip::tcp::resolver::flags(), legacy_resolve_handler());
#endif // !defined(ASIO_NO_DEPRECATED)
int i3 = resolver.async_resolve("", "",
ip::tcp::resolver::flags(), lazy);
(void)i3;
resolver.async_resolve(ip::tcp::v4(), "", "", resolve_handler());
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve(ip::tcp::v4(), "", "", legacy_resolve_handler());
#endif // !defined(ASIO_NO_DEPRECATED)
int i4 = resolver.async_resolve(ip::tcp::v4(), "", "", lazy);
(void)i4;
resolver.async_resolve(ip::tcp::v4(),
"", "", ip::tcp::resolver::flags(), resolve_handler());
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve(ip::tcp::v4(),
"", "", ip::tcp::resolver::flags(), legacy_resolve_handler());
#endif // !defined(ASIO_NO_DEPRECATED)
int i5 = resolver.async_resolve(ip::tcp::v4(),
"", "", ip::tcp::resolver::flags(), lazy);
(void)i5;
resolver.async_resolve(e, resolve_handler());
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve(e, legacy_resolve_handler());
#endif // !defined(ASIO_NO_DEPRECATED)
int i6 = resolver.async_resolve(e, lazy);
(void)i6;
}
catch (std::exception&)
{
}
}
} // namespace ip_tcp_resolver_compile
//------------------------------------------------------------------------------
// ip_tcp_resolver_entry_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::tcp::resolver::entry compile and link correctly. Runtime failures are
// ignored.
namespace ip_tcp_resolver_entry_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
const ip::tcp::endpoint endpoint;
const std::string host_name;
const std::string service_name;
const std::allocator<char> alloc;
try
{
// basic_resolver_entry constructors.
const ip::basic_resolver_entry<ip::tcp> entry1;
ip::basic_resolver_entry<ip::tcp> entry2(endpoint, host_name, service_name);
ip::basic_resolver_entry<ip::tcp> entry3(entry1);
ip::basic_resolver_entry<ip::tcp> entry4(std::move(entry2));
// basic_resolver_entry functions.
ip::tcp::endpoint e1 = entry1.endpoint();
(void)e1;
ip::tcp::endpoint e2 = entry1;
(void)e2;
std::string s1 = entry1.host_name();
(void)s1;
std::string s2 = entry1.host_name(alloc);
(void)s2;
std::string s3 = entry1.service_name();
(void)s3;
std::string s4 = entry1.service_name(alloc);
(void)s4;
}
catch (std::exception&)
{
}
}
} // namespace ip_tcp_resolver_entry_compile
//------------------------------------------------------------------------------
// ip_tcp_iostream_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public types and member functions on the
// class ip::tcp::iostream compile and link correctly. Runtime failures are
// ignored.
namespace ip_tcp_iostream_compile {
void test()
{
#if !defined(ASIO_NO_IOSTREAM)
using namespace asio;
namespace ip = asio::ip;
asio::io_context ioc;
asio::ip::tcp::socket sock(ioc);
// basic_socket_iostream typedefs.
(void)static_cast<ip::tcp::iostream::protocol_type*>(0);
(void)static_cast<ip::tcp::iostream::endpoint_type*>(0);
(void)static_cast<ip::tcp::iostream::clock_type*>(0);
(void)static_cast<ip::tcp::iostream::time_point*>(0);
(void)static_cast<ip::tcp::iostream::duration*>(0);
(void)static_cast<ip::tcp::iostream::traits_type*>(0);
// basic_socket_iostream constructors.
ip::tcp::iostream ios1;
ip::tcp::iostream ios2(std::move(sock));
ip::tcp::iostream ios3("hostname", "service");
// basic_socket_iostream operators.
ios1 = ip::tcp::iostream();
ios2 = std::move(ios1);
// basic_socket_iostream members.
ios1.connect("hostname", "service");
ios1.close();
(void)static_cast<std::streambuf*>(ios1.rdbuf());
basic_socket<ip::tcp>& sref = ios1.socket();
(void)sref;
asio::error_code ec = ios1.error();
(void)ec;
ip::tcp::iostream::time_point tp = ios1.expiry();
(void)tp;
ios1.expires_at(tp);
ip::tcp::iostream::duration d = ip::tcp::iostream::duration();
ios1.expires_after(d);
// iostream operators.
int i = 0;
ios1 >> i;
ios1 << i;
#endif // !defined(ASIO_NO_IOSTREAM)
}
} // namespace ip_tcp_iostream_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/tcp",
ASIO_COMPILE_TEST_CASE(ip_tcp_compile::test)
ASIO_TEST_CASE(ip_tcp_runtime::test)
ASIO_COMPILE_TEST_CASE(ip_tcp_socket_compile::test)
ASIO_TEST_CASE(ip_tcp_socket_runtime::test)
ASIO_COMPILE_TEST_CASE(ip_tcp_acceptor_compile::test)
ASIO_TEST_CASE(ip_tcp_acceptor_runtime::test)
ASIO_COMPILE_TEST_CASE(ip_tcp_resolver_compile::test)
ASIO_COMPILE_TEST_CASE(ip_tcp_resolver_entry_compile::test)
ASIO_COMPILE_TEST_CASE(ip_tcp_resolver_entry_compile::test)
ASIO_COMPILE_TEST_CASE(ip_tcp_iostream_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address_v4_range.cpp | //
// address_v4_range.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/address_v4_range.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address_v4_range",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/resolver_query_base.cpp | //
// resolver_query_base.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/resolver_query_base.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ip/resolver_query_base",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/network_v4.cpp | //
// network_v4.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail 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 "asio/ip/network_v4.hpp"
#include "../unit_test.hpp"
#include <sstream>
//------------------------------------------------------------------------------
// ip_network_v4_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::network_v4 compile and link correctly. Runtime failures are ignored.
namespace ip_network_v4_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
asio::error_code ec;
// network_v4 constructors.
ip::network_v4 net1(ip::make_address_v4("192.168.1.0"), 32);
ip::network_v4 net2(ip::make_address_v4("192.168.1.0"),
ip::make_address_v4("255.255.255.0"));
// network_v4 functions.
ip::address_v4 addr1 = net1.address();
(void)addr1;
unsigned short prefix_len = net1.prefix_length();
(void)prefix_len;
ip::address_v4 addr2 = net1.netmask();
(void)addr2;
ip::address_v4 addr3 = net1.network();
(void)addr3;
ip::address_v4 addr4 = net1.broadcast();
(void)addr4;
ip::address_v4_range hosts = net1.hosts();
(void)hosts;
ip::network_v4 net3 = net1.canonical();
(void)net3;
bool b1 = net1.is_host();
(void)b1;
bool b2 = net1.is_subnet_of(net2);
(void)b2;
std::string s1 = net1.to_string();
(void)s1;
std::string s2 = net1.to_string(ec);
(void)s2;
// network_v4 comparisons.
bool b3 = (net1 == net2);
(void)b3;
bool b4 = (net1 != net2);
(void)b4;
// network_v4 creation functions.
net1 = ip::make_network_v4(ip::address_v4(), 24);
net1 = ip::make_network_v4(ip::address_v4(), ip::address_v4());
net1 = ip::make_network_v4("10.0.0.0/8");
net1 = ip::make_network_v4("10.0.0.0/8", ec);
net1 = ip::make_network_v4(s1);
net1 = ip::make_network_v4(s1, ec);
#if defined(ASIO_HAS_STRING_VIEW)
# if defined(ASIO_HAS_STD_STRING_VIEW)
std::string_view string_view_value("10.0.0.0/8");
# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_value("10.0.0.0/8");
# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
net1 = ip::make_network_v4(string_view_value);
net1 = ip::make_network_v4(string_view_value, ec);
#endif // defined(ASIO_HAS_STRING_VIEW)
// network_v4 I/O.
std::ostringstream os;
os << net1;
#if !defined(BOOST_NO_STD_WSTREAMBUF)
std::wostringstream wos;
wos << net1;
#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
}
catch (std::exception&)
{
}
}
} // namespace ip_network_v4_compile
//------------------------------------------------------------------------------
// ip_network_v4_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that the various public member functions meet the
// necessary postconditions.
namespace ip_network_v4_runtime {
void test()
{
using asio::ip::address_v4;
using asio::ip::make_address_v4;
using asio::ip::network_v4;
using asio::ip::make_network_v4;
address_v4 addr = make_address_v4("1.2.3.4");
// calculate prefix length
network_v4 net1(addr, make_address_v4("255.255.255.0"));
ASIO_CHECK(net1.prefix_length() == 24);
network_v4 net2(addr, make_address_v4("255.255.255.192"));
ASIO_CHECK(net2.prefix_length() == 26);
network_v4 net3(addr, make_address_v4("128.0.0.0"));
ASIO_CHECK(net3.prefix_length() == 1);
std::string msg;
try
{
make_network_v4(addr, make_address_v4("255.255.255.1"));
}
catch(std::exception& ex)
{
msg = ex.what();
}
ASIO_CHECK(msg == std::string("non-contiguous netmask"));
msg.clear();
try
{
make_network_v4(addr, make_address_v4("0.255.255.0"));
}
catch(std::exception& ex)
{
msg = ex.what();
}
ASIO_CHECK(msg == std::string("non-contiguous netmask"));
// calculate netmask
network_v4 net4(addr, 23);
ASIO_CHECK(net4.netmask() == make_address_v4("255.255.254.0"));
network_v4 net5(addr, 12);
ASIO_CHECK(net5.netmask() == make_address_v4("255.240.0.0"));
network_v4 net6(addr, 24);
ASIO_CHECK(net6.netmask() == make_address_v4("255.255.255.0"));
network_v4 net7(addr, 16);
ASIO_CHECK(net7.netmask() == make_address_v4("255.255.0.0"));
network_v4 net8(addr, 8);
ASIO_CHECK(net8.netmask() == make_address_v4("255.0.0.0"));
network_v4 net9(addr, 32);
ASIO_CHECK(net9.netmask() == make_address_v4("255.255.255.255"));
network_v4 net10(addr, 1);
ASIO_CHECK(net10.netmask() == make_address_v4("128.0.0.0"));
network_v4 net11(addr, 0);
ASIO_CHECK(net11.netmask() == make_address_v4("0.0.0.0"));
msg.clear();
try
{
make_network_v4(addr, 33);
}
catch(std::out_of_range& ex)
{
msg = ex.what();
}
ASIO_CHECK(msg == std::string("prefix length too large"));
// construct address range from address and prefix length
ASIO_CHECK(network_v4(make_address_v4("192.168.77.100"), 32).network() == make_address_v4("192.168.77.100"));
ASIO_CHECK(network_v4(make_address_v4("192.168.77.100"), 24).network() == make_address_v4("192.168.77.0"));
ASIO_CHECK(network_v4(make_address_v4("192.168.77.128"), 25).network() == make_address_v4("192.168.77.128"));
// construct address range from string in CIDR notation
ASIO_CHECK(make_network_v4("192.168.77.100/32").network() == make_address_v4("192.168.77.100"));
ASIO_CHECK(make_network_v4("192.168.77.100/24").network() == make_address_v4("192.168.77.0"));
ASIO_CHECK(make_network_v4("192.168.77.128/25").network() == make_address_v4("192.168.77.128"));
// construct network from invalid string
asio::error_code ec;
make_network_v4("10.0.0.256/24", ec);
ASIO_CHECK(!!ec);
make_network_v4("10.0.0.0/33", ec);
ASIO_CHECK(!!ec);
make_network_v4("10.0.0.0/-1", ec);
ASIO_CHECK(!!ec);
make_network_v4("10.0.0.0/", ec);
ASIO_CHECK(!!ec);
make_network_v4("10.0.0.0", ec);
ASIO_CHECK(!!ec);
// prefix length
ASIO_CHECK(make_network_v4("193.99.144.80/24").prefix_length() == 24);
ASIO_CHECK(network_v4(make_address_v4("193.99.144.80"), 24).prefix_length() == 24);
ASIO_CHECK(network_v4(make_address_v4("192.168.77.0"), make_address_v4("255.255.255.0")).prefix_length() == 24);
// to string
std::string a("192.168.77.0/32");
ASIO_CHECK(make_network_v4(a.c_str()).to_string() == a);
ASIO_CHECK(network_v4(make_address_v4("192.168.77.10"), 24).to_string() == std::string("192.168.77.10/24"));
// return host part
ASIO_CHECK(make_network_v4("192.168.77.11/24").address() == make_address_v4("192.168.77.11"));
// return host in CIDR notation
ASIO_CHECK(make_network_v4("192.168.78.30/20").address().to_string() == "192.168.78.30");
// return network in CIDR notation
ASIO_CHECK(make_network_v4("192.168.78.30/20").canonical().to_string() == "192.168.64.0/20");
// is host
ASIO_CHECK(make_network_v4("192.168.77.0/32").is_host());
ASIO_CHECK(!make_network_v4("192.168.77.0/31").is_host());
// is real subnet of
ASIO_CHECK(make_network_v4("192.168.0.192/24").is_subnet_of(make_network_v4("192.168.0.0/16")));
ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.192.168/16")));
ASIO_CHECK(make_network_v4("192.168.0.192/24").is_subnet_of(make_network_v4("192.168.192.168/16")));
ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.0.0/16")));
ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.0.0/23")));
ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.0.0/0")));
ASIO_CHECK(make_network_v4("192.168.0.0/32").is_subnet_of(make_network_v4("192.168.0.0/24")));
ASIO_CHECK(!make_network_v4("192.168.0.0/32").is_subnet_of(make_network_v4("192.168.0.0/32")));
ASIO_CHECK(!make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.1.0/24")));
ASIO_CHECK(!make_network_v4("192.168.0.0/16").is_subnet_of(make_network_v4("192.168.1.0/24")));
network_v4 r(make_network_v4("192.168.0.0/24"));
ASIO_CHECK(!r.is_subnet_of(r));
network_v4 net12(make_network_v4("192.168.0.2/24"));
network_v4 net13(make_network_v4("192.168.1.1/28"));
network_v4 net14(make_network_v4("192.168.1.21/28"));
// network
ASIO_CHECK(net12.network() == make_address_v4("192.168.0.0"));
ASIO_CHECK(net13.network() == make_address_v4("192.168.1.0"));
ASIO_CHECK(net14.network() == make_address_v4("192.168.1.16"));
// netmask
ASIO_CHECK(net12.netmask() == make_address_v4("255.255.255.0"));
ASIO_CHECK(net13.netmask() == make_address_v4("255.255.255.240"));
ASIO_CHECK(net14.netmask() == make_address_v4("255.255.255.240"));
// broadcast
ASIO_CHECK(net12.broadcast() == make_address_v4("192.168.0.255"));
ASIO_CHECK(net13.broadcast() == make_address_v4("192.168.1.15"));
ASIO_CHECK(net14.broadcast() == make_address_v4("192.168.1.31"));
// iterator
ASIO_CHECK(std::distance(net12.hosts().begin(),net12.hosts().end()) == 254);
ASIO_CHECK(*net12.hosts().begin() == make_address_v4("192.168.0.1"));
ASIO_CHECK(net12.hosts().end() != net12.hosts().find(make_address_v4("192.168.0.10")));
ASIO_CHECK(net12.hosts().end() == net12.hosts().find(make_address_v4("192.168.1.10")));
ASIO_CHECK(std::distance(net13.hosts().begin(),net13.hosts().end()) == 14);
ASIO_CHECK(*net13.hosts().begin() == make_address_v4("192.168.1.1"));
ASIO_CHECK(net13.hosts().end() != net13.hosts().find(make_address_v4("192.168.1.14")));
ASIO_CHECK(net13.hosts().end() == net13.hosts().find(make_address_v4("192.168.1.15")));
ASIO_CHECK(std::distance(net14.hosts().begin(),net14.hosts().end()) == 14);
ASIO_CHECK(*net14.hosts().begin() == make_address_v4("192.168.1.17"));
ASIO_CHECK(net14.hosts().end() != net14.hosts().find(make_address_v4("192.168.1.30")));
ASIO_CHECK(net14.hosts().end() == net14.hosts().find(make_address_v4("192.168.1.31")));
}
} // namespace ip_network_v4_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/network_v4",
ASIO_COMPILE_TEST_CASE(ip_network_v4_compile::test)
ASIO_TEST_CASE(ip_network_v4_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/icmp.cpp | //
// icmp.cpp
// ~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/icmp.hpp"
#include <cstring>
#include "asio/io_context.hpp"
#include "asio/placeholders.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.hpp"
#include "../archetypes/gettable_socket_option.hpp"
#include "../archetypes/io_control_command.hpp"
#include "../archetypes/settable_socket_option.hpp"
//------------------------------------------------------------------------------
// ip_icmp_socket_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::icmp::socket compile and link correctly. Runtime failures are ignored.
namespace ip_icmp_socket_compile {
struct connect_handler
{
connect_handler() {}
void operator()(const asio::error_code&) {}
connect_handler(connect_handler&&) {}
private:
connect_handler(const connect_handler&);
};
struct send_handler
{
send_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
send_handler(send_handler&&) {}
private:
send_handler(const send_handler&);
};
struct receive_handler
{
receive_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
receive_handler(receive_handler&&) {}
private:
receive_handler(const receive_handler&);
};
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
socket_base::message_flags in_flags = 0;
archetypes::settable_socket_option<void> settable_socket_option1;
archetypes::settable_socket_option<int> settable_socket_option2;
archetypes::settable_socket_option<double> settable_socket_option3;
archetypes::gettable_socket_option<void> gettable_socket_option1;
archetypes::gettable_socket_option<int> gettable_socket_option2;
archetypes::gettable_socket_option<double> gettable_socket_option3;
archetypes::io_control_command io_control_command;
archetypes::immediate_handler immediate;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_datagram_socket constructors.
ip::icmp::socket socket1(ioc);
ip::icmp::socket socket2(ioc, ip::icmp::v4());
ip::icmp::socket socket3(ioc, ip::icmp::v6());
ip::icmp::socket socket4(ioc, ip::icmp::endpoint(ip::icmp::v4(), 0));
ip::icmp::socket socket5(ioc, ip::icmp::endpoint(ip::icmp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::icmp::socket::native_handle_type native_socket1
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
ip::icmp::socket socket6(ioc, ip::icmp::v4(), native_socket1);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::icmp::socket socket7(ioc_ex);
ip::icmp::socket socket8(ioc_ex, ip::icmp::v4());
ip::icmp::socket socket9(ioc_ex, ip::icmp::v6());
ip::icmp::socket socket10(ioc_ex, ip::icmp::endpoint(ip::icmp::v4(), 0));
ip::icmp::socket socket11(ioc_ex, ip::icmp::endpoint(ip::icmp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::icmp::socket::native_handle_type native_socket2
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
ip::icmp::socket socket12(ioc_ex, ip::icmp::v4(), native_socket2);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::icmp::socket socket13(std::move(socket6));
// basic_datagram_socket operators.
socket1 = ip::icmp::socket(ioc);
socket1 = std::move(socket2);
// basic_io_object functions.
ip::icmp::socket::executor_type ex = socket1.get_executor();
(void)ex;
// basic_socket functions.
ip::icmp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
(void)lowest_layer;
const ip::icmp::socket& socket14 = socket1;
const ip::icmp::socket::lowest_layer_type& lowest_layer2
= socket14.lowest_layer();
(void)lowest_layer2;
socket1.open(ip::icmp::v4());
socket1.open(ip::icmp::v6());
socket1.open(ip::icmp::v4(), ec);
socket1.open(ip::icmp::v6(), ec);
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::icmp::socket::native_handle_type native_socket3
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
socket1.assign(ip::icmp::v4(), native_socket3);
ip::icmp::socket::native_handle_type native_socket4
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
socket1.assign(ip::icmp::v4(), native_socket4, ec);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
bool is_open = socket1.is_open();
(void)is_open;
socket1.close();
socket1.close(ec);
socket1.release();
socket1.release(ec);
ip::icmp::socket::native_handle_type native_socket5
= socket1.native_handle();
(void)native_socket5;
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(ip::icmp::endpoint(ip::icmp::v4(), 0));
socket1.bind(ip::icmp::endpoint(ip::icmp::v6(), 0));
socket1.bind(ip::icmp::endpoint(ip::icmp::v4(), 0), ec);
socket1.bind(ip::icmp::endpoint(ip::icmp::v6(), 0), ec);
socket1.connect(ip::icmp::endpoint(ip::icmp::v4(), 0));
socket1.connect(ip::icmp::endpoint(ip::icmp::v6(), 0));
socket1.connect(ip::icmp::endpoint(ip::icmp::v4(), 0), ec);
socket1.connect(ip::icmp::endpoint(ip::icmp::v6(), 0), ec);
socket1.async_connect(ip::icmp::endpoint(ip::icmp::v4(), 0),
connect_handler());
socket1.async_connect(ip::icmp::endpoint(ip::icmp::v6(), 0),
connect_handler());
socket1.async_connect(ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
socket1.async_connect(ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
int i1 = socket1.async_connect(ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
(void)i1;
int i2 = socket1.async_connect(ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
(void)i2;
socket1.set_option(settable_socket_option1);
socket1.set_option(settable_socket_option1, ec);
socket1.set_option(settable_socket_option2);
socket1.set_option(settable_socket_option2, ec);
socket1.set_option(settable_socket_option3);
socket1.set_option(settable_socket_option3, ec);
socket1.get_option(gettable_socket_option1);
socket1.get_option(gettable_socket_option1, ec);
socket1.get_option(gettable_socket_option2);
socket1.get_option(gettable_socket_option2, ec);
socket1.get_option(gettable_socket_option3);
socket1.get_option(gettable_socket_option3, ec);
socket1.io_control(io_control_command);
socket1.io_control(io_control_command, ec);
bool non_blocking1 = socket1.non_blocking();
(void)non_blocking1;
socket1.non_blocking(true);
socket1.non_blocking(false, ec);
bool non_blocking2 = socket1.native_non_blocking();
(void)non_blocking2;
socket1.native_non_blocking(true);
socket1.native_non_blocking(false, ec);
ip::icmp::endpoint endpoint1 = socket1.local_endpoint();
(void)endpoint1;
ip::icmp::endpoint endpoint2 = socket1.local_endpoint(ec);
(void)endpoint2;
ip::icmp::endpoint endpoint3 = socket1.remote_endpoint();
(void)endpoint3;
ip::icmp::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.async_send(buffer(mutable_char_buffer), immediate);
socket1.async_send(buffer(const_char_buffer), immediate);
socket1.async_send(null_buffers(), immediate);
socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
int i3 = socket1.async_send(buffer(mutable_char_buffer), lazy);
(void)i3;
int i4 = socket1.async_send(buffer(const_char_buffer), lazy);
(void)i4;
int i5 = socket1.async_send(null_buffers(), lazy);
(void)i5;
int i6 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
(void)i6;
int i7 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
(void)i7;
int i8 = socket1.async_send(null_buffers(), in_flags, lazy);
(void)i8;
socket1.send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0));
socket1.send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0));
socket1.send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0));
socket1.send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0));
socket1.send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0));
socket1.send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0));
socket1.send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags);
socket1.send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags);
socket1.send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags);
socket1.send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags);
socket1.send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags);
socket1.send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags);
socket1.send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, ec);
socket1.send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, ec);
socket1.send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, ec);
socket1.send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, ec);
socket1.send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, ec);
socket1.send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, ec);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), send_handler());
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), send_handler());
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, send_handler());
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, send_handler());
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, immediate);
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, immediate);
socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, immediate);
int i9 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
(void)i9;
int i10 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
(void)i10;
int i11 = socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
(void)i11;
int i12 = socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
(void)i12;
int i13 = socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
(void)i13;
int i14 = socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
(void)i14;
int i15 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, lazy);
(void)i15;
int i16 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, lazy);
(void)i16;
int i17 = socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, lazy);
(void)i17;
int i18 = socket1.async_send_to(buffer(const_char_buffer),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, lazy);
(void)i18;
int i19 = socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, lazy);
(void)i19;
int i20 = socket1.async_send_to(null_buffers(),
ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, lazy);
(void)i20;
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.async_receive(buffer(mutable_char_buffer), immediate);
socket1.async_receive(null_buffers(), immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_receive(null_buffers(), in_flags, immediate);
int i21 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
(void)i21;
int i22 = socket1.async_receive(null_buffers(), lazy);
(void)i22;
int i23 = socket1.async_receive(buffer(mutable_char_buffer),
in_flags, lazy);
(void)i23;
int i24 = socket1.async_receive(null_buffers(), in_flags, lazy);
(void)i24;
ip::icmp::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());
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, immediate);
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, in_flags, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, in_flags, immediate);
int i25 = socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, lazy);
(void)i25;
int i26 = socket1.async_receive_from(null_buffers(),
endpoint, lazy);
(void)i26;
int i27 = socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, in_flags, lazy);
(void)i27;
int i28 = socket1.async_receive_from(null_buffers(),
endpoint, in_flags, lazy);
(void)i28;
}
catch (std::exception&)
{
}
}
} // namespace ip_icmp_socket_compile
//------------------------------------------------------------------------------
// ip_icmp_resolver_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::icmp::resolver compile and link correctly. Runtime failures are ignored.
namespace ip_icmp_resolver_compile {
struct resolve_handler
{
resolve_handler() {}
void operator()(const asio::error_code&,
asio::ip::icmp::resolver::results_type) {}
resolve_handler(resolve_handler&&) {}
private:
resolve_handler(const resolve_handler&);
};
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
archetypes::lazy_handler lazy;
asio::error_code ec;
#if !defined(ASIO_NO_DEPRECATED)
ip::icmp::resolver::query q(ip::icmp::v4(), "localhost", "0");
#endif // !defined(ASIO_NO_DEPRECATED)
ip::icmp::endpoint e(ip::address_v4::loopback(), 0);
// basic_resolver constructors.
ip::icmp::resolver resolver(ioc);
ip::icmp::resolver resolver2(ioc_ex);
ip::icmp::resolver resolver3(std::move(resolver));
// basic_resolver operators.
resolver = ip::icmp::resolver(ioc);
resolver = std::move(resolver3);
// basic_io_object functions.
ip::icmp::resolver::executor_type ex = resolver.get_executor();
(void)ex;
// basic_resolver functions.
resolver.cancel();
#if !defined(ASIO_NO_DEPRECATED)
ip::icmp::resolver::results_type results1 = resolver.resolve(q);
(void)results1;
ip::icmp::resolver::results_type results2 = resolver.resolve(q, ec);
(void)results2;
#endif // !defined(ASIO_NO_DEPRECATED)
ip::icmp::resolver::results_type results3 = resolver.resolve("", "");
(void)results3;
ip::icmp::resolver::results_type results4 = resolver.resolve("", "", ec);
(void)results4;
ip::icmp::resolver::results_type results5 =
resolver.resolve("", "", ip::icmp::resolver::flags());
(void)results5;
ip::icmp::resolver::results_type results6 =
resolver.resolve("", "", ip::icmp::resolver::flags(), ec);
(void)results6;
ip::icmp::resolver::results_type results7 =
resolver.resolve(ip::icmp::v4(), "", "");
(void)results7;
ip::icmp::resolver::results_type results8 =
resolver.resolve(ip::icmp::v4(), "", "", ec);
(void)results8;
ip::icmp::resolver::results_type results9 =
resolver.resolve(ip::icmp::v4(), "", "", ip::icmp::resolver::flags());
(void)results9;
ip::icmp::resolver::results_type results10 =
resolver.resolve(ip::icmp::v4(), "", "", ip::icmp::resolver::flags(), ec);
(void)results10;
ip::icmp::resolver::results_type results11 = resolver.resolve(e);
(void)results11;
ip::icmp::resolver::results_type results12 = resolver.resolve(e, ec);
(void)results12;
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve(q, resolve_handler());
int i1 = resolver.async_resolve(q, lazy);
(void)i1;
#endif // !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve("", "", resolve_handler());
int i2 = resolver.async_resolve("", "", lazy);
(void)i2;
resolver.async_resolve("", "",
ip::icmp::resolver::flags(), resolve_handler());
int i3 = resolver.async_resolve("", "",
ip::icmp::resolver::flags(), lazy);
(void)i3;
resolver.async_resolve(ip::icmp::v4(), "", "", resolve_handler());
int i4 = resolver.async_resolve(ip::icmp::v4(), "", "", lazy);
(void)i4;
resolver.async_resolve(ip::icmp::v4(),
"", "", ip::icmp::resolver::flags(), resolve_handler());
int i5 = resolver.async_resolve(ip::icmp::v4(),
"", "", ip::icmp::resolver::flags(), lazy);
(void)i5;
resolver.async_resolve(e, resolve_handler());
int i6 = resolver.async_resolve(e, lazy);
(void)i6;
}
catch (std::exception&)
{
}
}
} // namespace ip_icmp_resolver_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/icmp",
ASIO_COMPILE_TEST_CASE(ip_icmp_socket_compile::test)
ASIO_COMPILE_TEST_CASE(ip_icmp_resolver_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/udp.cpp | //
// udp.cpp
// ~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/udp.hpp"
#include <cstring>
#include <functional>
#include "asio/io_context.hpp"
#include "../unit_test.hpp"
#include "../archetypes/async_result.hpp"
#include "../archetypes/gettable_socket_option.hpp"
#include "../archetypes/io_control_command.hpp"
#include "../archetypes/settable_socket_option.hpp"
//------------------------------------------------------------------------------
// ip_udp_socket_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::udp::socket compile and link correctly. Runtime failures are ignored.
namespace ip_udp_socket_compile {
struct connect_handler
{
connect_handler() {}
void operator()(const asio::error_code&) {}
connect_handler(connect_handler&&) {}
private:
connect_handler(const connect_handler&);
};
struct wait_handler
{
wait_handler() {}
void operator()(const asio::error_code&) {}
wait_handler(wait_handler&&) {}
private:
wait_handler(const wait_handler&);
};
struct send_handler
{
send_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
send_handler(send_handler&&) {}
private:
send_handler(const send_handler&);
};
struct receive_handler
{
receive_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
receive_handler(receive_handler&&) {}
private:
receive_handler(const receive_handler&);
};
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
socket_base::message_flags in_flags = 0;
archetypes::settable_socket_option<void> settable_socket_option1;
archetypes::settable_socket_option<int> settable_socket_option2;
archetypes::settable_socket_option<double> settable_socket_option3;
archetypes::gettable_socket_option<void> gettable_socket_option1;
archetypes::gettable_socket_option<int> gettable_socket_option2;
archetypes::gettable_socket_option<double> gettable_socket_option3;
archetypes::io_control_command io_control_command;
archetypes::immediate_handler immediate;
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_datagram_socket constructors.
ip::udp::socket socket1(ioc);
ip::udp::socket socket2(ioc, ip::udp::v4());
ip::udp::socket socket3(ioc, ip::udp::v6());
ip::udp::socket socket4(ioc, ip::udp::endpoint(ip::udp::v4(), 0));
ip::udp::socket socket5(ioc, ip::udp::endpoint(ip::udp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::udp::socket::native_handle_type native_socket1
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
ip::udp::socket socket6(ioc, ip::udp::v4(), native_socket1);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::udp::socket socket7(ioc_ex);
ip::udp::socket socket8(ioc_ex, ip::udp::v4());
ip::udp::socket socket9(ioc_ex, ip::udp::v6());
ip::udp::socket socket10(ioc_ex, ip::udp::endpoint(ip::udp::v4(), 0));
ip::udp::socket socket11(ioc_ex, ip::udp::endpoint(ip::udp::v6(), 0));
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::udp::socket::native_handle_type native_socket2
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
ip::udp::socket socket12(ioc_ex, ip::udp::v4(), native_socket2);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
ip::udp::socket socket13(std::move(socket6));
// basic_datagram_socket operators.
socket1 = ip::udp::socket(ioc);
socket1 = std::move(socket2);
// basic_io_object functions.
ip::udp::socket::executor_type ex = socket1.get_executor();
(void)ex;
// basic_socket functions.
ip::udp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
(void)lowest_layer;
const ip::udp::socket& socket14 = socket1;
const ip::udp::socket::lowest_layer_type& lowest_layer2
= socket14.lowest_layer();
(void)lowest_layer2;
socket1.open(ip::udp::v4());
socket1.open(ip::udp::v6());
socket1.open(ip::udp::v4(), ec);
socket1.open(ip::udp::v6(), ec);
#if !defined(ASIO_WINDOWS_RUNTIME)
ip::udp::socket::native_handle_type native_socket3
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
socket1.assign(ip::udp::v4(), native_socket3);
ip::udp::socket::native_handle_type native_socket4
= ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
socket1.assign(ip::udp::v4(), native_socket4, ec);
#endif // !defined(ASIO_WINDOWS_RUNTIME)
bool is_open = socket1.is_open();
(void)is_open;
socket1.close();
socket1.close(ec);
socket1.release();
socket1.release(ec);
ip::udp::socket::native_handle_type native_socket5
= socket1.native_handle();
(void)native_socket5;
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(ip::udp::endpoint(ip::udp::v4(), 0));
socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0));
socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0), ec);
socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0), ec);
socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0));
socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0));
socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0), ec);
socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0), ec);
socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0),
connect_handler());
socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0),
connect_handler());
socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), immediate);
socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), immediate);
int i1 = socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), lazy);
(void)i1;
int i2 = socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), lazy);
(void)i2;
socket1.set_option(settable_socket_option1);
socket1.set_option(settable_socket_option1, ec);
socket1.set_option(settable_socket_option2);
socket1.set_option(settable_socket_option2, ec);
socket1.set_option(settable_socket_option3);
socket1.set_option(settable_socket_option3, ec);
socket1.get_option(gettable_socket_option1);
socket1.get_option(gettable_socket_option1, ec);
socket1.get_option(gettable_socket_option2);
socket1.get_option(gettable_socket_option2, ec);
socket1.get_option(gettable_socket_option3);
socket1.get_option(gettable_socket_option3, ec);
socket1.io_control(io_control_command);
socket1.io_control(io_control_command, ec);
bool non_blocking1 = socket1.non_blocking();
(void)non_blocking1;
socket1.non_blocking(true);
socket1.non_blocking(false, ec);
bool non_blocking2 = socket1.native_non_blocking();
(void)non_blocking2;
socket1.native_non_blocking(true);
socket1.native_non_blocking(false, ec);
ip::udp::endpoint endpoint1 = socket1.local_endpoint();
(void)endpoint1;
ip::udp::endpoint endpoint2 = socket1.local_endpoint(ec);
(void)endpoint2;
ip::udp::endpoint endpoint3 = socket1.remote_endpoint();
(void)endpoint3;
ip::udp::endpoint endpoint4 = socket1.remote_endpoint(ec);
(void)endpoint4;
socket1.shutdown(socket_base::shutdown_both);
socket1.shutdown(socket_base::shutdown_both, ec);
socket1.wait(socket_base::wait_read);
socket1.wait(socket_base::wait_write, ec);
socket1.async_wait(socket_base::wait_read, wait_handler());
socket1.async_wait(socket_base::wait_read, immediate);
int i3 = socket1.async_wait(socket_base::wait_write, lazy);
(void)i3;
// 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.async_send(buffer(mutable_char_buffer), immediate);
socket1.async_send(buffer(const_char_buffer), immediate);
socket1.async_send(null_buffers(), immediate);
socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
socket1.async_send(null_buffers(), in_flags, immediate);
int i4 = socket1.async_send(buffer(mutable_char_buffer), lazy);
(void)i4;
int i5 = socket1.async_send(buffer(const_char_buffer), lazy);
(void)i5;
int i6 = socket1.async_send(null_buffers(), lazy);
(void)i6;
int i7 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
(void)i7;
int i8 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
(void)i8;
int i9 = socket1.async_send(null_buffers(), in_flags, lazy);
(void)i9;
socket1.send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0));
socket1.send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0));
socket1.send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0));
socket1.send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0));
socket1.send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0));
socket1.send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0));
socket1.send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
socket1.send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
socket1.send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
socket1.send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
socket1.send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
socket1.send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
socket1.send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
socket1.send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
socket1.send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
socket1.send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
socket1.send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
socket1.send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), send_handler());
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), send_handler());
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler());
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler());
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler());
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), immediate);
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), immediate);
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, immediate);
socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, immediate);
socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, immediate);
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, immediate);
socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, immediate);
int i10 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), lazy);
(void)i10;
int i11 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), lazy);
(void)i11;
int i12 = socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), lazy);
(void)i12;
int i13 = socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), lazy);
(void)i13;
int i14 = socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), lazy);
(void)i14;
int i15 = socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), lazy);
(void)i15;
int i16 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
(void)i16;
int i17 = socket1.async_send_to(buffer(mutable_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
(void)i17;
int i18 = socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
(void)i18;
int i19 = socket1.async_send_to(buffer(const_char_buffer),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
(void)i19;
int i20 = socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
(void)i20;
int i21 = socket1.async_send_to(null_buffers(),
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
(void)i21;
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.async_receive(buffer(mutable_char_buffer), immediate);
socket1.async_receive(null_buffers(), immediate);
socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
socket1.async_receive(null_buffers(), in_flags, immediate);
int i22 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
(void)i22;
int i23 = socket1.async_receive(null_buffers(), lazy);
(void)i23;
int i24 = socket1.async_receive(buffer(mutable_char_buffer),
in_flags, lazy);
(void)i24;
int i25 = socket1.async_receive(null_buffers(), in_flags, lazy);
(void)i25;
ip::udp::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());
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, immediate);
socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, in_flags, immediate);
socket1.async_receive_from(null_buffers(),
endpoint, in_flags, immediate);
int i26 = socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, lazy);
(void)i26;
int i27 = socket1.async_receive_from(null_buffers(),
endpoint, lazy);
(void)i27;
int i28 = socket1.async_receive_from(buffer(mutable_char_buffer),
endpoint, in_flags, lazy);
(void)i28;
int i29 = socket1.async_receive_from(null_buffers(),
endpoint, in_flags, lazy);
(void)i29;
}
catch (std::exception&)
{
}
}
} // namespace ip_udp_socket_compile
//------------------------------------------------------------------------------
// ip_udp_socket_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the ip::udp::socket class.
namespace ip_udp_socket_runtime {
void handle_send(size_t expected_bytes_sent,
const asio::error_code& err, size_t bytes_sent)
{
ASIO_CHECK(!err);
ASIO_CHECK(expected_bytes_sent == bytes_sent);
}
void handle_recv(size_t expected_bytes_recvd,
const asio::error_code& err, size_t bytes_recvd)
{
ASIO_CHECK(!err);
ASIO_CHECK(expected_bytes_recvd == bytes_recvd);
}
void test()
{
using namespace std; // For memcmp and memset.
using namespace asio;
namespace ip = asio::ip;
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
io_context ioc;
ip::udp::socket s1(ioc, ip::udp::endpoint(ip::udp::v4(), 0));
ip::udp::endpoint target_endpoint = s1.local_endpoint();
target_endpoint.address(ip::address_v4::loopback());
ip::udp::socket s2(ioc);
s2.open(ip::udp::v4());
s2.bind(ip::udp::endpoint(ip::udp::v4(), 0));
char send_msg[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
s2.send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint);
char recv_msg[sizeof(send_msg)];
ip::udp::endpoint sender_endpoint;
size_t bytes_recvd = s1.receive_from(buffer(recv_msg, sizeof(recv_msg)),
sender_endpoint);
ASIO_CHECK(bytes_recvd == sizeof(send_msg));
ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
memset(recv_msg, 0, sizeof(recv_msg));
target_endpoint = sender_endpoint;
s1.async_send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint,
bindns::bind(handle_send, sizeof(send_msg), _1, _2));
s2.async_receive_from(buffer(recv_msg, sizeof(recv_msg)), sender_endpoint,
bindns::bind(handle_recv, sizeof(recv_msg), _1, _2));
ioc.run();
ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
}
} // namespace ip_udp_socket_runtime
//------------------------------------------------------------------------------
// ip_udp_resolver_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::udp::resolver compile and link correctly. Runtime failures are ignored.
namespace ip_udp_resolver_compile {
struct resolve_handler
{
resolve_handler() {}
void operator()(const asio::error_code&,
asio::ip::udp::resolver::results_type) {}
resolve_handler(resolve_handler&&) {}
private:
resolve_handler(const resolve_handler&);
};
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
archetypes::lazy_handler lazy;
asio::error_code ec;
#if !defined(ASIO_NO_DEPRECATED)
ip::udp::resolver::query q(ip::udp::v4(), "localhost", "0");
#endif // !defined(ASIO_NO_DEPRECATED)
ip::udp::endpoint e(ip::address_v4::loopback(), 0);
// basic_resolver constructors.
ip::udp::resolver resolver(ioc);
ip::udp::resolver resolver2(ioc_ex);
ip::udp::resolver resolver3(std::move(resolver));
// basic_resolver operators.
resolver = ip::udp::resolver(ioc);
resolver = std::move(resolver3);
// basic_io_object functions.
ip::udp::resolver::executor_type ex = resolver.get_executor();
(void)ex;
// basic_resolver functions.
resolver.cancel();
#if !defined(ASIO_NO_DEPRECATED)
ip::udp::resolver::results_type results1 = resolver.resolve(q);
(void)results1;
ip::udp::resolver::results_type results2 = resolver.resolve(q, ec);
(void)results2;
#endif // !defined(ASIO_NO_DEPRECATED)
ip::udp::resolver::results_type results3 = resolver.resolve("", "");
(void)results3;
ip::udp::resolver::results_type results4 = resolver.resolve("", "", ec);
(void)results4;
ip::udp::resolver::results_type results5 =
resolver.resolve("", "", ip::udp::resolver::flags());
(void)results5;
ip::udp::resolver::results_type results6 =
resolver.resolve("", "", ip::udp::resolver::flags(), ec);
(void)results6;
ip::udp::resolver::results_type results7 =
resolver.resolve(ip::udp::v4(), "", "");
(void)results7;
ip::udp::resolver::results_type results8 =
resolver.resolve(ip::udp::v4(), "", "", ec);
(void)results8;
ip::udp::resolver::results_type results9 =
resolver.resolve(ip::udp::v4(), "", "", ip::udp::resolver::flags());
(void)results9;
ip::udp::resolver::results_type results10 =
resolver.resolve(ip::udp::v4(), "", "", ip::udp::resolver::flags(), ec);
(void)results10;
ip::udp::resolver::results_type results11 = resolver.resolve(e);
(void)results11;
ip::udp::resolver::results_type results12 = resolver.resolve(e, ec);
(void)results12;
#if !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve(q, resolve_handler());
int i1 = resolver.async_resolve(q, lazy);
(void)i1;
#endif // !defined(ASIO_NO_DEPRECATED)
resolver.async_resolve("", "", resolve_handler());
int i2 = resolver.async_resolve("", "", lazy);
(void)i2;
resolver.async_resolve("", "",
ip::udp::resolver::flags(), resolve_handler());
int i3 = resolver.async_resolve("", "",
ip::udp::resolver::flags(), lazy);
(void)i3;
resolver.async_resolve(ip::udp::v4(), "", "", resolve_handler());
int i4 = resolver.async_resolve(ip::udp::v4(), "", "", lazy);
(void)i4;
resolver.async_resolve(ip::udp::v4(),
"", "", ip::udp::resolver::flags(), resolve_handler());
int i5 = resolver.async_resolve(ip::udp::v4(),
"", "", ip::udp::resolver::flags(), lazy);
(void)i5;
resolver.async_resolve(e, resolve_handler());
int i6 = resolver.async_resolve(e, lazy);
(void)i6;
}
catch (std::exception&)
{
}
}
} // namespace ip_udp_resolver_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/udp",
ASIO_COMPILE_TEST_CASE(ip_udp_socket_compile::test)
ASIO_TEST_CASE(ip_udp_socket_runtime::test)
ASIO_COMPILE_TEST_CASE(ip_udp_resolver_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address_v4_iterator.cpp | //
// address_v4_iterator.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/address_v4_iterator.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address_v4_iterator",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/v6_only.cpp | //
// v6_only.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/v6_only.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "asio/ip/udp.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// ip_v6_only_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that the ip::v6_only socket option compiles and
// link correctly. Runtime failures are ignored.
namespace ip_v6_only_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
ip::udp::socket sock(ioc);
// v6_only class.
ip::v6_only v6_only1(true);
sock.set_option(v6_only1);
ip::v6_only v6_only2;
sock.get_option(v6_only2);
v6_only1 = true;
(void)static_cast<bool>(v6_only1);
(void)static_cast<bool>(!v6_only1);
(void)static_cast<bool>(v6_only1.value());
}
catch (std::exception&)
{
}
}
} // namespace ip_v6_only_compile
//------------------------------------------------------------------------------
// ip_v6_only_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the ip::v6_only socket
// option.
namespace ip_v6_only_runtime {
void test()
{
using namespace asio;
namespace ip = asio::ip;
io_context ioc;
asio::error_code ec;
ip::tcp::endpoint ep_v6(ip::address_v6::loopback(), 0);
ip::tcp::acceptor acceptor_v6(ioc);
acceptor_v6.open(ep_v6.protocol(), ec);
acceptor_v6.bind(ep_v6, ec);
bool have_v6 = !ec;
acceptor_v6.close(ec);
acceptor_v6.open(ep_v6.protocol(), ec);
if (have_v6)
{
ip::v6_only v6_only1;
acceptor_v6.get_option(v6_only1, ec);
ASIO_CHECK(!ec);
bool have_dual_stack = !v6_only1.value();
if (have_dual_stack)
{
ip::v6_only v6_only2(false);
ASIO_CHECK(!v6_only2.value());
ASIO_CHECK(!static_cast<bool>(v6_only2));
ASIO_CHECK(!v6_only2);
acceptor_v6.set_option(v6_only2, ec);
ASIO_CHECK(!ec);
ip::v6_only v6_only3;
acceptor_v6.get_option(v6_only3, ec);
ASIO_CHECK(!ec);
ASIO_CHECK(!v6_only3.value());
ASIO_CHECK(!static_cast<bool>(v6_only3));
ASIO_CHECK(!v6_only3);
ip::v6_only v6_only4(true);
ASIO_CHECK(v6_only4.value());
ASIO_CHECK(static_cast<bool>(v6_only4));
ASIO_CHECK(!!v6_only4);
acceptor_v6.set_option(v6_only4, ec);
ASIO_CHECK(!ec);
ip::v6_only v6_only5;
acceptor_v6.get_option(v6_only5, ec);
ASIO_CHECK(!ec);
ASIO_CHECK(v6_only5.value());
ASIO_CHECK(static_cast<bool>(v6_only5));
ASIO_CHECK(!!v6_only5);
}
}
}
} // namespace ip_v6_only_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/v6_only",
ASIO_COMPILE_TEST_CASE(ip_v6_only_compile::test)
ASIO_TEST_CASE(ip_v6_only_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address_v6_range.cpp | //
// address_v6_range.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/address_v6_range.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address_v6_range",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address_v6_iterator.cpp | //
// address_v6_iterator.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/address_v6_iterator.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address_v6_iterator",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/basic_resolver_entry.cpp | //
// basic_resolver_entry.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/basic_resolver_entry.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ip/basic_resolver_entry",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address.cpp | //
// address.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/address.hpp"
#include "../unit_test.hpp"
#include <sstream>
//------------------------------------------------------------------------------
// ip_address_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::address compile and link correctly. Runtime failures are ignored.
namespace ip_address_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
asio::error_code ec;
// address constructors.
ip::address addr1;
const ip::address_v4 const_addr_v4;
ip::address addr2(const_addr_v4);
const ip::address_v6 const_addr_v6;
ip::address addr3(const_addr_v6);
// address functions.
bool b = addr1.is_v4();
(void)b;
b = addr1.is_v6();
(void)b;
b = addr1.is_loopback();
(void)b;
b = addr1.is_unspecified();
(void)b;
b = addr1.is_multicast();
(void)b;
ip::address_v4 addr_v4_value = addr1.to_v4();
(void)addr_v4_value;
ip::address_v6 addr_v6_value = addr1.to_v6();
(void)addr_v6_value;
std::string string_value = addr1.to_string();
#if !defined(ASIO_NO_DEPRECATED)
string_value = addr1.to_string(ec);
#endif // !defined(ASIO_NO_DEPRECATED)
// address static functions.
#if !defined(ASIO_NO_DEPRECATED)
addr1 = ip::address::from_string("127.0.0.1");
addr1 = ip::address::from_string("127.0.0.1", ec);
addr1 = ip::address::from_string(string_value);
addr1 = ip::address::from_string(string_value, ec);
#endif // !defined(ASIO_NO_DEPRECATED)
// address 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 creation functions.
addr1 = ip::make_address("127.0.0.1");
addr1 = ip::make_address("127.0.0.1", ec);
addr1 = ip::make_address(string_value);
addr1 = ip::make_address(string_value, ec);
#if defined(ASIO_HAS_STRING_VIEW)
# if defined(ASIO_HAS_STD_STRING_VIEW)
std::string_view string_view_value("127.0.0.1");
# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_value("127.0.0.1");
# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
addr1 = ip::make_address(string_view_value);
addr1 = ip::make_address(string_view_value, ec);
#endif // defined(ASIO_HAS_STRING_VIEW)
// address I/O.
std::ostringstream os;
os << addr1;
#if !defined(BOOST_NO_STD_WSTREAMBUF)
std::wostringstream wos;
wos << addr1;
#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
std::size_t hash1 = std::hash<ip::address>()(addr1);
(void)hash1;
}
catch (std::exception&)
{
}
}
} // namespace ip_address_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address",
ASIO_COMPILE_TEST_CASE(ip_address_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/multicast.cpp | //
// multicast.cpp
// ~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/multicast.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/udp.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// ip_multicast_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all nested classes, enums and constants in
// ip::multicast compile and link correctly. Runtime failures are ignored.
namespace ip_multicast_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
ip::udp::socket sock(ioc);
const ip::address address;
const ip::address_v4 address_v4;
const ip::address_v6 address_v6;
// join_group class.
ip::multicast::join_group join_group1;
ip::multicast::join_group join_group2(address);
ip::multicast::join_group join_group3(address_v4);
ip::multicast::join_group join_group4(address_v4, address_v4);
ip::multicast::join_group join_group5(address_v6);
ip::multicast::join_group join_group6(address_v6, 1);
sock.set_option(join_group6);
// leave_group class.
ip::multicast::leave_group leave_group1;
ip::multicast::leave_group leave_group2(address);
ip::multicast::leave_group leave_group3(address_v4);
ip::multicast::leave_group leave_group4(address_v4, address_v4);
ip::multicast::leave_group leave_group5(address_v6);
ip::multicast::leave_group leave_group6(address_v6, 1);
sock.set_option(leave_group6);
// outbound_interface class.
ip::multicast::outbound_interface outbound_interface1;
ip::multicast::outbound_interface outbound_interface2(address_v4);
ip::multicast::outbound_interface outbound_interface3(1);
sock.set_option(outbound_interface3);
// hops class.
ip::multicast::hops hops1(1024);
sock.set_option(hops1);
ip::multicast::hops hops2;
sock.get_option(hops2);
hops1 = 1;
(void)static_cast<int>(hops1.value());
// enable_loopback class.
ip::multicast::enable_loopback enable_loopback1(true);
sock.set_option(enable_loopback1);
ip::multicast::enable_loopback enable_loopback2;
sock.get_option(enable_loopback2);
enable_loopback1 = true;
(void)static_cast<bool>(enable_loopback1);
(void)static_cast<bool>(!enable_loopback1);
(void)static_cast<bool>(enable_loopback1.value());
}
catch (std::exception&)
{
}
}
} // namespace ip_multicast_compile
//------------------------------------------------------------------------------
// ip_multicast_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the socket options defined
// in the ip::multicast namespace.
namespace ip_multicast_runtime {
#if defined(__hpux)
// HP-UX doesn't declare this function extern "C", so it is declared again here
// to avoid a linker error about an undefined symbol.
extern "C" unsigned int if_nametoindex(const char*);
#endif // defined(__hpux)
void test()
{
using namespace asio;
namespace ip = asio::ip;
io_context ioc;
asio::error_code ec;
ip::udp::endpoint ep_v4(ip::address_v4::loopback(), 0);
ip::udp::socket sock_v4(ioc);
sock_v4.open(ep_v4.protocol(), ec);
sock_v4.bind(ep_v4, ec);
bool have_v4 = !ec;
ip::udp::endpoint ep_v6(ip::address_v6::loopback(), 0);
ip::udp::socket sock_v6(ioc);
sock_v6.open(ep_v6.protocol(), ec);
sock_v6.bind(ep_v6, ec);
bool have_v6 = !ec;
ASIO_CHECK(have_v4 || have_v6);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Windows CE seems to have problems with some multicast group addresses.
// The following address works on CE, but as it is not a private multicast
// address it will not be used on other platforms.
const ip::address multicast_address_v4 = ip::make_address("239.0.0.4", ec);
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
const ip::address multicast_address_v4 = ip::make_address("239.255.0.1", ec);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!have_v4 || !ec);
#if (defined(__MACH__) && defined(__APPLE__)) \
|| defined(__FreeBSD__) \
|| defined(__NetBSD__) \
|| defined(__OpenBSD__)
const ip::address multicast_address_v6 = ip::make_address("ff02::1%lo0", ec);
#else // (defined(__MACH__) && defined(__APPLE__))
// || defined(__FreeBSD__)
// || defined(__NetBSD__)
// || defined(__OpenBSD__)
const ip::address multicast_address_v6 = ip::make_address("ff01::1", ec);
#endif // (defined(__MACH__) && defined(__APPLE__))
// || defined(__FreeBSD__)
// || defined(__NetBSD__)
// || defined(__OpenBSD__)
ASIO_CHECK(!have_v6 || !ec);
// join_group class.
if (have_v4)
{
ip::multicast::join_group join_group(multicast_address_v4);
sock_v4.set_option(join_group, ec);
ASIO_CHECK_MESSAGE(!ec || ec == error::no_such_device,
ec.value() << ", " << ec.message());
if (!ec)
{
// leave_group class.
ip::multicast::leave_group leave_group(multicast_address_v4);
sock_v4.set_option(leave_group, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
}
}
if (have_v6)
{
ip::multicast::join_group join_group(multicast_address_v6);
sock_v6.set_option(join_group, ec);
ASIO_CHECK_MESSAGE(!ec || ec == error::no_such_device,
ec.value() << ", " << ec.message());
if (!ec)
{
// leave_group class.
ip::multicast::leave_group leave_group(multicast_address_v6);
sock_v6.set_option(leave_group, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
}
}
// outbound_interface class.
if (have_v4)
{
ip::multicast::outbound_interface outbound_interface(
ip::address_v4::loopback());
sock_v4.set_option(outbound_interface, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
}
if (have_v6)
{
#if defined(__hpux)
ip::multicast::outbound_interface outbound_interface(if_nametoindex("lo0"));
#else
ip::multicast::outbound_interface outbound_interface(1);
#endif
sock_v6.set_option(outbound_interface, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
}
// hops class.
if (have_v4)
{
ip::multicast::hops hops1(1);
ASIO_CHECK(hops1.value() == 1);
sock_v4.set_option(hops1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ip::multicast::hops hops2;
sock_v4.get_option(hops2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(hops2.value() == 1);
ip::multicast::hops hops3(0);
ASIO_CHECK(hops3.value() == 0);
sock_v4.set_option(hops3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ip::multicast::hops hops4;
sock_v4.get_option(hops4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(hops4.value() == 0);
}
if (have_v6)
{
ip::multicast::hops hops1(1);
ASIO_CHECK(hops1.value() == 1);
sock_v6.set_option(hops1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ip::multicast::hops hops2;
sock_v6.get_option(hops2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(hops2.value() == 1);
ip::multicast::hops hops3(0);
ASIO_CHECK(hops3.value() == 0);
sock_v6.set_option(hops3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ip::multicast::hops hops4;
sock_v6.get_option(hops4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(hops4.value() == 0);
}
// enable_loopback class.
if (have_v4)
{
ip::multicast::enable_loopback enable_loopback1(true);
ASIO_CHECK(enable_loopback1.value());
ASIO_CHECK(static_cast<bool>(enable_loopback1));
ASIO_CHECK(!!enable_loopback1);
sock_v4.set_option(enable_loopback1, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ip::multicast::enable_loopback enable_loopback2;
sock_v4.get_option(enable_loopback2, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Not supported under Windows CE but can get value.
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(enable_loopback2.value());
ASIO_CHECK(static_cast<bool>(enable_loopback2));
ASIO_CHECK(!!enable_loopback2);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ip::multicast::enable_loopback enable_loopback3(false);
ASIO_CHECK(!enable_loopback3.value());
ASIO_CHECK(!static_cast<bool>(enable_loopback3));
ASIO_CHECK(!enable_loopback3);
sock_v4.set_option(enable_loopback3, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ip::multicast::enable_loopback enable_loopback4;
sock_v4.get_option(enable_loopback4, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Not supported under Windows CE but can get value.
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!enable_loopback4.value());
ASIO_CHECK(!static_cast<bool>(enable_loopback4));
ASIO_CHECK(!enable_loopback4);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
}
if (have_v6)
{
ip::multicast::enable_loopback enable_loopback1(true);
ASIO_CHECK(enable_loopback1.value());
ASIO_CHECK(static_cast<bool>(enable_loopback1));
ASIO_CHECK(!!enable_loopback1);
sock_v6.set_option(enable_loopback1, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ip::multicast::enable_loopback enable_loopback2;
sock_v6.get_option(enable_loopback2, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(enable_loopback2.value());
ASIO_CHECK(static_cast<bool>(enable_loopback2));
ASIO_CHECK(!!enable_loopback2);
ip::multicast::enable_loopback enable_loopback3(false);
ASIO_CHECK(!enable_loopback3.value());
ASIO_CHECK(!static_cast<bool>(enable_loopback3));
ASIO_CHECK(!enable_loopback3);
sock_v6.set_option(enable_loopback3, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ip::multicast::enable_loopback enable_loopback4;
sock_v6.get_option(enable_loopback4, ec);
ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
ASIO_CHECK(!enable_loopback4.value());
ASIO_CHECK(!static_cast<bool>(enable_loopback4));
ASIO_CHECK(!enable_loopback4);
}
}
} // namespace ip_multicast_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/multicast",
ASIO_COMPILE_TEST_CASE(ip_multicast_compile::test)
ASIO_TEST_CASE(ip_multicast_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/host_name.cpp | //
// host_name.cpp
// ~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/host_name.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// ip_host_name_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all host_name functions compile and link
// correctly. Runtime failures are ignored.
namespace ip_host_name_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
asio::error_code ec;
std::string host_name = ip::host_name();
std::string host_name2 = ip::host_name(ec);
}
catch (std::exception&)
{
}
}
} // namespace ip_host_name_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/host_name",
ASIO_COMPILE_TEST_CASE(ip_host_name_compile::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address_v4.cpp | //
// address_v4.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "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 asio;
namespace ip = asio::ip;
try
{
asio::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;
#if !defined(ASIO_NO_DEPRECATED)
b = addr1.is_class_a();
(void)b;
b = addr1.is_class_b();
(void)b;
b = addr1.is_class_c();
(void)b;
#endif // !defined(ASIO_NO_DEPRECATED)
b = addr1.is_multicast();
(void)b;
ip::address_v4::bytes_type bytes_value = addr1.to_bytes();
(void)bytes_value;
ip::address_v4::uint_type uint_value = addr1.to_uint();
(void)uint_value;
#if !defined(ASIO_NO_DEPRECATED)
unsigned long ulong_value = addr1.to_ulong();
(void)ulong_value;
#endif // !defined(ASIO_NO_DEPRECATED)
std::string string_value = addr1.to_string();
#if !defined(ASIO_NO_DEPRECATED)
string_value = addr1.to_string(ec);
#endif // !defined(ASIO_NO_DEPRECATED)
// address_v4 static functions.
#if !defined(ASIO_NO_DEPRECATED)
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);
#endif // !defined(ASIO_NO_DEPRECATED)
addr1 = ip::address_v4::any();
addr1 = ip::address_v4::loopback();
addr1 = ip::address_v4::broadcast();
#if !defined(ASIO_NO_DEPRECATED)
addr1 = ip::address_v4::broadcast(addr2, addr3);
addr1 = ip::address_v4::netmask(addr2);
#endif // !defined(ASIO_NO_DEPRECATED)
// 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 creation functions.
addr1 = ip::make_address_v4(const_bytes_value);
addr1 = ip::make_address_v4(const_ulong_value);
addr1 = ip::make_address_v4("127.0.0.1");
addr1 = ip::make_address_v4("127.0.0.1", ec);
addr1 = ip::make_address_v4(string_value);
addr1 = ip::make_address_v4(string_value, ec);
#if defined(ASIO_HAS_STRING_VIEW)
# if defined(ASIO_HAS_STD_STRING_VIEW)
std::string_view string_view_value("127.0.0.1");
# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_value("127.0.0.1");
# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
addr1 = ip::make_address_v4(string_view_value);
addr1 = ip::make_address_v4(string_view_value, ec);
#endif // defined(ASIO_HAS_STRING_VIEW)
// 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)
#if defined(ASIO_HAS_STD_HASH)
std::size_t hash1 = std::hash<ip::address_v4>()(addr1);
(void)hash1;
#endif // defined(ASIO_HAS_STD_HASH)
}
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 asio::ip::address_v4;
address_v4 a1;
ASIO_CHECK(a1.to_bytes()[0] == 0);
ASIO_CHECK(a1.to_bytes()[1] == 0);
ASIO_CHECK(a1.to_bytes()[2] == 0);
ASIO_CHECK(a1.to_bytes()[3] == 0);
ASIO_CHECK(a1.to_uint() == 0);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(a1.to_ulong() == 0);
#endif // !defined(ASIO_NO_DEPRECATED)
address_v4::bytes_type b1 = {{ 1, 2, 3, 4 }};
address_v4 a2(b1);
ASIO_CHECK(a2.to_bytes()[0] == 1);
ASIO_CHECK(a2.to_bytes()[1] == 2);
ASIO_CHECK(a2.to_bytes()[2] == 3);
ASIO_CHECK(a2.to_bytes()[3] == 4);
ASIO_CHECK(((a2.to_uint() >> 24) & 0xFF) == b1[0]);
ASIO_CHECK(((a2.to_uint() >> 16) & 0xFF) == b1[1]);
ASIO_CHECK(((a2.to_uint() >> 8) & 0xFF) == b1[2]);
ASIO_CHECK((a2.to_uint() & 0xFF) == b1[3]);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(((a2.to_ulong() >> 24) & 0xFF) == b1[0]);
ASIO_CHECK(((a2.to_ulong() >> 16) & 0xFF) == b1[1]);
ASIO_CHECK(((a2.to_ulong() >> 8) & 0xFF) == b1[2]);
ASIO_CHECK((a2.to_ulong() & 0xFF) == b1[3]);
#endif // !defined(ASIO_NO_DEPRECATED)
address_v4 a3(0x01020304);
ASIO_CHECK(a3.to_bytes()[0] == 1);
ASIO_CHECK(a3.to_bytes()[1] == 2);
ASIO_CHECK(a3.to_bytes()[2] == 3);
ASIO_CHECK(a3.to_bytes()[3] == 4);
ASIO_CHECK(a3.to_uint() == 0x01020304);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(a3.to_ulong() == 0x01020304);
#endif // !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(address_v4(0x7F000001).is_loopback());
ASIO_CHECK(address_v4(0x7F000002).is_loopback());
ASIO_CHECK(!address_v4(0x00000000).is_loopback());
ASIO_CHECK(!address_v4(0x01020304).is_loopback());
ASIO_CHECK(address_v4(0x00000000).is_unspecified());
ASIO_CHECK(!address_v4(0x7F000001).is_unspecified());
ASIO_CHECK(!address_v4(0x01020304).is_unspecified());
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(address_v4(0x01000000).is_class_a());
ASIO_CHECK(address_v4(0x7F000000).is_class_a());
ASIO_CHECK(!address_v4(0x80000000).is_class_a());
ASIO_CHECK(!address_v4(0xBFFF0000).is_class_a());
ASIO_CHECK(!address_v4(0xC0000000).is_class_a());
ASIO_CHECK(!address_v4(0xDFFFFF00).is_class_a());
ASIO_CHECK(!address_v4(0xE0000000).is_class_a());
ASIO_CHECK(!address_v4(0xEFFFFFFF).is_class_a());
ASIO_CHECK(!address_v4(0xF0000000).is_class_a());
ASIO_CHECK(!address_v4(0xFFFFFFFF).is_class_a());
ASIO_CHECK(!address_v4(0x01000000).is_class_b());
ASIO_CHECK(!address_v4(0x7F000000).is_class_b());
ASIO_CHECK(address_v4(0x80000000).is_class_b());
ASIO_CHECK(address_v4(0xBFFF0000).is_class_b());
ASIO_CHECK(!address_v4(0xC0000000).is_class_b());
ASIO_CHECK(!address_v4(0xDFFFFF00).is_class_b());
ASIO_CHECK(!address_v4(0xE0000000).is_class_b());
ASIO_CHECK(!address_v4(0xEFFFFFFF).is_class_b());
ASIO_CHECK(!address_v4(0xF0000000).is_class_b());
ASIO_CHECK(!address_v4(0xFFFFFFFF).is_class_b());
ASIO_CHECK(!address_v4(0x01000000).is_class_c());
ASIO_CHECK(!address_v4(0x7F000000).is_class_c());
ASIO_CHECK(!address_v4(0x80000000).is_class_c());
ASIO_CHECK(!address_v4(0xBFFF0000).is_class_c());
ASIO_CHECK(address_v4(0xC0000000).is_class_c());
ASIO_CHECK(address_v4(0xDFFFFF00).is_class_c());
ASIO_CHECK(!address_v4(0xE0000000).is_class_c());
ASIO_CHECK(!address_v4(0xEFFFFFFF).is_class_c());
ASIO_CHECK(!address_v4(0xF0000000).is_class_c());
ASIO_CHECK(!address_v4(0xFFFFFFFF).is_class_c());
#endif // !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(!address_v4(0x01000000).is_multicast());
ASIO_CHECK(!address_v4(0x7F000000).is_multicast());
ASIO_CHECK(!address_v4(0x80000000).is_multicast());
ASIO_CHECK(!address_v4(0xBFFF0000).is_multicast());
ASIO_CHECK(!address_v4(0xC0000000).is_multicast());
ASIO_CHECK(!address_v4(0xDFFFFF00).is_multicast());
ASIO_CHECK(address_v4(0xE0000000).is_multicast());
ASIO_CHECK(address_v4(0xEFFFFFFF).is_multicast());
ASIO_CHECK(!address_v4(0xF0000000).is_multicast());
ASIO_CHECK(!address_v4(0xFFFFFFFF).is_multicast());
address_v4 a4 = address_v4::any();
ASIO_CHECK(a4.to_bytes()[0] == 0);
ASIO_CHECK(a4.to_bytes()[1] == 0);
ASIO_CHECK(a4.to_bytes()[2] == 0);
ASIO_CHECK(a4.to_bytes()[3] == 0);
ASIO_CHECK(a4.to_uint() == 0);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(a4.to_ulong() == 0);
#endif // !defined(ASIO_NO_DEPRECATED)
address_v4 a5 = address_v4::loopback();
ASIO_CHECK(a5.to_bytes()[0] == 0x7F);
ASIO_CHECK(a5.to_bytes()[1] == 0);
ASIO_CHECK(a5.to_bytes()[2] == 0);
ASIO_CHECK(a5.to_bytes()[3] == 0x01);
ASIO_CHECK(a5.to_uint() == 0x7F000001);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(a5.to_ulong() == 0x7F000001);
#endif // !defined(ASIO_NO_DEPRECATED)
address_v4 a6 = address_v4::broadcast();
ASIO_CHECK(a6.to_bytes()[0] == 0xFF);
ASIO_CHECK(a6.to_bytes()[1] == 0xFF);
ASIO_CHECK(a6.to_bytes()[2] == 0xFF);
ASIO_CHECK(a6.to_bytes()[3] == 0xFF);
ASIO_CHECK(a6.to_uint() == 0xFFFFFFFF);
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(a6.to_ulong() == 0xFFFFFFFF);
#endif // !defined(ASIO_NO_DEPRECATED)
#if !defined(ASIO_NO_DEPRECATED)
address_v4 class_a_net(0xFF000000);
address_v4 class_b_net(0xFFFF0000);
address_v4 class_c_net(0xFFFFFF00);
address_v4 other_net(0xFFFFFFFF);
ASIO_CHECK(address_v4::netmask(address_v4(0x01000000)) == class_a_net);
ASIO_CHECK(address_v4::netmask(address_v4(0x7F000000)) == class_a_net);
ASIO_CHECK(address_v4::netmask(address_v4(0x80000000)) == class_b_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xBFFF0000)) == class_b_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xC0000000)) == class_c_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xDFFFFF00)) == class_c_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xE0000000)) == other_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xEFFFFFFF)) == other_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xF0000000)) == other_net);
ASIO_CHECK(address_v4::netmask(address_v4(0xFFFFFFFF)) == other_net);
#endif // !defined(ASIO_NO_DEPRECATED)
}
} // namespace ip_address_v4_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address_v4",
ASIO_COMPILE_TEST_CASE(ip_address_v4_compile::test)
ASIO_TEST_CASE(ip_address_v4_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/basic_endpoint.cpp | //
// basic_endpoint.cpp
// ~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/basic_endpoint.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ip/basic_endpoint",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/address_v6.cpp | //
// address_v6.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/address_v6.hpp"
#include "../unit_test.hpp"
#include <sstream>
//------------------------------------------------------------------------------
// ip_address_v6_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// ip::address_v6 compile and link correctly. Runtime failures are ignored.
namespace ip_address_v6_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
asio::error_code ec;
// address_v6 constructors.
ip::address_v6 addr1;
const ip::address_v6::bytes_type const_bytes_value = { { 0 } };
ip::address_v6 addr2(const_bytes_value);
// address_v6 functions.
unsigned long scope_id = addr1.scope_id();
addr1.scope_id(scope_id);
bool b = addr1.is_unspecified();
(void)b;
b = addr1.is_loopback();
(void)b;
b = addr1.is_multicast();
(void)b;
b = addr1.is_link_local();
(void)b;
b = addr1.is_site_local();
(void)b;
b = addr1.is_v4_mapped();
(void)b;
#if !defined(ASIO_NO_DEPRECATED)
b = addr1.is_v4_compatible();
(void)b;
#endif // !defined(ASIO_NO_DEPRECATED)
b = addr1.is_multicast_node_local();
(void)b;
b = addr1.is_multicast_link_local();
(void)b;
b = addr1.is_multicast_site_local();
(void)b;
b = addr1.is_multicast_org_local();
(void)b;
b = addr1.is_multicast_global();
(void)b;
ip::address_v6::bytes_type bytes_value = addr1.to_bytes();
(void)bytes_value;
std::string string_value = addr1.to_string();
#if !defined(ASIO_NO_DEPRECATED)
string_value = addr1.to_string(ec);
#endif // !defined(ASIO_NO_DEPRECATED)
#if !defined(ASIO_NO_DEPRECATED)
ip::address_v4 addr3 = addr1.to_v4();
#endif // !defined(ASIO_NO_DEPRECATED)
// address_v6 static functions.
#if !defined(ASIO_NO_DEPRECATED)
addr1 = ip::address_v6::from_string("0::0");
addr1 = ip::address_v6::from_string("0::0", ec);
addr1 = ip::address_v6::from_string(string_value);
addr1 = ip::address_v6::from_string(string_value, ec);
#endif // !defined(ASIO_NO_DEPRECATED)
addr1 = ip::address_v6::any();
addr1 = ip::address_v6::loopback();
#if !defined(ASIO_NO_DEPRECATED)
addr1 = ip::address_v6::v4_mapped(addr3);
addr1 = ip::address_v6::v4_compatible(addr3);
#endif // !defined(ASIO_NO_DEPRECATED)
// address_v6 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_v6 creation functions.
addr1 = ip::make_address_v6(const_bytes_value, scope_id);
addr1 = ip::make_address_v6("0::0");
addr1 = ip::make_address_v6("0::0", ec);
addr1 = ip::make_address_v6(string_value);
addr1 = ip::make_address_v6(string_value, ec);
#if defined(ASIO_HAS_STRING_VIEW)
# if defined(ASIO_HAS_STD_STRING_VIEW)
std::string_view string_view_value("0::0");
# else // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
std::experimental::string_view string_view_value("0::0");
# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
addr1 = ip::make_address_v6(string_view_value);
addr1 = ip::make_address_v6(string_view_value, ec);
#endif // defined(ASIO_HAS_STRING_VIEW)
// address_v6 IPv4-mapped conversion.
#if defined(ASIO_NO_DEPRECATED)
ip::address_v4 addr3;
#endif // defined(ASIO_NO_DEPRECATED)
addr1 = ip::make_address_v6(ip::v4_mapped, addr3);
addr3 = ip::make_address_v4(ip::v4_mapped, addr1);
// address_v6 I/O.
std::ostringstream os;
os << addr1;
#if !defined(BOOST_NO_STD_WSTREAMBUF)
std::wostringstream wos;
wos << addr1;
#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
#if defined(ASIO_HAS_STD_HASH)
std::size_t hash1 = std::hash<ip::address_v6>()(addr1);
(void)hash1;
#endif // defined(ASIO_HAS_STD_HASH)
}
catch (std::exception&)
{
}
}
} // namespace ip_address_v6_compile
//------------------------------------------------------------------------------
// ip_address_v6_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that the various public member functions meet the
// necessary postconditions.
namespace ip_address_v6_runtime {
void test()
{
using asio::ip::address_v6;
address_v6 a1;
ASIO_CHECK(a1.is_unspecified());
ASIO_CHECK(a1.scope_id() == 0);
address_v6::bytes_type b1 = {{ 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }};
address_v6 a2(b1, 12345);
ASIO_CHECK(a2.to_bytes()[0] == 1);
ASIO_CHECK(a2.to_bytes()[1] == 2);
ASIO_CHECK(a2.to_bytes()[2] == 3);
ASIO_CHECK(a2.to_bytes()[3] == 4);
ASIO_CHECK(a2.to_bytes()[4] == 5);
ASIO_CHECK(a2.to_bytes()[5] == 6);
ASIO_CHECK(a2.to_bytes()[6] == 7);
ASIO_CHECK(a2.to_bytes()[7] == 8);
ASIO_CHECK(a2.to_bytes()[8] == 9);
ASIO_CHECK(a2.to_bytes()[9] == 10);
ASIO_CHECK(a2.to_bytes()[10] == 11);
ASIO_CHECK(a2.to_bytes()[11] == 12);
ASIO_CHECK(a2.to_bytes()[12] == 13);
ASIO_CHECK(a2.to_bytes()[13] == 14);
ASIO_CHECK(a2.to_bytes()[14] == 15);
ASIO_CHECK(a2.to_bytes()[15] == 16);
ASIO_CHECK(a2.scope_id() == 12345);
address_v6 a3;
a3.scope_id(12345);
ASIO_CHECK(a3.scope_id() == 12345);
address_v6 unspecified_address;
address_v6::bytes_type loopback_bytes = {{ 0 }};
loopback_bytes[15] = 1;
address_v6 loopback_address(loopback_bytes);
address_v6::bytes_type link_local_bytes = {{ 0xFE, 0x80, 1 }};
address_v6 link_local_address(link_local_bytes);
address_v6::bytes_type site_local_bytes = {{ 0xFE, 0xC0, 1 }};
address_v6 site_local_address(site_local_bytes);
address_v6::bytes_type v4_mapped_bytes = {{ 0 }};
v4_mapped_bytes[10] = 0xFF, v4_mapped_bytes[11] = 0xFF;
v4_mapped_bytes[12] = 1, v4_mapped_bytes[13] = 2;
v4_mapped_bytes[14] = 3, v4_mapped_bytes[15] = 4;
address_v6 v4_mapped_address(v4_mapped_bytes);
address_v6::bytes_type v4_compat_bytes = {{ 0 }};
v4_compat_bytes[12] = 1, v4_compat_bytes[13] = 2;
v4_compat_bytes[14] = 3, v4_compat_bytes[15] = 4;
address_v6 v4_compat_address(v4_compat_bytes);
address_v6::bytes_type mcast_global_bytes = {{ 0xFF, 0x0E, 1 }};
address_v6 mcast_global_address(mcast_global_bytes);
address_v6::bytes_type mcast_link_local_bytes = {{ 0xFF, 0x02, 1 }};
address_v6 mcast_link_local_address(mcast_link_local_bytes);
address_v6::bytes_type mcast_node_local_bytes = {{ 0xFF, 0x01, 1 }};
address_v6 mcast_node_local_address(mcast_node_local_bytes);
address_v6::bytes_type mcast_org_local_bytes = {{ 0xFF, 0x08, 1 }};
address_v6 mcast_org_local_address(mcast_org_local_bytes);
address_v6::bytes_type mcast_site_local_bytes = {{ 0xFF, 0x05, 1 }};
address_v6 mcast_site_local_address(mcast_site_local_bytes);
ASIO_CHECK(!unspecified_address.is_loopback());
ASIO_CHECK(loopback_address.is_loopback());
ASIO_CHECK(!link_local_address.is_loopback());
ASIO_CHECK(!site_local_address.is_loopback());
ASIO_CHECK(!v4_mapped_address.is_loopback());
ASIO_CHECK(!v4_compat_address.is_loopback());
ASIO_CHECK(!mcast_global_address.is_loopback());
ASIO_CHECK(!mcast_link_local_address.is_loopback());
ASIO_CHECK(!mcast_node_local_address.is_loopback());
ASIO_CHECK(!mcast_org_local_address.is_loopback());
ASIO_CHECK(!mcast_site_local_address.is_loopback());
ASIO_CHECK(unspecified_address.is_unspecified());
ASIO_CHECK(!loopback_address.is_unspecified());
ASIO_CHECK(!link_local_address.is_unspecified());
ASIO_CHECK(!site_local_address.is_unspecified());
ASIO_CHECK(!v4_mapped_address.is_unspecified());
ASIO_CHECK(!v4_compat_address.is_unspecified());
ASIO_CHECK(!mcast_global_address.is_unspecified());
ASIO_CHECK(!mcast_link_local_address.is_unspecified());
ASIO_CHECK(!mcast_node_local_address.is_unspecified());
ASIO_CHECK(!mcast_org_local_address.is_unspecified());
ASIO_CHECK(!mcast_site_local_address.is_unspecified());
ASIO_CHECK(!unspecified_address.is_link_local());
ASIO_CHECK(!loopback_address.is_link_local());
ASIO_CHECK(link_local_address.is_link_local());
ASIO_CHECK(!site_local_address.is_link_local());
ASIO_CHECK(!v4_mapped_address.is_link_local());
ASIO_CHECK(!v4_compat_address.is_link_local());
ASIO_CHECK(!mcast_global_address.is_link_local());
ASIO_CHECK(!mcast_link_local_address.is_link_local());
ASIO_CHECK(!mcast_node_local_address.is_link_local());
ASIO_CHECK(!mcast_org_local_address.is_link_local());
ASIO_CHECK(!mcast_site_local_address.is_link_local());
ASIO_CHECK(!unspecified_address.is_site_local());
ASIO_CHECK(!loopback_address.is_site_local());
ASIO_CHECK(!link_local_address.is_site_local());
ASIO_CHECK(site_local_address.is_site_local());
ASIO_CHECK(!v4_mapped_address.is_site_local());
ASIO_CHECK(!v4_compat_address.is_site_local());
ASIO_CHECK(!mcast_global_address.is_site_local());
ASIO_CHECK(!mcast_link_local_address.is_site_local());
ASIO_CHECK(!mcast_node_local_address.is_site_local());
ASIO_CHECK(!mcast_org_local_address.is_site_local());
ASIO_CHECK(!mcast_site_local_address.is_site_local());
ASIO_CHECK(!unspecified_address.is_v4_mapped());
ASIO_CHECK(!loopback_address.is_v4_mapped());
ASIO_CHECK(!link_local_address.is_v4_mapped());
ASIO_CHECK(!site_local_address.is_v4_mapped());
ASIO_CHECK(v4_mapped_address.is_v4_mapped());
ASIO_CHECK(!v4_compat_address.is_v4_mapped());
ASIO_CHECK(!mcast_global_address.is_v4_mapped());
ASIO_CHECK(!mcast_link_local_address.is_v4_mapped());
ASIO_CHECK(!mcast_node_local_address.is_v4_mapped());
ASIO_CHECK(!mcast_org_local_address.is_v4_mapped());
ASIO_CHECK(!mcast_site_local_address.is_v4_mapped());
#if !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(!unspecified_address.is_v4_compatible());
ASIO_CHECK(!loopback_address.is_v4_compatible());
ASIO_CHECK(!link_local_address.is_v4_compatible());
ASIO_CHECK(!site_local_address.is_v4_compatible());
ASIO_CHECK(!v4_mapped_address.is_v4_compatible());
ASIO_CHECK(v4_compat_address.is_v4_compatible());
ASIO_CHECK(!mcast_global_address.is_v4_compatible());
ASIO_CHECK(!mcast_link_local_address.is_v4_compatible());
ASIO_CHECK(!mcast_node_local_address.is_v4_compatible());
ASIO_CHECK(!mcast_org_local_address.is_v4_compatible());
ASIO_CHECK(!mcast_site_local_address.is_v4_compatible());
#endif // !defined(ASIO_NO_DEPRECATED)
ASIO_CHECK(!unspecified_address.is_multicast());
ASIO_CHECK(!loopback_address.is_multicast());
ASIO_CHECK(!link_local_address.is_multicast());
ASIO_CHECK(!site_local_address.is_multicast());
ASIO_CHECK(!v4_mapped_address.is_multicast());
ASIO_CHECK(!v4_compat_address.is_multicast());
ASIO_CHECK(mcast_global_address.is_multicast());
ASIO_CHECK(mcast_link_local_address.is_multicast());
ASIO_CHECK(mcast_node_local_address.is_multicast());
ASIO_CHECK(mcast_org_local_address.is_multicast());
ASIO_CHECK(mcast_site_local_address.is_multicast());
ASIO_CHECK(!unspecified_address.is_multicast_global());
ASIO_CHECK(!loopback_address.is_multicast_global());
ASIO_CHECK(!link_local_address.is_multicast_global());
ASIO_CHECK(!site_local_address.is_multicast_global());
ASIO_CHECK(!v4_mapped_address.is_multicast_global());
ASIO_CHECK(!v4_compat_address.is_multicast_global());
ASIO_CHECK(mcast_global_address.is_multicast_global());
ASIO_CHECK(!mcast_link_local_address.is_multicast_global());
ASIO_CHECK(!mcast_node_local_address.is_multicast_global());
ASIO_CHECK(!mcast_org_local_address.is_multicast_global());
ASIO_CHECK(!mcast_site_local_address.is_multicast_global());
ASIO_CHECK(!unspecified_address.is_multicast_link_local());
ASIO_CHECK(!loopback_address.is_multicast_link_local());
ASIO_CHECK(!link_local_address.is_multicast_link_local());
ASIO_CHECK(!site_local_address.is_multicast_link_local());
ASIO_CHECK(!v4_mapped_address.is_multicast_link_local());
ASIO_CHECK(!v4_compat_address.is_multicast_link_local());
ASIO_CHECK(!mcast_global_address.is_multicast_link_local());
ASIO_CHECK(mcast_link_local_address.is_multicast_link_local());
ASIO_CHECK(!mcast_node_local_address.is_multicast_link_local());
ASIO_CHECK(!mcast_org_local_address.is_multicast_link_local());
ASIO_CHECK(!mcast_site_local_address.is_multicast_link_local());
ASIO_CHECK(!unspecified_address.is_multicast_node_local());
ASIO_CHECK(!loopback_address.is_multicast_node_local());
ASIO_CHECK(!link_local_address.is_multicast_node_local());
ASIO_CHECK(!site_local_address.is_multicast_node_local());
ASIO_CHECK(!v4_mapped_address.is_multicast_node_local());
ASIO_CHECK(!v4_compat_address.is_multicast_node_local());
ASIO_CHECK(!mcast_global_address.is_multicast_node_local());
ASIO_CHECK(!mcast_link_local_address.is_multicast_node_local());
ASIO_CHECK(mcast_node_local_address.is_multicast_node_local());
ASIO_CHECK(!mcast_org_local_address.is_multicast_node_local());
ASIO_CHECK(!mcast_site_local_address.is_multicast_node_local());
ASIO_CHECK(!unspecified_address.is_multicast_org_local());
ASIO_CHECK(!loopback_address.is_multicast_org_local());
ASIO_CHECK(!link_local_address.is_multicast_org_local());
ASIO_CHECK(!site_local_address.is_multicast_org_local());
ASIO_CHECK(!v4_mapped_address.is_multicast_org_local());
ASIO_CHECK(!v4_compat_address.is_multicast_org_local());
ASIO_CHECK(!mcast_global_address.is_multicast_org_local());
ASIO_CHECK(!mcast_link_local_address.is_multicast_org_local());
ASIO_CHECK(!mcast_node_local_address.is_multicast_org_local());
ASIO_CHECK(mcast_org_local_address.is_multicast_org_local());
ASIO_CHECK(!mcast_site_local_address.is_multicast_org_local());
ASIO_CHECK(!unspecified_address.is_multicast_site_local());
ASIO_CHECK(!loopback_address.is_multicast_site_local());
ASIO_CHECK(!link_local_address.is_multicast_site_local());
ASIO_CHECK(!site_local_address.is_multicast_site_local());
ASIO_CHECK(!v4_mapped_address.is_multicast_site_local());
ASIO_CHECK(!v4_compat_address.is_multicast_site_local());
ASIO_CHECK(!mcast_global_address.is_multicast_site_local());
ASIO_CHECK(!mcast_link_local_address.is_multicast_site_local());
ASIO_CHECK(!mcast_node_local_address.is_multicast_site_local());
ASIO_CHECK(!mcast_org_local_address.is_multicast_site_local());
ASIO_CHECK(mcast_site_local_address.is_multicast_site_local());
ASIO_CHECK(address_v6::loopback().is_loopback());
}
} // namespace ip_address_v6_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/address_v6",
ASIO_COMPILE_TEST_CASE(ip_address_v6_compile::test)
ASIO_TEST_CASE(ip_address_v6_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/basic_resolver_query.cpp | //
// basic_resolver_query.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/basic_resolver_query.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ip/basic_resolver_query",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/unicast.cpp | //
// unicast.cpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/unicast.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/udp.hpp"
#include "../unit_test.hpp"
//------------------------------------------------------------------------------
// ip_unicast_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all nested classes, enums and constants in
// ip::unicast compile and link correctly. Runtime failures are ignored.
namespace ip_unicast_compile {
void test()
{
using namespace asio;
namespace ip = asio::ip;
try
{
io_context ioc;
ip::udp::socket sock(ioc);
// hops class.
ip::unicast::hops hops1(1024);
sock.set_option(hops1);
ip::unicast::hops hops2;
sock.get_option(hops2);
hops1 = 1;
(void)static_cast<int>(hops1.value());
}
catch (std::exception&)
{
}
}
} // namespace ip_unicast_compile
//------------------------------------------------------------------------------
// ip_unicast_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks the runtime operation of the socket options defined
// in the ip::unicast namespace.
namespace ip_unicast_runtime {
void test()
{
using namespace asio;
namespace ip = asio::ip;
io_context ioc;
asio::error_code ec;
ip::udp::endpoint ep_v4(ip::address_v4::loopback(), 0);
ip::udp::socket sock_v4(ioc);
sock_v4.open(ep_v4.protocol(), ec);
sock_v4.bind(ep_v4, ec);
bool have_v4 = !ec;
ip::udp::endpoint ep_v6(ip::address_v6::loopback(), 0);
ip::udp::socket sock_v6(ioc);
sock_v6.open(ep_v6.protocol(), ec);
sock_v6.bind(ep_v6, ec);
bool have_v6 = !ec;
ASIO_CHECK(have_v4 || have_v6);
// hops class.
if (have_v4)
{
ip::unicast::hops hops1(1);
ASIO_CHECK(hops1.value() == 1);
sock_v4.set_option(hops1, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!ec);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ip::unicast::hops hops2;
sock_v4.get_option(hops2, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!ec);
ASIO_CHECK(hops2.value() == 1);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ip::unicast::hops hops3(255);
ASIO_CHECK(hops3.value() == 255);
sock_v4.set_option(hops3, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!ec);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ip::unicast::hops hops4;
sock_v4.get_option(hops4, ec);
#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
// Option is not supported under Windows CE.
ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
ec.value() << ", " << ec.message());
#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
ASIO_CHECK(!ec);
ASIO_CHECK(hops4.value() == 255);
#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
}
if (have_v6)
{
ip::unicast::hops hops1(1);
ASIO_CHECK(hops1.value() == 1);
sock_v6.set_option(hops1, ec);
ASIO_CHECK(!ec);
ip::unicast::hops hops2;
sock_v6.get_option(hops2, ec);
ASIO_CHECK(!ec);
ASIO_CHECK(hops2.value() == 1);
ip::unicast::hops hops3(255);
ASIO_CHECK(hops3.value() == 255);
sock_v6.set_option(hops3, ec);
ASIO_CHECK(!ec);
ip::unicast::hops hops4;
sock_v6.get_option(hops4, ec);
ASIO_CHECK(!ec);
ASIO_CHECK(hops4.value() == 255);
}
}
} // namespace ip_unicast_runtime
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"ip/unicast",
ASIO_COMPILE_TEST_CASE(ip_unicast_compile::test)
ASIO_TEST_CASE(ip_unicast_runtime::test)
)
|
0 | repos/asio/asio/src/tests/unit | repos/asio/asio/src/tests/unit/ip/basic_resolver.cpp | //
// basic_resolver.cpp
// ~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 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 "asio/ip/basic_resolver.hpp"
#include "../unit_test.hpp"
ASIO_TEST_SUITE
(
"ip/basic_resolver",
ASIO_TEST_CASE(null_test)
)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.