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