diff options
Diffstat (limited to '3rdparty/asio/src/tests/unit/use_future.cpp')
-rw-r--r-- | 3rdparty/asio/src/tests/unit/use_future.cpp | 1346 |
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) |