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.74 by jsr166, Sun May 24 01:42:14 2015 UTC vs.
Revision 1.81 by jsr166, Mon Jul 17 21:01:30 2017 UTC

# Line 21 | Line 21 | import junit.framework.AssertionFailedEr
21   import junit.framework.Test;
22   import junit.framework.TestSuite;
23  
24 + @SuppressWarnings("WaitNotInLoop") // we implement spurious-wakeup freedom
25   public class ReentrantReadWriteLockTest extends JSR166TestCase {
26      public static void main(String[] args) {
27          main(suite(), args);
# Line 155 | Line 156 | public class ReentrantReadWriteLockTest
156      enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
157  
158      /**
159 <     * Awaits condition using the specified AwaitMethod.
159 >     * Awaits condition "indefinitely" using the specified AwaitMethod.
160       */
161      void await(Condition c, AwaitMethod awaitMethod)
162              throws InterruptedException {
163 +        long timeoutMillis = 2 * LONG_DELAY_MS;
164          switch (awaitMethod) {
165          case await:
166              c.await();
167              break;
168          case awaitTimed:
169 <            assertTrue(c.await(2 * LONG_DELAY_MS, MILLISECONDS));
169 >            assertTrue(c.await(timeoutMillis, MILLISECONDS));
170              break;
171          case awaitNanos:
172 <            long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
173 <            assertTrue(nanosRemaining > 0);
172 >            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
173 >            long nanosRemaining = c.awaitNanos(timeoutNanos);
174 >            assertTrue(nanosRemaining > timeoutNanos / 2);
175 >            assertTrue(nanosRemaining <= timeoutNanos);
176              break;
177          case awaitUntil:
178 <            java.util.Date d = new java.util.Date();
175 <            assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
178 >            assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
179              break;
180          default:
181              throw new AssertionError();
# Line 229 | Line 232 | public class ReentrantReadWriteLockTest
232      public void testGetWriteHoldCount()      { testGetWriteHoldCount(false); }
233      public void testGetWriteHoldCount_fair() { testGetWriteHoldCount(true); }
234      public void testGetWriteHoldCount(boolean fair) {
235 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
235 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
236          for (int i = 1; i <= SIZE; i++) {
237              lock.writeLock().lock();
238              assertEquals(i,lock.getWriteHoldCount());
# Line 246 | Line 249 | public class ReentrantReadWriteLockTest
249      public void testGetHoldCount()      { testGetHoldCount(false); }
250      public void testGetHoldCount_fair() { testGetHoldCount(true); }
251      public void testGetHoldCount(boolean fair) {
252 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
252 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
253          for (int i = 1; i <= SIZE; i++) {
254              lock.writeLock().lock();
255              assertEquals(i,lock.writeLock().getHoldCount());
# Line 263 | Line 266 | public class ReentrantReadWriteLockTest
266      public void testGetReadHoldCount()      { testGetReadHoldCount(false); }
267      public void testGetReadHoldCount_fair() { testGetReadHoldCount(true); }
268      public void testGetReadHoldCount(boolean fair) {
269 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
269 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
270          for (int i = 1; i <= SIZE; i++) {
271              lock.readLock().lock();
272              assertEquals(i,lock.getReadHoldCount());
# Line 280 | Line 283 | public class ReentrantReadWriteLockTest
283      public void testWriteUnlock_IMSE()      { testWriteUnlock_IMSE(false); }
284      public void testWriteUnlock_IMSE_fair() { testWriteUnlock_IMSE(true); }
285      public void testWriteUnlock_IMSE(boolean fair) {
286 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
286 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
287          try {
288              lock.writeLock().unlock();
289              shouldThrow();
# Line 293 | Line 296 | public class ReentrantReadWriteLockTest
296      public void testReadUnlock_IMSE()      { testReadUnlock_IMSE(false); }
297      public void testReadUnlock_IMSE_fair() { testReadUnlock_IMSE(true); }
298      public void testReadUnlock_IMSE(boolean fair) {
299 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
299 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
300          try {
301              lock.readLock().unlock();
302              shouldThrow();
# Line 786 | Line 789 | public class ReentrantReadWriteLockTest
789      public void testWriteTryLock_Timeout(boolean fair) {
790          final PublicReentrantReadWriteLock lock =
791              new PublicReentrantReadWriteLock(fair);
792 +        final long timeoutMillis = timeoutMillis();
793          lock.writeLock().lock();
794          Thread t = newStartedThread(new CheckedRunnable() {
795              public void realRun() throws InterruptedException {
796                  long startTime = System.nanoTime();
793 –                long timeoutMillis = 10;
797                  assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
798                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
799              }});
# Line 810 | Line 813 | public class ReentrantReadWriteLockTest
813          Thread t = newStartedThread(new CheckedRunnable() {
814              public void realRun() throws InterruptedException {
815                  long startTime = System.nanoTime();
816 <                long timeoutMillis = 10;
816 >                long timeoutMillis = timeoutMillis();
817                  assertFalse(lock.readLock().tryLock(timeoutMillis, MILLISECONDS));
818                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
819              }});
# Line 922 | Line 925 | public class ReentrantReadWriteLockTest
925      public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
926      public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
927      public void testAwaitNanos_Timeout(boolean fair) {
928 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
929 +        final Condition c = lock.writeLock().newCondition();
930 +        final long timeoutMillis = timeoutMillis();
931 +        lock.writeLock().lock();
932 +        final long startTime = System.nanoTime();
933 +        final long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
934          try {
926 –            final ReentrantReadWriteLock lock =
927 –                new ReentrantReadWriteLock(fair);
928 –            final Condition c = lock.writeLock().newCondition();
929 –            lock.writeLock().lock();
930 –            long startTime = System.nanoTime();
931 –            long timeoutMillis = 10;
932 –            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
935              long nanosRemaining = c.awaitNanos(timeoutNanos);
936              assertTrue(nanosRemaining <= 0);
935 –            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
936 –            lock.writeLock().unlock();
937          } catch (InterruptedException fail) { threadUnexpectedException(fail); }
938 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
939 +        lock.writeLock().unlock();
940      }
941  
942      /**
# Line 943 | Line 945 | public class ReentrantReadWriteLockTest
945      public void testAwait_Timeout()      { testAwait_Timeout(false); }
946      public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
947      public void testAwait_Timeout(boolean fair) {
948 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
949 +        final Condition c = lock.writeLock().newCondition();
950 +        final long timeoutMillis = timeoutMillis();
951 +        lock.writeLock().lock();
952 +        final long startTime = System.nanoTime();
953          try {
947 –            final ReentrantReadWriteLock lock =
948 –                new ReentrantReadWriteLock(fair);
949 –            final Condition c = lock.writeLock().newCondition();
950 –            lock.writeLock().lock();
951 –            long startTime = System.nanoTime();
952 –            long timeoutMillis = 10;
954              assertFalse(c.await(timeoutMillis, MILLISECONDS));
954 –            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
955 –            lock.writeLock().unlock();
955          } catch (InterruptedException fail) { threadUnexpectedException(fail); }
956 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
957 +        lock.writeLock().unlock();
958      }
959  
960      /**
# Line 962 | Line 963 | public class ReentrantReadWriteLockTest
963      public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
964      public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
965      public void testAwaitUntil_Timeout(boolean fair) {
966 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
967 +        final Condition c = lock.writeLock().newCondition();
968 +        lock.writeLock().lock();
969 +        // We shouldn't assume that nanoTime and currentTimeMillis
970 +        // use the same time source, so don't use nanoTime here.
971 +        final java.util.Date delayedDate = delayedDate(timeoutMillis());
972          try {
973 <            final ReentrantReadWriteLock lock =
967 <                new ReentrantReadWriteLock(fair);
968 <            final Condition c = lock.writeLock().newCondition();
969 <            lock.writeLock().lock();
970 <            long startTime = System.nanoTime();
971 <            long timeoutMillis = 10;
972 <            java.util.Date d = new java.util.Date();
973 <            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
974 <            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
975 <            lock.writeLock().unlock();
973 >            assertFalse(c.awaitUntil(delayedDate));
974          } catch (InterruptedException fail) { threadUnexpectedException(fail); }
975 +        assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
976 +        lock.writeLock().unlock();
977      }
978  
979      /**
# Line 1010 | Line 1010 | public class ReentrantReadWriteLockTest
1010      public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
1011      public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
1012      public void testAwaitUninterruptibly(boolean fair) {
1013 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1014 <        final Condition c = lock.writeLock().newCondition();
1013 >        final Lock lock = new ReentrantReadWriteLock(fair).writeLock();
1014 >        final Condition condition = lock.newCondition();
1015          final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
1016  
1017          Thread t1 = newStartedThread(new CheckedRunnable() {
1018              public void realRun() {
1019                  // Interrupt before awaitUninterruptibly
1020 <                lock.writeLock().lock();
1020 >                lock.lock();
1021                  pleaseInterrupt.countDown();
1022                  Thread.currentThread().interrupt();
1023 <                c.awaitUninterruptibly();
1023 >                condition.awaitUninterruptibly();
1024                  assertTrue(Thread.interrupted());
1025 <                lock.writeLock().unlock();
1025 >                lock.unlock();
1026              }});
1027  
1028          Thread t2 = newStartedThread(new CheckedRunnable() {
1029              public void realRun() {
1030                  // Interrupt during awaitUninterruptibly
1031 <                lock.writeLock().lock();
1031 >                lock.lock();
1032                  pleaseInterrupt.countDown();
1033 <                c.awaitUninterruptibly();
1033 >                condition.awaitUninterruptibly();
1034                  assertTrue(Thread.interrupted());
1035 <                lock.writeLock().unlock();
1035 >                lock.unlock();
1036              }});
1037  
1038          await(pleaseInterrupt);
1039 –        lock.writeLock().lock();
1040 –        lock.writeLock().unlock();
1039          t2.interrupt();
1040 <
1041 <        assertThreadStaysAlive(t1);
1042 <        assertTrue(t2.isAlive());
1043 <
1044 <        lock.writeLock().lock();
1045 <        c.signalAll();
1046 <        lock.writeLock().unlock();
1040 >        lock.lock();
1041 >        lock.unlock();
1042 >        assertThreadBlocks(t1, Thread.State.WAITING);
1043 >        assertThreadBlocks(t2, Thread.State.WAITING);
1044 >
1045 >        lock.lock();
1046 >        condition.signalAll();
1047 >        lock.unlock();
1048  
1049          awaitTermination(t1);
1050          awaitTermination(t2);
# Line 1229 | 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 1631 | 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 1650 | 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 1663 | 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