1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // UNSUPPORTED: libcpp-has-no-threads
10 // UNSUPPORTED: c++03
11
12 // <future>
13
14 // template <class F, class... Args>
15 // future<typename result_of<F(Args...)>::type>
16 // async(F&& f, Args&&... args);
17
18 // template <class F, class... Args>
19 // future<typename result_of<F(Args...)>::type>
20 // async(launch policy, F&& f, Args&&... args);
21
22
23 #include <future>
24 #include <atomic>
25 #include <memory>
26 #include <cassert>
27
28 #include "test_macros.h"
29
30 typedef std::chrono::high_resolution_clock Clock;
31 typedef std::chrono::milliseconds ms;
32
33 std::atomic_bool invoked = ATOMIC_VAR_INIT(false);
34
f0()35 int f0()
36 {
37 invoked = true;
38 std::this_thread::sleep_for(ms(200));
39 return 3;
40 }
41
42 int i = 0;
43
f1()44 int& f1()
45 {
46 invoked = true;
47 std::this_thread::sleep_for(ms(200));
48 return i;
49 }
50
f2()51 void f2()
52 {
53 invoked = true;
54 std::this_thread::sleep_for(ms(200));
55 }
56
f3(int j)57 std::unique_ptr<int> f3(int j)
58 {
59 invoked = true;
60 std::this_thread::sleep_for(ms(200));
61 return std::unique_ptr<int>(new int(j));
62 }
63
f4(std::unique_ptr<int> && p)64 std::unique_ptr<int> f4(std::unique_ptr<int>&& p)
65 {
66 invoked = true;
67 std::this_thread::sleep_for(ms(200));
68 return std::move(p);
69 }
70
f5(int j)71 void f5(int j)
72 {
73 std::this_thread::sleep_for(ms(200));
74 ((void)j);
75 TEST_THROW(j);
76 }
77
78 template <class Ret, class CheckLamdba, class ...Args>
test(CheckLamdba && getAndCheckFn,bool IsDeferred,Args &&...args)79 void test(CheckLamdba&& getAndCheckFn, bool IsDeferred, Args&&... args) {
80 // Reset global state.
81 invoked = false;
82
83 // Create the future and wait
84 std::future<Ret> f = std::async(std::forward<Args>(args)...);
85 std::this_thread::sleep_for(ms(300));
86
87 // Check that deferred async's have not invoked the function.
88 assert(invoked == !IsDeferred);
89
90 // Time the call to f.get() and check that the returned value matches
91 // what is expected.
92 Clock::time_point t0 = Clock::now();
93 assert(getAndCheckFn(f));
94 Clock::time_point t1 = Clock::now();
95
96 // If the async is deferred it should take more than 100ms, otherwise
97 // it should take less than 100ms.
98 if (IsDeferred) {
99 assert(t1-t0 > ms(100));
100 } else {
101 assert(t1-t0 < ms(100));
102 }
103 }
104
main(int,char **)105 int main(int, char**)
106 {
107 // The default launch policy is implementation defined. libc++ defines
108 // it to be std::launch::async.
109 bool DefaultPolicyIsDeferred = false;
110 bool DPID = DefaultPolicyIsDeferred;
111
112 std::launch AnyPolicy = std::launch::async | std::launch::deferred;
113 LIBCPP_ASSERT(AnyPolicy == std::launch::any);
114
115 {
116 auto checkInt = [](std::future<int>& f) { return f.get() == 3; };
117 test<int>(checkInt, DPID, f0);
118 test<int>(checkInt, false, std::launch::async, f0);
119 test<int>(checkInt, true, std::launch::deferred, f0);
120 test<int>(checkInt, DPID, AnyPolicy, f0);
121 }
122 {
123 auto checkIntRef = [&](std::future<int&>& f) { return &f.get() == &i; };
124 test<int&>(checkIntRef, DPID, f1);
125 test<int&>(checkIntRef, false, std::launch::async, f1);
126 test<int&>(checkIntRef, true, std::launch::deferred, f1);
127 test<int&>(checkIntRef, DPID, AnyPolicy, f1);
128 }
129 {
130 auto checkVoid = [](std::future<void>& f) { f.get(); return true; };
131 test<void>(checkVoid, DPID, f2);
132 test<void>(checkVoid, false, std::launch::async, f2);
133 test<void>(checkVoid, true, std::launch::deferred, f2);
134 test<void>(checkVoid, DPID, AnyPolicy, f2);
135 }
136 {
137 using Ret = std::unique_ptr<int>;
138 auto checkUPtr = [](std::future<Ret>& f) { return *f.get() == 3; };
139 test<Ret>(checkUPtr, DPID, f3, 3);
140 test<Ret>(checkUPtr, DPID, f4, std::unique_ptr<int>(new int(3)));
141 }
142 #ifndef TEST_HAS_NO_EXCEPTIONS
143 {
144 std::future<void> f = std::async(f5, 3);
145 std::this_thread::sleep_for(ms(300));
146 try { f.get(); assert (false); } catch ( int ) {}
147 }
148 {
149 std::future<void> f = std::async(std::launch::deferred, f5, 3);
150 std::this_thread::sleep_for(ms(300));
151 try { f.get(); assert (false); } catch ( int ) {}
152 }
153 #endif
154 return 0;
155 }
156