libstdc++-v3/testsuite/30_threads/promise/members/set_value2.cc

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