| // |
| // use_future.cpp |
| // ~~~~~~~~~~~~~~ |
| // |
| // Copyright (c) 2003-2015 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) |