ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java
Revision: 1.13
Committed: Sun Dec 28 21:56:18 2003 UTC (20 years, 4 months ago) by dl
Branch: MAIN
Changes since 1.12: +192 -18 lines
Log Message: 
Add tests for AQS extensions; adjust others for protected condition methods

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     lock.writeLock().lock();
160     Thread t = new Thread(new Runnable() {
161 dl 1.4 public void run() {
162     try {
163 dl 1.1 lock.writeLock().lockInterruptibly();
164 dl 1.4 threadShouldThrow();
165     } catch(InterruptedException success){}
166 dl 1.1 }
167     });
168 dl 1.2 try {
169     t.start();
170     t.interrupt();
171     lock.writeLock().unlock();
172     t.join();
173     } catch(Exception e){
174 dl 1.4 unexpectedException();
175 dl 1.2 }
176 dl 1.1 }
177    
178 dl 1.4 /**
179     * timed write-trylock is interruptible
180     */
181     public void testWriteTryLock_Interrupted() {
182 dl 1.1 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
183     lock.writeLock().lock();
184     Thread t = new Thread(new Runnable() {
185 dl 1.4 public void run() {
186     try {
187 dl 1.1 lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
188 dl 1.4 threadShouldThrow();
189     } catch(InterruptedException success){}
190 dl 1.2 }
191     });
192     try {
193     t.start();
194     t.interrupt();
195     lock.writeLock().unlock();
196     t.join();
197     } catch(Exception e){
198 dl 1.4 unexpectedException();
199 dl 1.2 }
200     }
201    
202 dl 1.4 /**
203     * read-lockInterruptibly is interruptible
204     */
205     public void testReadLockInterruptibly_Interrupted() {
206 dl 1.2 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
207     lock.writeLock().lock();
208     Thread t = new Thread(new Runnable() {
209 dl 1.4 public void run() {
210     try {
211 dl 1.2 lock.readLock().lockInterruptibly();
212 dl 1.4 threadShouldThrow();
213     } 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     * timed read-trylock is interruptible
228     */
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     * write-trylock fails if locked
252     */
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     * read-trylock fails if locked
272     */
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     * Read trylock succeeds if readlocked but not writelocked
382     */
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     * write trylock fails when readlocked
405     */
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     * write timed trylock times out if locked
427     */
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     * read timed trylock times out if write-locked
451     */
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.13 * hasWaiters throws IAE if not owned
942     */
943     public void testHasWaitersIAE() {
944     final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
945     final Condition c = (lock.writeLock().newCondition());
946     final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
947     try {
948     lock2.hasWaiters(c);
949     shouldThrow();
950     } catch (IllegalArgumentException success) {
951     } catch (Exception ex) {
952     unexpectedException();
953     }
954     }
955    
956     /**
957     * hasWaiters throws IMSE if not locked
958     */
959     public void testHasWaitersIMSE() {
960     final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
961     final Condition c = (lock.writeLock().newCondition());
962     try {
963     lock.hasWaiters(c);
964     shouldThrow();
965     } catch (IllegalMonitorStateException success) {
966     } catch (Exception ex) {
967     unexpectedException();
968     }
969     }
970    
971    
972     /**
973     * getWaitQueueLength throws IAE if not owned
974     */
975     public void testGetWaitQueueLengthIAE() {
976     final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
977     final Condition c = (lock.writeLock().newCondition());
978     final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
979     try {
980     lock2.getWaitQueueLength(c);
981     shouldThrow();
982     } catch (IllegalArgumentException success) {
983     } catch (Exception ex) {
984     unexpectedException();
985     }
986     }
987    
988     /**
989     * getWaitQueueLength throws IMSE if not locked
990     */
991     public void testGetWaitQueueLengthIMSE() {
992     final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
993     final Condition c = (lock.writeLock().newCondition());
994     try {
995     lock.getWaitQueueLength(c);
996     shouldThrow();
997     } catch (IllegalMonitorStateException success) {
998     } catch (Exception ex) {
999     unexpectedException();
1000     }
1001     }
1002    
1003    
1004     /**
1005     * getWaitingThreads throws IAE if not owned
1006     */
1007     public void testGetWaitingThreadsIAE() {
1008     final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1009     final Condition c = (lock.writeLock().newCondition());
1010     final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1011     try {
1012     lock2.getWaitingThreads(c);
1013     shouldThrow();
1014     } catch (IllegalArgumentException success) {
1015     } catch (Exception ex) {
1016     unexpectedException();
1017     }
1018     }
1019    
1020     /**
1021     * getWaitingThreads throws IMSE if not locked
1022     */
1023     public void testGetWaitingThreadsIMSE() {
1024     final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1025     final Condition c = (lock.writeLock().newCondition());
1026     try {
1027     lock.getWaitingThreads(c);
1028     shouldThrow();
1029     } catch (IllegalMonitorStateException success) {
1030     } catch (Exception ex) {
1031     unexpectedException();
1032     }
1033     }
1034    
1035    
1036     /**
1037 dl 1.6 * hasWaiters returns true when a thread is waiting, else false
1038     */
1039     public void testHasWaiters() {
1040 dl 1.13 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1041     final Condition c = (lock.writeLock().newCondition());
1042 dl 1.6 Thread t = new Thread(new Runnable() {
1043     public void run() {
1044     try {
1045     lock.writeLock().lock();
1046 dl 1.13 threadAssertFalse(lock.hasWaiters(c));
1047     threadAssertEquals(0, lock.getWaitQueueLength(c));
1048 dl 1.6 c.await();
1049     lock.writeLock().unlock();
1050     }
1051     catch(InterruptedException e) {
1052     threadUnexpectedException();
1053     }
1054     }
1055     });
1056    
1057     try {
1058     t.start();
1059     Thread.sleep(SHORT_DELAY_MS);
1060     lock.writeLock().lock();
1061 dl 1.13 assertTrue(lock.hasWaiters(c));
1062     assertEquals(1, lock.getWaitQueueLength(c));
1063 dl 1.6 c.signal();
1064     lock.writeLock().unlock();
1065     Thread.sleep(SHORT_DELAY_MS);
1066     lock.writeLock().lock();
1067 dl 1.13 assertFalse(lock.hasWaiters(c));
1068     assertEquals(0, lock.getWaitQueueLength(c));
1069 dl 1.6 lock.writeLock().unlock();
1070     t.join(SHORT_DELAY_MS);
1071     assertFalse(t.isAlive());
1072     }
1073     catch (Exception ex) {
1074     unexpectedException();
1075     }
1076     }
1077    
1078     /**
1079     * getWaitQueueLength returns number of waiting threads
1080     */
1081     public void testGetWaitQueueLength() {
1082 dl 1.13 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1083     final Condition c = (lock.writeLock().newCondition());
1084     Thread t = new Thread(new Runnable() {
1085     public void run() {
1086     try {
1087     lock.writeLock().lock();
1088     threadAssertFalse(lock.hasWaiters(c));
1089     threadAssertEquals(0, lock.getWaitQueueLength(c));
1090     c.await();
1091     lock.writeLock().unlock();
1092     }
1093     catch(InterruptedException e) {
1094     threadUnexpectedException();
1095     }
1096     }
1097     });
1098    
1099     try {
1100     t.start();
1101     Thread.sleep(SHORT_DELAY_MS);
1102     lock.writeLock().lock();
1103     assertTrue(lock.hasWaiters(c));
1104     assertEquals(1, lock.getWaitQueueLength(c));
1105     c.signal();
1106     lock.writeLock().unlock();
1107     Thread.sleep(SHORT_DELAY_MS);
1108     lock.writeLock().lock();
1109     assertFalse(lock.hasWaiters(c));
1110     assertEquals(0, lock.getWaitQueueLength(c));
1111     lock.writeLock().unlock();
1112     t.join(SHORT_DELAY_MS);
1113     assertFalse(t.isAlive());
1114     }
1115     catch (Exception ex) {
1116     unexpectedException();
1117     }
1118     }
1119    
1120    
1121     /**
1122     * getWaitingThreads returns only and all waiting threads
1123     */
1124     public void testGetWaitingThreads() {
1125     final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1126     final Condition c = lock.writeLock().newCondition();
1127 dl 1.6 Thread t1 = new Thread(new Runnable() {
1128     public void run() {
1129     try {
1130     lock.writeLock().lock();
1131 dl 1.13 threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
1132 dl 1.6 c.await();
1133     lock.writeLock().unlock();
1134     }
1135     catch(InterruptedException e) {
1136     threadUnexpectedException();
1137     }
1138     }
1139     });
1140    
1141     Thread t2 = new Thread(new Runnable() {
1142     public void run() {
1143     try {
1144     lock.writeLock().lock();
1145 dl 1.13 threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
1146 dl 1.6 c.await();
1147     lock.writeLock().unlock();
1148     }
1149     catch(InterruptedException e) {
1150     threadUnexpectedException();
1151     }
1152     }
1153     });
1154    
1155     try {
1156 dl 1.13 lock.writeLock().lock();
1157     assertTrue(lock.getWaitingThreads(c).isEmpty());
1158     lock.writeLock().unlock();
1159 dl 1.6 t1.start();
1160     Thread.sleep(SHORT_DELAY_MS);
1161     t2.start();
1162     Thread.sleep(SHORT_DELAY_MS);
1163     lock.writeLock().lock();
1164 dl 1.13 assertTrue(lock.hasWaiters(c));
1165     assertTrue(lock.getWaitingThreads(c).contains(t1));
1166     assertTrue(lock.getWaitingThreads(c).contains(t2));
1167 dl 1.6 c.signalAll();
1168     lock.writeLock().unlock();
1169     Thread.sleep(SHORT_DELAY_MS);
1170     lock.writeLock().lock();
1171 dl 1.13 assertFalse(lock.hasWaiters(c));
1172     assertTrue(lock.getWaitingThreads(c).isEmpty());
1173 dl 1.6 lock.writeLock().unlock();
1174     t1.join(SHORT_DELAY_MS);
1175     t2.join(SHORT_DELAY_MS);
1176     assertFalse(t1.isAlive());
1177     assertFalse(t2.isAlive());
1178     }
1179     catch (Exception ex) {
1180     unexpectedException();
1181     }
1182     }
1183 dl 1.13
1184 dl 1.1 }