29 |
|
public void run() { |
30 |
|
try { |
31 |
|
lock.writeLock().lockInterruptibly(); |
32 |
< |
} catch (InterruptedException success){} |
32 |
> |
} catch (InterruptedException success) {} |
33 |
|
} |
34 |
|
} |
35 |
|
|
45 |
|
try { |
46 |
|
lock.writeLock().lockInterruptibly(); |
47 |
|
threadShouldThrow(); |
48 |
< |
} catch (InterruptedException success){} |
48 |
> |
} catch (InterruptedException success) {} |
49 |
|
} |
50 |
|
} |
51 |
|
|
181 |
|
try { |
182 |
|
rl.writeLock().unlock(); |
183 |
|
shouldThrow(); |
184 |
< |
} catch (IllegalMonitorStateException success){} |
184 |
> |
} catch (IllegalMonitorStateException success) {} |
185 |
|
} |
186 |
|
|
187 |
|
|
197 |
|
lock.writeLock().unlock(); |
198 |
|
lock.writeLock().lockInterruptibly(); |
199 |
|
lock.writeLock().unlock(); |
200 |
< |
} catch (InterruptedException success){} |
200 |
> |
} catch (InterruptedException success) {} |
201 |
|
} |
202 |
|
}); |
203 |
|
try { |
208 |
|
Thread.sleep(SHORT_DELAY_MS); |
209 |
|
lock.writeLock().unlock(); |
210 |
|
t.join(); |
211 |
< |
} catch (Exception e){ |
211 |
> |
} catch (Exception e) { |
212 |
|
unexpectedException(); |
213 |
|
} |
214 |
|
} |
223 |
|
public void run() { |
224 |
|
try { |
225 |
|
lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS); |
226 |
< |
} catch (InterruptedException success){} |
226 |
> |
} catch (InterruptedException success) {} |
227 |
|
} |
228 |
|
}); |
229 |
|
try { |
231 |
|
t.interrupt(); |
232 |
|
lock.writeLock().unlock(); |
233 |
|
t.join(); |
234 |
< |
} catch (Exception e){ |
234 |
> |
} catch (Exception e) { |
235 |
|
unexpectedException(); |
236 |
|
} |
237 |
|
} |
246 |
|
public void run() { |
247 |
|
try { |
248 |
|
lock.readLock().lockInterruptibly(); |
249 |
< |
} catch (InterruptedException success){} |
249 |
> |
} catch (InterruptedException success) {} |
250 |
|
} |
251 |
|
}); |
252 |
|
try { |
256 |
|
Thread.sleep(SHORT_DELAY_MS); |
257 |
|
lock.writeLock().unlock(); |
258 |
|
t.join(); |
259 |
< |
} catch (Exception e){ |
259 |
> |
} catch (Exception e) { |
260 |
|
unexpectedException(); |
261 |
|
} |
262 |
|
} |
272 |
|
try { |
273 |
|
lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS); |
274 |
|
threadShouldThrow(); |
275 |
< |
} catch (InterruptedException success){} |
275 |
> |
} catch (InterruptedException success) {} |
276 |
|
} |
277 |
|
}); |
278 |
|
try { |
279 |
|
t.start(); |
280 |
|
t.interrupt(); |
281 |
|
t.join(); |
282 |
< |
} catch (Exception e){ |
282 |
> |
} catch (Exception e) { |
283 |
|
unexpectedException(); |
284 |
|
} |
285 |
|
} |
300 |
|
t.start(); |
301 |
|
t.join(); |
302 |
|
lock.writeLock().unlock(); |
303 |
< |
} catch (Exception e){ |
303 |
> |
} catch (Exception e) { |
304 |
|
unexpectedException(); |
305 |
|
} |
306 |
|
} |
320 |
|
t.start(); |
321 |
|
t.join(); |
322 |
|
lock.writeLock().unlock(); |
323 |
< |
} catch (Exception e){ |
323 |
> |
} catch (Exception e) { |
324 |
|
unexpectedException(); |
325 |
|
} |
326 |
|
} |
341 |
|
t.start(); |
342 |
|
t.join(); |
343 |
|
lock.readLock().unlock(); |
344 |
< |
} catch (Exception e){ |
344 |
> |
} catch (Exception e) { |
345 |
|
unexpectedException(); |
346 |
|
} |
347 |
|
} |
375 |
|
assertTrue(!t1.isAlive()); |
376 |
|
assertTrue(!t2.isAlive()); |
377 |
|
|
378 |
< |
} catch (Exception e){ |
378 |
> |
} catch (Exception e) { |
379 |
|
unexpectedException(); |
380 |
|
} |
381 |
|
} |
409 |
|
assertTrue(!t1.isAlive()); |
410 |
|
assertTrue(!t2.isAlive()); |
411 |
|
|
412 |
< |
} catch (Exception e){ |
412 |
> |
} catch (Exception e) { |
413 |
|
unexpectedException(); |
414 |
|
} |
415 |
|
} |
459 |
|
assertTrue(!t1.isAlive()); |
460 |
|
assertTrue(!t2.isAlive()); |
461 |
|
|
462 |
< |
} catch (Exception e){ |
462 |
> |
} catch (Exception e) { |
463 |
|
unexpectedException(); |
464 |
|
} |
465 |
|
} |
498 |
|
assertTrue(!t1.isAlive()); |
499 |
|
assertTrue(!t2.isAlive()); |
500 |
|
|
501 |
< |
} catch (Exception e){ |
501 |
> |
} catch (Exception e) { |
502 |
|
unexpectedException(); |
503 |
|
} |
504 |
|
} |
538 |
|
assertTrue(!t1.isAlive()); |
539 |
|
assertTrue(!t2.isAlive()); |
540 |
|
|
541 |
< |
} catch (Exception e){ |
541 |
> |
} catch (Exception e) { |
542 |
|
unexpectedException(); |
543 |
|
} |
544 |
|
} |
589 |
|
assertTrue(!t1.isAlive()); |
590 |
|
assertTrue(!t2.isAlive()); |
591 |
|
|
592 |
< |
} catch (Exception e){ |
592 |
> |
} catch (Exception e) { |
593 |
|
unexpectedException(); |
594 |
|
} |
595 |
|
} |
629 |
|
assertTrue(!t1.isAlive()); |
630 |
|
assertTrue(!t2.isAlive()); |
631 |
|
|
632 |
< |
} catch (Exception e){ |
632 |
> |
} catch (Exception e) { |
633 |
|
unexpectedException(); |
634 |
|
} |
635 |
|
} |
672 |
|
assertTrue(!t1.isAlive()); |
673 |
|
assertTrue(!t2.isAlive()); |
674 |
|
|
675 |
< |
} catch (Exception e){ |
675 |
> |
} catch (Exception e) { |
676 |
|
unexpectedException(); |
677 |
|
} |
678 |
|
} |
694 |
|
t.start(); |
695 |
|
t.join(); |
696 |
|
lock.readLock().unlock(); |
697 |
< |
} catch (Exception e){ |
697 |
> |
} catch (Exception e) { |
698 |
|
unexpectedException(); |
699 |
|
} |
700 |
|
} |
716 |
|
t.start(); |
717 |
|
t.join(); |
718 |
|
lock.readLock().unlock(); |
719 |
< |
} catch (Exception e){ |
719 |
> |
} catch (Exception e) { |
720 |
|
unexpectedException(); |
721 |
|
} |
722 |
|
} |
738 |
|
t.start(); |
739 |
|
t.join(); |
740 |
|
lock.readLock().unlock(); |
741 |
< |
} catch (Exception e){ |
741 |
> |
} catch (Exception e) { |
742 |
|
unexpectedException(); |
743 |
|
} |
744 |
|
} |
760 |
|
t.start(); |
761 |
|
t.join(); |
762 |
|
lock.readLock().unlock(); |
763 |
< |
} catch (Exception e){ |
763 |
> |
} catch (Exception e) { |
764 |
|
unexpectedException(); |
765 |
|
} |
766 |
|
} |
786 |
|
t.start(); |
787 |
|
t.join(); |
788 |
|
lock.writeLock().unlock(); |
789 |
< |
} catch (Exception e){ |
789 |
> |
} catch (Exception e) { |
790 |
|
unexpectedException(); |
791 |
|
} |
792 |
|
} |
810 |
|
t.start(); |
811 |
|
t.join(); |
812 |
|
lock.writeLock().unlock(); |
813 |
< |
} catch (Exception e){ |
813 |
> |
} catch (Exception e) { |
814 |
|
unexpectedException(); |
815 |
|
} |
816 |
|
} |
843 |
|
Thread.sleep(SHORT_DELAY_MS); |
844 |
|
t.join(); |
845 |
|
lock.writeLock().unlock(); |
846 |
< |
} catch (Exception e){ |
846 |
> |
} catch (Exception e) { |
847 |
|
unexpectedException(); |
848 |
|
} |
849 |
|
} |
874 |
|
t.interrupt(); |
875 |
|
t.join(); |
876 |
|
lock.writeLock().unlock(); |
877 |
< |
} catch (Exception e){ |
877 |
> |
} catch (Exception e) { |
878 |
|
unexpectedException(); |
879 |
|
} |
880 |
|
} |
1216 |
|
ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject(); |
1217 |
|
r.readLock().lock(); |
1218 |
|
r.readLock().unlock(); |
1219 |
< |
} catch (Exception e){ |
1219 |
> |
} catch (Exception e) { |
1220 |
|
e.printStackTrace(); |
1221 |
|
unexpectedException(); |
1222 |
|
} |
1246 |
|
assertFalse(lock.hasQueuedThreads()); |
1247 |
|
t1.join(); |
1248 |
|
t2.join(); |
1249 |
< |
} catch (Exception e){ |
1249 |
> |
} catch (Exception e) { |
1250 |
|
unexpectedException(); |
1251 |
|
} |
1252 |
|
} |
1292 |
|
assertFalse(sync.hasQueuedThread(t2)); |
1293 |
|
t1.join(); |
1294 |
|
t2.join(); |
1295 |
< |
} catch (Exception e){ |
1295 |
> |
} catch (Exception e) { |
1296 |
|
unexpectedException(); |
1297 |
|
} |
1298 |
|
} |
1322 |
|
assertEquals(0, lock.getQueueLength()); |
1323 |
|
t1.join(); |
1324 |
|
t2.join(); |
1325 |
< |
} catch (Exception e){ |
1325 |
> |
} catch (Exception e) { |
1326 |
|
unexpectedException(); |
1327 |
|
} |
1328 |
|
} |
1354 |
|
assertTrue(lock.getQueuedThreads().isEmpty()); |
1355 |
|
t1.join(); |
1356 |
|
t2.join(); |
1357 |
< |
} catch (Exception e){ |
1357 |
> |
} catch (Exception e) { |
1358 |
|
unexpectedException(); |
1359 |
|
} |
1360 |
|
} |
1407 |
|
*/ |
1408 |
|
public void testHasWaitersIAE() { |
1409 |
|
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); |
1410 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1410 |
> |
final Condition c = lock.writeLock().newCondition(); |
1411 |
|
final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); |
1412 |
|
try { |
1413 |
|
lock2.hasWaiters(c); |
1423 |
|
*/ |
1424 |
|
public void testHasWaitersIMSE() { |
1425 |
|
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); |
1426 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1426 |
> |
final Condition c = lock.writeLock().newCondition(); |
1427 |
|
try { |
1428 |
|
lock.hasWaiters(c); |
1429 |
|
shouldThrow(); |
1439 |
|
*/ |
1440 |
|
public void testGetWaitQueueLengthIAE() { |
1441 |
|
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); |
1442 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1442 |
> |
final Condition c = lock.writeLock().newCondition(); |
1443 |
|
final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); |
1444 |
|
try { |
1445 |
|
lock2.getWaitQueueLength(c); |
1455 |
|
*/ |
1456 |
|
public void testGetWaitQueueLengthIMSE() { |
1457 |
|
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); |
1458 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1458 |
> |
final Condition c = lock.writeLock().newCondition(); |
1459 |
|
try { |
1460 |
|
lock.getWaitQueueLength(c); |
1461 |
|
shouldThrow(); |
1471 |
|
*/ |
1472 |
|
public void testGetWaitingThreadsIAE() { |
1473 |
|
final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); |
1474 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1474 |
> |
final Condition c = lock.writeLock().newCondition(); |
1475 |
|
final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock(); |
1476 |
|
try { |
1477 |
|
lock2.getWaitingThreads(c); |
1487 |
|
*/ |
1488 |
|
public void testGetWaitingThreadsIMSE() { |
1489 |
|
final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); |
1490 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1490 |
> |
final Condition c = lock.writeLock().newCondition(); |
1491 |
|
try { |
1492 |
|
lock.getWaitingThreads(c); |
1493 |
|
shouldThrow(); |
1503 |
|
*/ |
1504 |
|
public void testHasWaiters() { |
1505 |
|
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); |
1506 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1506 |
> |
final Condition c = lock.writeLock().newCondition(); |
1507 |
|
Thread t = new Thread(new Runnable() { |
1508 |
|
public void run() { |
1509 |
|
try { |
1545 |
|
*/ |
1546 |
|
public void testGetWaitQueueLength() { |
1547 |
|
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); |
1548 |
< |
final Condition c = (lock.writeLock().newCondition()); |
1548 |
> |
final Condition c = lock.writeLock().newCondition(); |
1549 |
|
Thread t = new Thread(new Runnable() { |
1550 |
|
public void run() { |
1551 |
|
try { |