summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/src/tests/unit/use_future.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/src/tests/unit/use_future.cpp')
-rw-r--r--3rdparty/asio/src/tests/unit/use_future.cpp1346
1 files changed, 1346 insertions, 0 deletions
diff --git a/3rdparty/asio/src/tests/unit/use_future.cpp b/3rdparty/asio/src/tests/unit/use_future.cpp
new file mode 100644
index 00000000000..bc6e3b859b6
--- /dev/null
+++ b/3rdparty/asio/src/tests/unit/use_future.cpp
@@ -0,0 +1,1346 @@
+//
+// use_future.cpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2016 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/use_future.hpp"
+
+#include <string>
+#include "unit_test.hpp"
+
+#if defined(ASIO_HAS_STD_FUTURE)
+
+#include "archetypes/async_ops.hpp"
+#include "archetypes/deprecated_async_ops.hpp"
+
+void use_future_0_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<void> f;
+
+ f = async_op_0(use_future);
+ try
+ {
+ f.get();
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_0(true, use_future);
+ try
+ {
+ f.get();
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_0(false, use_future);
+ try
+ {
+ f.get();
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_0(true, use_future);
+ try
+ {
+ f.get();
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_0(false, use_future);
+ try
+ {
+ f.get();
+ ASIO_CHECK(false);
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+void use_future_1_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+
+ f = async_op_1(use_future);
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_1(true, use_future);
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_1(false, use_future);
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(false);
+ (void)i;
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_1(true, use_future);
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_1(false, use_future);
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(false);
+ (void)i;
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+void use_future_2_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<std::tuple<int, double>> f;
+
+ f = async_op_2(use_future);
+ try
+ {
+ int i;
+ double d;
+ std::tie(i, d) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_2(true, use_future);
+ try
+ {
+ int i;
+ double d;
+ std::tie(i, d) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_2(false, use_future);
+ try
+ {
+ std::tuple<int, double> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_2(true, use_future);
+ try
+ {
+ int i;
+ double d;
+ std::tie(i, d) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_2(false, use_future);
+ try
+ {
+ std::tuple<int, double> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+void use_future_3_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<std::tuple<int, double, char>> f;
+
+ f = async_op_3(use_future);
+ try
+ {
+ int i;
+ double d;
+ char c;
+ std::tie(i, d, c) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ ASIO_CHECK(c == 'a');
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_3(true, use_future);
+ try
+ {
+ int i;
+ double d;
+ char c;
+ std::tie(i, d, c) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ ASIO_CHECK(c == 'a');
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_3(false, use_future);
+ try
+ {
+ std::tuple<int, double, char> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_3(true, use_future);
+ try
+ {
+ int i;
+ double d;
+ char c;
+ std::tie(i, d, c) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ ASIO_CHECK(c == 'a');
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_3(false, use_future);
+ try
+ {
+ std::tuple<int, double, char> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+int package_0()
+{
+ return 42;
+}
+
+int package_ec_0(asio::error_code ec)
+{
+ return ec ? 0 : 42;
+}
+
+int package_ex_0(std::exception_ptr ex)
+{
+ return ex ? 0 : 42;
+}
+
+void use_future_package_0_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+
+ f = async_op_0(use_future(package_0));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_0(true, use_future(&package_ec_0));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_0(false, use_future(package_ec_0));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_0(true, use_future(package_ex_0));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_0(false, use_future(package_ex_0));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+int package_1(int i)
+{
+ return i;
+}
+
+int package_ec_1(asio::error_code ec, int i)
+{
+ return ec ? 0 : i;
+}
+
+int package_ex_1(std::exception_ptr ex, int i)
+{
+ return ex ? 0 : i;
+}
+
+void use_future_package_1_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+
+ f = async_op_1(use_future(package_1));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_1(true, use_future(package_ec_1));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_1(false, use_future(package_ec_1));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_1(true, use_future(package_ex_1));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_1(false, use_future(package_ex_1));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+int package_2(int i, double)
+{
+ return i;
+}
+
+int package_ec_2(asio::error_code ec, int i, double)
+{
+ return ec ? 0 : i;
+}
+
+int package_ex_2(std::exception_ptr ex, int i, double)
+{
+ return ex ? 0 : i;
+}
+
+void use_future_package_2_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+
+ f = async_op_2(use_future(package_2));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_2(true, use_future(package_ec_2));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_2(false, use_future(package_ec_2));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_2(true, use_future(package_ex_2));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_2(false, use_future(package_ex_2));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+int package_3(int i, double, char)
+{
+ return i;
+}
+
+int package_ec_3(asio::error_code ec, int i, double, char)
+{
+ return ec ? 0 : i;
+}
+
+int package_ex_3(std::exception_ptr ex, int i, double, char)
+{
+ return ex ? 0 : i;
+}
+
+void use_future_package_3_test()
+{
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+
+ f = async_op_3(use_future(package_3));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_3(true, use_future(package_ec_3));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ec_3(false, use_future(package_ec_3));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_3(true, use_future(package_ex_3));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_3(false, use_future(package_ex_3));
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+}
+
+void deprecated_use_future_0_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<void> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_0(ctx, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ f.get();
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_0(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ f.get();
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_0(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ f.get();
+ ASIO_CHECK(false);
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_0(true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ f.get();
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = async_op_ex_0(false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ f.get();
+ ASIO_CHECK(false);
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_1_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_1(ctx, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_1(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_1(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(false);
+ (void)i;
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_1(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_1(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(false);
+ (void)i;
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_2_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<std::tuple<int, double>> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_2(ctx, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i;
+ double d;
+ std::tie(i, d) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_2(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i;
+ double d;
+ std::tie(i, d) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_2(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ std::tuple<int, double> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_2(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i;
+ double d;
+ std::tie(i, d) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_2(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ std::tuple<int, double> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_3_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<std::tuple<int, double, char>> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_3(ctx, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i;
+ double d;
+ char c;
+ std::tie(i, d, c) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ ASIO_CHECK(c == 'a');
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_3(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i;
+ double d;
+ char c;
+ std::tie(i, d, c) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ ASIO_CHECK(c == 'a');
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_3(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ std::tuple<int, double, char> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (asio::system_error& e)
+ {
+ ASIO_CHECK(e.code() == asio::error::operation_aborted);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_3(ctx, true, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i;
+ double d;
+ char c;
+ std::tie(i, d, c) = f.get();
+ ASIO_CHECK(i == 42);
+ ASIO_CHECK(d == 2.0);
+ ASIO_CHECK(c == 'a');
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_3(ctx, false, use_future);
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ std::tuple<int, double, char> t = f.get();
+ ASIO_CHECK(false);
+ (void)t;
+ }
+ catch (std::exception& e)
+ {
+ ASIO_CHECK(e.what() == std::string("blah"));
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_package_0_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_0(ctx, use_future(package_0));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_0(ctx, true, use_future(&package_ec_0));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_0(ctx, false, use_future(package_ec_0));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_0(ctx, true, use_future(package_ex_0));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_0(ctx, false, use_future(package_ex_0));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_package_1_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_1(ctx, use_future(package_1));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_1(ctx, true, use_future(package_ec_1));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_1(ctx, false, use_future(package_ec_1));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_1(ctx, true, use_future(package_ex_1));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_1(ctx, false, use_future(package_ex_1));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_package_2_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_2(ctx, use_future(package_2));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_2(ctx, true, use_future(package_ec_2));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_2(ctx, false, use_future(package_ec_2));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_2(ctx, true, use_future(package_ex_2));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_2(ctx, false, use_future(package_ex_2));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+void deprecated_use_future_package_3_test()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+ using asio::use_future;
+ using namespace archetypes;
+
+ std::future<int> f;
+ asio::io_context ctx;
+
+ f = deprecated_async_op_3(ctx, use_future(package_3));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_3(ctx, true, use_future(package_ec_3));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ec_3(ctx, false, use_future(package_ec_3));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_3(ctx, true, use_future(package_ex_3));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 42);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+
+ f = deprecated_async_op_ex_3(ctx, false, use_future(package_ex_3));
+ ctx.restart();
+ ctx.run();
+ try
+ {
+ int i = f.get();
+ ASIO_CHECK(i == 0);
+ }
+ catch (...)
+ {
+ ASIO_CHECK(false);
+ }
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+ASIO_TEST_SUITE
+(
+ "use_future",
+ ASIO_TEST_CASE(use_future_0_test)
+ ASIO_TEST_CASE(use_future_1_test)
+ ASIO_TEST_CASE(use_future_2_test)
+ ASIO_TEST_CASE(use_future_3_test)
+ ASIO_TEST_CASE(use_future_package_0_test)
+ ASIO_TEST_CASE(use_future_package_1_test)
+ ASIO_TEST_CASE(use_future_package_2_test)
+ ASIO_TEST_CASE(use_future_package_3_test)
+ ASIO_TEST_CASE(deprecated_use_future_0_test)
+ ASIO_TEST_CASE(deprecated_use_future_1_test)
+ ASIO_TEST_CASE(deprecated_use_future_2_test)
+ ASIO_TEST_CASE(deprecated_use_future_3_test)
+ ASIO_TEST_CASE(deprecated_use_future_package_0_test)
+ ASIO_TEST_CASE(deprecated_use_future_package_1_test)
+ ASIO_TEST_CASE(deprecated_use_future_package_2_test)
+ ASIO_TEST_CASE(deprecated_use_future_package_3_test)
+)
+
+#else // defined(ASIO_HAS_STD_FUTURE)
+
+ASIO_TEST_SUITE
+(
+ "use_future",
+ ASIO_TEST_CASE(null_test)
+)
+
+#endif // defined(ASIO_HAS_STD_FUTURE)