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:
L0()32 L0() : locked_(false) {}
33
lock()34 void lock()
35 {
36 locked_ = true;
37 }
38
try_lock()39 bool try_lock()
40 {
41 locked_ = true;
42 return locked_;
43 }
44
unlock()45 void unlock() {locked_ = false;}
46
locked() const47 bool locked() const {return locked_;}
48 };
49
50 class L1
51 {
52 bool locked_;
53
54 public:
L1()55 L1() : locked_(false) {}
56
lock()57 void lock()
58 {
59 locked_ = true;
60 }
61
try_lock()62 bool try_lock()
63 {
64 locked_ = false;
65 return locked_;
66 }
67
unlock()68 void unlock() {locked_ = false;}
69
locked() const70 bool locked() const {return locked_;}
71 };
72
73 class L2
74 {
75 bool locked_;
76
77 public:
L2()78 L2() : locked_(false) {}
79
lock()80 void lock()
81 {
82 TEST_THROW(1);
83 }
84
try_lock()85 bool try_lock()
86 {
87 TEST_THROW(1);
88 return locked_;
89 }
90
unlock()91 void unlock() {locked_ = false;}
92
locked() const93 bool locked() const {return locked_;}
94 };
95
main()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 #if TEST_STD_VER >= 11
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 // TEST_STD_VER >= 11
522 }
523