1 // { dg-do run }
2 // { dg-options "-pthread"  }
3 // { dg-require-effective-target c++11 }
4 // { dg-require-effective-target pthread }
5 // { dg-require-cstdint "" }
6 // { dg-require-gthreads "" }
7 
8 // Copyright (C) 2009-2018 Free Software Foundation, Inc.
9 //
10 // This file is part of the GNU ISO C++ Library.  This library is free
11 // software; you can redistribute it and/or modify it under the
12 // terms of the GNU General Public License as published by the
13 // Free Software Foundation; either version 3, or (at your option)
14 // any later version.
15 
16 // This library is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 // GNU General Public License for more details.
20 
21 // You should have received a copy of the GNU General Public License along
22 // with this library; see the file COPYING3.  If not see
23 // <http://www.gnu.org/licenses/>.
24 
25 // Test that promise::set_value throws when required.
26 
27 #include <future>
28 #include <testsuite_hooks.h>
29 
30 // Check for promise_already_satisfied error conditions.
31 
test01()32 void test01()
33 {
34   bool test = false;
35 
36   std::promise<int> p1;
37   std::future<int> f1 = p1.get_future();
38 
39   p1.set_value(1);
40 
41   try
42   {
43     p1.set_value(2);
44     VERIFY( false );
45   }
46   catch (std::future_error& e)
47   {
48     VERIFY(e.code() ==
49         std::make_error_code(std::future_errc::promise_already_satisfied));
50     test = true;
51   }
52 
53   std::chrono::milliseconds delay(1);
54   VERIFY( f1.wait_for(delay) == std::future_status::ready );
55   VERIFY( f1.get() == 1 );
56   VERIFY( test );
57 }
58 
test02()59 void test02()
60 {
61   bool test = false;
62 
63   std::promise<int> p1;
64   std::future<int> f1 = p1.get_future();
65 
66   p1.set_value(3);
67 
68   try
69   {
70     p1.set_exception(std::make_exception_ptr(4));
71     VERIFY( false );
72   }
73   catch (std::future_error& e)
74   {
75     VERIFY(e.code() ==
76         std::make_error_code(std::future_errc::promise_already_satisfied));
77     test = true;
78   }
79 
80   std::chrono::milliseconds delay(1);
81   VERIFY( f1.wait_for(delay) == std::future_status::ready );
82   VERIFY( f1.get() == 3 );
83   VERIFY( test );
84 }
85 
test03()86 void test03()
87 {
88   bool test = false;
89 
90   std::promise<int> p1;
91   std::future<int> f1 = p1.get_future();
92 
93   p1.set_exception(std::make_exception_ptr(4));
94 
95   try
96   {
97     p1.set_value(3);
98     VERIFY( false );
99   }
100   catch (std::future_error& e)
101   {
102     VERIFY(e.code() ==
103         std::make_error_code(std::future_errc::promise_already_satisfied));
104     test = true;
105   }
106 
107   std::chrono::milliseconds delay(1);
108   VERIFY( f1.wait_for(delay) == std::future_status::ready );
109   test = false;
110   try
111   {
112     f1.get();
113     VERIFY( false );
114   }
115   catch (int e)
116   {
117     VERIFY(e == 4 );
118     test = true;
119   }
120 
121   VERIFY( test );
122 }
123 
test04()124 void test04()
125 {
126   bool test = false;
127 
128   std::promise<int&> p1;
129   std::future<int&> f1 = p1.get_future();
130 
131   int i = 1;
132   p1.set_value(i);
133 
134   try
135   {
136     p1.set_value(i);
137     VERIFY( false );
138   }
139   catch (std::future_error& e)
140   {
141     VERIFY(e.code() ==
142         std::make_error_code(std::future_errc::promise_already_satisfied));
143     test = true;
144   }
145 
146   std::chrono::milliseconds delay(1);
147   VERIFY( f1.wait_for(delay) == std::future_status::ready );
148   VERIFY( f1.get() == 1 );
149   VERIFY( test );
150 }
151 
test05()152 void test05()
153 {
154   bool test = false;
155 
156   std::promise<int&> p1;
157   std::future<int&> f1 = p1.get_future();
158 
159   int i = 3;
160   p1.set_value(i);
161 
162   try
163   {
164     p1.set_exception(std::make_exception_ptr(4));
165     VERIFY( false );
166   }
167   catch (std::future_error& e)
168   {
169     VERIFY(e.code() ==
170         std::make_error_code(std::future_errc::promise_already_satisfied));
171     test = true;
172   }
173 
174   std::chrono::milliseconds delay(1);
175   VERIFY( f1.wait_for(delay) == std::future_status::ready );
176   VERIFY( f1.get() == 3 );
177   VERIFY( test );
178 }
179 
test06()180 void test06()
181 {
182   bool test = false;
183 
184   std::promise<int&> p1;
185   std::future<int&> f1 = p1.get_future();
186 
187   p1.set_exception(std::make_exception_ptr(4));
188 
189   try
190   {
191     int i = 3;
192     p1.set_value(i);
193     VERIFY( false );
194   }
195   catch (std::future_error& e)
196   {
197     VERIFY(e.code() ==
198         std::make_error_code(std::future_errc::promise_already_satisfied));
199     test = true;
200   }
201 
202   std::chrono::milliseconds delay(1);
203   VERIFY( f1.wait_for(delay) == std::future_status::ready );
204   test = false;
205   try
206   {
207     f1.get();
208     VERIFY( false );
209   }
210   catch (int e)
211   {
212     VERIFY(e == 4 );
213     test = true;
214   }
215 
216   VERIFY( test );
217 }
218 
test07()219 void test07()
220 {
221   bool test = false;
222 
223   std::promise<void> p1;
224   std::future<void> f1 = p1.get_future();
225 
226   p1.set_value();
227 
228   try
229   {
230     p1.set_value();
231     VERIFY( false );
232   }
233   catch (std::future_error& e)
234   {
235     VERIFY(e.code() ==
236         std::make_error_code(std::future_errc::promise_already_satisfied));
237     test = true;
238   }
239 
240   std::chrono::milliseconds delay(1);
241   VERIFY( f1.wait_for(delay) == std::future_status::ready );
242   f1.get();
243   VERIFY( test );
244 }
245 
test08()246 void test08()
247 {
248   bool test = false;
249 
250   std::promise<void> p1;
251   std::future<void> f1 = p1.get_future();
252 
253   p1.set_value();
254 
255   try
256   {
257     p1.set_exception(std::make_exception_ptr(4));
258     VERIFY( false );
259   }
260   catch (std::future_error& e)
261   {
262     VERIFY(e.code() ==
263         std::make_error_code(std::future_errc::promise_already_satisfied));
264     test = true;
265   }
266 
267   std::chrono::milliseconds delay(1);
268   VERIFY( f1.wait_for(delay) == std::future_status::ready );
269   f1.get();
270   VERIFY( test );
271 }
272 
test09()273 void test09()
274 {
275   bool test = false;
276 
277   std::promise<void> p1;
278   std::future<void> f1 = p1.get_future();
279 
280   p1.set_exception(std::make_exception_ptr(4));
281 
282   try
283   {
284     p1.set_value();
285     VERIFY( false );
286   }
287   catch (std::future_error& e)
288   {
289     VERIFY(e.code() ==
290         std::make_error_code(std::future_errc::promise_already_satisfied));
291     test = true;
292   }
293 
294   std::chrono::milliseconds delay(1);
295   VERIFY( f1.wait_for(delay) == std::future_status::ready );
296   test = false;
297   try
298   {
299     f1.get();
300     VERIFY( false );
301   }
302   catch (int e)
303   {
304     VERIFY(e == 4 );
305     test = true;
306   }
307 
308   VERIFY( test );
309 }
310 
311 // Check for no_state error condition (PR libstdc++/80316)
312 
test10()313 void test10()
314 {
315   using namespace std;
316 
317   promise<int> p1;
318   promise<int> p2(std::move(p1));
319   try
320   {
321     p1.set_value(1);
322     VERIFY( false );
323   }
324   catch (std::future_error& e)
325   {
326     VERIFY(e.code() == make_error_code(future_errc::no_state));
327   }
328 }
329 
test11()330 void test11()
331 {
332   using namespace std;
333 
334   promise<int&> p1;
335   promise<int&> p2(std::move(p1));
336   try
337   {
338     int i = 0;
339     p1.set_value(i);
340     VERIFY( false );
341   }
342   catch (std::future_error& e)
343   {
344     VERIFY(e.code() == make_error_code(future_errc::no_state));
345   }
346 }
347 
test12()348 void test12()
349 {
350   using namespace std;
351 
352   promise<void> p1;
353   promise<void> p2(std::move(p1));
354   try
355   {
356     p1.set_value();
357     VERIFY( false );
358   }
359   catch (std::future_error& e)
360   {
361     VERIFY(e.code() == make_error_code(future_errc::no_state));
362   }
363 }
364 
main()365 int main()
366 {
367   test01();
368   test02();
369   test03();
370   test04();
371   test05();
372   test06();
373   test07();
374   test08();
375   test09();
376   test10();
377   test11();
378   test12();
379   return 0;
380 }
381