//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads
// UNSUPPORTED: c++03
// ALLOW_RETRIES: 3
// <future>
// template <class F, class... Args>
// future<typename result_of<F(Args...)>::type>
// async(F&& f, Args&&... args);
// template <class F, class... Args>
// future<typename result_of<F(Args...)>::type>
// async(launch policy, F&& f, Args&&... args);
#include <atomic>
#include <cassert>
#include <chrono>
#include <future>
#include <memory>
#include "test_macros.h"
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::milliseconds ms;
std::atomic_bool invoked{false};
int f0()
{
invoked = true;
std::this_thread::sleep_for(ms(200));
return 3;
}
int i = 0;
int& f1()
{
invoked = true;
std::this_thread::sleep_for(ms(200));
return i;
}
void f2()
{
invoked = true;
std::this_thread::sleep_for(ms(200));
}
std::unique_ptr<int> f3(int j)
{
invoked = true;
std::this_thread::sleep_for(ms(200));
return std::unique_ptr<int>(new int(j));
}
std::unique_ptr<int> f4(std::unique_ptr<int>&& p)
{
invoked = true;
std::this_thread::sleep_for(ms(200));
return std::move(p);
}
void f5(int j)
{
std::this_thread::sleep_for(ms(200));
((void)j);
TEST_THROW(j);
}
template <class Ret, class CheckLambda, class... Args>
void test(CheckLambda&& getAndCheckFn, bool IsDeferred, Args&&... args) {
// Reset global state.
invoked = false;
// Create the future and wait
std::future<Ret> f = std::async(std::forward<Args>(args)...);
std::this_thread::sleep_for(ms(300));
// Check that deferred async's have not invoked the function.
assert(invoked == !IsDeferred);
// Time the call to f.get() and check that the returned value matches
// what is expected.
Clock::time_point t0 = Clock::now();
assert(getAndCheckFn(f));
Clock::time_point t1 = Clock::now();
// If the async is deferred it should take more than 100ms, otherwise
// it should take less than 100ms.
if (IsDeferred) {
assert(t1 - t0 > ms(100));
} else {
assert(t1 - t0 < ms(100));
}
}
int main(int, char**)
{
// The default launch policy is implementation defined. libc++ defines
// it to be std::launch::async.
bool DefaultPolicyIsDeferred = false;
bool DPID = DefaultPolicyIsDeferred;
std::launch AnyPolicy = std::launch::async | std::launch::deferred;
LIBCPP_ASSERT(AnyPolicy == std::launch::any);
{
auto checkInt = [](std::future<int>& f) { return f.get() == 3; };
test<int>(checkInt, DPID, f0);
test<int>(checkInt, false, std::launch::async, f0);
test<int>(checkInt, true, std::launch::deferred, f0);
test<int>(checkInt, DPID, AnyPolicy, f0);
}
{
auto checkIntRef = [&](std::future<int&>& f) { return &f.get() == &i; };
test<int&>(checkIntRef, DPID, f1);
test<int&>(checkIntRef, false, std::launch::async, f1);
test<int&>(checkIntRef, true, std::launch::deferred, f1);
test<int&>(checkIntRef, DPID, AnyPolicy, f1);
}
{
auto checkVoid = [](std::future<void>& f) { f.get(); return true; };
test<void>(checkVoid, DPID, f2);
test<void>(checkVoid, false, std::launch::async, f2);
test<void>(checkVoid, true, std::launch::deferred, f2);
test<void>(checkVoid, DPID, AnyPolicy, f2);
}
{
using Ret = std::unique_ptr<int>;
auto checkUPtr = [](std::future<Ret>& f) { return *f.get() == 3; };
test<Ret>(checkUPtr, DPID, f3, 3);
test<Ret>(checkUPtr, DPID, f4, std::unique_ptr<int>(new int(3)));
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::future<void> f = std::async(f5, 3);
std::this_thread::sleep_for(ms(300));
try { f.get(); assert (false); } catch ( int ) {}
}
{
std::future<void> f = std::async(std::launch::deferred, f5, 3);
std::this_thread::sleep_for(ms(300));
try { f.get(); assert (false); } catch ( int ) {}
}
#endif
return 0;
}