libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/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 // This test hangs forever when built against libstdc++ (Oct 2016).
  12 // UNSUPPORTED: stdlib=libstdc++
  13
  14 // This test isn't quite standards-conforming: it's testing our specific
  15 // algorithm, where when lx.try_lock() fails we start the next attempt
  16 // with an unconditional lx.lock(). Thus our algorithm can handle a list
  17 // of mutexes where at-most-one of them is of the evil type `class L1`,
  18 // but will loop forever if two or more of them are `class L1`.
  19
  20 // <mutex>
  21
  22 // template <class L1, class L2, class... L3>
  23 //   void lock(L1&, L2&, L3&...);
  24
  25 #include <mutex>
  26 #include <cassert>
  27
  28 #include "test_macros.h"
  29
  30 class L0
  31 {
  32     bool locked_;
  33
  34 public:
  35     L0() : locked_(false) {}
  36
  37     void lock()
  38     {
  39         locked_ = true;
  40     }
  41
  42     bool try_lock()
  43     {
  44         locked_ = true;
  45         return locked_;
  46     }
  47
  48     void unlock() {locked_ = false;}
  49
  50     bool locked() const {return locked_;}
  51 };
  52
  53 class L1
  54 {
  55     bool locked_;
  56
  57 public:
  58     L1() : locked_(false) {}
  59
  60     void lock()
  61     {
  62         locked_ = true;
  63     }
  64
  65     bool try_lock()
  66     {
  67         locked_ = false;
  68         return locked_;
  69     }
  70
  71     void unlock() {locked_ = false;}
  72
  73     bool locked() const {return locked_;}
  74 };
  75
  76 class L2
  77 {
  78     bool locked_;
  79
  80 public:
  81     L2() : locked_(false) {}
  82
  83     void lock()
  84     {
  85         TEST_THROW(1);
  86     }
  87
  88     bool try_lock()
  89     {
  90         TEST_THROW(1);
  91         return locked_;
  92     }
  93
  94     void unlock() {locked_ = false;}
  95
  96     bool locked() const {return locked_;}
  97 };
  98
  99 int main(int, char**)
 100 {
 101     {
 102         L0 l0;
 103         L0 l1;
 104         std::lock(l0, l1);
 105         assert(l0.locked());
 106         assert(l1.locked());
 107     }
 108     {
 109         L0 l0;
 110         L1 l1;
 111         std::lock(l0, l1);
 112         assert(l0.locked());
 113         assert(l1.locked());
 114     }
 115     {
 116         L1 l0;
 117         L0 l1;
 118         std::lock(l0, l1);
 119         assert(l0.locked());
 120         assert(l1.locked());
 121     }
 122 #ifndef TEST_HAS_NO_EXCEPTIONS
 123     {
 124         L0 l0;
 125         L2 l1;
 126         try
 127         {
 128             std::lock(l0, l1);
 129             assert(false);
 130         }
 131         catch (int)
 132         {
 133             assert(!l0.locked());
 134             assert(!l1.locked());
 135         }
 136     }
 137     {
 138         L2 l0;
 139         L0 l1;
 140         try
 141         {
 142             std::lock(l0, l1);
 143             assert(false);
 144         }
 145         catch (int)
 146         {
 147             assert(!l0.locked());
 148             assert(!l1.locked());
 149         }
 150     }
 151     {
 152         L1 l0;
 153         L2 l1;
 154         try
 155         {
 156             std::lock(l0, l1);
 157             assert(false);
 158         }
 159         catch (int)
 160         {
 161             assert(!l0.locked());
 162             assert(!l1.locked());
 163         }
 164     }
 165     {
 166         L2 l0;
 167         L1 l1;
 168         try
 169         {
 170             std::lock(l0, l1);
 171             assert(false);
 172         }
 173         catch (int)
 174         {
 175             assert(!l0.locked());
 176             assert(!l1.locked());
 177         }
 178     }
 179     {
 180         L2 l0;
 181         L2 l1;
 182         try
 183         {
 184             std::lock(l0, l1);
 185             assert(false);
 186         }
 187         catch (int)
 188         {
 189             assert(!l0.locked());
 190             assert(!l1.locked());
 191         }
 192     }
 193 #endif
 194 #if TEST_STD_VER >= 11
 195     {
 196         L0 l0;
 197         L0 l1;
 198         L0 l2;
 199         std::lock(l0, l1, l2);
 200         assert(l0.locked());
 201         assert(l1.locked());
 202         assert(l2.locked());
 203     }
 204 #ifndef TEST_HAS_NO_EXCEPTIONS
 205     {
 206         L2 l0;
 207         L2 l1;
 208         L2 l2;
 209         try
 210         {
 211             std::lock(l0, l1, l2);
 212             assert(false);
 213         }
 214         catch (int)
 215         {
 216             assert(!l0.locked());
 217             assert(!l1.locked());
 218             assert(!l2.locked());
 219         }
 220     }
 221 #endif
 222     {
 223         L0 l0;
 224         L0 l1;
 225         L1 l2;
 226         std::lock(l0, l1, l2);
 227         assert(l0.locked());
 228         assert(l1.locked());
 229         assert(l2.locked());
 230     }
 231     {
 232         L0 l0;
 233         L1 l1;
 234         L0 l2;
 235         std::lock(l0, l1, l2);
 236         assert(l0.locked());
 237         assert(l1.locked());
 238         assert(l2.locked());
 239     }
 240     {
 241         L1 l0;
 242         L0 l1;
 243         L0 l2;
 244         std::lock(l0, l1, l2);
 245         assert(l0.locked());
 246         assert(l1.locked());
 247         assert(l2.locked());
 248     }
 249 #ifndef TEST_HAS_NO_EXCEPTIONS
 250     {
 251         L0 l0;
 252         L0 l1;
 253         L2 l2;
 254         try
 255         {
 256             std::lock(l0, l1, l2);
 257             assert(false);
 258         }
 259         catch (int)
 260         {
 261             assert(!l0.locked());
 262             assert(!l1.locked());
 263             assert(!l2.locked());
 264         }
 265     }
 266     {
 267         L0 l0;
 268         L2 l1;
 269         L0 l2;
 270         try
 271         {
 272             std::lock(l0, l1, l2);
 273             assert(false);
 274         }
 275         catch (int)
 276         {
 277             assert(!l0.locked());
 278             assert(!l1.locked());
 279             assert(!l2.locked());
 280         }
 281     }
 282     {
 283         L2 l0;
 284         L0 l1;
 285         L0 l2;
 286         try
 287         {
 288             std::lock(l0, l1, l2);
 289             assert(false);
 290         }
 291         catch (int)
 292         {
 293             assert(!l0.locked());
 294             assert(!l1.locked());
 295             assert(!l2.locked());
 296         }
 297     }
 298     {
 299         L2 l0;
 300         L2 l1;
 301         L0 l2;
 302         try
 303         {
 304             std::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         L0 l1;
 317         L2 l2;
 318         try
 319         {
 320             std::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         L0 l0;
 332         L2 l1;
 333         L2 l2;
 334         try
 335         {
 336             std::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         L2 l0;
 348         L2 l1;
 349         L1 l2;
 350         try
 351         {
 352             std::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         L1 l1;
 365         L2 l2;
 366         try
 367         {
 368             std::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         L1 l0;
 380         L2 l1;
 381         L2 l2;
 382         try
 383         {
 384             std::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 #endif // TEST_HAS_NO_EXCEPTIONS
 395     {
 396         L0 l0;
 397         L0 l1;
 398         L0 l2;
 399         L0 l3;
 400         std::lock(l0, l1, l2, l3);
 401         assert(l0.locked());
 402         assert(l1.locked());
 403         assert(l2.locked());
 404         assert(l3.locked());
 405     }
 406     {
 407         L0 l0;
 408         L0 l1;
 409         L0 l2;
 410         L1 l3;
 411         std::lock(l0, l1, l2, l3);
 412         assert(l0.locked());
 413         assert(l1.locked());
 414         assert(l2.locked());
 415         assert(l3.locked());
 416     }
 417     {
 418         L0 l0;
 419         L0 l1;
 420         L1 l2;
 421         L0 l3;
 422         std::lock(l0, l1, l2, l3);
 423         assert(l0.locked());
 424         assert(l1.locked());
 425         assert(l2.locked());
 426         assert(l3.locked());
 427     }
 428     {
 429         L0 l0;
 430         L1 l1;
 431         L0 l2;
 432         L0 l3;
 433         std::lock(l0, l1, l2, l3);
 434         assert(l0.locked());
 435         assert(l1.locked());
 436         assert(l2.locked());
 437         assert(l3.locked());
 438     }
 439     {
 440         L1 l0;
 441         L0 l1;
 442         L0 l2;
 443         L0 l3;
 444         std::lock(l0, l1, l2, l3);
 445         assert(l0.locked());
 446         assert(l1.locked());
 447         assert(l2.locked());
 448         assert(l3.locked());
 449     }
 450 #ifndef TEST_HAS_NO_EXCEPTIONS
 451     {
 452         L0 l0;
 453         L0 l1;
 454         L0 l2;
 455         L2 l3;
 456         try
 457         {
 458             std::lock(l0, l1, l2, l3);
 459             assert(false);
 460         }
 461         catch (int)
 462         {
 463             assert(!l0.locked());
 464             assert(!l1.locked());
 465             assert(!l2.locked());
 466             assert(!l3.locked());
 467         }
 468     }
 469     {
 470         L0 l0;
 471         L0 l1;
 472         L2 l2;
 473         L0 l3;
 474         try
 475         {
 476             std::lock(l0, l1, l2, l3);
 477             assert(false);
 478         }
 479         catch (int)
 480         {
 481             assert(!l0.locked());
 482             assert(!l1.locked());
 483             assert(!l2.locked());
 484             assert(!l3.locked());
 485         }
 486     }
 487     {
 488         L0 l0;
 489         L2 l1;
 490         L0 l2;
 491         L0 l3;
 492         try
 493         {
 494             std::lock(l0, l1, l2, l3);
 495             assert(false);
 496         }
 497         catch (int)
 498         {
 499             assert(!l0.locked());
 500             assert(!l1.locked());
 501             assert(!l2.locked());
 502             assert(!l3.locked());
 503         }
 504     }
 505     {
 506         L2 l0;
 507         L0 l1;
 508         L0 l2;
 509         L0 l3;
 510         try
 511         {
 512             std::lock(l0, l1, l2, l3);
 513             assert(false);
 514         }
 515         catch (int)
 516         {
 517             assert(!l0.locked());
 518             assert(!l1.locked());
 519             assert(!l2.locked());
 520             assert(!l3.locked());
 521         }
 522     }
 523 #endif // TEST_HAS_NO_EXCEPTIONS
 524 #endif // TEST_STD_VER >= 11
 525
 526   return 0;
 527 }