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