/[cvs]/jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java
ViewVC logotype

Contents of /jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.16 - (show annotations)
Sun Jan 11 16:02:33 2004 UTC (15 years, 7 months ago) by dl
Branch: MAIN
Changes since 1.15: +119 -114 lines
Simplify/shorten AQS method names

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

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27