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.78 by jsr166, Fri Jul 3 05:48:30 2015 UTC vs.
Revision 1.79 by jsr166, Sun Jan 1 20:34:39 2017 UTC

# Line 231 | Line 231 | public class ReentrantReadWriteLockTest
231      public void testGetWriteHoldCount()      { testGetWriteHoldCount(false); }
232      public void testGetWriteHoldCount_fair() { testGetWriteHoldCount(true); }
233      public void testGetWriteHoldCount(boolean fair) {
234 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
234 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
235          for (int i = 1; i <= SIZE; i++) {
236              lock.writeLock().lock();
237              assertEquals(i,lock.getWriteHoldCount());
# Line 248 | Line 248 | public class ReentrantReadWriteLockTest
248      public void testGetHoldCount()      { testGetHoldCount(false); }
249      public void testGetHoldCount_fair() { testGetHoldCount(true); }
250      public void testGetHoldCount(boolean fair) {
251 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
251 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
252          for (int i = 1; i <= SIZE; i++) {
253              lock.writeLock().lock();
254              assertEquals(i,lock.writeLock().getHoldCount());
# Line 265 | Line 265 | public class ReentrantReadWriteLockTest
265      public void testGetReadHoldCount()      { testGetReadHoldCount(false); }
266      public void testGetReadHoldCount_fair() { testGetReadHoldCount(true); }
267      public void testGetReadHoldCount(boolean fair) {
268 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
268 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
269          for (int i = 1; i <= SIZE; i++) {
270              lock.readLock().lock();
271              assertEquals(i,lock.getReadHoldCount());
# Line 282 | Line 282 | public class ReentrantReadWriteLockTest
282      public void testWriteUnlock_IMSE()      { testWriteUnlock_IMSE(false); }
283      public void testWriteUnlock_IMSE_fair() { testWriteUnlock_IMSE(true); }
284      public void testWriteUnlock_IMSE(boolean fair) {
285 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
285 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
286          try {
287              lock.writeLock().unlock();
288              shouldThrow();
# Line 295 | Line 295 | public class ReentrantReadWriteLockTest
295      public void testReadUnlock_IMSE()      { testReadUnlock_IMSE(false); }
296      public void testReadUnlock_IMSE_fair() { testReadUnlock_IMSE(true); }
297      public void testReadUnlock_IMSE(boolean fair) {
298 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
298 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
299          try {
300              lock.readLock().unlock();
301              shouldThrow();
# Line 788 | Line 788 | public class ReentrantReadWriteLockTest
788      public void testWriteTryLock_Timeout(boolean fair) {
789          final PublicReentrantReadWriteLock lock =
790              new PublicReentrantReadWriteLock(fair);
791 +        final long timeoutMillis = timeoutMillis();
792          lock.writeLock().lock();
793          Thread t = newStartedThread(new CheckedRunnable() {
794              public void realRun() throws InterruptedException {
795                  long startTime = System.nanoTime();
795 –                long timeoutMillis = 10;
796                  assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
797                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
798              }});
# Line 812 | Line 812 | public class ReentrantReadWriteLockTest
812          Thread t = newStartedThread(new CheckedRunnable() {
813              public void realRun() throws InterruptedException {
814                  long startTime = System.nanoTime();
815 <                long timeoutMillis = 10;
815 >                long timeoutMillis = timeoutMillis();
816                  assertFalse(lock.readLock().tryLock(timeoutMillis, MILLISECONDS));
817                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
818              }});
# Line 924 | Line 924 | public class ReentrantReadWriteLockTest
924      public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
925      public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
926      public void testAwaitNanos_Timeout(boolean fair) {
927 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
928 +        final Condition c = lock.writeLock().newCondition();
929 +        final long timeoutMillis = timeoutMillis();
930 +        lock.writeLock().lock();
931 +        final long startTime = System.nanoTime();
932 +        final long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
933          try {
928 –            final ReentrantReadWriteLock lock =
929 –                new ReentrantReadWriteLock(fair);
930 –            final Condition c = lock.writeLock().newCondition();
931 –            lock.writeLock().lock();
932 –            long startTime = System.nanoTime();
933 –            long timeoutMillis = 10;
934 –            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
934              long nanosRemaining = c.awaitNanos(timeoutNanos);
935              assertTrue(nanosRemaining <= 0);
937 –            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
938 –            lock.writeLock().unlock();
936          } catch (InterruptedException fail) { threadUnexpectedException(fail); }
937 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
938 +        lock.writeLock().unlock();
939      }
940  
941      /**
# Line 945 | Line 944 | public class ReentrantReadWriteLockTest
944      public void testAwait_Timeout()      { testAwait_Timeout(false); }
945      public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
946      public void testAwait_Timeout(boolean fair) {
947 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
948 +        final Condition c = lock.writeLock().newCondition();
949 +        final long timeoutMillis = timeoutMillis();
950 +        lock.writeLock().lock();
951 +        final long startTime = System.nanoTime();
952          try {
949 –            final ReentrantReadWriteLock lock =
950 –                new ReentrantReadWriteLock(fair);
951 –            final Condition c = lock.writeLock().newCondition();
952 –            lock.writeLock().lock();
953 –            long startTime = System.nanoTime();
954 –            long timeoutMillis = 10;
953              assertFalse(c.await(timeoutMillis, MILLISECONDS));
956 –            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
957 –            lock.writeLock().unlock();
954          } catch (InterruptedException fail) { threadUnexpectedException(fail); }
955 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
956 +        lock.writeLock().unlock();
957      }
958  
959      /**
# Line 964 | Line 962 | public class ReentrantReadWriteLockTest
962      public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
963      public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
964      public void testAwaitUntil_Timeout(boolean fair) {
965 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
966 +        final Condition c = lock.writeLock().newCondition();
967 +        lock.writeLock().lock();
968 +        // We shouldn't assume that nanoTime and currentTimeMillis
969 +        // use the same time source, so don't use nanoTime here.
970 +        final java.util.Date delayedDate = delayedDate(timeoutMillis());
971          try {
968 –            final ReentrantReadWriteLock lock =
969 –                new ReentrantReadWriteLock(fair);
970 –            final Condition c = lock.writeLock().newCondition();
971 –            lock.writeLock().lock();
972 –            // We shouldn't assume that nanoTime and currentTimeMillis
973 –            // use the same time source, so don't use nanoTime here.
974 –            java.util.Date delayedDate = delayedDate(timeoutMillis());
972              assertFalse(c.awaitUntil(delayedDate));
976 –            assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
977 –            lock.writeLock().unlock();
973          } catch (InterruptedException fail) { threadUnexpectedException(fail); }
974 +        assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
975 +        lock.writeLock().unlock();
976      }
977  
978      /**
# Line 1231 | Line 1228 | public class ReentrantReadWriteLockTest
1228      public void testSerialization()      { testSerialization(false); }
1229      public void testSerialization_fair() { testSerialization(true); }
1230      public void testSerialization(boolean fair) {
1231 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1231 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1232          lock.writeLock().lock();
1233          lock.readLock().lock();
1234  
# Line 1633 | Line 1630 | public class ReentrantReadWriteLockTest
1630      public void testToString()      { testToString(false); }
1631      public void testToString_fair() { testToString(true); }
1632      public void testToString(boolean fair) {
1633 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1633 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1634          assertTrue(lock.toString().contains("Write locks = 0"));
1635          assertTrue(lock.toString().contains("Read locks = 0"));
1636          lock.writeLock().lock();
1637          assertTrue(lock.toString().contains("Write locks = 1"));
1638          assertTrue(lock.toString().contains("Read locks = 0"));
1639 +        lock.writeLock().lock();
1640 +        assertTrue(lock.toString().contains("Write locks = 2"));
1641 +        assertTrue(lock.toString().contains("Read locks = 0"));
1642 +        lock.writeLock().unlock();
1643          lock.writeLock().unlock();
1644          lock.readLock().lock();
1645 +        assertTrue(lock.toString().contains("Write locks = 0"));
1646 +        assertTrue(lock.toString().contains("Read locks = 1"));
1647          lock.readLock().lock();
1648          assertTrue(lock.toString().contains("Write locks = 0"));
1649          assertTrue(lock.toString().contains("Read locks = 2"));
# Line 1652 | Line 1655 | public class ReentrantReadWriteLockTest
1655      public void testReadLockToString()      { testReadLockToString(false); }
1656      public void testReadLockToString_fair() { testReadLockToString(true); }
1657      public void testReadLockToString(boolean fair) {
1658 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1658 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1659          assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1660          lock.readLock().lock();
1661 +        assertTrue(lock.readLock().toString().contains("Read locks = 1"));
1662          lock.readLock().lock();
1663          assertTrue(lock.readLock().toString().contains("Read locks = 2"));
1664 +        lock.readLock().unlock();
1665 +        assertTrue(lock.readLock().toString().contains("Read locks = 1"));
1666 +        lock.readLock().unlock();
1667 +        assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1668      }
1669  
1670      /**
# Line 1665 | Line 1673 | public class ReentrantReadWriteLockTest
1673      public void testWriteLockToString()      { testWriteLockToString(false); }
1674      public void testWriteLockToString_fair() { testWriteLockToString(true); }
1675      public void testWriteLockToString(boolean fair) {
1676 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1676 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1677          assertTrue(lock.writeLock().toString().contains("Unlocked"));
1678          lock.writeLock().lock();
1679 <        assertTrue(lock.writeLock().toString().contains("Locked"));
1679 >        assertTrue(lock.writeLock().toString().contains("Locked by"));
1680          lock.writeLock().unlock();
1681          assertTrue(lock.writeLock().toString().contains("Unlocked"));
1682      }

Diff Legend

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