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

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