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++ and MSVC. In order to allow 13 // validation of the test suite against other STLs we have to mark it 14 // unsupported. 15 // UNSUPPORTED: libstdc++, msvc 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 } 523
