ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java
Revision: 1.17
Committed: Thu Jan 8 01:29:46 2004 UTC (20 years, 4 months ago) by dl
Branch: MAIN
Changes since 1.16: +0 -1 lines
Log Message: 
Add Atomic array constructor tests; adjust timings on other tests

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