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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.45 by jsr166, Sun May 1 23:49:41 2011 UTC vs.
Revision 1.52 by jsr166, Mon May 2 00:34:12 2011 UTC

# Line 59 | Line 59 | public class ReentrantReadWriteLockTest
59      }
60  
61      /**
62 +     * Releases lock, checking that it had a hold count of 1.
63 +     */
64 +    void releaseLock(ReentrantReadWriteLock.WriteLock lock) {
65 +        assertTrue(lock.isHeldByCurrentThread());
66 +        lock.unlock();
67 +        assertFalse(lock.isHeldByCurrentThread());
68 +    }
69 +
70 +    /**
71       * Constructor sets given fairness, and is in unlocked state
72       */
73      public void testConstructor() {
# Line 194 | Line 203 | public class ReentrantReadWriteLockTest
203          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
204              public void realRun() throws InterruptedException {
205                  lock.writeLock().lockInterruptibly();
197 –                lock.writeLock().unlock();
198 –                lock.writeLock().lockInterruptibly();
199 –                lock.writeLock().unlock();
206              }});
207  
208          Thread.sleep(SHORT_DELAY_MS);
209          t.interrupt();
204 –        Thread.sleep(SHORT_DELAY_MS);
205 –        lock.writeLock().unlock();
210          t.join();
211 +        releaseLock(lock.writeLock());
212      }
213  
214      /**
# Line 219 | Line 224 | public class ReentrantReadWriteLockTest
224  
225          Thread.sleep(SHORT_DELAY_MS);
226          t.interrupt();
222 –        lock.writeLock().unlock();
227          t.join();
228 +        releaseLock(lock.writeLock());
229      }
230  
231      /**
# Line 236 | Line 241 | public class ReentrantReadWriteLockTest
241  
242          Thread.sleep(SHORT_DELAY_MS);
243          t.interrupt();
239 –        Thread.sleep(SHORT_DELAY_MS);
240 –        lock.writeLock().unlock();
244          t.join();
245 +        releaseLock(lock.writeLock());
246      }
247  
248      /**
# Line 255 | Line 259 | public class ReentrantReadWriteLockTest
259          Thread.sleep(SHORT_DELAY_MS);
260          t.interrupt();
261          t.join();
262 +        releaseLock(lock.writeLock());
263      }
264  
265  
# Line 677 | Line 682 | public class ReentrantReadWriteLockTest
682  
683          Thread.sleep(SHORT_DELAY_MS);
684          t.interrupt();
680 –        Thread.sleep(SHORT_DELAY_MS);
685          t.join();
686 <        lock.writeLock().unlock();
686 >        releaseLock(lock.writeLock());
687      }
688  
689      /**
# Line 696 | Line 700 | public class ReentrantReadWriteLockTest
700          Thread.sleep(SHORT_DELAY_MS);
701          t.interrupt();
702          t.join();
703 <        lock.writeLock().unlock();
703 >        releaseLock(lock.writeLock());
704      }
705  
706      /**
# Line 842 | Line 846 | public class ReentrantReadWriteLockTest
846      public void testAwait_Interrupt() throws InterruptedException {
847          final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
848          final Condition c = lock.writeLock().newCondition();
849 +        final CountDownLatch locked = new CountDownLatch(1);
850          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
851              public void realRun() throws InterruptedException {
852                  lock.writeLock().lock();
853 <                c.await();
854 <                lock.writeLock().unlock();
853 >                assertTrue(lock.isWriteLocked());
854 >                locked.countDown();
855 >                try { c.await(); }
856 >                finally { lock.writeLock().unlock(); }
857              }});
858  
859 <        Thread.sleep(SHORT_DELAY_MS);
859 >        locked.await();
860 >        while (lock.isWriteLocked())
861 >            Thread.yield();
862          t.interrupt();
863 <        t.join(SHORT_DELAY_MS);
864 <        assertFalse(t.isAlive());
863 >        awaitTermination(t, LONG_DELAY_MS);
864 >        assertFalse(lock.isWriteLocked());
865      }
866  
867      /**
# Line 861 | Line 870 | public class ReentrantReadWriteLockTest
870      public void testAwaitNanos_Interrupt() throws InterruptedException {
871          final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
872          final Condition c = lock.writeLock().newCondition();
873 +        final CountDownLatch locked = new CountDownLatch(1);
874          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
875              public void realRun() throws InterruptedException {
876                  lock.writeLock().lock();
877 <                c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
878 <                lock.writeLock().unlock();
877 >                assertTrue(lock.isWriteLocked());
878 >                locked.countDown();
879 >                try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
880 >                finally { lock.writeLock().unlock(); }
881              }});
882  
883 <        Thread.sleep(SHORT_DELAY_MS);
883 >        locked.await();
884 >        while (lock.isWriteLocked())
885 >            Thread.yield();
886          t.interrupt();
887 <        t.join(SHORT_DELAY_MS);
888 <        assertFalse(t.isAlive());
887 >        awaitTermination(t, LONG_DELAY_MS);
888 >        assertFalse(lock.isWriteLocked());
889      }
890  
891      /**
# Line 880 | Line 894 | public class ReentrantReadWriteLockTest
894      public void testAwaitUntil_Interrupt() throws InterruptedException {
895          final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
896          final Condition c = lock.writeLock().newCondition();
897 +        final CountDownLatch locked = new CountDownLatch(1);
898          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
899              public void realRun() throws InterruptedException {
900                  lock.writeLock().lock();
901 +                assertTrue(lock.isWriteLocked());
902 +                locked.countDown();
903                  java.util.Date d = new java.util.Date();
904 <                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
905 <                lock.writeLock().unlock();
904 >                try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
905 >                finally { lock.writeLock().unlock(); }
906              }});
907  
908 <        Thread.sleep(SHORT_DELAY_MS);
908 >        locked.await();
909 >        while (lock.isWriteLocked())
910 >            Thread.yield();
911          t.interrupt();
912 <        t.join(SHORT_DELAY_MS);
913 <        assertFalse(t.isAlive());
912 >        awaitTermination(t, LONG_DELAY_MS);
913 >        assertFalse(lock.isWriteLocked());
914      }
915  
916      /**

Diff Legend

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