summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/src/tests/unit/connect.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/src/tests/unit/connect.cpp')
-rw-r--r--3rdparty/asio/src/tests/unit/connect.cpp1169
1 files changed, 1167 insertions, 2 deletions
diff --git a/3rdparty/asio/src/tests/unit/connect.cpp b/3rdparty/asio/src/tests/unit/connect.cpp
index 3b0a43248f3..b7306b02abe 100644
--- a/3rdparty/asio/src/tests/unit/connect.cpp
+++ b/3rdparty/asio/src/tests/unit/connect.cpp
@@ -2,7 +2,7 @@
// connect.cpp
// ~~~~~~~~~~~
//
-// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2021 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)
@@ -16,10 +16,1175 @@
// Test that header file is self-contained.
#include "asio/connect.hpp"
+#include <vector>
+#include "asio/detail/thread.hpp"
+#include "asio/ip/tcp.hpp"
+
+#if defined(ASIO_HAS_BOOST_BIND)
+# include <boost/bind/bind.hpp>
+#else // defined(ASIO_HAS_BOOST_BIND)
+# include <functional>
+#endif // defined(ASIO_HAS_BOOST_BIND)
+
#include "unit_test.hpp"
+#if defined(ASIO_HAS_BOOST_BIND)
+namespace bindns = boost;
+#else // defined(ASIO_HAS_BOOST_BIND)
+namespace bindns = std;
+#endif // defined(ASIO_HAS_BOOST_BIND)
+using bindns::placeholders::_1;
+using bindns::placeholders::_2;
+
+class connection_sink
+{
+public:
+ connection_sink()
+ : acceptor_(io_context_,
+ asio::ip::tcp::endpoint(
+ asio::ip::address_v4::loopback(), 0)),
+ target_endpoint_(acceptor_.local_endpoint()),
+ socket_(io_context_),
+ thread_(bindns::bind(&connection_sink::run, this))
+ {
+ }
+
+ ~connection_sink()
+ {
+ io_context_.stop();
+ thread_.join();
+ }
+
+ asio::ip::tcp::endpoint target_endpoint()
+ {
+ return target_endpoint_;
+ }
+
+private:
+ void run()
+ {
+ io_context_.run();
+ }
+
+ void handle_accept()
+ {
+ socket_.close();
+ acceptor_.async_accept(socket_,
+ bindns::bind(&connection_sink::handle_accept, this));
+ }
+
+ asio::io_context io_context_;
+ asio::ip::tcp::acceptor acceptor_;
+ asio::ip::tcp::endpoint target_endpoint_;
+ asio::ip::tcp::socket socket_;
+ asio::detail::thread thread_;
+};
+
+bool true_cond_1(const asio::error_code& /*ec*/,
+ const asio::ip::tcp::endpoint& /*endpoint*/)
+{
+ return true;
+}
+
+struct true_cond_2
+{
+ template <typename Endpoint>
+ bool operator()(const asio::error_code& /*ec*/,
+ const Endpoint& /*endpoint*/)
+ {
+ return true;
+ }
+};
+
+std::vector<asio::ip::tcp::endpoint>::const_iterator legacy_true_cond_1(
+ const asio::error_code& /*ec*/,
+ std::vector<asio::ip::tcp::endpoint>::const_iterator next)
+{
+ return next;
+}
+
+struct legacy_true_cond_2
+{
+ template <typename Iterator>
+ Iterator operator()(const asio::error_code& /*ec*/, Iterator next)
+ {
+ return next;
+ }
+};
+
+bool false_cond(const asio::error_code& /*ec*/,
+ const asio::ip::tcp::endpoint& /*endpoint*/)
+{
+ return false;
+}
+
+void range_handler(const asio::error_code& ec,
+ const asio::ip::tcp::endpoint& endpoint,
+ asio::error_code* out_ec,
+ asio::ip::tcp::endpoint* out_endpoint)
+{
+ *out_ec = ec;
+ *out_endpoint = endpoint;
+}
+
+void iter_handler(const asio::error_code& ec,
+ std::vector<asio::ip::tcp::endpoint>::const_iterator iter,
+ asio::error_code* out_ec,
+ std::vector<asio::ip::tcp::endpoint>::const_iterator* out_iter)
+{
+ *out_ec = ec;
+ *out_iter = iter;
+}
+
+void test_connect_range()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ asio::ip::tcp::endpoint result;
+
+ try
+ {
+ result = asio::connect(socket, endpoints);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints);
+ ASIO_CHECK(result == endpoints[0]);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints);
+ ASIO_CHECK(result == endpoints[0]);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, endpoints);
+ ASIO_CHECK(result == endpoints[1]);
+}
+
+void test_connect_range_ec()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ asio::ip::tcp::endpoint result;
+ asio::error_code ec;
+
+ result = asio::connect(socket, endpoints, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints, ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints, ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, endpoints, ec);
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+}
+
+void test_connect_range_cond()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ asio::ip::tcp::endpoint result;
+
+ try
+ {
+ result = asio::connect(socket, endpoints, true_cond_1);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, endpoints, true_cond_2());
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, endpoints, legacy_true_cond_1);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, endpoints, legacy_true_cond_2());
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, endpoints, false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints, true_cond_1);
+ ASIO_CHECK(result == endpoints[0]);
+
+ result = asio::connect(socket, endpoints, true_cond_2());
+ ASIO_CHECK(result == endpoints[0]);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1);
+ ASIO_CHECK(result == endpoints[0]);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2());
+ ASIO_CHECK(result == endpoints[0]);
+
+ try
+ {
+ result = asio::connect(socket, endpoints, false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints, true_cond_1);
+ ASIO_CHECK(result == endpoints[0]);
+
+ result = asio::connect(socket, endpoints, true_cond_2());
+ ASIO_CHECK(result == endpoints[0]);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1);
+ ASIO_CHECK(result == endpoints[0]);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2());
+ ASIO_CHECK(result == endpoints[0]);
+
+ try
+ {
+ result = asio::connect(socket, endpoints, false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, endpoints, true_cond_1);
+ ASIO_CHECK(result == endpoints[1]);
+
+ result = asio::connect(socket, endpoints, true_cond_2());
+ ASIO_CHECK(result == endpoints[1]);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1);
+ ASIO_CHECK(result == endpoints[1]);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2());
+ ASIO_CHECK(result == endpoints[1]);
+
+ try
+ {
+ result = asio::connect(socket, endpoints, false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+}
+
+void test_connect_range_cond_ec()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ asio::ip::tcp::endpoint result;
+ asio::error_code ec;
+
+ result = asio::connect(socket, endpoints, true_cond_1, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, endpoints, true_cond_2(), ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, endpoints, false_cond, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints, true_cond_1, ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, true_cond_2(), ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, false_cond, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, endpoints, true_cond_1, ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, true_cond_2(), ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, false_cond, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, endpoints, true_cond_1, ec);
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, true_cond_2(), ec);
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, endpoints, false_cond, ec);
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+}
+
+void test_connect_iter()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
+ std::vector<asio::ip::tcp::endpoint>::const_iterator result;
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
+ ASIO_CHECK(result == cendpoints.begin());
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
+ ASIO_CHECK(result == cendpoints.begin());
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+}
+
+void test_connect_iter_ec()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
+ std::vector<asio::ip::tcp::endpoint>::const_iterator result;
+ asio::error_code ec;
+
+ result = asio::connect(socket,
+ cendpoints.begin(), cendpoints.end(), ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket,
+ cendpoints.begin(), cendpoints.end(), ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket,
+ cendpoints.begin(), cendpoints.end(), ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket,
+ cendpoints.begin(), cendpoints.end(), ec);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+}
+
+void test_connect_iter_cond()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
+ std::vector<asio::ip::tcp::endpoint>::const_iterator result;
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2());
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2());
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1);
+ ASIO_CHECK(result == cendpoints.begin());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2());
+ ASIO_CHECK(result == cendpoints.begin());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1);
+ ASIO_CHECK(result == cendpoints.begin());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2());
+ ASIO_CHECK(result == cendpoints.begin());
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1);
+ ASIO_CHECK(result == cendpoints.begin());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2());
+ ASIO_CHECK(result == cendpoints.begin());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1);
+ ASIO_CHECK(result == cendpoints.begin());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2());
+ ASIO_CHECK(result == cendpoints.begin());
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2());
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2());
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+
+ try
+ {
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond);
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::not_found);
+ }
+}
+
+void test_connect_iter_cond_ec()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
+ std::vector<asio::ip::tcp::endpoint>::const_iterator result;
+ asio::error_code ec;
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond, ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond, ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond, ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_1, ec);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), legacy_true_cond_2(), ec);
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ result = asio::connect(socket, cendpoints.begin(),
+ cendpoints.end(), false_cond, ec);
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+}
+
+void test_async_connect_range()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ asio::ip::tcp::endpoint result;
+ asio::error_code ec;
+
+ asio::async_connect(socket, endpoints,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, endpoints,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, endpoints,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ asio::async_connect(socket, endpoints,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+}
+
+void test_async_connect_range_cond()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ asio::ip::tcp::endpoint result;
+ asio::error_code ec;
+
+ asio::async_connect(socket, endpoints, true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, endpoints, true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, endpoints, false_cond,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, endpoints, true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, false_cond,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, endpoints, true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[0]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, false_cond,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ asio::async_connect(socket, endpoints, true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_1,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, legacy_true_cond_2(),
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == endpoints[1]);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, endpoints, false_cond,
+ bindns::bind(range_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == asio::ip::tcp::endpoint());
+ ASIO_CHECK(ec == asio::error::not_found);
+}
+
+void test_async_connect_iter()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
+ std::vector<asio::ip::tcp::endpoint>::const_iterator result;
+ asio::error_code ec;
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+}
+
+void test_async_connect_iter_cond()
+{
+ connection_sink sink;
+ asio::io_context io_context;
+ asio::ip::tcp::socket socket(io_context);
+ std::vector<asio::ip::tcp::endpoint> endpoints;
+ const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
+ std::vector<asio::ip::tcp::endpoint>::const_iterator result;
+ asio::error_code ec;
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.push_back(sink.target_endpoint());
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin());
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+
+ endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.begin() + 1);
+ ASIO_CHECK(!ec);
+
+ asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
+ false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
+ io_context.restart();
+ io_context.run();
+ ASIO_CHECK(result == cendpoints.end());
+ ASIO_CHECK(ec == asio::error::not_found);
+}
+
ASIO_TEST_SUITE
(
"connect",
- ASIO_TEST_CASE(null_test)
+ ASIO_TEST_CASE(test_connect_range)
+ ASIO_TEST_CASE(test_connect_range_ec)
+ ASIO_TEST_CASE(test_connect_range_cond)
+ ASIO_TEST_CASE(test_connect_range_cond_ec)
+ ASIO_TEST_CASE(test_connect_iter)
+ ASIO_TEST_CASE(test_connect_iter_ec)
+ ASIO_TEST_CASE(test_connect_iter_cond)
+ ASIO_TEST_CASE(test_connect_iter_cond_ec)
+ ASIO_TEST_CASE(test_async_connect_range)
+ ASIO_TEST_CASE(test_async_connect_range_cond)
+ ASIO_TEST_CASE(test_async_connect_iter)
+ ASIO_TEST_CASE(test_async_connect_iter_cond)
)