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()32void 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()59void 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()86void 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()124void 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()152void 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()180void 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()219void 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()246void 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()273void 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()313void 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()330void 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()348void 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()365int 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