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.66 by jsr166, Fri Jun 3 05:07:14 2011 UTC vs.
Revision 1.80 by jsr166, Sun May 14 02:03:15 2017 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 >
11 > import java.util.Arrays;
12 > import java.util.Collection;
13 > import java.util.HashSet;
14 > import java.util.concurrent.CountDownLatch;
15   import java.util.concurrent.atomic.AtomicBoolean;
16   import java.util.concurrent.locks.Condition;
17   import java.util.concurrent.locks.Lock;
18   import java.util.concurrent.locks.ReentrantReadWriteLock;
19 < import java.util.concurrent.CountDownLatch;
20 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
21 < import java.util.*;
19 >
20 > import junit.framework.AssertionFailedError;
21 > import junit.framework.Test;
22 > import junit.framework.TestSuite;
23  
24   public class ReentrantReadWriteLockTest extends JSR166TestCase {
25      public static void main(String[] args) {
26 <        junit.textui.TestRunner.run(suite());
26 >        main(suite(), args);
27      }
28      public static Test suite() {
29          return new TestSuite(ReentrantReadWriteLockTest.class);
# Line 85 | Line 91 | public class ReentrantReadWriteLockTest
91              Thread.yield();
92          }
93          assertTrue(t.isAlive());
94 <        assertTrue(lock.getOwner() != t);
94 >        assertNotSame(t, lock.getOwner());
95      }
96  
97      /**
# Line 146 | Line 152 | public class ReentrantReadWriteLockTest
152          lock.writeLock().unlock();
153      }
154  
155 <    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
155 >    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
156  
157      /**
158 <     * Awaits condition using the specified AwaitMethod.
158 >     * Awaits condition "indefinitely" using the specified AwaitMethod.
159       */
160      void await(Condition c, AwaitMethod awaitMethod)
161              throws InterruptedException {
162 +        long timeoutMillis = 2 * LONG_DELAY_MS;
163          switch (awaitMethod) {
164          case await:
165              c.await();
166              break;
167          case awaitTimed:
168 <            assertTrue(c.await(2 * LONG_DELAY_MS, MILLISECONDS));
168 >            assertTrue(c.await(timeoutMillis, MILLISECONDS));
169              break;
170          case awaitNanos:
171 <            long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
172 <            assertTrue(nanosRemaining > 0);
171 >            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
172 >            long nanosRemaining = c.awaitNanos(timeoutNanos);
173 >            assertTrue(nanosRemaining > timeoutNanos / 2);
174 >            assertTrue(nanosRemaining <= timeoutNanos);
175              break;
176          case awaitUntil:
177 <            java.util.Date d = new java.util.Date();
169 <            assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
177 >            assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
178              break;
179 +        default:
180 +            throw new AssertionError();
181          }
182      }
183  
# Line 221 | 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());
238          }
239          for (int i = SIZE; i > 0; i--) {
240              lock.writeLock().unlock();
241 <            assertEquals(i-1,lock.getWriteHoldCount());
241 >            assertEquals(i - 1,lock.getWriteHoldCount());
242          }
243      }
244  
# Line 238 | 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());
255          }
256          for (int i = SIZE; i > 0; i--) {
257              lock.writeLock().unlock();
258 <            assertEquals(i-1,lock.writeLock().getHoldCount());
258 >            assertEquals(i - 1,lock.writeLock().getHoldCount());
259          }
260      }
261  
# Line 255 | 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());
272          }
273          for (int i = SIZE; i > 0; i--) {
274              lock.readLock().unlock();
275 <            assertEquals(i-1,lock.getReadHoldCount());
275 >            assertEquals(i - 1,lock.getReadHoldCount());
276          }
277      }
278  
# Line 272 | 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 285 | 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 778 | 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();
785 –                long timeoutMillis = 10;
796                  assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
797                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
798              }});
# Line 802 | 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 822 | Line 832 | public class ReentrantReadWriteLockTest
832              new PublicReentrantReadWriteLock(fair);
833          try {
834              lock.writeLock().lockInterruptibly();
835 <        } catch (InterruptedException ie) {
826 <            threadUnexpectedException(ie);
827 <        }
835 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
836          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
837              public void realRun() throws InterruptedException {
838                  lock.writeLock().lockInterruptibly();
# Line 849 | Line 857 | public class ReentrantReadWriteLockTest
857              lock.readLock().lockInterruptibly();
858              lock.readLock().unlock();
859              lock.writeLock().lockInterruptibly();
860 <        } catch (InterruptedException ie) {
853 <            threadUnexpectedException(ie);
854 <        }
860 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
861          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
862              public void realRun() throws InterruptedException {
863                  lock.readLock().lockInterruptibly();
# Line 877 | Line 883 | public class ReentrantReadWriteLockTest
883                  await(c, awaitMethod);
884                  shouldThrow();
885              } catch (IllegalMonitorStateException success) {
886 <            } catch (InterruptedException e) { threadUnexpectedException(e); }
886 >            } catch (InterruptedException fail) {
887 >                threadUnexpectedException(fail);
888 >            }
889              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
890          }
891      }
# Line 916 | 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 {
920 –            final ReentrantReadWriteLock lock =
921 –                new ReentrantReadWriteLock(fair);
922 –            final Condition c = lock.writeLock().newCondition();
923 –            lock.writeLock().lock();
924 –            long startTime = System.nanoTime();
925 –            long timeoutMillis = 10;
926 –            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
934              long nanosRemaining = c.awaitNanos(timeoutNanos);
935              assertTrue(nanosRemaining <= 0);
936 <            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
937 <            lock.writeLock().unlock();
938 <        } catch (InterruptedException e) {
932 <            threadUnexpectedException(e);
933 <        }
936 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
937 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
938 >        lock.writeLock().unlock();
939      }
940  
941      /**
# Line 939 | 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 {
943 –            final ReentrantReadWriteLock lock =
944 –                new ReentrantReadWriteLock(fair);
945 –            final Condition c = lock.writeLock().newCondition();
946 –            lock.writeLock().lock();
947 –            long startTime = System.nanoTime();
948 –            long timeoutMillis = 10;
953              assertFalse(c.await(timeoutMillis, MILLISECONDS));
954 <            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
955 <            lock.writeLock().unlock();
956 <        } catch (InterruptedException e) {
953 <            threadUnexpectedException(e);
954 <        }
954 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
955 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
956 >        lock.writeLock().unlock();
957      }
958  
959      /**
# Line 960 | 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 {
972 <            final ReentrantReadWriteLock lock =
973 <                new ReentrantReadWriteLock(fair);
974 <            final Condition c = lock.writeLock().newCondition();
975 <            lock.writeLock().lock();
968 <            long startTime = System.nanoTime();
969 <            long timeoutMillis = 10;
970 <            java.util.Date d = new java.util.Date();
971 <            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
972 <            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
973 <            lock.writeLock().unlock();
974 <        } catch (InterruptedException e) {
975 <            threadUnexpectedException(e);
976 <        }
972 >            assertFalse(c.awaitUntil(delayedDate));
973 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
974 >        assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
975 >        lock.writeLock().unlock();
976      }
977  
978      /**
# Line 1010 | Line 1009 | public class ReentrantReadWriteLockTest
1009      public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
1010      public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
1011      public void testAwaitUninterruptibly(boolean fair) {
1012 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1013 <        final Condition c = lock.writeLock().newCondition();
1012 >        final Lock lock = new ReentrantReadWriteLock(fair).writeLock();
1013 >        final Condition condition = lock.newCondition();
1014          final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
1015  
1016          Thread t1 = newStartedThread(new CheckedRunnable() {
1017              public void realRun() {
1018                  // Interrupt before awaitUninterruptibly
1019 <                lock.writeLock().lock();
1019 >                lock.lock();
1020                  pleaseInterrupt.countDown();
1021                  Thread.currentThread().interrupt();
1022 <                c.awaitUninterruptibly();
1022 >                condition.awaitUninterruptibly();
1023                  assertTrue(Thread.interrupted());
1024 <                lock.writeLock().unlock();
1024 >                lock.unlock();
1025              }});
1026  
1027          Thread t2 = newStartedThread(new CheckedRunnable() {
1028              public void realRun() {
1029                  // Interrupt during awaitUninterruptibly
1030 <                lock.writeLock().lock();
1030 >                lock.lock();
1031                  pleaseInterrupt.countDown();
1032 <                c.awaitUninterruptibly();
1032 >                condition.awaitUninterruptibly();
1033                  assertTrue(Thread.interrupted());
1034 <                lock.writeLock().unlock();
1034 >                lock.unlock();
1035              }});
1036  
1037          await(pleaseInterrupt);
1039 –        lock.writeLock().lock();
1040 –        lock.writeLock().unlock();
1038          t2.interrupt();
1039 <
1040 <        assertThreadStaysAlive(t1);
1041 <        assertTrue(t2.isAlive());
1042 <
1043 <        lock.writeLock().lock();
1044 <        c.signalAll();
1045 <        lock.writeLock().unlock();
1039 >        lock.lock();
1040 >        lock.unlock();
1041 >        assertThreadBlocks(t1, Thread.State.WAITING);
1042 >        assertThreadBlocks(t2, Thread.State.WAITING);
1043 >
1044 >        lock.lock();
1045 >        condition.signalAll();
1046 >        lock.unlock();
1047  
1048          awaitTermination(t1);
1049          awaitTermination(t2);
# Line 1229 | Line 1227 | public class ReentrantReadWriteLockTest
1227      public void testSerialization()      { testSerialization(false); }
1228      public void testSerialization_fair() { testSerialization(true); }
1229      public void testSerialization(boolean fair) {
1230 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1230 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1231          lock.writeLock().lock();
1232          lock.readLock().lock();
1233  
# Line 1631 | Line 1629 | public class ReentrantReadWriteLockTest
1629      public void testToString()      { testToString(false); }
1630      public void testToString_fair() { testToString(true); }
1631      public void testToString(boolean fair) {
1632 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1632 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1633          assertTrue(lock.toString().contains("Write locks = 0"));
1634          assertTrue(lock.toString().contains("Read locks = 0"));
1635          lock.writeLock().lock();
1636          assertTrue(lock.toString().contains("Write locks = 1"));
1637          assertTrue(lock.toString().contains("Read locks = 0"));
1638 +        lock.writeLock().lock();
1639 +        assertTrue(lock.toString().contains("Write locks = 2"));
1640 +        assertTrue(lock.toString().contains("Read locks = 0"));
1641 +        lock.writeLock().unlock();
1642          lock.writeLock().unlock();
1643          lock.readLock().lock();
1644 +        assertTrue(lock.toString().contains("Write locks = 0"));
1645 +        assertTrue(lock.toString().contains("Read locks = 1"));
1646          lock.readLock().lock();
1647          assertTrue(lock.toString().contains("Write locks = 0"));
1648          assertTrue(lock.toString().contains("Read locks = 2"));
# Line 1650 | Line 1654 | public class ReentrantReadWriteLockTest
1654      public void testReadLockToString()      { testReadLockToString(false); }
1655      public void testReadLockToString_fair() { testReadLockToString(true); }
1656      public void testReadLockToString(boolean fair) {
1657 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1657 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1658          assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1659          lock.readLock().lock();
1660 +        assertTrue(lock.readLock().toString().contains("Read locks = 1"));
1661          lock.readLock().lock();
1662          assertTrue(lock.readLock().toString().contains("Read locks = 2"));
1663 +        lock.readLock().unlock();
1664 +        assertTrue(lock.readLock().toString().contains("Read locks = 1"));
1665 +        lock.readLock().unlock();
1666 +        assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1667      }
1668  
1669      /**
# Line 1663 | Line 1672 | public class ReentrantReadWriteLockTest
1672      public void testWriteLockToString()      { testWriteLockToString(false); }
1673      public void testWriteLockToString_fair() { testWriteLockToString(true); }
1674      public void testWriteLockToString(boolean fair) {
1675 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1675 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1676          assertTrue(lock.writeLock().toString().contains("Unlocked"));
1677          lock.writeLock().lock();
1678 <        assertTrue(lock.writeLock().toString().contains("Locked"));
1678 >        assertTrue(lock.writeLock().toString().contains("Locked by"));
1679          lock.writeLock().unlock();
1680          assertTrue(lock.writeLock().toString().contains("Unlocked"));
1681      }

Diff Legend

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