test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp

   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
  12 // <mutex>
  13
  14 // template <class L1, class L2, class... L3>
  15 //   int try_lock(L1&, L2&, L3&...);
  16
  17 #include <mutex>
  18 #include <cassert>
  19
  20 #include "test_macros.h"
  21
  22 class L0
  23 {
  24     bool locked_;
  25
  26 public:
  27     L0() : locked_(false) {}
  28
  29     bool try_lock()
  30     {
  31         locked_ = true;
  32         return locked_;
  33     }
  34
  35     void unlock() {locked_ = false;}
  36
  37     bool locked() const {return locked_;}
  38 };
  39
  40 class L1
  41 {
  42     bool locked_;
  43
  44 public:
  45     L1() : locked_(false) {}
  46
  47     bool try_lock()
  48     {
  49         locked_ = false;
  50         return locked_;
  51     }
  52
  53     void unlock() {locked_ = false;}
  54
  55     bool locked() const {return locked_;}
  56 };
  57
  58 class L2
  59 {
  60     bool locked_;
  61
  62 public:
  63     L2() : locked_(false) {}
  64
  65     bool try_lock()
  66     {
  67         TEST_THROW(1);
  68         return locked_;
  69     }
  70
  71     void unlock() {locked_ = false;}
  72
  73     bool locked() const {return locked_;}
  74 };
  75
  76 int main()
  77 {
  78     {
  79         L0 l0;
  80         L0 l1;
  81         assert(std::try_lock(l0, l1) == -1);
  82         assert(l0.locked());
  83         assert(l1.locked());
  84     }
  85     {
  86         L0 l0;
  87         L1 l1;
  88         assert(std::try_lock(l0, l1) == 1);
  89         assert(!l0.locked());
  90         assert(!l1.locked());
  91     }
  92     {
  93         L1 l0;
  94         L0 l1;
  95         assert(std::try_lock(l0, l1) == 0);
  96         assert(!l0.locked());
  97         assert(!l1.locked());
  98     }
  99 #ifndef TEST_HAS_NO_EXCEPTIONS
 100     {
 101         L0 l0;
 102         L2 l1;
 103         try
 104         {
 105             std::try_lock(l0, l1);
 106             assert(false);
 107         }
 108         catch (int)
 109         {
 110             assert(!l0.locked());
 111             assert(!l1.locked());
 112         }
 113     }
 114     {
 115         L2 l0;
 116         L0 l1;
 117         try
 118         {
 119             std::try_lock(l0, l1);
 120             assert(false);
 121         }
 122         catch (int)
 123         {
 124             assert(!l0.locked());
 125             assert(!l1.locked());
 126         }
 127     }
 128 #endif
 129 #ifndef _LIBCPP_HAS_NO_VARIADICS
 130     {
 131         L0 l0;
 132         L0 l1;
 133         L0 l2;
 134         assert(std::try_lock(l0, l1, l2) == -1);
 135         assert(l0.locked());
 136         assert(l1.locked());
 137         assert(l2.locked());
 138     }
 139     {
 140         L1 l0;
 141         L1 l1;
 142         L1 l2;
 143         assert(std::try_lock(l0, l1, l2) == 0);
 144         assert(!l0.locked());
 145         assert(!l1.locked());
 146         assert(!l2.locked());
 147     }
 148 #ifndef TEST_HAS_NO_EXCEPTIONS
 149     {
 150         L2 l0;
 151         L2 l1;
 152         L2 l2;
 153         try
 154         {
 155             std::try_lock(l0, l1, l2);
 156             assert(false);
 157         }
 158         catch (int)
 159         {
 160             assert(!l0.locked());
 161             assert(!l1.locked());
 162             assert(!l2.locked());
 163         }
 164     }
 165     {
 166         L0 l0;
 167         L1 l1;
 168         L2 l2;
 169         assert(std::try_lock(l0, l1, l2) == 1);
 170         assert(!l0.locked());
 171         assert(!l1.locked());
 172         assert(!l2.locked());
 173     }
 174 #endif
 175     {
 176         L0 l0;
 177         L0 l1;
 178         L1 l2;
 179         assert(std::try_lock(l0, l1, l2) == 2);
 180         assert(!l0.locked());
 181         assert(!l1.locked());
 182         assert(!l2.locked());
 183     }
 184     {
 185         L0 l0;
 186         L1 l1;
 187         L0 l2;
 188         assert(std::try_lock(l0, l1, l2) == 1);
 189         assert(!l0.locked());
 190         assert(!l1.locked());
 191         assert(!l2.locked());
 192     }
 193     {
 194         L1 l0;
 195         L0 l1;
 196         L0 l2;
 197         assert(std::try_lock(l0, l1, l2) == 0);
 198         assert(!l0.locked());
 199         assert(!l1.locked());
 200         assert(!l2.locked());
 201     }
 202 #ifndef TEST_HAS_NO_EXCEPTIONS
 203     {
 204         L0 l0;
 205         L0 l1;
 206         L2 l2;
 207         try
 208         {
 209             std::try_lock(l0, l1, l2);
 210             assert(false);
 211         }
 212         catch (int)
 213         {
 214             assert(!l0.locked());
 215             assert(!l1.locked());
 216             assert(!l2.locked());
 217         }
 218     }
 219     {
 220         L0 l0;
 221         L2 l1;
 222         L0 l2;
 223         try
 224         {
 225             std::try_lock(l0, l1, l2);
 226             assert(false);
 227         }
 228         catch (int)
 229         {
 230             assert(!l0.locked());
 231             assert(!l1.locked());
 232             assert(!l2.locked());
 233         }
 234     }
 235     {
 236         L2 l0;
 237         L0 l1;
 238         L0 l2;
 239         try
 240         {
 241             std::try_lock(l0, l1, l2);
 242             assert(false);
 243         }
 244         catch (int)
 245         {
 246             assert(!l0.locked());
 247             assert(!l1.locked());
 248             assert(!l2.locked());
 249         }
 250     }
 251 #endif
 252     {
 253         L1 l0;
 254         L1 l1;
 255         L0 l2;
 256         assert(std::try_lock(l0, l1, l2) == 0);
 257         assert(!l0.locked());
 258         assert(!l1.locked());
 259         assert(!l2.locked());
 260     }
 261     {
 262         L1 l0;
 263         L0 l1;
 264         L1 l2;
 265         assert(std::try_lock(l0, l1, l2) == 0);
 266         assert(!l0.locked());
 267         assert(!l1.locked());
 268         assert(!l2.locked());
 269     }
 270     {
 271         L0 l0;
 272         L1 l1;
 273         L1 l2;
 274         assert(std::try_lock(l0, l1, l2) == 1);
 275         assert(!l0.locked());
 276         assert(!l1.locked());
 277         assert(!l2.locked());
 278     }
 279 #ifndef TEST_HAS_NO_EXCEPTIONS
 280     {
 281         L1 l0;
 282         L1 l1;
 283         L2 l2;
 284         assert(std::try_lock(l0, l1, l2) == 0);
 285         assert(!l0.locked());
 286         assert(!l1.locked());
 287         assert(!l2.locked());
 288     }
 289     {
 290         L1 l0;
 291         L2 l1;
 292         L1 l2;
 293         assert(std::try_lock(l0, l1, l2) == 0);
 294         assert(!l0.locked());
 295         assert(!l1.locked());
 296         assert(!l2.locked());
 297     }
 298     {
 299         L2 l0;
 300         L1 l1;
 301         L1 l2;
 302         try
 303         {
 304             std::try_lock(l0, l1, l2);
 305             assert(false);
 306         }
 307         catch (int)
 308         {
 309             assert(!l0.locked());
 310             assert(!l1.locked());
 311             assert(!l2.locked());
 312         }
 313     }
 314     {
 315         L2 l0;
 316         L2 l1;
 317         L0 l2;
 318         try
 319         {
 320             std::try_lock(l0, l1, l2);
 321             assert(false);
 322         }
 323         catch (int)
 324         {
 325             assert(!l0.locked());
 326             assert(!l1.locked());
 327             assert(!l2.locked());
 328         }
 329     }
 330     {
 331         L2 l0;
 332         L0 l1;
 333         L2 l2;
 334         try
 335         {
 336             std::try_lock(l0, l1, l2);
 337             assert(false);
 338         }
 339         catch (int)
 340         {
 341             assert(!l0.locked());
 342             assert(!l1.locked());
 343             assert(!l2.locked());
 344         }
 345     }
 346     {
 347         L0 l0;
 348         L2 l1;
 349         L2 l2;
 350         try
 351         {
 352             std::try_lock(l0, l1, l2);
 353             assert(false);
 354         }
 355         catch (int)
 356         {
 357             assert(!l0.locked());
 358             assert(!l1.locked());
 359             assert(!l2.locked());
 360         }
 361     }
 362     {
 363         L2 l0;
 364         L2 l1;
 365         L1 l2;
 366         try
 367         {
 368             std::try_lock(l0, l1, l2);
 369             assert(false);
 370         }
 371         catch (int)
 372         {
 373             assert(!l0.locked());
 374             assert(!l1.locked());
 375             assert(!l2.locked());
 376         }
 377     }
 378     {
 379         L2 l0;
 380         L1 l1;
 381         L2 l2;
 382         try
 383         {
 384             std::try_lock(l0, l1, l2);
 385             assert(false);
 386         }
 387         catch (int)
 388         {
 389             assert(!l0.locked());
 390             assert(!l1.locked());
 391             assert(!l2.locked());
 392         }
 393     }
 394     {
 395         L1 l0;
 396         L2 l1;
 397         L2 l2;
 398         assert(std::try_lock(l0, l1, l2) == 0);
 399         assert(!l0.locked());
 400         assert(!l1.locked());
 401         assert(!l2.locked());
 402     }
 403     {
 404         L0 l0;
 405         L2 l1;
 406         L1 l2;
 407         try
 408         {
 409             std::try_lock(l0, l1, l2);
 410             assert(false);
 411         }
 412         catch (int)
 413         {
 414             assert(!l0.locked());
 415             assert(!l1.locked());
 416             assert(!l2.locked());
 417         }
 418     }
 419     {
 420         L1 l0;
 421         L0 l1;
 422         L2 l2;
 423         assert(std::try_lock(l0, l1, l2) == 0);
 424         assert(!l0.locked());
 425         assert(!l1.locked());
 426         assert(!l2.locked());
 427     }
 428     {
 429         L1 l0;
 430         L2 l1;
 431         L0 l2;
 432         assert(std::try_lock(l0, l1, l2) == 0);
 433         assert(!l0.locked());
 434         assert(!l1.locked());
 435         assert(!l2.locked());
 436     }
 437     {
 438         L2 l0;
 439         L0 l1;
 440         L1 l2;
 441         try
 442         {
 443             std::try_lock(l0, l1, l2);
 444             assert(false);
 445         }
 446         catch (int)
 447         {
 448             assert(!l0.locked());
 449             assert(!l1.locked());
 450             assert(!l2.locked());
 451         }
 452     }
 453     {
 454         L2 l0;
 455         L1 l1;
 456         L0 l2;
 457         try
 458         {
 459             std::try_lock(l0, l1, l2);
 460             assert(false);
 461         }
 462         catch (int)
 463         {
 464             assert(!l0.locked());
 465             assert(!l1.locked());
 466             assert(!l2.locked());
 467         }
 468     }
 469 #endif  // TEST_HAS_NO_EXCEPTIONS
 470     {
 471         L0 l0;
 472         L0 l1;
 473         L0 l2;
 474         L0 l3;
 475         assert(std::try_lock(l0, l1, l2, l3) == -1);
 476         assert(l0.locked());
 477         assert(l1.locked());
 478         assert(l2.locked());
 479         assert(l3.locked());
 480     }
 481     {
 482         L1 l0;
 483         L0 l1;
 484         L0 l2;
 485         L0 l3;
 486         assert(std::try_lock(l0, l1, l2, l3) == 0);
 487         assert(!l0.locked());
 488         assert(!l1.locked());
 489         assert(!l2.locked());
 490         assert(!l3.locked());
 491     }
 492     {
 493         L0 l0;
 494         L1 l1;
 495         L0 l2;
 496         L0 l3;
 497         assert(std::try_lock(l0, l1, l2, l3) == 1);
 498         assert(!l0.locked());
 499         assert(!l1.locked());
 500         assert(!l2.locked());
 501         assert(!l3.locked());
 502     }
 503     {
 504         L0 l0;
 505         L0 l1;
 506         L1 l2;
 507         L0 l3;
 508         assert(std::try_lock(l0, l1, l2, l3) == 2);
 509         assert(!l0.locked());
 510         assert(!l1.locked());
 511         assert(!l2.locked());
 512         assert(!l3.locked());
 513     }
 514     {
 515         L0 l0;
 516         L0 l1;
 517         L0 l2;
 518         L1 l3;
 519         assert(std::try_lock(l0, l1, l2, l3) == 3);
 520         assert(!l0.locked());
 521         assert(!l1.locked());
 522         assert(!l2.locked());
 523         assert(!l3.locked());
 524     }
 525 #endif  // _LIBCPP_HAS_NO_VARIADICS
 526 }