ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java
Revision: 1.37
Committed: Sat Nov 21 10:25:05 2009 UTC (14 years, 5 months ago) by jsr166
Branch: MAIN
Changes since 1.36: +111 -134 lines
Log Message: 
improve exception handling

File Contents

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