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

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.41 by jsr166, Sat May 7 02:51:33 2011 UTC vs.
Revision 1.44 by jsr166, Sat May 7 03:40:45 2011 UTC

# Line 59 | Line 59 | public class ReentrantLockTest extends J
59      }
60  
61      /**
62 +     * Checks that condition c has no waiters.
63 +     */
64 +    void assertHasNoWaiters(PublicReentrantLock lock, Condition c) {
65 +        assertHasWaiters(lock, c, new Thread[] {});
66 +    }
67 +
68 +    /**
69 +     * Checks that condition c has exactly the given waiter threads.
70 +     */
71 +    void assertHasWaiters(PublicReentrantLock lock, Condition c,
72 +                          Thread... threads) {
73 +        lock.lock();
74 +        assertEquals(threads.length > 0, lock.hasWaiters(c));
75 +        assertEquals(threads.length, lock.getWaitQueueLength(c));
76 +        assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
77 +        assertEquals(threads.length, lock.getWaitingThreads(c).size());
78 +        assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
79 +                     new HashSet<Thread>(Arrays.asList(threads)));
80 +        lock.unlock();
81 +    }
82 +
83 +    /**
84       * Constructor sets given fairness
85       */
86      public void testConstructor() {
# Line 131 | Line 153 | public class ReentrantLockTest extends J
153          lock.unlock();
154          delay(SHORT_DELAY_MS);
155          assertFalse(lock.hasQueuedThreads());
156 <        t1.join();
157 <        t2.join();
156 >        awaitTermination(t1);
157 >        awaitTermination(t2);
158      }
159  
160      /**
# Line 156 | Line 178 | public class ReentrantLockTest extends J
178          lock.unlock();
179          delay(SHORT_DELAY_MS);
180          assertEquals(0, lock.getQueueLength());
181 <        t1.join();
182 <        t2.join();
181 >        awaitTermination(t1);
182 >        awaitTermination(t2);
183      }
184  
185      /**
# Line 181 | Line 203 | public class ReentrantLockTest extends J
203          lock.unlock();
204          delay(SHORT_DELAY_MS);
205          assertEquals(0, lock.getQueueLength());
206 <        t1.join();
207 <        t2.join();
206 >        awaitTermination(t1);
207 >        awaitTermination(t2);
208      }
209  
210      /**
# Line 222 | Line 244 | public class ReentrantLockTest extends J
244          assertFalse(sync.hasQueuedThread(t1));
245          delay(SHORT_DELAY_MS);
246          assertFalse(sync.hasQueuedThread(t2));
247 <        t1.join();
248 <        t2.join();
247 >        awaitTermination(t1);
248 >        awaitTermination(t2);
249      }
250  
251  
# Line 251 | Line 273 | public class ReentrantLockTest extends J
273          lock.unlock();
274          delay(SHORT_DELAY_MS);
275          assertTrue(lock.getQueuedThreads().isEmpty());
276 <        t1.join();
277 <        t2.join();
276 >        awaitTermination(t1);
277 >        awaitTermination(t2);
278      }
279  
280  
# Line 269 | Line 291 | public class ReentrantLockTest extends J
291  
292          delay(SHORT_DELAY_MS);
293          t.interrupt();
294 <        t.join();
294 >        awaitTermination(t);
295      }
296  
297  
# Line 284 | Line 306 | public class ReentrantLockTest extends J
306                  assertFalse(lock.tryLock());
307              }});
308  
309 <        t.join();
309 >        awaitTermination(t);
310          lock.unlock();
311      }
312  
# Line 299 | Line 321 | public class ReentrantLockTest extends J
321                  assertFalse(lock.tryLock(1, MILLISECONDS));
322              }});
323  
324 <        t.join();
324 >        awaitTermination(t);
325          lock.unlock();
326      }
327  
# Line 337 | Line 359 | public class ReentrantLockTest extends J
359  
360          delay(SHORT_DELAY_MS);
361          assertTrue(lock.isLocked());
362 <        t.join();
362 >        awaitTermination(t);
363          assertFalse(lock.isLocked());
364      }
365  
# Line 353 | Line 375 | public class ReentrantLockTest extends J
375          t.interrupt();
376          delay(SHORT_DELAY_MS);
377          lock.unlock();
378 <        t.join();
378 >        awaitTermination(t);
379      }
380  
381      /**
# Line 367 | Line 389 | public class ReentrantLockTest extends J
389          t.interrupt();
390          assertTrue(lock.isLocked());
391          assertTrue(lock.isHeldByCurrentThread());
392 <        t.join();
392 >        awaitTermination(t);
393      }
394  
395      /**
# Line 446 | Line 468 | public class ReentrantLockTest extends J
468          lock.lock();
469          c.signal();
470          lock.unlock();
471 <        t.join(SHORT_DELAY_MS);
450 <        assertFalse(t.isAlive());
471 >        awaitTermination(t);
472      }
473  
474      /**
# Line 589 | Line 610 | public class ReentrantLockTest extends J
610          assertFalse(lock.hasWaiters(c));
611          assertEquals(0, lock.getWaitQueueLength(c));
612          lock.unlock();
613 <        t.join(SHORT_DELAY_MS);
593 <        assertFalse(t.isAlive());
613 >        awaitTermination(t);
614      }
615  
616      /**
# Line 630 | Line 650 | public class ReentrantLockTest extends J
650          assertFalse(lock.hasWaiters(c));
651          assertEquals(0, lock.getWaitQueueLength(c));
652          lock.unlock();
653 <        t1.join(SHORT_DELAY_MS);
654 <        t2.join(SHORT_DELAY_MS);
635 <        assertFalse(t1.isAlive());
636 <        assertFalse(t2.isAlive());
653 >        awaitTermination(t1);
654 >        awaitTermination(t2);
655      }
656  
657      /**
# Line 676 | Line 694 | public class ReentrantLockTest extends J
694          assertFalse(lock.hasWaiters(c));
695          assertTrue(lock.getWaitingThreads(c).isEmpty());
696          lock.unlock();
697 <        t1.join(SHORT_DELAY_MS);
698 <        t2.join(SHORT_DELAY_MS);
681 <        assertFalse(t1.isAlive());
682 <        assertFalse(t2.isAlive());
697 >        awaitTermination(t1);
698 >        awaitTermination(t2);
699      }
700  
701      /** A helper class for uninterruptible wait tests */
# Line 741 | Line 757 | public class ReentrantLockTest extends J
757       * await is interruptible
758       */
759      public void testAwait_Interrupt() throws InterruptedException {
760 <        final ReentrantLock lock = new ReentrantLock();
760 >        final PublicReentrantLock lock = new PublicReentrantLock();
761          final Condition c = lock.newCondition();
762 +        final CountDownLatch locked = new CountDownLatch(1);
763          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
764              public void realRun() throws InterruptedException {
765                  lock.lock();
766 <                c.await();
766 >                assertTrue(lock.isLocked());
767 >                assertTrue(lock.isHeldByCurrentThread());
768 >                assertHasNoWaiters(lock, c);
769 >                locked.countDown();
770 >                try {
771 >                    c.await();
772 >                } finally {
773 >                    assertTrue(lock.isLocked());
774 >                    assertTrue(lock.isHeldByCurrentThread());
775 >                    assertHasNoWaiters(lock, c);
776 >                    lock.unlock();
777 >                    assertFalse(Thread.interrupted());
778 >                }
779              }});
780  
781 <        delay(SHORT_DELAY_MS);
781 >        locked.await();
782 >        assertHasWaiters(lock, c, t);
783          t.interrupt();
784 <        t.join(SHORT_DELAY_MS);
785 <        assertFalse(t.isAlive());
784 >        awaitTermination(t);
785 >        assertFalse(lock.isLocked());
786      }
787  
788      /**
789       * awaitNanos is interruptible
790       */
791      public void testAwaitNanos_Interrupt() throws InterruptedException {
792 <        final ReentrantLock lock = new ReentrantLock();
792 >        final PublicReentrantLock lock = new PublicReentrantLock();
793          final Condition c = lock.newCondition();
794 +        final CountDownLatch locked = new CountDownLatch(1);
795          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
796              public void realRun() throws InterruptedException {
797                  lock.lock();
798 <                c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
798 >                assertTrue(lock.isLocked());
799 >                assertTrue(lock.isHeldByCurrentThread());
800 >                assertHasNoWaiters(lock, c);
801 >                locked.countDown();
802 >                try {
803 >                    c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
804 >                } finally {
805 >                    assertTrue(lock.isLocked());
806 >                    assertTrue(lock.isHeldByCurrentThread());
807 >                    assertHasNoWaiters(lock, c);
808 >                    lock.unlock();
809 >                    assertFalse(Thread.interrupted());
810 >                }
811              }});
812  
813 <        delay(SHORT_DELAY_MS);
813 >        locked.await();
814 >        assertHasWaiters(lock, c, t);
815          t.interrupt();
816 <        t.join(SHORT_DELAY_MS);
817 <        assertFalse(t.isAlive());
816 >        awaitTermination(t);
817 >        assertFalse(lock.isLocked());
818      }
819  
820      /**
821       * awaitUntil is interruptible
822       */
823      public void testAwaitUntil_Interrupt() throws InterruptedException {
824 <        final ReentrantLock lock = new ReentrantLock();
824 >        final PublicReentrantLock lock = new PublicReentrantLock();
825          final Condition c = lock.newCondition();
826 +        final CountDownLatch locked = new CountDownLatch(1);
827          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
828              public void realRun() throws InterruptedException {
829                  lock.lock();
830 +                assertTrue(lock.isLocked());
831 +                assertTrue(lock.isHeldByCurrentThread());
832 +                assertHasNoWaiters(lock, c);
833 +                locked.countDown();
834                  java.util.Date d = new java.util.Date();
835 <                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
835 >                try {
836 >                    c.awaitUntil(new java.util.Date(d.getTime() + 10000));
837 >                } finally {
838 >                    assertTrue(lock.isLocked());
839 >                    assertTrue(lock.isHeldByCurrentThread());
840 >                    assertHasNoWaiters(lock, c);
841 >                    lock.unlock();
842 >                    assertFalse(Thread.interrupted());
843 >                }
844              }});
845  
846 <        delay(SHORT_DELAY_MS);
846 >        locked.await();
847 >        assertHasWaiters(lock, c, t);
848          t.interrupt();
849 <        t.join(SHORT_DELAY_MS);
850 <        assertFalse(t.isAlive());
849 >        awaitTermination(t);
850 >        assertFalse(lock.isLocked());
851      }
852  
853      /**
# Line 816 | Line 874 | public class ReentrantLockTest extends J
874          lock.lock();
875          c.signalAll();
876          lock.unlock();
877 <        t1.join(SHORT_DELAY_MS);
878 <        t2.join(SHORT_DELAY_MS);
821 <        assertFalse(t1.isAlive());
822 <        assertFalse(t2.isAlive());
877 >        awaitTermination(t1);
878 >        awaitTermination(t2);
879      }
880  
881      /**
# Line 852 | Line 908 | public class ReentrantLockTest extends J
908          lock.lock();
909          c.signalAll();
910          lock.unlock();
911 <        t1.join(SHORT_DELAY_MS);
912 <        t2.join(SHORT_DELAY_MS);
857 <        assertFalse(t1.isAlive());
858 <        assertFalse(t2.isAlive());
911 >        awaitTermination(t1);
912 >        awaitTermination(t2);
913      }
914  
915      /**

Diff Legend

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