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