ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java
(Generate patch)

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.28 by jsr166, Wed Nov 18 16:04:34 2009 UTC vs.
Revision 1.32 by jsr166, Mon Nov 30 08:31:09 2009 UTC

# Line 10 | Line 10
10   import junit.framework.*;
11   import java.util.*;
12   import java.util.concurrent.*;
13 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
14   import java.util.concurrent.locks.*;
15   import java.io.*;
16  
# Line 93 | Line 94 | public class AbstractQueuedSynchronizerT
94       * isHeldExclusively is false upon construction
95       */
96      public void testIsHeldExclusively() {
97 <        Mutex rl = new Mutex();
97 >        Mutex rl = new Mutex();
98          assertFalse(rl.isHeldExclusively());
99      }
100  
# Line 101 | Line 102 | public class AbstractQueuedSynchronizerT
102       * acquiring released sync succeeds
103       */
104      public void testAcquire() {
105 <        Mutex rl = new Mutex();
105 >        Mutex rl = new Mutex();
106          rl.acquire(1);
107          assertTrue(rl.isHeldExclusively());
108          rl.release(1);
# Line 112 | Line 113 | public class AbstractQueuedSynchronizerT
113       * tryAcquire on an released sync succeeds
114       */
115      public void testTryAcquire() {
116 <        Mutex rl = new Mutex();
116 >        Mutex rl = new Mutex();
117          assertTrue(rl.tryAcquire(1));
118          assertTrue(rl.isHeldExclusively());
119          rl.release(1);
# Line 122 | Line 123 | public class AbstractQueuedSynchronizerT
123       * hasQueuedThreads reports whether there are waiting threads
124       */
125      public void testhasQueuedThreads() throws InterruptedException {
126 <        final Mutex sync = new Mutex();
126 >        final Mutex sync = new Mutex();
127          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
128          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
129          assertFalse(sync.hasQueuedThreads());
# Line 147 | Line 148 | public class AbstractQueuedSynchronizerT
148       * isQueued(null) throws NPE
149       */
150      public void testIsQueuedNPE() {
151 <        final Mutex sync = new Mutex();
151 >        final Mutex sync = new Mutex();
152          try {
153              sync.isQueued(null);
154              shouldThrow();
# Line 158 | Line 159 | public class AbstractQueuedSynchronizerT
159       * isQueued reports whether a thread is queued.
160       */
161      public void testIsQueued() throws InterruptedException {
162 <        final Mutex sync = new Mutex();
162 >        final Mutex sync = new Mutex();
163          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
164          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
165          assertFalse(sync.isQueued(t1));
# Line 188 | Line 189 | public class AbstractQueuedSynchronizerT
189       * getFirstQueuedThread returns first waiting thread or null if none
190       */
191      public void testGetFirstQueuedThread() throws InterruptedException {
192 <        final Mutex sync = new Mutex();
192 >        final Mutex sync = new Mutex();
193          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
194          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
195          assertNull(sync.getFirstQueuedThread());
# Line 215 | Line 216 | public class AbstractQueuedSynchronizerT
216       * hasContended reports false if no thread has ever blocked, else true
217       */
218      public void testHasContended() throws InterruptedException {
219 <        final Mutex sync = new Mutex();
219 >        final Mutex sync = new Mutex();
220          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
221          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
222          assertFalse(sync.hasContended());
# Line 240 | Line 241 | public class AbstractQueuedSynchronizerT
241       * getQueuedThreads includes waiting threads
242       */
243      public void testGetQueuedThreads() throws InterruptedException {
244 <        final Mutex sync = new Mutex();
244 >        final Mutex sync = new Mutex();
245          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
246          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
247          assertTrue(sync.getQueuedThreads().isEmpty());
# Line 268 | Line 269 | public class AbstractQueuedSynchronizerT
269       * getExclusiveQueuedThreads includes waiting threads
270       */
271      public void testGetExclusiveQueuedThreads() throws InterruptedException {
272 <        final Mutex sync = new Mutex();
272 >        final Mutex sync = new Mutex();
273          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
274          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
275          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
# Line 296 | Line 297 | public class AbstractQueuedSynchronizerT
297       * getSharedQueuedThreads does not include exclusively waiting threads
298       */
299      public void testGetSharedQueuedThreads() throws InterruptedException {
300 <        final Mutex sync = new Mutex();
300 >        final Mutex sync = new Mutex();
301          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
302          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
303          assertTrue(sync.getSharedQueuedThreads().isEmpty());
# Line 322 | Line 323 | public class AbstractQueuedSynchronizerT
323       * tryAcquireNanos is interruptible.
324       */
325      public void testInterruptedException2() throws InterruptedException {
326 <        final Mutex sync = new Mutex();
327 <        sync.acquire(1);
328 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
326 >        final Mutex sync = new Mutex();
327 >        sync.acquire(1);
328 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
329              public void realRun() throws InterruptedException {
330 <                sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
330 >                sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000L * 1000L);
331              }});
332  
333          t.start();
334 +        Thread.sleep(SHORT_DELAY_MS);
335          t.interrupt();
336          t.join();
337      }
# Line 339 | Line 341 | public class AbstractQueuedSynchronizerT
341       * TryAcquire on exclusively held sync fails
342       */
343      public void testTryAcquireWhenSynced() throws InterruptedException {
344 <        final Mutex sync = new Mutex();
345 <        sync.acquire(1);
346 <        Thread t = new Thread(new CheckedRunnable() {
344 >        final Mutex sync = new Mutex();
345 >        sync.acquire(1);
346 >        Thread t = new Thread(new CheckedRunnable() {
347              public void realRun() {
348                  threadAssertFalse(sync.tryAcquire(1));
349              }});
# Line 355 | Line 357 | public class AbstractQueuedSynchronizerT
357       * tryAcquireNanos on an exclusively held sync times out
358       */
359      public void testAcquireNanos_Timeout() throws InterruptedException {
360 <        final Mutex sync = new Mutex();
361 <        sync.acquire(1);
362 <        Thread t = new Thread(new CheckedRunnable() {
360 >        final Mutex sync = new Mutex();
361 >        sync.acquire(1);
362 >        Thread t = new Thread(new CheckedRunnable() {
363              public void realRun() throws InterruptedException {
364 <                threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));
364 >                threadAssertFalse(sync.tryAcquireNanos(1, SHORT_DELAY_MS * 1000L * 1000L));
365              }});
366  
367          t.start();
# Line 372 | Line 374 | public class AbstractQueuedSynchronizerT
374       * getState is true when acquired and false when not
375       */
376      public void testGetState() throws InterruptedException {
377 <        final Mutex sync = new Mutex();
378 <        sync.acquire(1);
379 <        assertTrue(sync.isHeldExclusively());
380 <        sync.release(1);
381 <        assertFalse(sync.isHeldExclusively());
382 <        Thread t = new Thread(new CheckedRunnable() {
377 >        final Mutex sync = new Mutex();
378 >        sync.acquire(1);
379 >        assertTrue(sync.isHeldExclusively());
380 >        sync.release(1);
381 >        assertFalse(sync.isHeldExclusively());
382 >        Thread t = new Thread(new CheckedRunnable() {
383              public void realRun() throws InterruptedException {
384                  sync.acquire(1);
385                  Thread.sleep(SMALL_DELAY_MS);
# Line 396 | Line 398 | public class AbstractQueuedSynchronizerT
398       * acquireInterruptibly is interruptible.
399       */
400      public void testAcquireInterruptibly1() throws InterruptedException {
401 <        final Mutex sync = new Mutex();
402 <        sync.acquire(1);
403 <        Thread t = new Thread(new InterruptedSyncRunnable(sync));
401 >        final Mutex sync = new Mutex();
402 >        sync.acquire(1);
403 >        Thread t = new Thread(new InterruptedSyncRunnable(sync));
404  
405          t.start();
406          Thread.sleep(SHORT_DELAY_MS);
# Line 412 | Line 414 | public class AbstractQueuedSynchronizerT
414       * acquireInterruptibly succeeds when released, else is interruptible
415       */
416      public void testAcquireInterruptibly2() throws InterruptedException {
417 <        final Mutex sync = new Mutex();
417 >        final Mutex sync = new Mutex();
418          sync.acquireInterruptibly(1);
419 <        Thread t = new Thread(new InterruptedSyncRunnable(sync));
419 >        Thread t = new Thread(new InterruptedSyncRunnable(sync));
420          t.start();
421 +        Thread.sleep(SHORT_DELAY_MS);
422          t.interrupt();
423          assertTrue(sync.isHeldExclusively());
424          t.join();
# Line 425 | Line 428 | public class AbstractQueuedSynchronizerT
428       * owns is true for a condition created by sync else false
429       */
430      public void testOwns() {
431 <        final Mutex sync = new Mutex();
431 >        final Mutex sync = new Mutex();
432          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
433          final Mutex sync2 = new Mutex();
434          assertTrue(sync.owns(c));
# Line 436 | Line 439 | public class AbstractQueuedSynchronizerT
439       * Calling await without holding sync throws IllegalMonitorStateException
440       */
441      public void testAwait_IllegalMonitor() throws InterruptedException {
442 <        final Mutex sync = new Mutex();
442 >        final Mutex sync = new Mutex();
443          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
444          try {
445              c.await();
# Line 448 | Line 451 | public class AbstractQueuedSynchronizerT
451       * Calling signal without holding sync throws IllegalMonitorStateException
452       */
453      public void testSignal_IllegalMonitor() {
454 <        final Mutex sync = new Mutex();
454 >        final Mutex sync = new Mutex();
455          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
456          try {
457              c.signal();
# Line 460 | Line 463 | public class AbstractQueuedSynchronizerT
463       * awaitNanos without a signal times out
464       */
465      public void testAwaitNanos_Timeout() throws InterruptedException {
466 <        final Mutex sync = new Mutex();
466 >        final Mutex sync = new Mutex();
467          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
468          sync.acquire(1);
469          long t = c.awaitNanos(100);
# Line 472 | Line 475 | public class AbstractQueuedSynchronizerT
475       *  Timed await without a signal times out
476       */
477      public void testAwait_Timeout() throws InterruptedException {
478 <        final Mutex sync = new Mutex();
478 >        final Mutex sync = new Mutex();
479          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
480          sync.acquire(1);
481 <        assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
481 >        assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
482          sync.release(1);
483      }
484  
# Line 483 | Line 486 | public class AbstractQueuedSynchronizerT
486       * awaitUntil without a signal times out
487       */
488      public void testAwaitUntil_Timeout() throws InterruptedException {
489 <        final Mutex sync = new Mutex();
489 >        final Mutex sync = new Mutex();
490          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
491          sync.acquire(1);
492          java.util.Date d = new java.util.Date();
# Line 495 | Line 498 | public class AbstractQueuedSynchronizerT
498       * await returns when signalled
499       */
500      public void testAwait() throws InterruptedException {
501 <        final Mutex sync = new Mutex();
501 >        final Mutex sync = new Mutex();
502          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
503 <        Thread t = new Thread(new CheckedRunnable() {
503 >        Thread t = new Thread(new CheckedRunnable() {
504              public void realRun() throws InterruptedException {
505                  sync.acquire(1);
506                  c.await();
# Line 519 | Line 522 | public class AbstractQueuedSynchronizerT
522       * hasWaiters throws NPE if null
523       */
524      public void testHasWaitersNPE() {
525 <        final Mutex sync = new Mutex();
525 >        final Mutex sync = new Mutex();
526          try {
527              sync.hasWaiters(null);
528              shouldThrow();
# Line 530 | Line 533 | public class AbstractQueuedSynchronizerT
533       * getWaitQueueLength throws NPE if null
534       */
535      public void testGetWaitQueueLengthNPE() {
536 <        final Mutex sync = new Mutex();
536 >        final Mutex sync = new Mutex();
537          try {
538              sync.getWaitQueueLength(null);
539              shouldThrow();
# Line 542 | Line 545 | public class AbstractQueuedSynchronizerT
545       * getWaitingThreads throws NPE if null
546       */
547      public void testGetWaitingThreadsNPE() {
548 <        final Mutex sync = new Mutex();
548 >        final Mutex sync = new Mutex();
549          try {
550              sync.getWaitingThreads(null);
551              shouldThrow();
# Line 554 | Line 557 | public class AbstractQueuedSynchronizerT
557       * hasWaiters throws IAE if not owned
558       */
559      public void testHasWaitersIAE() {
560 <        final Mutex sync = new Mutex();
560 >        final Mutex sync = new Mutex();
561          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
562 <        final Mutex sync2 = new Mutex();
562 >        final Mutex sync2 = new Mutex();
563          try {
564              sync2.hasWaiters(c);
565              shouldThrow();
# Line 567 | Line 570 | public class AbstractQueuedSynchronizerT
570       * hasWaiters throws IMSE if not synced
571       */
572      public void testHasWaitersIMSE() {
573 <        final Mutex sync = new Mutex();
573 >        final Mutex sync = new Mutex();
574          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
575          try {
576              sync.hasWaiters(c);
# Line 580 | Line 583 | public class AbstractQueuedSynchronizerT
583       * getWaitQueueLength throws IAE if not owned
584       */
585      public void testGetWaitQueueLengthIAE() {
586 <        final Mutex sync = new Mutex();
586 >        final Mutex sync = new Mutex();
587          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
588 <        final Mutex sync2 = new Mutex();
588 >        final Mutex sync2 = new Mutex();
589          try {
590              sync2.getWaitQueueLength(c);
591              shouldThrow();
# Line 593 | Line 596 | public class AbstractQueuedSynchronizerT
596       * getWaitQueueLength throws IMSE if not synced
597       */
598      public void testGetWaitQueueLengthIMSE() {
599 <        final Mutex sync = new Mutex();
599 >        final Mutex sync = new Mutex();
600          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
601          try {
602              sync.getWaitQueueLength(c);
# Line 606 | Line 609 | public class AbstractQueuedSynchronizerT
609       * getWaitingThreads throws IAE if not owned
610       */
611      public void testGetWaitingThreadsIAE() {
612 <        final Mutex sync = new Mutex();
612 >        final Mutex sync = new Mutex();
613          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
614 <        final Mutex sync2 = new Mutex();
614 >        final Mutex sync2 = new Mutex();
615          try {
616              sync2.getWaitingThreads(c);
617              shouldThrow();
# Line 619 | Line 622 | public class AbstractQueuedSynchronizerT
622       * getWaitingThreads throws IMSE if not synced
623       */
624      public void testGetWaitingThreadsIMSE() {
625 <        final Mutex sync = new Mutex();
625 >        final Mutex sync = new Mutex();
626          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
627          try {
628              sync.getWaitingThreads(c);
# Line 633 | Line 636 | public class AbstractQueuedSynchronizerT
636       * hasWaiters returns true when a thread is waiting, else false
637       */
638      public void testHasWaiters() throws InterruptedException {
639 <        final Mutex sync = new Mutex();
639 >        final Mutex sync = new Mutex();
640          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
641 <        Thread t = new Thread(new CheckedRunnable() {
641 >        Thread t = new Thread(new CheckedRunnable() {
642              public void realRun() throws InterruptedException {
643                  sync.acquire(1);
644                  threadAssertFalse(sync.hasWaiters(c));
# Line 664 | Line 667 | public class AbstractQueuedSynchronizerT
667       * getWaitQueueLength returns number of waiting threads
668       */
669      public void testGetWaitQueueLength() throws InterruptedException {
670 <        final Mutex sync = new Mutex();
670 >        final Mutex sync = new Mutex();
671          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
672 <        Thread t1 = new Thread(new CheckedRunnable() {
672 >        Thread t1 = new Thread(new CheckedRunnable() {
673              public void realRun() throws InterruptedException {
674                  sync.acquire(1);
675                  threadAssertFalse(sync.hasWaiters(c));
# Line 675 | Line 678 | public class AbstractQueuedSynchronizerT
678                  sync.release(1);
679              }});
680  
681 <        Thread t2 = new Thread(new CheckedRunnable() {
681 >        Thread t2 = new Thread(new CheckedRunnable() {
682              public void realRun() throws InterruptedException {
683                  sync.acquire(1);
684                  threadAssertTrue(sync.hasWaiters(c));
# Line 708 | Line 711 | public class AbstractQueuedSynchronizerT
711       * getWaitingThreads returns only and all waiting threads
712       */
713      public void testGetWaitingThreads() throws InterruptedException {
714 <        final Mutex sync = new Mutex();
714 >        final Mutex sync = new Mutex();
715          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
716 <        Thread t1 = new Thread(new CheckedRunnable() {
716 >        Thread t1 = new Thread(new CheckedRunnable() {
717              public void realRun() throws InterruptedException {
718                  sync.acquire(1);
719                  threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
# Line 718 | Line 721 | public class AbstractQueuedSynchronizerT
721                  sync.release(1);
722              }});
723  
724 <        Thread t2 = new Thread(new CheckedRunnable() {
724 >        Thread t2 = new Thread(new CheckedRunnable() {
725              public void realRun() throws InterruptedException {
726                  sync.acquire(1);
727                  threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
# Line 756 | Line 759 | public class AbstractQueuedSynchronizerT
759       * awaitUninterruptibly doesn't abort on interrupt
760       */
761      public void testAwaitUninterruptibly() throws InterruptedException {
762 <        final Mutex sync = new Mutex();
762 >        final Mutex sync = new Mutex();
763          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
764 <        Thread t = new Thread(new CheckedRunnable() {
764 >        Thread t = new Thread(new CheckedRunnable() {
765              public void realRun() {
766                  sync.acquire(1);
767                  c.awaitUninterruptibly();
# Line 779 | Line 782 | public class AbstractQueuedSynchronizerT
782       * await is interruptible
783       */
784      public void testAwait_Interrupt() throws InterruptedException {
785 <        final Mutex sync = new Mutex();
785 >        final Mutex sync = new Mutex();
786          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
787 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
788 <            public void realRun() throws InterruptedException {
787 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
788 >            public void realRun() throws InterruptedException {
789                  sync.acquire(1);
790                  c.await();
788 –                sync.release(1);
791              }});
792  
793          t.start();
# Line 799 | Line 801 | public class AbstractQueuedSynchronizerT
801       * awaitNanos is interruptible
802       */
803      public void testAwaitNanos_Interrupt() throws InterruptedException {
804 <        final Mutex sync = new Mutex();
804 >        final Mutex sync = new Mutex();
805          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
806 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
807 <            public void realRun() throws InterruptedException {
806 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
807 >            public void realRun() throws InterruptedException {
808                  sync.acquire(1);
809 <                c.awaitNanos(1000 * 1000 * 1000); // 1 sec
808 <                sync.release(1);
809 >                c.awaitNanos(LONG_DELAY_MS * 1000L * 1000L);
810              }});
811  
812          t.start();
# Line 819 | Line 820 | public class AbstractQueuedSynchronizerT
820       * awaitUntil is interruptible
821       */
822      public void testAwaitUntil_Interrupt() throws InterruptedException {
823 <        final Mutex sync = new Mutex();
823 >        final Mutex sync = new Mutex();
824          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
825 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
826 <            public void realRun() throws InterruptedException {
825 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
826 >            public void realRun() throws InterruptedException {
827                  sync.acquire(1);
828                  java.util.Date d = new java.util.Date();
829                  c.awaitUntil(new java.util.Date(d.getTime() + 10000));
829 –                sync.release(1);
830              }});
831  
832          t.start();
# Line 840 | Line 840 | public class AbstractQueuedSynchronizerT
840       * signalAll wakes up all threads
841       */
842      public void testSignalAll() throws InterruptedException {
843 <        final Mutex sync = new Mutex();
843 >        final Mutex sync = new Mutex();
844          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
845 <        Thread t1 = new Thread(new CheckedRunnable() {
845 >        Thread t1 = new Thread(new CheckedRunnable() {
846              public void realRun() throws InterruptedException {
847                  sync.acquire(1);
848                  c.await();
849                  sync.release(1);
850              }});
851  
852 <        Thread t2 = new Thread(new CheckedRunnable() {
852 >        Thread t2 = new Thread(new CheckedRunnable() {
853              public void realRun() throws InterruptedException {
854                  sync.acquire(1);
855                  c.await();
# Line 905 | Line 905 | public class AbstractQueuedSynchronizerT
905       * tryReleaseShared setting state changes getState
906       */
907      public void testGetStateWithReleaseShared() {
908 <        final BooleanLatch l = new BooleanLatch();
909 <        assertFalse(l.isSignalled());
910 <        l.releaseShared(0);
911 <        assertTrue(l.isSignalled());
908 >        final BooleanLatch l = new BooleanLatch();
909 >        assertFalse(l.isSignalled());
910 >        l.releaseShared(0);
911 >        assertTrue(l.isSignalled());
912      }
913  
914      /**
915       * releaseShared has no effect when already signalled
916       */
917      public void testReleaseShared() {
918 <        final BooleanLatch l = new BooleanLatch();
919 <        assertFalse(l.isSignalled());
920 <        l.releaseShared(0);
921 <        assertTrue(l.isSignalled());
922 <        l.releaseShared(0);
923 <        assertTrue(l.isSignalled());
918 >        final BooleanLatch l = new BooleanLatch();
919 >        assertFalse(l.isSignalled());
920 >        l.releaseShared(0);
921 >        assertTrue(l.isSignalled());
922 >        l.releaseShared(0);
923 >        assertTrue(l.isSignalled());
924      }
925  
926      /**
927       * acquireSharedInterruptibly returns after release, but not before
928       */
929      public void testAcquireSharedInterruptibly() throws InterruptedException {
930 <        final BooleanLatch l = new BooleanLatch();
930 >        final BooleanLatch l = new BooleanLatch();
931  
932 <        Thread t = new Thread(new CheckedRunnable() {
932 >        Thread t = new Thread(new CheckedRunnable() {
933              public void realRun() throws InterruptedException {
934                  threadAssertFalse(l.isSignalled());
935                  l.acquireSharedInterruptibly(0);
# Line 949 | Line 949 | public class AbstractQueuedSynchronizerT
949       * acquireSharedTimed returns after release
950       */
951      public void testAsquireSharedTimed() throws InterruptedException {
952 <        final BooleanLatch l = new BooleanLatch();
952 >        final BooleanLatch l = new BooleanLatch();
953  
954 <        Thread t = new Thread(new CheckedRunnable() {
954 >        Thread t = new Thread(new CheckedRunnable() {
955              public void realRun() throws InterruptedException {
956                  threadAssertFalse(l.isSignalled());
957 <                threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
957 >                threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS * 1000L * 1000L));
958                  threadAssertTrue(l.isSignalled());
959              }});
960  
# Line 971 | Line 971 | public class AbstractQueuedSynchronizerT
971       */
972      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
973          final BooleanLatch l = new BooleanLatch();
974 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
975 <            public void realRun() throws InterruptedException {
974 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
975 >            public void realRun() throws InterruptedException {
976                  threadAssertFalse(l.isSignalled());
977                  l.acquireSharedInterruptibly(0);
978              }});
979  
980 <        t.start();
980 >        t.start();
981          assertFalse(l.isSignalled());
982          t.interrupt();
983          t.join();
# Line 988 | Line 988 | public class AbstractQueuedSynchronizerT
988       */
989      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
990          final BooleanLatch l = new BooleanLatch();
991 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
992 <            public void realRun() throws InterruptedException {
991 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
992 >            public void realRun() throws InterruptedException {
993                  threadAssertFalse(l.isSignalled());
994 <                l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
994 >                l.tryAcquireSharedNanos(0, SMALL_DELAY_MS * 1000L * 1000L);
995              }});
996  
997          t.start();
# Line 1006 | Line 1006 | public class AbstractQueuedSynchronizerT
1006       */
1007      public void testAcquireSharedNanos_Timeout() throws InterruptedException {
1008          final BooleanLatch l = new BooleanLatch();
1009 <        Thread t = new Thread(new CheckedRunnable() {
1009 >        Thread t = new Thread(new CheckedRunnable() {
1010              public void realRun() throws InterruptedException {
1011                  threadAssertFalse(l.isSignalled());
1012 <                threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
1012 >                threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS * 1000L * 1000L));
1013              }});
1014  
1015          t.start();

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines