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.65 by jsr166, Tue May 31 16:16:24 2011 UTC vs.
Revision 1.70 by jsr166, Wed Dec 31 20:34:16 2014 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) {
# 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.
# Line 168 | Line 174 | public class ReentrantReadWriteLockTest
174              java.util.Date d = new java.util.Date();
175              assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
176              break;
177 +        default:
178 +            throw new AssertionError();
179          }
180      }
181  
# Line 1005 | Line 1013 | public class ReentrantReadWriteLockTest
1013      }
1014  
1015      /**
1016 <     * awaitUninterruptibly doesn't abort on interrupt
1016 >     * awaitUninterruptibly is uninterruptible
1017       */
1018      public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
1019      public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
1020      public void testAwaitUninterruptibly(boolean fair) {
1021          final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1022          final Condition c = lock.writeLock().newCondition();
1023 <        final CountDownLatch locked = new CountDownLatch(1);
1024 <        Thread t = newStartedThread(new CheckedRunnable() {
1023 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
1024 >
1025 >        Thread t1 = newStartedThread(new CheckedRunnable() {
1026              public void realRun() {
1027 +                // Interrupt before awaitUninterruptibly
1028                  lock.writeLock().lock();
1029 <                locked.countDown();
1029 >                pleaseInterrupt.countDown();
1030 >                Thread.currentThread().interrupt();
1031                  c.awaitUninterruptibly();
1032                  assertTrue(Thread.interrupted());
1033                  lock.writeLock().unlock();
1034              }});
1035  
1036 <        await(locked);
1036 >        Thread t2 = newStartedThread(new CheckedRunnable() {
1037 >            public void realRun() {
1038 >                // Interrupt during awaitUninterruptibly
1039 >                lock.writeLock().lock();
1040 >                pleaseInterrupt.countDown();
1041 >                c.awaitUninterruptibly();
1042 >                assertTrue(Thread.interrupted());
1043 >                lock.writeLock().unlock();
1044 >            }});
1045 >
1046 >        await(pleaseInterrupt);
1047          lock.writeLock().lock();
1048          lock.writeLock().unlock();
1049 <        t.interrupt();
1050 <        long timeoutMillis = 10;
1051 <        assertThreadStaysAlive(t, timeoutMillis);
1049 >        t2.interrupt();
1050 >
1051 >        assertThreadStaysAlive(t1);
1052 >        assertTrue(t2.isAlive());
1053 >
1054          lock.writeLock().lock();
1055 <        c.signal();
1055 >        c.signalAll();
1056          lock.writeLock().unlock();
1057 <        awaitTermination(t);
1057 >
1058 >        awaitTermination(t1);
1059 >        awaitTermination(t2);
1060      }
1061  
1062      /**

Diff Legend

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