ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java
Revision: 1.55
Committed: Mon May 2 01:15:26 2011 UTC (13 years ago) by jsr166
Branch: MAIN
Changes since 1.54: +2 -0 lines
Log Message: 
improve testReadAfterWriteLock

File Contents

# Content
1 /*
2 * Written by Doug Lea with assistance from members of JCP JSR-166
3 * Expert Group and released to the public domain, as explained at
4 * http://creativecommons.org/publicdomain/zero/1.0/
5 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 * Pat Fisher, Mike Judd.
7 */
8
9 import junit.framework.*;
10 import java.util.concurrent.locks.*;
11 import java.util.concurrent.*;
12 import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 import java.io.*;
14 import java.util.*;
15
16 public class ReentrantReadWriteLockTest extends JSR166TestCase {
17 public static void main(String[] args) {
18 junit.textui.TestRunner.run(suite());
19 }
20 public static Test suite() {
21 return new TestSuite(ReentrantReadWriteLockTest.class);
22 }
23
24 /**
25 * A runnable calling lockInterruptibly
26 */
27 class InterruptibleLockRunnable extends CheckedRunnable {
28 final ReentrantReadWriteLock lock;
29 InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
30 public void realRun() throws InterruptedException {
31 lock.writeLock().lockInterruptibly();
32 }
33 }
34
35
36 /**
37 * A runnable calling lockInterruptibly that expects to be
38 * interrupted
39 */
40 class InterruptedLockRunnable extends CheckedInterruptedRunnable {
41 final ReentrantReadWriteLock lock;
42 InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
43 public void realRun() throws InterruptedException {
44 lock.writeLock().lockInterruptibly();
45 }
46 }
47
48 /**
49 * Subclass to expose protected methods
50 */
51 static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
52 PublicReentrantReadWriteLock() { super(); }
53 public Collection<Thread> getQueuedThreads() {
54 return super.getQueuedThreads();
55 }
56 public Collection<Thread> getWaitingThreads(Condition c) {
57 return super.getWaitingThreads(c);
58 }
59 }
60
61 /**
62 * Releases write lock, checking that it had a hold count of 1.
63 */
64 void releaseWriteLock(ReentrantReadWriteLock lock) {
65 ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
66 assertTrue(writeLock.isHeldByCurrentThread());
67 writeLock.unlock();
68 assertFalse(writeLock.isHeldByCurrentThread());
69 }
70
71 /**
72 * Constructor sets given fairness, and is in unlocked state
73 */
74 public void testConstructor() {
75 ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
76 assertFalse(rl.isFair());
77 assertFalse(rl.isWriteLocked());
78 assertEquals(0, rl.getReadLockCount());
79 ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
80 assertTrue(r2.isFair());
81 assertFalse(r2.isWriteLocked());
82 assertEquals(0, r2.getReadLockCount());
83 ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
84 assertFalse(r3.isFair());
85 assertFalse(r3.isWriteLocked());
86 assertEquals(0, r3.getReadLockCount());
87 }
88
89 /**
90 * write-locking and read-locking an unlocked lock succeed
91 */
92 public void testLock() {
93 ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
94 rl.writeLock().lock();
95 assertTrue(rl.isWriteLocked());
96 assertTrue(rl.isWriteLockedByCurrentThread());
97 assertTrue(rl.writeLock().isHeldByCurrentThread());
98 assertEquals(0, rl.getReadLockCount());
99 rl.writeLock().unlock();
100 assertFalse(rl.isWriteLocked());
101 assertFalse(rl.isWriteLockedByCurrentThread());
102 assertFalse(rl.writeLock().isHeldByCurrentThread());
103 assertEquals(0, rl.getReadLockCount());
104 rl.readLock().lock();
105 assertFalse(rl.isWriteLocked());
106 assertFalse(rl.isWriteLockedByCurrentThread());
107 assertEquals(1, rl.getReadLockCount());
108 rl.readLock().unlock();
109 assertFalse(rl.isWriteLocked());
110 assertFalse(rl.isWriteLockedByCurrentThread());
111 assertEquals(0, rl.getReadLockCount());
112 }
113
114
115 /**
116 * locking an unlocked fair lock succeeds
117 */
118 public void testFairLock() {
119 ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
120 rl.writeLock().lock();
121 assertTrue(rl.isWriteLocked());
122 assertTrue(rl.isWriteLockedByCurrentThread());
123 assertTrue(rl.writeLock().isHeldByCurrentThread());
124 assertEquals(0, rl.getReadLockCount());
125 rl.writeLock().unlock();
126 assertFalse(rl.isWriteLocked());
127 assertFalse(rl.isWriteLockedByCurrentThread());
128 assertFalse(rl.writeLock().isHeldByCurrentThread());
129 assertEquals(0, rl.getReadLockCount());
130 rl.readLock().lock();
131 assertFalse(rl.isWriteLocked());
132 assertFalse(rl.isWriteLockedByCurrentThread());
133 assertEquals(1, rl.getReadLockCount());
134 rl.readLock().unlock();
135 assertFalse(rl.isWriteLocked());
136 assertFalse(rl.isWriteLockedByCurrentThread());
137 assertEquals(0, rl.getReadLockCount());
138 }
139
140 /**
141 * getWriteHoldCount returns number of recursive holds
142 */
143 public void testGetWriteHoldCount() {
144 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
145 for (int i = 1; i <= SIZE; i++) {
146 lock.writeLock().lock();
147 assertEquals(i,lock.getWriteHoldCount());
148 }
149 for (int i = SIZE; i > 0; i--) {
150 lock.writeLock().unlock();
151 assertEquals(i-1,lock.getWriteHoldCount());
152 }
153 }
154
155 /**
156 * WriteLock.getHoldCount returns number of recursive holds
157 */
158 public void testGetHoldCount() {
159 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
160 for (int i = 1; i <= SIZE; i++) {
161 lock.writeLock().lock();
162 assertEquals(i,lock.writeLock().getHoldCount());
163 }
164 for (int i = SIZE; i > 0; i--) {
165 lock.writeLock().unlock();
166 assertEquals(i-1,lock.writeLock().getHoldCount());
167 }
168 }
169
170 /**
171 * getReadHoldCount returns number of recursive holds
172 */
173 public void testGetReadHoldCount() {
174 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
175 for (int i = 1; i <= SIZE; i++) {
176 lock.readLock().lock();
177 assertEquals(i,lock.getReadHoldCount());
178 }
179 for (int i = SIZE; i > 0; i--) {
180 lock.readLock().unlock();
181 assertEquals(i-1,lock.getReadHoldCount());
182 }
183 }
184
185
186 /**
187 * write-unlocking an unlocked lock throws IllegalMonitorStateException
188 */
189 public void testUnlock_IllegalMonitorStateException() {
190 ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
191 try {
192 rl.writeLock().unlock();
193 shouldThrow();
194 } catch (IllegalMonitorStateException success) {}
195 }
196
197
198 /**
199 * write-lockInterruptibly is interruptible
200 */
201 public void testWriteLockInterruptibly_Interrupted() throws Exception {
202 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
203 lock.writeLock().lock();
204 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
205 public void realRun() throws InterruptedException {
206 lock.writeLock().lockInterruptibly();
207 }});
208
209 Thread.sleep(SHORT_DELAY_MS);
210 t.interrupt();
211 awaitTermination(t, LONG_DELAY_MS);
212 releaseWriteLock(lock);
213 }
214
215 /**
216 * timed write-tryLock is interruptible
217 */
218 public void testWriteTryLock_Interrupted() throws InterruptedException {
219 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
220 lock.writeLock().lock();
221 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
222 public void realRun() throws InterruptedException {
223 lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS);
224 }});
225
226 Thread.sleep(SHORT_DELAY_MS);
227 t.interrupt();
228 awaitTermination(t, LONG_DELAY_MS);
229 releaseWriteLock(lock);
230 }
231
232 /**
233 * read-lockInterruptibly is interruptible
234 */
235 public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
236 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
237 lock.writeLock().lock();
238 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
239 public void realRun() throws InterruptedException {
240 lock.readLock().lockInterruptibly();
241 }});
242
243 Thread.sleep(SHORT_DELAY_MS);
244 t.interrupt();
245 awaitTermination(t, LONG_DELAY_MS);
246 releaseWriteLock(lock);
247 }
248
249 /**
250 * timed read-tryLock is interruptible
251 */
252 public void testReadTryLock_Interrupted() throws InterruptedException {
253 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
254 lock.writeLock().lock();
255 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
256 public void realRun() throws InterruptedException {
257 lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
258 }});
259
260 Thread.sleep(SHORT_DELAY_MS);
261 t.interrupt();
262 awaitTermination(t, LONG_DELAY_MS);
263 releaseWriteLock(lock);
264 }
265
266
267 /**
268 * write-tryLock fails if locked
269 */
270 public void testWriteTryLockWhenLocked() throws InterruptedException {
271 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
272 lock.writeLock().lock();
273 Thread t = newStartedThread(new CheckedRunnable() {
274 public void realRun() {
275 assertFalse(lock.writeLock().tryLock());
276 }});
277
278 awaitTermination(t, LONG_DELAY_MS);
279 releaseWriteLock(lock);
280 }
281
282 /**
283 * read-tryLock fails if locked
284 */
285 public void testReadTryLockWhenLocked() throws InterruptedException {
286 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
287 lock.writeLock().lock();
288 Thread t = newStartedThread(new CheckedRunnable() {
289 public void realRun() {
290 assertFalse(lock.readLock().tryLock());
291 }});
292
293 awaitTermination(t, LONG_DELAY_MS);
294 releaseWriteLock(lock);
295 }
296
297 /**
298 * Multiple threads can hold a read lock when not write-locked
299 */
300 public void testMultipleReadLocks() throws InterruptedException {
301 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
302 lock.readLock().lock();
303 Thread t = newStartedThread(new CheckedRunnable() {
304 public void realRun() {
305 assertTrue(lock.readLock().tryLock());
306 lock.readLock().unlock();
307 }});
308
309 awaitTermination(t, LONG_DELAY_MS);
310 lock.readLock().unlock();
311 }
312
313 /**
314 * A writelock succeeds after reading threads unlock
315 */
316 public void testWriteAfterMultipleReadLocks() throws InterruptedException {
317 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
318 lock.readLock().lock();
319 Thread t1 = newStartedThread(new CheckedRunnable() {
320 public void realRun() {
321 lock.readLock().lock();
322 lock.readLock().unlock();
323 }});
324 Thread t2 = newStartedThread(new CheckedRunnable() {
325 public void realRun() {
326 lock.writeLock().lock();
327 lock.writeLock().unlock();
328 }});
329
330 Thread.sleep(SHORT_DELAY_MS);
331 lock.readLock().unlock();
332 awaitTermination(t1, LONG_DELAY_MS);
333 awaitTermination(t2, LONG_DELAY_MS);
334 }
335
336 /**
337 * Readlocks succeed after a writing thread unlocks
338 */
339 public void testReadAfterWriteLock() throws InterruptedException {
340 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
341 lock.writeLock().lock();
342 Thread t1 = newStartedThread(new CheckedRunnable() {
343 public void realRun() {
344 lock.readLock().lock();
345 lock.readLock().unlock();
346 }});
347 Thread t2 = newStartedThread(new CheckedRunnable() {
348 public void realRun() {
349 lock.readLock().lock();
350 lock.readLock().unlock();
351 }});
352
353 Thread.sleep(SHORT_DELAY_MS);
354 assertTrue(t1.isAlive());
355 assertTrue(t2.isAlive());
356 releaseWriteLock(lock);
357 awaitTermination(t1, LONG_DELAY_MS);
358 awaitTermination(t2, LONG_DELAY_MS);
359 }
360
361 /**
362 * Read trylock succeeds if write locked by current thread
363 */
364 public void testReadHoldingWriteLock() {
365 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
366 lock.writeLock().lock();
367 assertTrue(lock.readLock().tryLock());
368 lock.readLock().unlock();
369 lock.writeLock().unlock();
370 }
371
372 /**
373 * Read lock succeeds if write locked by current thread even if
374 * other threads are waiting for readlock
375 */
376 public void testReadHoldingWriteLock2() throws InterruptedException {
377 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
378 lock.writeLock().lock();
379 Thread t1 = newStartedThread(new CheckedRunnable() {
380 public void realRun() {
381 lock.readLock().lock();
382 lock.readLock().unlock();
383 }});
384 Thread t2 = newStartedThread(new CheckedRunnable() {
385 public void realRun() {
386 lock.readLock().lock();
387 lock.readLock().unlock();
388 }});
389
390 lock.readLock().lock();
391 lock.readLock().unlock();
392 Thread.sleep(SHORT_DELAY_MS);
393 lock.readLock().lock();
394 lock.readLock().unlock();
395 lock.writeLock().unlock();
396 awaitTermination(t1, LONG_DELAY_MS);
397 awaitTermination(t2, LONG_DELAY_MS);
398 }
399
400 /**
401 * Read lock succeeds if write locked by current thread even if
402 * other threads are waiting for writelock
403 */
404 public void testReadHoldingWriteLock3() throws InterruptedException {
405 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
406 lock.writeLock().lock();
407 Thread t1 = newStartedThread(new CheckedRunnable() {
408 public void realRun() {
409 lock.writeLock().lock();
410 lock.writeLock().unlock();
411 }});
412 Thread t2 = newStartedThread(new CheckedRunnable() {
413 public void realRun() {
414 lock.writeLock().lock();
415 lock.writeLock().unlock();
416 }});
417
418 lock.readLock().lock();
419 lock.readLock().unlock();
420 Thread.sleep(SHORT_DELAY_MS);
421 lock.readLock().lock();
422 lock.readLock().unlock();
423 lock.writeLock().unlock();
424 awaitTermination(t1, LONG_DELAY_MS);
425 awaitTermination(t2, LONG_DELAY_MS);
426 }
427
428
429 /**
430 * Write lock succeeds if write locked by current thread even if
431 * other threads are waiting for writelock
432 */
433 public void testWriteHoldingWriteLock4() throws InterruptedException {
434 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
435 lock.writeLock().lock();
436 Thread t1 = newStartedThread(new CheckedRunnable() {
437 public void realRun() {
438 lock.writeLock().lock();
439 lock.writeLock().unlock();
440 }});
441 Thread t2 = newStartedThread(new CheckedRunnable() {
442 public void realRun() {
443 lock.writeLock().lock();
444 lock.writeLock().unlock();
445 }});
446
447 lock.writeLock().lock();
448 lock.writeLock().unlock();
449 Thread.sleep(SHORT_DELAY_MS);
450 lock.writeLock().lock();
451 lock.writeLock().unlock();
452 lock.writeLock().unlock();
453 awaitTermination(t1, LONG_DELAY_MS);
454 awaitTermination(t2, LONG_DELAY_MS);
455 }
456
457
458 /**
459 * Fair Read trylock succeeds if write locked by current thread
460 */
461 public void testReadHoldingWriteLockFair() {
462 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
463 lock.writeLock().lock();
464 assertTrue(lock.readLock().tryLock());
465 lock.readLock().unlock();
466 lock.writeLock().unlock();
467 }
468
469 /**
470 * Fair Read lock succeeds if write locked by current thread even if
471 * other threads are waiting for readlock
472 */
473 public void testReadHoldingWriteLockFair2() throws InterruptedException {
474 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
475 lock.writeLock().lock();
476 Thread t1 = newStartedThread(new CheckedRunnable() {
477 public void realRun() {
478 lock.readLock().lock();
479 lock.readLock().unlock();
480 }});
481 Thread t2 = newStartedThread(new CheckedRunnable() {
482 public void realRun() {
483 lock.readLock().lock();
484 lock.readLock().unlock();
485 }});
486
487 lock.readLock().lock();
488 lock.readLock().unlock();
489 Thread.sleep(SHORT_DELAY_MS);
490 lock.readLock().lock();
491 lock.readLock().unlock();
492 lock.writeLock().unlock();
493 awaitTermination(t1, LONG_DELAY_MS);
494 awaitTermination(t2, LONG_DELAY_MS);
495 }
496
497
498 /**
499 * Fair Read lock succeeds if write locked by current thread even if
500 * other threads are waiting for writelock
501 */
502 public void testReadHoldingWriteLockFair3() throws InterruptedException {
503 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
504 lock.writeLock().lock();
505 Thread t1 = newStartedThread(new CheckedRunnable() {
506 public void realRun() {
507 lock.writeLock().lock();
508 lock.writeLock().unlock();
509 }});
510 Thread t2 = newStartedThread(new CheckedRunnable() {
511 public void realRun() {
512 lock.writeLock().lock();
513 lock.writeLock().unlock();
514 }});
515
516 lock.readLock().lock();
517 lock.readLock().unlock();
518 Thread.sleep(SHORT_DELAY_MS);
519 lock.readLock().lock();
520 lock.readLock().unlock();
521 lock.writeLock().unlock();
522 awaitTermination(t1, LONG_DELAY_MS);
523 awaitTermination(t2, LONG_DELAY_MS);
524 }
525
526
527 /**
528 * Fair Write lock succeeds if write locked by current thread even if
529 * other threads are waiting for writelock
530 */
531 public void testWriteHoldingWriteLockFair4() throws InterruptedException {
532 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
533 lock.writeLock().lock();
534 Thread t1 = newStartedThread(new CheckedRunnable() {
535 public void realRun() {
536 lock.writeLock().lock();
537 lock.writeLock().unlock();
538 }});
539 Thread t2 = newStartedThread(new CheckedRunnable() {
540 public void realRun() {
541 lock.writeLock().lock();
542 lock.writeLock().unlock();
543 }});
544
545 Thread.sleep(SHORT_DELAY_MS);
546 assertTrue(lock.isWriteLockedByCurrentThread());
547 assertEquals(1, lock.getWriteHoldCount());
548 lock.writeLock().lock();
549 assertEquals(2, lock.getWriteHoldCount());
550 lock.writeLock().unlock();
551 lock.writeLock().lock();
552 lock.writeLock().unlock();
553 lock.writeLock().unlock();
554 awaitTermination(t1, LONG_DELAY_MS);
555 awaitTermination(t2, LONG_DELAY_MS);
556 }
557
558
559 /**
560 * Read tryLock succeeds if readlocked but not writelocked
561 */
562 public void testTryLockWhenReadLocked() throws InterruptedException {
563 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
564 lock.readLock().lock();
565 Thread t = newStartedThread(new CheckedRunnable() {
566 public void realRun() {
567 assertTrue(lock.readLock().tryLock());
568 lock.readLock().unlock();
569 }});
570
571 awaitTermination(t, LONG_DELAY_MS);
572 lock.readLock().unlock();
573 }
574
575 /**
576 * write tryLock fails when readlocked
577 */
578 public void testWriteTryLockWhenReadLocked() throws InterruptedException {
579 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
580 lock.readLock().lock();
581 Thread t = newStartedThread(new CheckedRunnable() {
582 public void realRun() {
583 assertFalse(lock.writeLock().tryLock());
584 }});
585
586 awaitTermination(t, LONG_DELAY_MS);
587 lock.readLock().unlock();
588 }
589
590
591 /**
592 * Fair Read tryLock succeeds if readlocked but not writelocked
593 */
594 public void testTryLockWhenReadLockedFair() throws InterruptedException {
595 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
596 lock.readLock().lock();
597 Thread t = newStartedThread(new CheckedRunnable() {
598 public void realRun() {
599 assertTrue(lock.readLock().tryLock());
600 lock.readLock().unlock();
601 }});
602
603 awaitTermination(t, LONG_DELAY_MS);
604 lock.readLock().unlock();
605 }
606
607
608
609 /**
610 * Fair write tryLock fails when readlocked
611 */
612 public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
613 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
614 lock.readLock().lock();
615 Thread t = newStartedThread(new CheckedRunnable() {
616 public void realRun() {
617 assertFalse(lock.writeLock().tryLock());
618 }});
619
620 awaitTermination(t, LONG_DELAY_MS);
621 lock.readLock().unlock();
622 }
623
624
625
626 /**
627 * write timed tryLock times out if locked
628 */
629 public void testWriteTryLock_Timeout() throws InterruptedException {
630 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
631 lock.writeLock().lock();
632 Thread t = newStartedThread(new CheckedRunnable() {
633 public void realRun() throws InterruptedException {
634 assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
635 }});
636
637 awaitTermination(t, LONG_DELAY_MS);
638 assertTrue(lock.writeLock().isHeldByCurrentThread());
639 lock.writeLock().unlock();
640 }
641
642 /**
643 * read timed tryLock times out if write-locked
644 */
645 public void testReadTryLock_Timeout() throws InterruptedException {
646 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
647 lock.writeLock().lock();
648 Thread t = newStartedThread(new CheckedRunnable() {
649 public void realRun() throws InterruptedException {
650 assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
651 }});
652
653 awaitTermination(t, LONG_DELAY_MS);
654 assertTrue(lock.writeLock().isHeldByCurrentThread());
655 lock.writeLock().unlock();
656 }
657
658
659 /**
660 * write lockInterruptibly succeeds if lock free else is interruptible
661 */
662 public void testWriteLockInterruptibly() throws InterruptedException {
663 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
664 lock.writeLock().lockInterruptibly();
665 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
666 public void realRun() throws InterruptedException {
667 lock.writeLock().lockInterruptibly();
668 }});
669
670 Thread.sleep(SHORT_DELAY_MS);
671 t.interrupt();
672 awaitTermination(t, LONG_DELAY_MS);
673 releaseWriteLock(lock);
674 }
675
676 /**
677 * read lockInterruptibly succeeds if lock free else is interruptible
678 */
679 public void testReadLockInterruptibly() throws InterruptedException {
680 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
681 lock.writeLock().lockInterruptibly();
682 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
683 public void realRun() throws InterruptedException {
684 lock.readLock().lockInterruptibly();
685 }});
686
687 Thread.sleep(SHORT_DELAY_MS);
688 t.interrupt();
689 awaitTermination(t, LONG_DELAY_MS);
690 releaseWriteLock(lock);
691 }
692
693 /**
694 * Calling await without holding lock throws IllegalMonitorStateException
695 */
696 public void testAwait_IllegalMonitor() throws InterruptedException {
697 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
698 final Condition c = lock.writeLock().newCondition();
699 try {
700 c.await();
701 shouldThrow();
702 } catch (IllegalMonitorStateException success) {}
703 }
704
705 /**
706 * Calling signal without holding lock throws IllegalMonitorStateException
707 */
708 public void testSignal_IllegalMonitor() {
709 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
710 final Condition c = lock.writeLock().newCondition();
711 try {
712 c.signal();
713 shouldThrow();
714 } catch (IllegalMonitorStateException success) {}
715 }
716
717 /**
718 * awaitNanos without a signal times out
719 */
720 public void testAwaitNanos_Timeout() throws InterruptedException {
721 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
722 final Condition c = lock.writeLock().newCondition();
723
724 lock.writeLock().lock();
725 long t = c.awaitNanos(100);
726 assertTrue(t <= 0);
727 lock.writeLock().unlock();
728 }
729
730
731 /**
732 * timed await without a signal times out
733 */
734 public void testAwait_Timeout() throws InterruptedException {
735 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
736 final Condition c = lock.writeLock().newCondition();
737 lock.writeLock().lock();
738 assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
739 lock.writeLock().unlock();
740 }
741
742 /**
743 * awaitUntil without a signal times out
744 */
745 public void testAwaitUntil_Timeout() throws InterruptedException {
746 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
747 final Condition c = lock.writeLock().newCondition();
748 lock.writeLock().lock();
749 java.util.Date d = new java.util.Date();
750 assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
751 lock.writeLock().unlock();
752 }
753
754 /**
755 * await returns when signalled
756 */
757 public void testAwait() throws InterruptedException {
758 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
759 final Condition c = lock.writeLock().newCondition();
760 Thread t = newStartedThread(new CheckedRunnable() {
761 public void realRun() throws InterruptedException {
762 lock.writeLock().lock();
763 c.await();
764 lock.writeLock().unlock();
765 }});
766
767 Thread.sleep(SHORT_DELAY_MS);
768 lock.writeLock().lock();
769 c.signal();
770 lock.writeLock().unlock();
771 awaitTermination(t, LONG_DELAY_MS);
772 }
773
774 /** A helper class for uninterruptible wait tests */
775 class UninterruptableThread extends Thread {
776 private Lock lock;
777 private Condition c;
778
779 public volatile boolean canAwake = false;
780 public volatile boolean interrupted = false;
781 public volatile boolean lockStarted = false;
782
783 public UninterruptableThread(Lock lock, Condition c) {
784 this.lock = lock;
785 this.c = c;
786 }
787
788 public synchronized void run() {
789 lock.lock();
790 lockStarted = true;
791
792 while (!canAwake) {
793 c.awaitUninterruptibly();
794 }
795
796 interrupted = isInterrupted();
797 lock.unlock();
798 }
799 }
800
801 /**
802 * awaitUninterruptibly doesn't abort on interrupt
803 */
804 public void testAwaitUninterruptibly() throws InterruptedException {
805 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
806 final Condition c = lock.writeLock().newCondition();
807 UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c);
808
809 thread.start();
810
811 while (!thread.lockStarted) {
812 Thread.sleep(100);
813 }
814
815 lock.writeLock().lock();
816 try {
817 thread.interrupt();
818 thread.canAwake = true;
819 c.signal();
820 } finally {
821 lock.writeLock().unlock();
822 }
823
824 awaitTermination(thread, LONG_DELAY_MS);
825 assertTrue(thread.interrupted);
826 }
827
828 /**
829 * await is interruptible
830 */
831 public void testAwait_Interrupt() throws InterruptedException {
832 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
833 final Condition c = lock.writeLock().newCondition();
834 final CountDownLatch locked = new CountDownLatch(1);
835 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
836 public void realRun() throws InterruptedException {
837 lock.writeLock().lock();
838 assertTrue(lock.isWriteLocked());
839 locked.countDown();
840 try { c.await(); }
841 finally { lock.writeLock().unlock(); }
842 }});
843
844 locked.await();
845 while (lock.isWriteLocked())
846 Thread.yield();
847 t.interrupt();
848 awaitTermination(t, LONG_DELAY_MS);
849 assertFalse(lock.isWriteLocked());
850 }
851
852 /**
853 * awaitNanos is interruptible
854 */
855 public void testAwaitNanos_Interrupt() throws InterruptedException {
856 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
857 final Condition c = lock.writeLock().newCondition();
858 final CountDownLatch locked = new CountDownLatch(1);
859 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
860 public void realRun() throws InterruptedException {
861 lock.writeLock().lock();
862 assertTrue(lock.isWriteLocked());
863 locked.countDown();
864 try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
865 finally { lock.writeLock().unlock(); }
866 }});
867
868 locked.await();
869 while (lock.isWriteLocked())
870 Thread.yield();
871 t.interrupt();
872 awaitTermination(t, LONG_DELAY_MS);
873 assertFalse(lock.isWriteLocked());
874 }
875
876 /**
877 * awaitUntil is interruptible
878 */
879 public void testAwaitUntil_Interrupt() throws InterruptedException {
880 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
881 final Condition c = lock.writeLock().newCondition();
882 final CountDownLatch locked = new CountDownLatch(1);
883 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
884 public void realRun() throws InterruptedException {
885 lock.writeLock().lock();
886 assertTrue(lock.isWriteLocked());
887 locked.countDown();
888 java.util.Date d = new java.util.Date();
889 try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
890 finally { lock.writeLock().unlock(); }
891 }});
892
893 locked.await();
894 while (lock.isWriteLocked())
895 Thread.yield();
896 t.interrupt();
897 awaitTermination(t, LONG_DELAY_MS);
898 assertFalse(lock.isWriteLocked());
899 }
900
901 /**
902 * signalAll wakes up all threads
903 */
904 public void testSignalAll() throws InterruptedException {
905 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
906 final Condition c = lock.writeLock().newCondition();
907 Thread t1 = newStartedThread(new CheckedRunnable() {
908 public void realRun() throws InterruptedException {
909 lock.writeLock().lock();
910 c.await();
911 lock.writeLock().unlock();
912 }});
913
914 Thread t2 = newStartedThread(new CheckedRunnable() {
915 public void realRun() throws InterruptedException {
916 lock.writeLock().lock();
917 c.await();
918 lock.writeLock().unlock();
919 }});
920
921 Thread.sleep(SHORT_DELAY_MS);
922 lock.writeLock().lock();
923 c.signalAll();
924 lock.writeLock().unlock();
925 awaitTermination(t1, LONG_DELAY_MS);
926 awaitTermination(t2, LONG_DELAY_MS);
927 }
928
929 /**
930 * A serialized lock deserializes as unlocked
931 */
932 public void testSerialization() throws Exception {
933 ReentrantReadWriteLock l = new ReentrantReadWriteLock();
934 l.readLock().lock();
935 l.readLock().unlock();
936
937 ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
938 ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
939 out.writeObject(l);
940 out.close();
941
942 ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
943 ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
944 ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
945 r.readLock().lock();
946 r.readLock().unlock();
947 }
948
949 /**
950 * hasQueuedThreads reports whether there are waiting threads
951 */
952 public void testhasQueuedThreads() throws InterruptedException {
953 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
954 Thread t1 = new Thread(new InterruptedLockRunnable(lock));
955 Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
956 assertFalse(lock.hasQueuedThreads());
957 lock.writeLock().lock();
958 t1.start();
959 Thread.sleep(SHORT_DELAY_MS);
960 assertTrue(lock.hasQueuedThreads());
961 t2.start();
962 Thread.sleep(SHORT_DELAY_MS);
963 assertTrue(lock.hasQueuedThreads());
964 t1.interrupt();
965 Thread.sleep(SHORT_DELAY_MS);
966 assertTrue(lock.hasQueuedThreads());
967 lock.writeLock().unlock();
968 Thread.sleep(SHORT_DELAY_MS);
969 assertFalse(lock.hasQueuedThreads());
970 awaitTermination(t1, LONG_DELAY_MS);
971 awaitTermination(t2, LONG_DELAY_MS);
972 }
973
974 /**
975 * hasQueuedThread(null) throws NPE
976 */
977 public void testHasQueuedThreadNPE() {
978 final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
979 try {
980 sync.hasQueuedThread(null);
981 shouldThrow();
982 } catch (NullPointerException success) {}
983 }
984
985 /**
986 * hasQueuedThread reports whether a thread is queued.
987 */
988 public void testHasQueuedThread() throws InterruptedException {
989 final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
990 Thread t1 = new Thread(new InterruptedLockRunnable(sync));
991 Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
992 assertFalse(sync.hasQueuedThread(t1));
993 assertFalse(sync.hasQueuedThread(t2));
994 sync.writeLock().lock();
995 t1.start();
996 Thread.sleep(SHORT_DELAY_MS);
997 assertTrue(sync.hasQueuedThread(t1));
998 t2.start();
999 Thread.sleep(SHORT_DELAY_MS);
1000 assertTrue(sync.hasQueuedThread(t1));
1001 assertTrue(sync.hasQueuedThread(t2));
1002 t1.interrupt();
1003 Thread.sleep(SHORT_DELAY_MS);
1004 assertFalse(sync.hasQueuedThread(t1));
1005 assertTrue(sync.hasQueuedThread(t2));
1006 sync.writeLock().unlock();
1007 Thread.sleep(SHORT_DELAY_MS);
1008 assertFalse(sync.hasQueuedThread(t1));
1009 Thread.sleep(SHORT_DELAY_MS);
1010 assertFalse(sync.hasQueuedThread(t2));
1011 awaitTermination(t1, LONG_DELAY_MS);
1012 awaitTermination(t2, LONG_DELAY_MS);
1013 }
1014
1015
1016 /**
1017 * getQueueLength reports number of waiting threads
1018 */
1019 public void testGetQueueLength() throws InterruptedException {
1020 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1021 Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1022 Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1023 assertEquals(0, lock.getQueueLength());
1024 lock.writeLock().lock();
1025 t1.start();
1026 Thread.sleep(SHORT_DELAY_MS);
1027 assertEquals(1, lock.getQueueLength());
1028 t2.start();
1029 Thread.sleep(SHORT_DELAY_MS);
1030 assertEquals(2, lock.getQueueLength());
1031 t1.interrupt();
1032 Thread.sleep(SHORT_DELAY_MS);
1033 assertEquals(1, lock.getQueueLength());
1034 lock.writeLock().unlock();
1035 Thread.sleep(SHORT_DELAY_MS);
1036 assertEquals(0, lock.getQueueLength());
1037 awaitTermination(t1, LONG_DELAY_MS);
1038 awaitTermination(t2, LONG_DELAY_MS);
1039 }
1040
1041 /**
1042 * getQueuedThreads includes waiting threads
1043 */
1044 public void testGetQueuedThreads() throws InterruptedException {
1045 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1046 Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1047 Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1048 assertTrue(lock.getQueuedThreads().isEmpty());
1049 lock.writeLock().lock();
1050 assertTrue(lock.getQueuedThreads().isEmpty());
1051 t1.start();
1052 Thread.sleep(SHORT_DELAY_MS);
1053 assertTrue(lock.getQueuedThreads().contains(t1));
1054 t2.start();
1055 Thread.sleep(SHORT_DELAY_MS);
1056 assertTrue(lock.getQueuedThreads().contains(t1));
1057 assertTrue(lock.getQueuedThreads().contains(t2));
1058 t1.interrupt();
1059 Thread.sleep(SHORT_DELAY_MS);
1060 assertFalse(lock.getQueuedThreads().contains(t1));
1061 assertTrue(lock.getQueuedThreads().contains(t2));
1062 lock.writeLock().unlock();
1063 Thread.sleep(SHORT_DELAY_MS);
1064 assertTrue(lock.getQueuedThreads().isEmpty());
1065 awaitTermination(t1, LONG_DELAY_MS);
1066 awaitTermination(t2, LONG_DELAY_MS);
1067 }
1068
1069 /**
1070 * hasWaiters throws NPE if null
1071 */
1072 public void testHasWaitersNPE() {
1073 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1074 try {
1075 lock.hasWaiters(null);
1076 shouldThrow();
1077 } catch (NullPointerException success) {}
1078 }
1079
1080 /**
1081 * getWaitQueueLength throws NPE if null
1082 */
1083 public void testGetWaitQueueLengthNPE() {
1084 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1085 try {
1086 lock.getWaitQueueLength(null);
1087 shouldThrow();
1088 } catch (NullPointerException success) {}
1089 }
1090
1091
1092 /**
1093 * getWaitingThreads throws NPE if null
1094 */
1095 public void testGetWaitingThreadsNPE() {
1096 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1097 try {
1098 lock.getWaitingThreads(null);
1099 shouldThrow();
1100 } catch (NullPointerException success) {}
1101 }
1102
1103 /**
1104 * hasWaiters throws IAE if not owned
1105 */
1106 public void testHasWaitersIAE() {
1107 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1108 final Condition c = lock.writeLock().newCondition();
1109 final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1110 try {
1111 lock2.hasWaiters(c);
1112 shouldThrow();
1113 } catch (IllegalArgumentException success) {}
1114 }
1115
1116 /**
1117 * hasWaiters throws IMSE if not locked
1118 */
1119 public void testHasWaitersIMSE() {
1120 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1121 final Condition c = lock.writeLock().newCondition();
1122 try {
1123 lock.hasWaiters(c);
1124 shouldThrow();
1125 } catch (IllegalMonitorStateException success) {}
1126 }
1127
1128
1129 /**
1130 * getWaitQueueLength throws IAE if not owned
1131 */
1132 public void testGetWaitQueueLengthIAE() {
1133 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1134 final Condition c = lock.writeLock().newCondition();
1135 final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1136 try {
1137 lock2.getWaitQueueLength(c);
1138 shouldThrow();
1139 } catch (IllegalArgumentException success) {}
1140 }
1141
1142 /**
1143 * getWaitQueueLength throws IMSE if not locked
1144 */
1145 public void testGetWaitQueueLengthIMSE() {
1146 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1147 final Condition c = lock.writeLock().newCondition();
1148 try {
1149 lock.getWaitQueueLength(c);
1150 shouldThrow();
1151 } catch (IllegalMonitorStateException success) {}
1152 }
1153
1154
1155 /**
1156 * getWaitingThreads throws IAE if not owned
1157 */
1158 public void testGetWaitingThreadsIAE() {
1159 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1160 final Condition c = lock.writeLock().newCondition();
1161 final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1162 try {
1163 lock2.getWaitingThreads(c);
1164 shouldThrow();
1165 } catch (IllegalArgumentException success) {}
1166 }
1167
1168 /**
1169 * getWaitingThreads throws IMSE if not locked
1170 */
1171 public void testGetWaitingThreadsIMSE() {
1172 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1173 final Condition c = lock.writeLock().newCondition();
1174 try {
1175 lock.getWaitingThreads(c);
1176 shouldThrow();
1177 } catch (IllegalMonitorStateException success) {}
1178 }
1179
1180
1181 /**
1182 * hasWaiters returns true when a thread is waiting, else false
1183 */
1184 public void testHasWaiters() throws InterruptedException {
1185 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1186 final Condition c = lock.writeLock().newCondition();
1187 Thread t = newStartedThread(new CheckedRunnable() {
1188 public void realRun() throws InterruptedException {
1189 lock.writeLock().lock();
1190 assertFalse(lock.hasWaiters(c));
1191 assertEquals(0, lock.getWaitQueueLength(c));
1192 c.await();
1193 lock.writeLock().unlock();
1194 }});
1195
1196 Thread.sleep(SHORT_DELAY_MS);
1197 lock.writeLock().lock();
1198 assertTrue(lock.hasWaiters(c));
1199 assertEquals(1, lock.getWaitQueueLength(c));
1200 c.signal();
1201 lock.writeLock().unlock();
1202 Thread.sleep(SHORT_DELAY_MS);
1203 lock.writeLock().lock();
1204 assertFalse(lock.hasWaiters(c));
1205 assertEquals(0, lock.getWaitQueueLength(c));
1206 lock.writeLock().unlock();
1207 awaitTermination(t, LONG_DELAY_MS);
1208 }
1209
1210 /**
1211 * getWaitQueueLength returns number of waiting threads
1212 */
1213 public void testGetWaitQueueLength() throws InterruptedException {
1214 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1215 final Condition c = lock.writeLock().newCondition();
1216 Thread t = newStartedThread(new CheckedRunnable() {
1217 public void realRun() throws InterruptedException {
1218 lock.writeLock().lock();
1219 assertFalse(lock.hasWaiters(c));
1220 assertEquals(0, lock.getWaitQueueLength(c));
1221 c.await();
1222 lock.writeLock().unlock();
1223 }});
1224
1225 Thread.sleep(SHORT_DELAY_MS);
1226 lock.writeLock().lock();
1227 assertTrue(lock.hasWaiters(c));
1228 assertEquals(1, lock.getWaitQueueLength(c));
1229 c.signal();
1230 lock.writeLock().unlock();
1231 Thread.sleep(SHORT_DELAY_MS);
1232 lock.writeLock().lock();
1233 assertFalse(lock.hasWaiters(c));
1234 assertEquals(0, lock.getWaitQueueLength(c));
1235 lock.writeLock().unlock();
1236 awaitTermination(t, LONG_DELAY_MS);
1237 }
1238
1239
1240 /**
1241 * getWaitingThreads returns only and all waiting threads
1242 */
1243 public void testGetWaitingThreads() throws InterruptedException {
1244 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1245 final Condition c = lock.writeLock().newCondition();
1246 Thread t1 = new Thread(new CheckedRunnable() {
1247 public void realRun() throws InterruptedException {
1248 lock.writeLock().lock();
1249 assertTrue(lock.getWaitingThreads(c).isEmpty());
1250 c.await();
1251 lock.writeLock().unlock();
1252 }});
1253
1254 Thread t2 = new Thread(new CheckedRunnable() {
1255 public void realRun() throws InterruptedException {
1256 lock.writeLock().lock();
1257 assertFalse(lock.getWaitingThreads(c).isEmpty());
1258 c.await();
1259 lock.writeLock().unlock();
1260 }});
1261
1262 lock.writeLock().lock();
1263 assertTrue(lock.getWaitingThreads(c).isEmpty());
1264 lock.writeLock().unlock();
1265 t1.start();
1266 Thread.sleep(SHORT_DELAY_MS);
1267 t2.start();
1268 Thread.sleep(SHORT_DELAY_MS);
1269 lock.writeLock().lock();
1270 assertTrue(lock.hasWaiters(c));
1271 assertTrue(lock.getWaitingThreads(c).contains(t1));
1272 assertTrue(lock.getWaitingThreads(c).contains(t2));
1273 c.signalAll();
1274 lock.writeLock().unlock();
1275 Thread.sleep(SHORT_DELAY_MS);
1276 lock.writeLock().lock();
1277 assertFalse(lock.hasWaiters(c));
1278 assertTrue(lock.getWaitingThreads(c).isEmpty());
1279 lock.writeLock().unlock();
1280 awaitTermination(t1, LONG_DELAY_MS);
1281 awaitTermination(t2, LONG_DELAY_MS);
1282 }
1283
1284 /**
1285 * toString indicates current lock state
1286 */
1287 public void testToString() {
1288 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1289 String us = lock.toString();
1290 assertTrue(us.indexOf("Write locks = 0") >= 0);
1291 assertTrue(us.indexOf("Read locks = 0") >= 0);
1292 lock.writeLock().lock();
1293 String ws = lock.toString();
1294 assertTrue(ws.indexOf("Write locks = 1") >= 0);
1295 assertTrue(ws.indexOf("Read locks = 0") >= 0);
1296 lock.writeLock().unlock();
1297 lock.readLock().lock();
1298 lock.readLock().lock();
1299 String rs = lock.toString();
1300 assertTrue(rs.indexOf("Write locks = 0") >= 0);
1301 assertTrue(rs.indexOf("Read locks = 2") >= 0);
1302 }
1303
1304 /**
1305 * readLock.toString indicates current lock state
1306 */
1307 public void testReadLockToString() {
1308 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1309 String us = lock.readLock().toString();
1310 assertTrue(us.indexOf("Read locks = 0") >= 0);
1311 lock.readLock().lock();
1312 lock.readLock().lock();
1313 String rs = lock.readLock().toString();
1314 assertTrue(rs.indexOf("Read locks = 2") >= 0);
1315 }
1316
1317 /**
1318 * writeLock.toString indicates current lock state
1319 */
1320 public void testWriteLockToString() {
1321 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1322 String us = lock.writeLock().toString();
1323 assertTrue(us.indexOf("Unlocked") >= 0);
1324 lock.writeLock().lock();
1325 String ls = lock.writeLock().toString();
1326 assertTrue(ls.indexOf("Locked") >= 0);
1327 }
1328
1329 }