[ViewVC] Diff of: jsr166/jsr166/src/test/tck/StampedLockTest.java

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.2 by jsr166, Fri Feb 1 21:44:41 2013 UTC vs.
Revision 1.47 by dl, Tue Jan 26 13:33:06 2021 UTC

+ * with assistance from members of JCP JSR-166 Expert Group and
+ * released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
-–
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
-–
+ * Pat Fisher, Mike Judd.
+ */
-<
+import junit.framework.*;
->
+import static java.util.concurrent.TimeUnit.DAYS;
->
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
->
->
+import static java.util.concurrent.locks.StampedLock.isLockStamp;
->
+import static java.util.concurrent.locks.StampedLock.isOptimisticReadStamp;
->
+import static java.util.concurrent.locks.StampedLock.isReadLockStamp;
->
+import static java.util.concurrent.locks.StampedLock.isWriteLockStamp;
->
->
+import java.util.ArrayList;
->
+import java.util.List;
->
+import java.util.concurrent.Callable;
->
+import java.util.concurrent.CompletableFuture;
->
+import java.util.concurrent.CountDownLatch;
->
+import java.util.concurrent.Future;
->
+import java.util.concurrent.ThreadLocalRandom;
->
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
-–
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
-–
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.StampedLock;
-<
+import java.util.concurrent.CountDownLatch;
-<
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
-<
+import java.util.*;
->
+import java.util.function.BiConsumer;
->
+import java.util.function.Consumer;
->
+import java.util.function.Function;
->
->
+import junit.framework.Test;
->
+import junit.framework.TestSuite;
+public class StampedLockTest extends JSR166TestCase {
+    public static void main(String[] args) {
-<
+        junit.textui.TestRunner.run(suite());
->
+        main(suite(), args);
+    public static Test suite() {
+        return new TestSuite(StampedLockTest.class);
-<
+    // XXXX Just a skeleton implementation for now.
-<
+    public void testTODO() { fail("StampedLockTest needs help"); }
->
+    /**
->
+     * Releases write lock, checking isWriteLocked before and after
->
+     */
->
+    void releaseWriteLock(StampedLock lock, long stamp) {
->
+        assertTrue(lock.isWriteLocked());
->
+        assertValid(lock, stamp);
->
+        lock.unlockWrite(stamp);
->
+        assertFalse(lock.isWriteLocked());
->
+        assertFalse(lock.validate(stamp));
->
+    }
->
->
+    /**
->
+     * Releases read lock, checking isReadLocked before and after
->
+     */
->
+    void releaseReadLock(StampedLock lock, long stamp) {
->
+        assertTrue(lock.isReadLocked());
->
+        assertValid(lock, stamp);
->
+        lock.unlockRead(stamp);
->
+        assertFalse(lock.isReadLocked());
->
+        assertTrue(lock.validate(stamp));
->
+    }
->
->
+    long assertNonZero(long v) {
->
+        assertTrue(v != 0L);
->
+        return v;
->
+    }
->
->
+    long assertValid(StampedLock lock, long stamp) {
->
+        assertTrue(stamp != 0L);
->
+        assertTrue(lock.validate(stamp));
->
+        return stamp;
->
+    }
->
->
+    void assertUnlocked(StampedLock lock) {
->
+        assertFalse(lock.isReadLocked());
->
+        assertFalse(lock.isWriteLocked());
->
+        assertEquals(0, lock.getReadLockCount());
->
+        assertValid(lock, lock.tryOptimisticRead());
->
+    }
->
->
+    List<Action> lockLockers(Lock lock) {
->
+        return List.of(
->
+            () -> lock.lock(),
->
+            () -> lock.lockInterruptibly(),
->
+            () -> lock.tryLock(),
->
+            () -> lock.tryLock(Long.MIN_VALUE, DAYS),
->
+            () -> lock.tryLock(0L, DAYS),
->
+            () -> lock.tryLock(Long.MAX_VALUE, DAYS));
->
+    }
->
->
+    List<Function<StampedLock, Long>> readLockers() {
->
+        return List.of(
->
+            sl -> sl.readLock(),
->
+            sl -> sl.tryReadLock(),
->
+            sl -> readLockInterruptiblyUninterrupted(sl),
->
+            sl -> tryReadLockUninterrupted(sl, Long.MIN_VALUE, DAYS),
->
+            sl -> tryReadLockUninterrupted(sl, 0L, DAYS),
->
+            sl -> sl.tryConvertToReadLock(sl.tryOptimisticRead()));
->
+    }
->
->
+    List<BiConsumer<StampedLock, Long>> readUnlockers() {
->
+        return List.of(
->
+            (sl, stamp) -> sl.unlockRead(stamp),
->
+            (sl, stamp) -> assertTrue(sl.tryUnlockRead()),
->
+            (sl, stamp) -> sl.asReadLock().unlock(),
->
+            (sl, stamp) -> sl.unlock(stamp),
->
+            (sl, stamp) -> assertValid(sl, sl.tryConvertToOptimisticRead(stamp)));
->
+    }
->
->
+    List<Function<StampedLock, Long>> writeLockers() {
->
+        return List.of(
->
+            sl -> sl.writeLock(),
->
+            sl -> sl.tryWriteLock(),
->
+            sl -> writeLockInterruptiblyUninterrupted(sl),
->
+            sl -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS),
->
+            sl -> tryWriteLockUninterrupted(sl, 0L, DAYS),
->
+            sl -> sl.tryConvertToWriteLock(sl.tryOptimisticRead()));
->
+    }
->
->
+    List<BiConsumer<StampedLock, Long>> writeUnlockers() {
->
+        return List.of(
->
+            (sl, stamp) -> sl.unlockWrite(stamp),
->
+            (sl, stamp) -> assertTrue(sl.tryUnlockWrite()),
->
+            (sl, stamp) -> sl.asWriteLock().unlock(),
->
+            (sl, stamp) -> sl.unlock(stamp),
->
+            (sl, stamp) -> assertValid(sl, sl.tryConvertToOptimisticRead(stamp)));
->
+    }
->
->
+    /**
->
+     * Constructed StampedLock is in unlocked state
->
+     */
->
+    public void testConstructor() {
->
+        assertUnlocked(new StampedLock());
->
+    }
->
->
+    /**
->
+     * write-locking, then unlocking, an unlocked lock succeed
->
+     */
->
+    public void testWriteLock_lockUnlock() {
->
+        StampedLock lock = new StampedLock();
->
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers())
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            assertFalse(lock.isWriteLocked());
->
+            assertFalse(lock.isReadLocked());
->
+            assertEquals(0, lock.getReadLockCount());
->
->
+            long s = writeLocker.apply(lock);
->
+            assertValid(lock, s);
->
+            assertTrue(lock.isWriteLocked());
->
+            assertFalse(lock.isReadLocked());
->
+            assertEquals(0, lock.getReadLockCount());
->
+            writeUnlocker.accept(lock, s);
->
+            assertUnlocked(lock);
->
+        }
->
+    }
->
->
+    /**
->
+     * read-locking, then unlocking, an unlocked lock succeed
->
+     */
->
+    public void testReadLock_lockUnlock() {
->
+        StampedLock lock = new StampedLock();
->
->
+        for (Function<StampedLock, Long> readLocker : readLockers())
->
+        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
->
+            long s = 42;
->
+            for (int i = 0; i < 2; i++) {
->
+                s = assertValid(lock, readLocker.apply(lock));
->
+                assertFalse(lock.isWriteLocked());
->
+                assertTrue(lock.isReadLocked());
->
+                assertEquals(i + 1, lock.getReadLockCount());
->
+            }
->
+            for (int i = 0; i < 2; i++) {
->
+                assertFalse(lock.isWriteLocked());
->
+                assertTrue(lock.isReadLocked());
->
+                assertEquals(2 - i, lock.getReadLockCount());
->
+                readUnlocker.accept(lock, s);
->
+            }
->
+            assertUnlocked(lock);
->
+        }
->
+    }
->
->
+    /**
->
+     * tryUnlockWrite fails if not write locked
->
+     */
->
+    public void testTryUnlockWrite_failure() {
->
+        StampedLock lock = new StampedLock();
->
+        assertFalse(lock.tryUnlockWrite());
->
->
+        for (Function<StampedLock, Long> readLocker : readLockers())
->
+        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
->
+            long s = assertValid(lock, readLocker.apply(lock));
->
+            assertFalse(lock.tryUnlockWrite());
->
+            assertTrue(lock.isReadLocked());
->
+            readUnlocker.accept(lock, s);
->
+            assertUnlocked(lock);
->
+        }
->
+    }
->
->
+    /**
->
+     * tryUnlockRead fails if not read locked
->
+     */
->
+    public void testTryUnlockRead_failure() {
->
+        StampedLock lock = new StampedLock();
->
+        assertFalse(lock.tryUnlockRead());
->
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers())
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            long s = writeLocker.apply(lock);
->
+            assertFalse(lock.tryUnlockRead());
->
+            assertTrue(lock.isWriteLocked());
->
+            writeUnlocker.accept(lock, s);
->
+            assertUnlocked(lock);
->
+        }
->
+    }
-<
+    public void testConstructor() { new StampedLock(); }
->
+    /**
->
+     * validate(0L) fails
->
+     */
->
+    public void testValidate0() {
->
+        StampedLock lock = new StampedLock();
->
+        assertFalse(lock.validate(0L));
->
+    }
->
->
+    /**
->
+     * A stamp obtained from a successful lock operation validates while the lock is held
->
+     */
->
+    public void testValidate() throws InterruptedException {
->
+        StampedLock lock = new StampedLock();
->
->
+        for (Function<StampedLock, Long> readLocker : readLockers())
->
+        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
->
+            long s = assertNonZero(readLocker.apply(lock));
->
+            assertTrue(lock.validate(s));
->
+            readUnlocker.accept(lock, s);
->
+        }
->
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers())
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            long s = assertNonZero(writeLocker.apply(lock));
->
+            assertTrue(lock.validate(s));
->
+            writeUnlocker.accept(lock, s);
->
+        }
->
+    }
->
->
+    /**
->
+     * A stamp obtained from an unsuccessful lock operation does not validate
->
+     */
->
+    public void testValidate2() throws InterruptedException {
->
+        StampedLock lock = new StampedLock();
->
+        long s = assertNonZero(lock.writeLock());
->
+        assertTrue(lock.validate(s));
->
+        assertFalse(lock.validate(lock.tryWriteLock()));
->
+        assertFalse(lock.validate(lock.tryWriteLock(randomExpiredTimeout(),
->
+                                                    randomTimeUnit())));
->
+        assertFalse(lock.validate(lock.tryReadLock()));
->
+        assertFalse(lock.validate(lock.tryWriteLock(randomExpiredTimeout(),
->
+                                                    randomTimeUnit())));
->
+        assertFalse(lock.validate(lock.tryOptimisticRead()));
->
+        lock.unlockWrite(s);
->
+    }
->
->
+    void assertThrowInterruptedExceptionWhenPreInterrupted(Action[] actions) {
->
+        for (Action action : actions) {
->
+            Thread.currentThread().interrupt();
->
+            try {
->
+                action.run();
->
+                shouldThrow();
->
+            }
->
+            catch (InterruptedException success) {}
->
+            catch (Throwable fail) { threadUnexpectedException(fail); }
->
+            assertFalse(Thread.interrupted());
->
+        }
->
+    }
->
->
+    /**
->
+     * interruptible operations throw InterruptedException when pre-interrupted
->
+     */
->
+    public void testInterruptibleOperationsThrowInterruptedExceptionWhenPreInterrupted() {
->
+        final StampedLock lock = new StampedLock();
->
->
+        Action[] interruptibleLockActions = {
->
+            () -> lock.writeLockInterruptibly(),
->
+            () -> lock.tryWriteLock(Long.MIN_VALUE, DAYS),
->
+            () -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.readLockInterruptibly(),
->
+            () -> lock.tryReadLock(Long.MIN_VALUE, DAYS),
->
+            () -> lock.tryReadLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.asWriteLock().lockInterruptibly(),
->
+            () -> lock.asWriteLock().tryLock(0L, DAYS),
->
+            () -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.asReadLock().lockInterruptibly(),
->
+            () -> lock.asReadLock().tryLock(0L, DAYS),
->
+            () -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),
->
+        };
->
+        shuffle(interruptibleLockActions);
->
->
+        assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
->
+        {
->
+            long s = lock.writeLock();
->
+            assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
->
+            lock.unlockWrite(s);
->
+        }
->
+        {
->
+            long s = lock.readLock();
->
+            assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
->
+            lock.unlockRead(s);
->
+        }
->
+    }
->
->
+    void assertThrowInterruptedExceptionWhenInterrupted(Action[] actions) {
->
+        int n = actions.length;
->
+        Future<?>[] futures = new Future<?>[n];
->
+        CountDownLatch threadsStarted = new CountDownLatch(n);
->
+        CountDownLatch done = new CountDownLatch(n);
->
->
+        for (int i = 0; i < n; i++) {
->
+            Action action = actions[i];
->
+            futures[i] = cachedThreadPool.submit(new CheckedRunnable() {
->
+                public void realRun() throws Throwable {
->
+                    threadsStarted.countDown();
->
+                    try {
->
+                        action.run();
->
+                        shouldThrow();
->
+                    }
->
+                    catch (InterruptedException success) {}
->
+                    catch (Throwable fail) { threadUnexpectedException(fail); }
->
+                    assertFalse(Thread.interrupted());
->
+                    done.countDown();
->
+                }});
->
+        }
->
->
+        await(threadsStarted);
->
+        assertEquals(n, done.getCount());
->
+        for (Future<?> future : futures) // Interrupt all the tasks
->
+            future.cancel(true);
->
+        await(done);
->
+    }
->
->
+    /**
->
+     * interruptible operations throw InterruptedException when write locked and interrupted
->
+     */
->
+    public void testInterruptibleOperationsThrowInterruptedExceptionWriteLockedInterrupted() {
->
+        final StampedLock lock = new StampedLock();
->
+        long stamp = lock.writeLock();
->
->
+        Action[] interruptibleLockBlockingActions = {
->
+            () -> lock.writeLockInterruptibly(),
->
+            () -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.readLockInterruptibly(),
->
+            () -> lock.tryReadLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.asWriteLock().lockInterruptibly(),
->
+            () -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.asReadLock().lockInterruptibly(),
->
+            () -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),
->
+        };
->
+        shuffle(interruptibleLockBlockingActions);
->
->
+        assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);
->
->
+        releaseWriteLock(lock, stamp);
->
+    }
->
->
+    /**
->
+     * interruptible operations throw InterruptedException when read locked and interrupted
->
+     */
->
+    public void testInterruptibleOperationsThrowInterruptedExceptionReadLockedInterrupted() {
->
+        final StampedLock lock = new StampedLock();
->
+        long stamp = lock.readLock();
->
->
+        Action[] interruptibleLockBlockingActions = {
->
+            () -> lock.writeLockInterruptibly(),
->
+            () -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
->
+            () -> lock.asWriteLock().lockInterruptibly(),
->
+            () -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
->
+        };
->
+        shuffle(interruptibleLockBlockingActions);
->
->
+        assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);
->
->
+        releaseReadLock(lock, stamp);
->
+    }
->
->
+    /**
->
+     * Non-interruptible operations ignore and preserve interrupt status
->
+     */
->
+    public void testNonInterruptibleOperationsIgnoreInterrupts() {
->
+        final StampedLock lock = new StampedLock();
->
+        Thread.currentThread().interrupt();
->
->
+        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
->
+            long s = assertValid(lock, lock.readLock());
->
+            readUnlocker.accept(lock, s);
->
+            s = assertValid(lock, lock.tryReadLock());
->
+            readUnlocker.accept(lock, s);
->
+        }
->
->
+        lock.asReadLock().lock();
->
+        lock.asReadLock().unlock();
->
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            long s = assertValid(lock, lock.writeLock());
->
+            writeUnlocker.accept(lock, s);
->
+            s = assertValid(lock, lock.tryWriteLock());
->
+            writeUnlocker.accept(lock, s);
->
+        }
->
->
+        lock.asWriteLock().lock();
->
+        lock.asWriteLock().unlock();
->
->
+        assertTrue(Thread.interrupted());
->
+    }
->
->
+    /**
->
+     * tryWriteLock on an unlocked lock succeeds
->
+     */
->
+    public void testTryWriteLock() {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.tryWriteLock();
->
+        assertTrue(s != 0L);
->
+        assertTrue(lock.isWriteLocked());
->
+        assertEquals(0L, lock.tryWriteLock());
->
+        releaseWriteLock(lock, s);
->
+    }
->
->
+    /**
->
+     * tryWriteLock fails if locked
->
+     */
->
+    public void testTryWriteLockWhenLocked() {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.writeLock();
->
+        Thread t = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                assertEquals(0L, lock.tryWriteLock());
->
+            }});
->
->
+        assertEquals(0L, lock.tryWriteLock());
->
+        awaitTermination(t);
->
+        releaseWriteLock(lock, s);
->
+    }
->
->
+    /**
->
+     * tryReadLock fails if write-locked
->
+     */
->
+    public void testTryReadLockWhenLocked() {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.writeLock();
->
+        Thread t = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                assertEquals(0L, lock.tryReadLock());
->
+            }});
->
->
+        assertEquals(0L, lock.tryReadLock());
->
+        awaitTermination(t);
->
+        releaseWriteLock(lock, s);
->
+    }
->
->
+    /**
->
+     * Multiple threads can hold a read lock when not write-locked
->
+     */
->
+    public void testMultipleReadLocks() {
->
+        final StampedLock lock = new StampedLock();
->
+        final long s = lock.readLock();
->
+        Thread t = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() throws InterruptedException {
->
+                long s2 = lock.tryReadLock();
->
+                assertValid(lock, s2);
->
+                lock.unlockRead(s2);
->
+                long s3 = lock.tryReadLock(LONG_DELAY_MS, MILLISECONDS);
->
+                assertValid(lock, s3);
->
+                lock.unlockRead(s3);
->
+                long s4 = lock.readLock();
->
+                assertValid(lock, s4);
->
+                lock.unlockRead(s4);
->
+                lock.asReadLock().lock();
->
+                lock.asReadLock().unlock();
->
+                lock.asReadLock().lockInterruptibly();
->
+                lock.asReadLock().unlock();
->
+                lock.asReadLock().tryLock(Long.MIN_VALUE, DAYS);
->
+                lock.asReadLock().unlock();
->
+            }});
->
->
+        awaitTermination(t);
->
+        lock.unlockRead(s);
->
+    }
->
->
+    /**
->
+     * writeLock() succeeds only after a reading thread unlocks
->
+     */
->
+    public void testWriteAfterReadLock() throws InterruptedException {
->
+        final CountDownLatch aboutToLock = new CountDownLatch(1);
->
+        final StampedLock lock = new StampedLock();
->
+        long rs = lock.readLock();
->
+        Thread t = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                aboutToLock.countDown();
->
+                long s = lock.writeLock();
->
+                assertTrue(lock.isWriteLocked());
->
+                assertFalse(lock.isReadLocked());
->
+                lock.unlockWrite(s);
->
+            }});
->
->
+        await(aboutToLock);
->
+        assertThreadBlocks(t, Thread.State.WAITING);
->
+        assertFalse(lock.isWriteLocked());
->
+        assertTrue(lock.isReadLocked());
->
+        lock.unlockRead(rs);
->
+        awaitTermination(t);
->
+        assertUnlocked(lock);
->
+    }
-<
+//     /**
-<
+//      * A runnable calling lockInterruptibly
-<
+//      */
-<
+//     class InterruptibleLockRunnable extends CheckedRunnable {
-<
+//         final ReentrantReadWriteLock lock;
-<
+//         InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
-<
+//         public void realRun() throws InterruptedException {
-<
+//             lock.writeLock().lockInterruptibly();
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * A runnable calling lockInterruptibly that expects to be
-<
+//      * interrupted
-<
+//      */
-<
+//     class InterruptedLockRunnable extends CheckedInterruptedRunnable {
-<
+//         final ReentrantReadWriteLock lock;
-<
+//         InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
-<
+//         public void realRun() throws InterruptedException {
-<
+//             lock.writeLock().lockInterruptibly();
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * Subclass to expose protected methods
-<
+//      */
-<
+//     static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
-<
+//         PublicReentrantReadWriteLock() { super(); }
-<
+//         PublicReentrantReadWriteLock(boolean fair) { super(fair); }
-<
+//         public Thread getOwner() {
-<
+//             return super.getOwner();
-<
+//         }
-<
+//         public Collection<Thread> getQueuedThreads() {
-<
+//             return super.getQueuedThreads();
-<
+//         }
-<
+//         public Collection<Thread> getWaitingThreads(Condition c) {
-<
+//             return super.getWaitingThreads(c);
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * Releases write lock, checking that it had a hold count of 1.
-<
+//      */
-<
+//     void releaseWriteLock(PublicReentrantReadWriteLock lock) {
-<
+//         ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         assertEquals(1, lock.getWriteHoldCount());
-<
+//         writeLock.unlock();
-<
+//         assertNotWriteLocked(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Spin-waits until lock.hasQueuedThread(t) becomes true.
-<
+//      */
-<
+//     void waitForQueuedThread(PublicReentrantReadWriteLock lock, Thread t) {
-<
+//         long startTime = System.nanoTime();
-<
+//         while (!lock.hasQueuedThread(t)) {
-<
+//             if (millisElapsedSince(startTime) > LONG_DELAY_MS)
-<
+//                 throw new AssertionFailedError("timed out");
-<
+//             Thread.yield();
-<
+//         }
-<
+//         assertTrue(t.isAlive());
-<
+//         assertTrue(lock.getOwner() != t);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Checks that lock is not write-locked.
-<
+//      */
-<
+//     void assertNotWriteLocked(PublicReentrantReadWriteLock lock) {
-<
+//         assertFalse(lock.isWriteLocked());
-<
+//         assertFalse(lock.isWriteLockedByCurrentThread());
-<
+//         assertFalse(lock.writeLock().isHeldByCurrentThread());
-<
+//         assertEquals(0, lock.getWriteHoldCount());
-<
+//         assertEquals(0, lock.writeLock().getHoldCount());
-<
+//         assertNull(lock.getOwner());
-<
+//     }
-<
-<
+//     /**
-<
+//      * Checks that lock is write-locked by the given thread.
-<
+//      */
-<
+//     void assertWriteLockedBy(PublicReentrantReadWriteLock lock, Thread t) {
-<
+//         assertTrue(lock.isWriteLocked());
-<
+//         assertSame(t, lock.getOwner());
-<
+//         assertEquals(t == Thread.currentThread(),
-<
+//                      lock.isWriteLockedByCurrentThread());
-<
+//         assertEquals(t == Thread.currentThread(),
-<
+//                      lock.writeLock().isHeldByCurrentThread());
-<
+//         assertEquals(t == Thread.currentThread(),
-<
+//                      lock.getWriteHoldCount() > 0);
-<
+//         assertEquals(t == Thread.currentThread(),
-<
+//                      lock.writeLock().getHoldCount() > 0);
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
+//     }
-<
-<
+//     /**
-<
+//      * Checks that lock is write-locked by the current thread.
-<
+//      */
-<
+//     void assertWriteLockedByMoi(PublicReentrantReadWriteLock lock) {
-<
+//         assertWriteLockedBy(lock, Thread.currentThread());
-<
+//     }
-<
-<
+//     /**
-<
+//      * Checks that condition c has no waiters.
-<
+//      */
-<
+//     void assertHasNoWaiters(PublicReentrantReadWriteLock lock, Condition c) {
-<
+//         assertHasWaiters(lock, c, new Thread[] {});
-<
+//     }
-<
-<
+//     /**
-<
+//      * Checks that condition c has exactly the given waiter threads.
-<
+//      */
-<
+//     void assertHasWaiters(PublicReentrantReadWriteLock lock, Condition c,
-<
+//                           Thread... threads) {
-<
+//         lock.writeLock().lock();
-<
+//         assertEquals(threads.length > 0, lock.hasWaiters(c));
-<
+//         assertEquals(threads.length, lock.getWaitQueueLength(c));
-<
+//         assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
-<
+//         assertEquals(threads.length, lock.getWaitingThreads(c).size());
-<
+//         assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
-<
+//                      new HashSet<Thread>(Arrays.asList(threads)));
-<
+//         lock.writeLock().unlock();
-<
+//     }
-<
-<
+//     enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
-<
-<
+//     /**
-<
+//      * Awaits condition using the specified AwaitMethod.
-<
+//      */
-<
+//     void await(Condition c, AwaitMethod awaitMethod)
-<
+//             throws InterruptedException {
-<
+//         switch (awaitMethod) {
-<
+//         case await:
-<
+//             c.await();
-<
+//             break;
-<
+//         case awaitTimed:
-<
+//             assertTrue(c.await(2 * LONG_DELAY_MS, MILLISECONDS));
-<
+//             break;
-<
+//         case awaitNanos:
-<
+//             long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
-<
+//             assertTrue(nanosRemaining > 0);
-<
+//             break;
-<
+//         case awaitUntil:
-<
+//             java.util.Date d = new java.util.Date();
-<
+//             assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
-<
+//             break;
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * Constructor sets given fairness, and is in unlocked state
-<
+//      */
-<
+//     public void testConstructor() {
-<
+//         PublicReentrantReadWriteLock lock;
-<
-<
+//         lock = new PublicReentrantReadWriteLock();
-<
+//         assertFalse(lock.isFair());
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
-<
+//         lock = new PublicReentrantReadWriteLock(true);
-<
+//         assertTrue(lock.isFair());
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
-<
+//         lock = new PublicReentrantReadWriteLock(false);
-<
+//         assertFalse(lock.isFair());
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
+//     }
-<
-<
+//     /**
-<
+//      * write-locking and read-locking an unlocked lock succeed
-<
+//      */
-<
+//     public void testLock()      { testLock(false); }
-<
+//     public void testLock_fair() { testLock(true); }
-<
+//     public void testLock(boolean fair) {
-<
+//         PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         assertNotWriteLocked(lock);
-<
+//         lock.writeLock().lock();
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         lock.writeLock().unlock();
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
+//         lock.readLock().lock();
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(1, lock.getReadLockCount());
-<
+//         lock.readLock().unlock();
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWriteHoldCount returns number of recursive holds
-<
+//      */
-<
+//     public void testGetWriteHoldCount()      { testGetWriteHoldCount(false); }
-<
+//     public void testGetWriteHoldCount_fair() { testGetWriteHoldCount(true); }
-<
+//     public void testGetWriteHoldCount(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         for (int i = 1; i <= SIZE; i++) {
-<
+//             lock.writeLock().lock();
-<
+//             assertEquals(i,lock.getWriteHoldCount());
-<
+//         }
-<
+//         for (int i = SIZE; i > 0; i--) {
-<
+//             lock.writeLock().unlock();
-<
+//             assertEquals(i-1,lock.getWriteHoldCount());
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * writelock.getHoldCount returns number of recursive holds
-<
+//      */
-<
+//     public void testGetHoldCount()      { testGetHoldCount(false); }
-<
+//     public void testGetHoldCount_fair() { testGetHoldCount(true); }
-<
+//     public void testGetHoldCount(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         for (int i = 1; i <= SIZE; i++) {
-<
+//             lock.writeLock().lock();
-<
+//             assertEquals(i,lock.writeLock().getHoldCount());
-<
+//         }
-<
+//         for (int i = SIZE; i > 0; i--) {
-<
+//             lock.writeLock().unlock();
-<
+//             assertEquals(i-1,lock.writeLock().getHoldCount());
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * getReadHoldCount returns number of recursive holds
-<
+//      */
-<
+//     public void testGetReadHoldCount()      { testGetReadHoldCount(false); }
-<
+//     public void testGetReadHoldCount_fair() { testGetReadHoldCount(true); }
-<
+//     public void testGetReadHoldCount(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         for (int i = 1; i <= SIZE; i++) {
-<
+//             lock.readLock().lock();
-<
+//             assertEquals(i,lock.getReadHoldCount());
-<
+//         }
-<
+//         for (int i = SIZE; i > 0; i--) {
-<
+//             lock.readLock().unlock();
-<
+//             assertEquals(i-1,lock.getReadHoldCount());
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * write-unlocking an unlocked lock throws IllegalMonitorStateException
-<
+//      */
-<
+//     public void testWriteUnlock_IMSE()      { testWriteUnlock_IMSE(false); }
-<
+//     public void testWriteUnlock_IMSE_fair() { testWriteUnlock_IMSE(true); }
-<
+//     public void testWriteUnlock_IMSE(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.writeLock().unlock();
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * read-unlocking an unlocked lock throws IllegalMonitorStateException
-<
+//      */
-<
+//     public void testReadUnlock_IMSE()      { testReadUnlock_IMSE(false); }
-<
+//     public void testReadUnlock_IMSE_fair() { testReadUnlock_IMSE(true); }
-<
+//     public void testReadUnlock_IMSE(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.readLock().unlock();
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * write-lockInterruptibly is interruptible
-<
+//      */
-<
+//     public void testWriteLockInterruptibly_Interruptible()      { testWriteLockInterruptibly_Interruptible(false); }
-<
+//     public void testWriteLockInterruptibly_Interruptible_fair() { testWriteLockInterruptibly_Interruptible(true); }
-<
+//     public void testWriteLockInterruptibly_Interruptible(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lockInterruptibly();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t);
-<
+//         t.interrupt();
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * timed write-tryLock is interruptible
-<
+//      */
-<
+//     public void testWriteTryLock_Interruptible()      { testWriteTryLock_Interruptible(false); }
-<
+//     public void testWriteTryLock_Interruptible_fair() { testWriteTryLock_Interruptible(true); }
-<
+//     public void testWriteTryLock_Interruptible(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t);
-<
+//         t.interrupt();
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * read-lockInterruptibly is interruptible
-<
+//      */
-<
+//     public void testReadLockInterruptibly_Interruptible()      { testReadLockInterruptibly_Interruptible(false); }
-<
+//     public void testReadLockInterruptibly_Interruptible_fair() { testReadLockInterruptibly_Interruptible(true); }
-<
+//     public void testReadLockInterruptibly_Interruptible(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.readLock().lockInterruptibly();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t);
-<
+//         t.interrupt();
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * timed read-tryLock is interruptible
-<
+//      */
-<
+//     public void testReadTryLock_Interruptible()      { testReadTryLock_Interruptible(false); }
-<
+//     public void testReadTryLock_Interruptible_fair() { testReadTryLock_Interruptible(true); }
-<
+//     public void testReadTryLock_Interruptible(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.readLock().tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t);
-<
+//         t.interrupt();
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * write-tryLock on an unlocked lock succeeds
-<
+//      */
-<
+//     public void testWriteTryLock()      { testWriteTryLock(false); }
-<
+//     public void testWriteTryLock_fair() { testWriteTryLock(true); }
-<
+//     public void testWriteTryLock(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         assertTrue(lock.writeLock().tryLock());
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         assertTrue(lock.writeLock().tryLock());
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         lock.writeLock().unlock();
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * write-tryLock fails if locked
-<
+//      */
-<
+//     public void testWriteTryLockWhenLocked()      { testWriteTryLockWhenLocked(false); }
-<
+//     public void testWriteTryLockWhenLocked_fair() { testWriteTryLockWhenLocked(true); }
-<
+//     public void testWriteTryLockWhenLocked(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertFalse(lock.writeLock().tryLock());
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * read-tryLock fails if locked
-<
+//      */
-<
+//     public void testReadTryLockWhenLocked()      { testReadTryLockWhenLocked(false); }
-<
+//     public void testReadTryLockWhenLocked_fair() { testReadTryLockWhenLocked(true); }
-<
+//     public void testReadTryLockWhenLocked(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertFalse(lock.readLock().tryLock());
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Multiple threads can hold a read lock when not write-locked
-<
+//      */
-<
+//     public void testMultipleReadLocks()      { testMultipleReadLocks(false); }
-<
+//     public void testMultipleReadLocks_fair() { testMultipleReadLocks(true); }
-<
+//     public void testMultipleReadLocks(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         lock.readLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 assertTrue(lock.readLock().tryLock());
-<
+//                 lock.readLock().unlock();
-<
+//                 assertTrue(lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS));
-<
+//                 lock.readLock().unlock();
-<
+//                 lock.readLock().lock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         lock.readLock().unlock();
-<
+//     }
-<
-<
+//     /**
-<
+//      * A writelock succeeds only after a reading thread unlocks
-<
+//      */
-<
+//     public void testWriteAfterReadLock()      { testWriteAfterReadLock(false); }
-<
+//     public void testWriteAfterReadLock_fair() { testWriteAfterReadLock(true); }
-<
+//     public void testWriteAfterReadLock(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.readLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertEquals(1, lock.getReadLockCount());
-<
+//                 lock.writeLock().lock();
-<
+//                 assertEquals(0, lock.getReadLockCount());
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
+//         waitForQueuedThread(lock, t);
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(1, lock.getReadLockCount());
-<
+//         lock.readLock().unlock();
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
+//         awaitTermination(t);
-<
+//         assertNotWriteLocked(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * A writelock succeeds only after reading threads unlock
-<
+//      */
-<
+//     public void testWriteAfterMultipleReadLocks()      { testWriteAfterMultipleReadLocks(false); }
-<
+//     public void testWriteAfterMultipleReadLocks_fair() { testWriteAfterMultipleReadLocks(true); }
-<
+//     public void testWriteAfterMultipleReadLocks(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().lock();
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().lock();
-<
+//                 assertEquals(3, lock.getReadLockCount());
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
+//         awaitTermination(t1);
-<
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertEquals(2, lock.getReadLockCount());
-<
+//                 lock.writeLock().lock();
-<
+//                 assertEquals(0, lock.getReadLockCount());
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(2, lock.getReadLockCount());
-<
+//         lock.readLock().unlock();
-<
+//         lock.readLock().unlock();
-<
+//         assertEquals(0, lock.getReadLockCount());
-<
+//         awaitTermination(t2);
-<
+//         assertNotWriteLocked(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * A thread that tries to acquire a fair read lock (non-reentrantly)
-<
+//      * will block if there is a waiting writer thread
-<
+//      */
-<
+//     public void testReaderWriterReaderFairFifo() {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(true);
-<
+//         final AtomicBoolean t1GotLock = new AtomicBoolean(false);
-<
-<
+//         lock.readLock().lock();
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertEquals(1, lock.getReadLockCount());
-<
+//                 lock.writeLock().lock();
-<
+//                 assertEquals(0, lock.getReadLockCount());
-<
+//                 t1GotLock.set(true);
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
+//         waitForQueuedThread(lock, t1);
-<
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertEquals(1, lock.getReadLockCount());
-<
+//                 lock.readLock().lock();
-<
+//                 assertEquals(1, lock.getReadLockCount());
-<
+//                 assertTrue(t1GotLock.get());
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertTrue(t1.isAlive());
-<
+//         assertNotWriteLocked(lock);
-<
+//         assertEquals(1, lock.getReadLockCount());
-<
+//         lock.readLock().unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//         assertNotWriteLocked(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Readlocks succeed only after a writing thread unlocks
-<
+//      */
-<
+//     public void testReadAfterWriteLock()      { testReadAfterWriteLock(false); }
-<
+//     public void testReadAfterWriteLock_fair() { testReadAfterWriteLock(true); }
-<
+//     public void testReadAfterWriteLock(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().lock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().lock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         releaseWriteLock(lock);
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Read trylock succeeds if write locked by current thread
-<
+//      */
-<
+//     public void testReadHoldingWriteLock()      { testReadHoldingWriteLock(false); }
-<
+//     public void testReadHoldingWriteLock_fair() { testReadHoldingWriteLock(true); }
-<
+//     public void testReadHoldingWriteLock(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         assertTrue(lock.readLock().tryLock());
-<
+//         lock.readLock().unlock();
-<
+//         lock.writeLock().unlock();
-<
+//     }
-<
-<
+//     /**
-<
+//      * Read trylock succeeds (barging) even in the presence of waiting
-<
+//      * readers and/or writers
-<
+//      */
-<
+//     public void testReadTryLockBarging()      { testReadTryLockBarging(false); }
-<
+//     public void testReadTryLockBarging_fair() { testReadTryLockBarging(true); }
-<
+//     public void testReadTryLockBarging(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.readLock().lock();
-<
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.writeLock().lock();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t1);
-<
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().lock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
-<
+//         if (fair)
-<
+//             waitForQueuedThread(lock, t2);
-<
-<
+//         Thread t3 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().tryLock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
-<
+//         assertTrue(lock.getReadLockCount() > 0);
-<
+//         awaitTermination(t3);
-<
+//         assertTrue(t1.isAlive());
-<
+//         if (fair) assertTrue(t2.isAlive());
-<
+//         lock.readLock().unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Read lock succeeds if write locked by current thread even if
-<
+//      * other threads are waiting for readlock
-<
+//      */
-<
+//     public void testReadHoldingWriteLock2()      { testReadHoldingWriteLock2(false); }
-<
+//     public void testReadHoldingWriteLock2_fair() { testReadHoldingWriteLock2(true); }
-<
+//     public void testReadHoldingWriteLock2(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().unlock();
-<
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().lock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.readLock().lock();
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().unlock();
-<
+//         releaseWriteLock(lock);
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Read lock succeeds if write locked by current thread even if
-<
+//      * other threads are waiting for writelock
-<
+//      */
-<
+//     public void testReadHoldingWriteLock3()      { testReadHoldingWriteLock3(false); }
-<
+//     public void testReadHoldingWriteLock3_fair() { testReadHoldingWriteLock3(true); }
-<
+//     public void testReadHoldingWriteLock3(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().unlock();
-<
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.writeLock().lock();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.writeLock().lock();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().unlock();
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Write lock succeeds if write locked by current thread even if
-<
+//      * other threads are waiting for writelock
-<
+//      */
-<
+//     public void testWriteHoldingWriteLock4()      { testWriteHoldingWriteLock4(false); }
-<
+//     public void testWriteHoldingWriteLock4_fair() { testWriteHoldingWriteLock4(true); }
-<
+//     public void testWriteHoldingWriteLock4(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         lock.writeLock().lock();
-<
+//         lock.writeLock().unlock();
-<
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.writeLock().lock();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 lock.writeLock().lock();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         assertEquals(1, lock.getWriteHoldCount());
-<
+//         lock.writeLock().lock();
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         assertEquals(2, lock.getWriteHoldCount());
-<
+//         lock.writeLock().unlock();
-<
+//         assertWriteLockedByMoi(lock);
-<
+//         assertEquals(1, lock.getWriteHoldCount());
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Read tryLock succeeds if readlocked but not writelocked
-<
+//      */
-<
+//     public void testTryLockWhenReadLocked()      { testTryLockWhenReadLocked(false); }
-<
+//     public void testTryLockWhenReadLocked_fair() { testTryLockWhenReadLocked(true); }
-<
+//     public void testTryLockWhenReadLocked(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         lock.readLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertTrue(lock.readLock().tryLock());
-<
+//                 lock.readLock().unlock();
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         lock.readLock().unlock();
-<
+//     }
-<
-<
+//     /**
-<
+//      * write tryLock fails when readlocked
-<
+//      */
-<
+//     public void testWriteTryLockWhenReadLocked()      { testWriteTryLockWhenReadLocked(false); }
-<
+//     public void testWriteTryLockWhenReadLocked_fair() { testWriteTryLockWhenReadLocked(true); }
-<
+//     public void testWriteTryLockWhenReadLocked(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         lock.readLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 assertFalse(lock.writeLock().tryLock());
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         lock.readLock().unlock();
-<
+//     }
-<
-<
+//     /**
-<
+//      * write timed tryLock times out if locked
-<
+//      */
-<
+//     public void testWriteTryLock_Timeout()      { testWriteTryLock_Timeout(false); }
-<
+//     public void testWriteTryLock_Timeout_fair() { testWriteTryLock_Timeout(true); }
-<
+//     public void testWriteTryLock_Timeout(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 long startTime = System.nanoTime();
-<
+//                 long timeoutMillis = 10;
-<
+//                 assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
-<
+//                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * read timed tryLock times out if write-locked
-<
+//      */
-<
+//     public void testReadTryLock_Timeout()      { testReadTryLock_Timeout(false); }
-<
+//     public void testReadTryLock_Timeout_fair() { testReadTryLock_Timeout(true); }
-<
+//     public void testReadTryLock_Timeout(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 long startTime = System.nanoTime();
-<
+//                 long timeoutMillis = 10;
-<
+//                 assertFalse(lock.readLock().tryLock(timeoutMillis, MILLISECONDS));
-<
+//                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-<
+//             }});
-<
-<
+//         awaitTermination(t);
-<
+//         assertTrue(lock.writeLock().isHeldByCurrentThread());
-<
+//         lock.writeLock().unlock();
-<
+//     }
-<
-<
+//     /**
-<
+//      * write lockInterruptibly succeeds if unlocked, else is interruptible
-<
+//      */
-<
+//     public void testWriteLockInterruptibly()      { testWriteLockInterruptibly(false); }
-<
+//     public void testWriteLockInterruptibly_fair() { testWriteLockInterruptibly(true); }
-<
+//     public void testWriteLockInterruptibly(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.writeLock().lockInterruptibly();
-<
+//         } catch (InterruptedException ie) {
-<
+//             threadUnexpectedException(ie);
-<
+//         }
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lockInterruptibly();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t);
-<
+//         t.interrupt();
-<
+//         assertTrue(lock.writeLock().isHeldByCurrentThread());
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * read lockInterruptibly succeeds if lock free else is interruptible
-<
+//      */
-<
+//     public void testReadLockInterruptibly()      { testReadLockInterruptibly(false); }
-<
+//     public void testReadLockInterruptibly_fair() { testReadLockInterruptibly(true); }
-<
+//     public void testReadLockInterruptibly(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.readLock().lockInterruptibly();
-<
+//             lock.readLock().unlock();
-<
+//             lock.writeLock().lockInterruptibly();
-<
+//         } catch (InterruptedException ie) {
-<
+//             threadUnexpectedException(ie);
-<
+//         }
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.readLock().lockInterruptibly();
-<
+//             }});
-<
-<
+//         waitForQueuedThread(lock, t);
-<
+//         t.interrupt();
-<
+//         awaitTermination(t);
-<
+//         releaseWriteLock(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * Calling await without holding lock throws IllegalMonitorStateException
-<
+//      */
-<
+//     public void testAwait_IMSE()      { testAwait_IMSE(false); }
-<
+//     public void testAwait_IMSE_fair() { testAwait_IMSE(true); }
-<
+//     public void testAwait_IMSE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         for (AwaitMethod awaitMethod : AwaitMethod.values()) {
-<
+//             long startTime = System.nanoTime();
-<
+//             try {
-<
+//                 await(c, awaitMethod);
-<
+//                 shouldThrow();
-<
+//             } catch (IllegalMonitorStateException success) {
-<
+//             } catch (InterruptedException e) { threadUnexpectedException(e); }
-<
+//             assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * Calling signal without holding lock throws IllegalMonitorStateException
-<
+//      */
-<
+//     public void testSignal_IMSE()      { testSignal_IMSE(false); }
-<
+//     public void testSignal_IMSE_fair() { testSignal_IMSE(true); }
-<
+//     public void testSignal_IMSE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         try {
-<
+//             c.signal();
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * Calling signalAll without holding lock throws IllegalMonitorStateException
-<
+//      */
-<
+//     public void testSignalAll_IMSE()      { testSignalAll_IMSE(false); }
-<
+//     public void testSignalAll_IMSE_fair() { testSignalAll_IMSE(true); }
-<
+//     public void testSignalAll_IMSE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         try {
-<
+//             c.signalAll();
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * awaitNanos without a signal times out
-<
+//      */
-<
+//     public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
-<
+//     public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
-<
+//     public void testAwaitNanos_Timeout(boolean fair) {
-<
+//         try {
-<
+//             final ReentrantReadWriteLock lock =
-<
+//                 new ReentrantReadWriteLock(fair);
-<
+//             final Condition c = lock.writeLock().newCondition();
-<
+//             lock.writeLock().lock();
-<
+//             long startTime = System.nanoTime();
-<
+//             long timeoutMillis = 10;
-<
+//             long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
-<
+//             long nanosRemaining = c.awaitNanos(timeoutNanos);
-<
+//             assertTrue(nanosRemaining <= 0);
-<
+//             assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-<
+//             lock.writeLock().unlock();
-<
+//         } catch (InterruptedException e) {
-<
+//             threadUnexpectedException(e);
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * timed await without a signal times out
-<
+//      */
-<
+//     public void testAwait_Timeout()      { testAwait_Timeout(false); }
-<
+//     public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
-<
+//     public void testAwait_Timeout(boolean fair) {
-<
+//         try {
-<
+//             final ReentrantReadWriteLock lock =
-<
+//                 new ReentrantReadWriteLock(fair);
-<
+//             final Condition c = lock.writeLock().newCondition();
-<
+//             lock.writeLock().lock();
-<
+//             long startTime = System.nanoTime();
-<
+//             long timeoutMillis = 10;
-<
+//             assertFalse(c.await(timeoutMillis, MILLISECONDS));
-<
+//             assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-<
+//             lock.writeLock().unlock();
-<
+//         } catch (InterruptedException e) {
-<
+//             threadUnexpectedException(e);
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * awaitUntil without a signal times out
-<
+//      */
-<
+//     public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
-<
+//     public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
-<
+//     public void testAwaitUntil_Timeout(boolean fair) {
-<
+//         try {
-<
+//             final ReentrantReadWriteLock lock =
-<
+//                 new ReentrantReadWriteLock(fair);
-<
+//             final Condition c = lock.writeLock().newCondition();
-<
+//             lock.writeLock().lock();
-<
+//             long startTime = System.nanoTime();
-<
+//             long timeoutMillis = 10;
-<
+//             java.util.Date d = new java.util.Date();
-<
+//             assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
-<
+//             assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-<
+//             lock.writeLock().unlock();
-<
+//         } catch (InterruptedException e) {
-<
+//             threadUnexpectedException(e);
-<
+//         }
-<
+//     }
-<
-<
+//     /**
-<
+//      * await returns when signalled
-<
+//      */
-<
+//     public void testAwait()      { testAwait(false); }
-<
+//     public void testAwait_fair() { testAwait(true); }
-<
+//     public void testAwait(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked = new CountDownLatch(1);
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 locked.countDown();
-<
+//                 c.await();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         await(locked);
-<
+//         lock.writeLock().lock();
-<
+//         assertHasWaiters(lock, c, t);
-<
+//         c.signal();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         assertTrue(t.isAlive());
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t);
-<
+//     }
-<
-<
+//     /**
-<
+//      * awaitUninterruptibly is uninterruptible
-<
+//      */
-<
+//     public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
-<
+//     public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
-<
+//     public void testAwaitUninterruptibly(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
-<
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 // Interrupt before awaitUninterruptibly
-<
+//                 lock.writeLock().lock();
-<
+//                 pleaseInterrupt.countDown();
-<
+//                 Thread.currentThread().interrupt();
-<
+//                 c.awaitUninterruptibly();
-<
+//                 assertTrue(Thread.interrupted());
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() {
-<
+//                 // Interrupt during awaitUninterruptibly
-<
+//                 lock.writeLock().lock();
-<
+//                 pleaseInterrupt.countDown();
-<
+//                 c.awaitUninterruptibly();
-<
+//                 assertTrue(Thread.interrupted());
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         await(pleaseInterrupt);
-<
+//         lock.writeLock().lock();
-<
+//         lock.writeLock().unlock();
-<
+//         t2.interrupt();
-<
-<
+//         assertThreadStaysAlive(t1);
-<
+//         assertTrue(t2.isAlive());
-<
-<
+//         lock.writeLock().lock();
-<
+//         c.signalAll();
-<
+//         lock.writeLock().unlock();
-<
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * await/awaitNanos/awaitUntil is interruptible
-<
+//      */
-<
+//     public void testInterruptible_await()           { testInterruptible(false, AwaitMethod.await); }
-<
+//     public void testInterruptible_await_fair()      { testInterruptible(true,  AwaitMethod.await); }
-<
+//     public void testInterruptible_awaitTimed()      { testInterruptible(false, AwaitMethod.awaitTimed); }
-<
+//     public void testInterruptible_awaitTimed_fair() { testInterruptible(true,  AwaitMethod.awaitTimed); }
-<
+//     public void testInterruptible_awaitNanos()      { testInterruptible(false, AwaitMethod.awaitNanos); }
-<
+//     public void testInterruptible_awaitNanos_fair() { testInterruptible(true,  AwaitMethod.awaitNanos); }
-<
+//     public void testInterruptible_awaitUntil()      { testInterruptible(false, AwaitMethod.awaitUntil); }
-<
+//     public void testInterruptible_awaitUntil_fair() { testInterruptible(true,  AwaitMethod.awaitUntil); }
-<
+//     public void testInterruptible(boolean fair, final AwaitMethod awaitMethod) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked = new CountDownLatch(1);
-<
+//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 assertWriteLockedByMoi(lock);
-<
+//                 assertHasNoWaiters(lock, c);
-<
+//                 locked.countDown();
-<
+//                 try {
-<
+//                     await(c, awaitMethod);
-<
+//                 } finally {
-<
+//                     assertWriteLockedByMoi(lock);
-<
+//                     assertHasNoWaiters(lock, c);
-<
+//                     lock.writeLock().unlock();
-<
+//                     assertFalse(Thread.interrupted());
-<
+//                 }
-<
+//             }});
-<
-<
+//         await(locked);
-<
+//         assertHasWaiters(lock, c, t);
-<
+//         t.interrupt();
-<
+//         awaitTermination(t);
-<
+//         assertNotWriteLocked(lock);
-<
+//     }
-<
-<
+//     /**
-<
+//      * signalAll wakes up all threads
-<
+//      */
-<
+//     public void testSignalAll_await()           { testSignalAll(false, AwaitMethod.await); }
-<
+//     public void testSignalAll_await_fair()      { testSignalAll(true,  AwaitMethod.await); }
-<
+//     public void testSignalAll_awaitTimed()      { testSignalAll(false, AwaitMethod.awaitTimed); }
-<
+//     public void testSignalAll_awaitTimed_fair() { testSignalAll(true,  AwaitMethod.awaitTimed); }
-<
+//     public void testSignalAll_awaitNanos()      { testSignalAll(false, AwaitMethod.awaitNanos); }
-<
+//     public void testSignalAll_awaitNanos_fair() { testSignalAll(true,  AwaitMethod.awaitNanos); }
-<
+//     public void testSignalAll_awaitUntil()      { testSignalAll(false, AwaitMethod.awaitUntil); }
-<
+//     public void testSignalAll_awaitUntil_fair() { testSignalAll(true,  AwaitMethod.awaitUntil); }
-<
+//     public void testSignalAll(boolean fair, final AwaitMethod awaitMethod) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked = new CountDownLatch(2);
-<
+//         final Lock writeLock = lock.writeLock();
-<
+//         class Awaiter extends CheckedRunnable {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 writeLock.lock();
-<
+//                 locked.countDown();
-<
+//                 await(c, awaitMethod);
-<
+//                 writeLock.unlock();
-<
+//             }
-<
+//         }
-<
-<
+//         Thread t1 = newStartedThread(new Awaiter());
-<
+//         Thread t2 = newStartedThread(new Awaiter());
-<
-<
+//         await(locked);
-<
+//         writeLock.lock();
-<
+//         assertHasWaiters(lock, c, t1, t2);
-<
+//         c.signalAll();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         writeLock.unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * signal wakes up waiting threads in FIFO order
-<
+//      */
-<
+//     public void testSignalWakesFifo()      { testSignalWakesFifo(false); }
-<
+//     public void testSignalWakesFifo_fair() { testSignalWakesFifo(true); }
-<
+//     public void testSignalWakesFifo(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked1 = new CountDownLatch(1);
-<
+//         final CountDownLatch locked2 = new CountDownLatch(1);
-<
+//         final Lock writeLock = lock.writeLock();
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 writeLock.lock();
-<
+//                 locked1.countDown();
-<
+//                 c.await();
-<
+//                 writeLock.unlock();
-<
+//             }});
-<
-<
+//         await(locked1);
-<
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 writeLock.lock();
-<
+//                 locked2.countDown();
-<
+//                 c.await();
-<
+//                 writeLock.unlock();
-<
+//             }});
-<
-<
+//         await(locked2);
-<
-<
+//         writeLock.lock();
-<
+//         assertHasWaiters(lock, c, t1, t2);
-<
+//         assertFalse(lock.hasQueuedThreads());
-<
+//         c.signal();
-<
+//         assertHasWaiters(lock, c, t2);
-<
+//         assertTrue(lock.hasQueuedThread(t1));
-<
+//         assertFalse(lock.hasQueuedThread(t2));
-<
+//         c.signal();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         assertTrue(lock.hasQueuedThread(t1));
-<
+//         assertTrue(lock.hasQueuedThread(t2));
-<
+//         writeLock.unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * await after multiple reentrant locking preserves lock count
-<
+//      */
-<
+//     public void testAwaitLockCount()      { testAwaitLockCount(false); }
-<
+//     public void testAwaitLockCount_fair() { testAwaitLockCount(true); }
-<
+//     public void testAwaitLockCount(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked = new CountDownLatch(2);
-<
+//         Thread t1 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 assertWriteLockedByMoi(lock);
-<
+//                 assertEquals(1, lock.writeLock().getHoldCount());
-<
+//                 locked.countDown();
-<
+//                 c.await();
-<
+//                 assertWriteLockedByMoi(lock);
-<
+//                 assertEquals(1, lock.writeLock().getHoldCount());
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         Thread t2 = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 lock.writeLock().lock();
-<
+//                 assertWriteLockedByMoi(lock);
-<
+//                 assertEquals(2, lock.writeLock().getHoldCount());
-<
+//                 locked.countDown();
-<
+//                 c.await();
-<
+//                 assertWriteLockedByMoi(lock);
-<
+//                 assertEquals(2, lock.writeLock().getHoldCount());
-<
+//                 lock.writeLock().unlock();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         await(locked);
-<
+//         lock.writeLock().lock();
-<
+//         assertHasWaiters(lock, c, t1, t2);
-<
+//         c.signalAll();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
+//     }
-<
-<
+//     /**
-<
+//      * A serialized lock deserializes as unlocked
-<
+//      */
-<
+//     public void testSerialization()      { testSerialization(false); }
-<
+//     public void testSerialization_fair() { testSerialization(true); }
-<
+//     public void testSerialization(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         lock.writeLock().lock();
-<
+//         lock.readLock().lock();
-<
-<
+//         ReentrantReadWriteLock clone = serialClone(lock);
-<
+//         assertEquals(lock.isFair(), clone.isFair());
-<
+//         assertTrue(lock.isWriteLocked());
-<
+//         assertFalse(clone.isWriteLocked());
-<
+//         assertEquals(1, lock.getReadLockCount());
-<
+//         assertEquals(0, clone.getReadLockCount());
-<
+//         clone.writeLock().lock();
-<
+//         clone.readLock().lock();
-<
+//         assertTrue(clone.isWriteLocked());
-<
+//         assertEquals(1, clone.getReadLockCount());
-<
+//         clone.readLock().unlock();
-<
+//         clone.writeLock().unlock();
-<
+//         assertFalse(clone.isWriteLocked());
-<
+//         assertEquals(1, lock.getReadLockCount());
-<
+//         assertEquals(0, clone.getReadLockCount());
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasQueuedThreads reports whether there are waiting threads
-<
+//      */
-<
+//     public void testHasQueuedThreads()      { testHasQueuedThreads(false); }
-<
+//     public void testHasQueuedThreads_fair() { testHasQueuedThreads(true); }
-<
+//     public void testHasQueuedThreads(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-<
+//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-<
+//         assertFalse(lock.hasQueuedThreads());
-<
+//         lock.writeLock().lock();
-<
+//         assertFalse(lock.hasQueuedThreads());
-<
+//         t1.start();
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         assertTrue(lock.hasQueuedThreads());
-<
+//         t2.start();
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertTrue(lock.hasQueuedThreads());
-<
+//         t1.interrupt();
-<
+//         awaitTermination(t1);
-<
+//         assertTrue(lock.hasQueuedThreads());
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t2);
-<
+//         assertFalse(lock.hasQueuedThreads());
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasQueuedThread(null) throws NPE
-<
+//      */
-<
+//     public void testHasQueuedThreadNPE()      { testHasQueuedThreadNPE(false); }
-<
+//     public void testHasQueuedThreadNPE_fair() { testHasQueuedThreadNPE(true); }
-<
+//     public void testHasQueuedThreadNPE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.hasQueuedThread(null);
-<
+//             shouldThrow();
-<
+//         } catch (NullPointerException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasQueuedThread reports whether a thread is queued
-<
+//      */
-<
+//     public void testHasQueuedThread()      { testHasQueuedThread(false); }
-<
+//     public void testHasQueuedThread_fair() { testHasQueuedThread(true); }
-<
+//     public void testHasQueuedThread(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-<
+//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-<
+//         assertFalse(lock.hasQueuedThread(t1));
-<
+//         assertFalse(lock.hasQueuedThread(t2));
-<
+//         lock.writeLock().lock();
-<
+//         t1.start();
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         assertTrue(lock.hasQueuedThread(t1));
-<
+//         assertFalse(lock.hasQueuedThread(t2));
-<
+//         t2.start();
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertTrue(lock.hasQueuedThread(t1));
-<
+//         assertTrue(lock.hasQueuedThread(t2));
-<
+//         t1.interrupt();
-<
+//         awaitTermination(t1);
-<
+//         assertFalse(lock.hasQueuedThread(t1));
-<
+//         assertTrue(lock.hasQueuedThread(t2));
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t2);
-<
+//         assertFalse(lock.hasQueuedThread(t1));
-<
+//         assertFalse(lock.hasQueuedThread(t2));
-<
+//     }
-<
-<
+//     /**
-<
+//      * getQueueLength reports number of waiting threads
-<
+//      */
-<
+//     public void testGetQueueLength()      { testGetQueueLength(false); }
-<
+//     public void testGetQueueLength_fair() { testGetQueueLength(true); }
-<
+//     public void testGetQueueLength(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-<
+//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-<
+//         assertEquals(0, lock.getQueueLength());
-<
+//         lock.writeLock().lock();
-<
+//         t1.start();
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         assertEquals(1, lock.getQueueLength());
-<
+//         t2.start();
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertEquals(2, lock.getQueueLength());
-<
+//         t1.interrupt();
-<
+//         awaitTermination(t1);
-<
+//         assertEquals(1, lock.getQueueLength());
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t2);
-<
+//         assertEquals(0, lock.getQueueLength());
-<
+//     }
-<
-<
+//     /**
-<
+//      * getQueuedThreads includes waiting threads
-<
+//      */
-<
+//     public void testGetQueuedThreads()      { testGetQueuedThreads(false); }
-<
+//     public void testGetQueuedThreads_fair() { testGetQueuedThreads(true); }
-<
+//     public void testGetQueuedThreads(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-<
+//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-<
+//         assertTrue(lock.getQueuedThreads().isEmpty());
-<
+//         lock.writeLock().lock();
-<
+//         assertTrue(lock.getQueuedThreads().isEmpty());
-<
+//         t1.start();
-<
+//         waitForQueuedThread(lock, t1);
-<
+//         assertEquals(1, lock.getQueuedThreads().size());
-<
+//         assertTrue(lock.getQueuedThreads().contains(t1));
-<
+//         t2.start();
-<
+//         waitForQueuedThread(lock, t2);
-<
+//         assertEquals(2, lock.getQueuedThreads().size());
-<
+//         assertTrue(lock.getQueuedThreads().contains(t1));
-<
+//         assertTrue(lock.getQueuedThreads().contains(t2));
-<
+//         t1.interrupt();
-<
+//         awaitTermination(t1);
-<
+//         assertFalse(lock.getQueuedThreads().contains(t1));
-<
+//         assertTrue(lock.getQueuedThreads().contains(t2));
-<
+//         assertEquals(1, lock.getQueuedThreads().size());
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t2);
-<
+//         assertTrue(lock.getQueuedThreads().isEmpty());
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasWaiters throws NPE if null
-<
+//      */
-<
+//     public void testHasWaitersNPE()      { testHasWaitersNPE(false); }
-<
+//     public void testHasWaitersNPE_fair() { testHasWaitersNPE(true); }
-<
+//     public void testHasWaitersNPE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.hasWaiters(null);
-<
+//             shouldThrow();
-<
+//         } catch (NullPointerException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitQueueLength throws NPE if null
-<
+//      */
-<
+//     public void testGetWaitQueueLengthNPE()      { testGetWaitQueueLengthNPE(false); }
-<
+//     public void testGetWaitQueueLengthNPE_fair() { testGetWaitQueueLengthNPE(true); }
-<
+//     public void testGetWaitQueueLengthNPE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.getWaitQueueLength(null);
-<
+//             shouldThrow();
-<
+//         } catch (NullPointerException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitingThreads throws NPE if null
-<
+//      */
-<
+//     public void testGetWaitingThreadsNPE()      { testGetWaitingThreadsNPE(false); }
-<
+//     public void testGetWaitingThreadsNPE_fair() { testGetWaitingThreadsNPE(true); }
-<
+//     public void testGetWaitingThreadsNPE(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock.getWaitingThreads(null);
-<
+//             shouldThrow();
-<
+//         } catch (NullPointerException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasWaiters throws IllegalArgumentException if not owned
-<
+//      */
-<
+//     public void testHasWaitersIAE()      { testHasWaitersIAE(false); }
-<
+//     public void testHasWaitersIAE_fair() { testHasWaitersIAE(true); }
-<
+//     public void testHasWaitersIAE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock2.hasWaiters(c);
-<
+//             shouldThrow();
-<
+//         } catch (IllegalArgumentException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasWaiters throws IllegalMonitorStateException if not locked
-<
+//      */
-<
+//     public void testHasWaitersIMSE()      { testHasWaitersIMSE(false); }
-<
+//     public void testHasWaitersIMSE_fair() { testHasWaitersIMSE(true); }
-<
+//     public void testHasWaitersIMSE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         try {
-<
+//             lock.hasWaiters(c);
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitQueueLength throws IllegalArgumentException if not owned
-<
+//      */
-<
+//     public void testGetWaitQueueLengthIAE()      { testGetWaitQueueLengthIAE(false); }
-<
+//     public void testGetWaitQueueLengthIAE_fair() { testGetWaitQueueLengthIAE(true); }
-<
+//     public void testGetWaitQueueLengthIAE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock2.getWaitQueueLength(c);
-<
+//             shouldThrow();
-<
+//         } catch (IllegalArgumentException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitQueueLength throws IllegalMonitorStateException if not locked
-<
+//      */
-<
+//     public void testGetWaitQueueLengthIMSE()      { testGetWaitQueueLengthIMSE(false); }
-<
+//     public void testGetWaitQueueLengthIMSE_fair() { testGetWaitQueueLengthIMSE(true); }
-<
+//     public void testGetWaitQueueLengthIMSE(boolean fair) {
-<
+//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         try {
-<
+//             lock.getWaitQueueLength(c);
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitingThreads throws IllegalArgumentException if not owned
-<
+//      */
-<
+//     public void testGetWaitingThreadsIAE()      { testGetWaitingThreadsIAE(false); }
-<
+//     public void testGetWaitingThreadsIAE_fair() { testGetWaitingThreadsIAE(true); }
-<
+//     public void testGetWaitingThreadsIAE(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final PublicReentrantReadWriteLock lock2 =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         try {
-<
+//             lock2.getWaitingThreads(c);
-<
+//             shouldThrow();
-<
+//         } catch (IllegalArgumentException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitingThreads throws IllegalMonitorStateException if not locked
-<
+//      */
-<
+//     public void testGetWaitingThreadsIMSE()      { testGetWaitingThreadsIMSE(false); }
-<
+//     public void testGetWaitingThreadsIMSE_fair() { testGetWaitingThreadsIMSE(true); }
-<
+//     public void testGetWaitingThreadsIMSE(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         try {
-<
+//             lock.getWaitingThreads(c);
-<
+//             shouldThrow();
-<
+//         } catch (IllegalMonitorStateException success) {}
-<
+//     }
-<
-<
+//     /**
-<
+//      * hasWaiters returns true when a thread is waiting, else false
-<
+//      */
-<
+//     public void testHasWaiters()      { testHasWaiters(false); }
-<
+//     public void testHasWaiters_fair() { testHasWaiters(true); }
-<
+//     public void testHasWaiters(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked = new CountDownLatch(1);
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 assertHasNoWaiters(lock, c);
-<
+//                 assertFalse(lock.hasWaiters(c));
-<
+//                 locked.countDown();
-<
+//                 c.await();
-<
+//                 assertHasNoWaiters(lock, c);
-<
+//                 assertFalse(lock.hasWaiters(c));
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         await(locked);
-<
+//         lock.writeLock().lock();
-<
+//         assertHasWaiters(lock, c, t);
-<
+//         assertTrue(lock.hasWaiters(c));
-<
+//         c.signal();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         assertFalse(lock.hasWaiters(c));
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t);
-<
+//         assertHasNoWaiters(lock, c);
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitQueueLength returns number of waiting threads
-<
+//      */
-<
+//     public void testGetWaitQueueLength()      { testGetWaitQueueLength(false); }
-<
+//     public void testGetWaitQueueLength_fair() { testGetWaitQueueLength(true); }
-<
+//     public void testGetWaitQueueLength(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked = new CountDownLatch(1);
-<
+//         Thread t = newStartedThread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 assertEquals(0, lock.getWaitQueueLength(c));
-<
+//                 locked.countDown();
-<
+//                 c.await();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         await(locked);
-<
+//         lock.writeLock().lock();
-<
+//         assertHasWaiters(lock, c, t);
-<
+//         assertEquals(1, lock.getWaitQueueLength(c));
-<
+//         c.signal();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         assertEquals(0, lock.getWaitQueueLength(c));
-<
+//         lock.writeLock().unlock();
-<
+//         awaitTermination(t);
-<
+//     }
-<
-<
+//     /**
-<
+//      * getWaitingThreads returns only and all waiting threads
-<
+//      */
-<
+//     public void testGetWaitingThreads()      { testGetWaitingThreads(false); }
-<
+//     public void testGetWaitingThreads_fair() { testGetWaitingThreads(true); }
-<
+//     public void testGetWaitingThreads(boolean fair) {
-<
+//         final PublicReentrantReadWriteLock lock =
-<
+//             new PublicReentrantReadWriteLock(fair);
-<
+//         final Condition c = lock.writeLock().newCondition();
-<
+//         final CountDownLatch locked1 = new CountDownLatch(1);
-<
+//         final CountDownLatch locked2 = new CountDownLatch(1);
-<
+//         Thread t1 = new Thread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 assertTrue(lock.getWaitingThreads(c).isEmpty());
-<
+//                 locked1.countDown();
-<
+//                 c.await();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         Thread t2 = new Thread(new CheckedRunnable() {
-<
+//             public void realRun() throws InterruptedException {
-<
+//                 lock.writeLock().lock();
-<
+//                 assertFalse(lock.getWaitingThreads(c).isEmpty());
-<
+//                 locked2.countDown();
-<
+//                 c.await();
-<
+//                 lock.writeLock().unlock();
-<
+//             }});
-<
-<
+//         lock.writeLock().lock();
-<
+//         assertTrue(lock.getWaitingThreads(c).isEmpty());
-<
+//         lock.writeLock().unlock();
-<
-<
+//         t1.start();
-<
+//         await(locked1);
-<
+//         t2.start();
-<
+//         await(locked2);
-<
-<
+//         lock.writeLock().lock();
-<
+//         assertTrue(lock.hasWaiters(c));
-<
+//         assertTrue(lock.getWaitingThreads(c).contains(t1));
-<
+//         assertTrue(lock.getWaitingThreads(c).contains(t2));
-<
+//         assertEquals(2, lock.getWaitingThreads(c).size());
-<
+//         c.signalAll();
-<
+//         assertHasNoWaiters(lock, c);
-<
+//         lock.writeLock().unlock();
-<
-<
+//         awaitTermination(t1);
-<
+//         awaitTermination(t2);
-<
-<
+//         assertHasNoWaiters(lock, c);
-<
+//     }
-<
-<
+//     /**
-<
+//      * toString indicates current lock state
-<
+//      */
-<
+//     public void testToString()      { testToString(false); }
-<
+//     public void testToString_fair() { testToString(true); }
-<
+//     public void testToString(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         assertTrue(lock.toString().contains("Write locks = 0"));
-<
+//         assertTrue(lock.toString().contains("Read locks = 0"));
-<
+//         lock.writeLock().lock();
-<
+//         assertTrue(lock.toString().contains("Write locks = 1"));
-<
+//         assertTrue(lock.toString().contains("Read locks = 0"));
-<
+//         lock.writeLock().unlock();
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().lock();
-<
+//         assertTrue(lock.toString().contains("Write locks = 0"));
-<
+//         assertTrue(lock.toString().contains("Read locks = 2"));
-<
+//     }
-<
-<
+//     /**
-<
+//      * readLock.toString indicates current lock state
-<
+//      */
-<
+//     public void testReadLockToString()      { testReadLockToString(false); }
-<
+//     public void testReadLockToString_fair() { testReadLockToString(true); }
-<
+//     public void testReadLockToString(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         assertTrue(lock.readLock().toString().contains("Read locks = 0"));
-<
+//         lock.readLock().lock();
-<
+//         lock.readLock().lock();
-<
+//         assertTrue(lock.readLock().toString().contains("Read locks = 2"));
-<
+//     }
-<
-<
+//     /**
-<
+//      * writeLock.toString indicates current lock state
-<
+//      */
-<
+//     public void testWriteLockToString()      { testWriteLockToString(false); }
-<
+//     public void testWriteLockToString_fair() { testWriteLockToString(true); }
-<
+//     public void testWriteLockToString(boolean fair) {
-<
+//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
-<
+//         assertTrue(lock.writeLock().toString().contains("Unlocked"));
-<
+//         lock.writeLock().lock();
-<
+//         assertTrue(lock.writeLock().toString().contains("Locked"));
-<
+//         lock.writeLock().unlock();
-<
+//         assertTrue(lock.writeLock().toString().contains("Unlocked"));
-<
+//     }
->
+    /**
->
+     * writeLock() succeeds only after reading threads unlock
->
+     */
->
+    public void testWriteAfterMultipleReadLocks() {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.readLock();
->
+        Thread t1 = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                long rs = lock.readLock();
->
+                lock.unlockRead(rs);
->
+            }});
->
->
+        awaitTermination(t1);
->
->
+        Thread t2 = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                long ws = lock.writeLock();
->
+                lock.unlockWrite(ws);
->
+            }});
->
->
+        assertTrue(lock.isReadLocked());
->
+        assertFalse(lock.isWriteLocked());
->
+        lock.unlockRead(s);
->
+        awaitTermination(t2);
->
+        assertUnlocked(lock);
->
+    }
->
->
+    /**
->
+     * readLock() succeed only after a writing thread unlocks
->
+     */
->
+    public void testReadAfterWriteLock() {
->
+        final StampedLock lock = new StampedLock();
->
+        final CountDownLatch threadsStarted = new CountDownLatch(2);
->
+        final long s = lock.writeLock();
->
+        final Runnable acquireReleaseReadLock = new CheckedRunnable() {
->
+            public void realRun() {
->
+                threadsStarted.countDown();
->
+                long rs = lock.readLock();
->
+                assertTrue(lock.isReadLocked());
->
+                assertFalse(lock.isWriteLocked());
->
+                lock.unlockRead(rs);
->
+            }};
->
+        Thread t1 = newStartedThread(acquireReleaseReadLock);
->
+        Thread t2 = newStartedThread(acquireReleaseReadLock);
->
->
+        await(threadsStarted);
->
+        assertThreadBlocks(t1, Thread.State.WAITING);
->
+        assertThreadBlocks(t2, Thread.State.WAITING);
->
+        assertTrue(lock.isWriteLocked());
->
+        assertFalse(lock.isReadLocked());
->
+        releaseWriteLock(lock, s);
->
+        awaitTermination(t1);
->
+        awaitTermination(t2);
->
+        assertUnlocked(lock);
->
+    }
->
->
+    /**
->
+     * tryReadLock succeeds if read locked but not write locked
->
+     */
->
+    public void testTryLockWhenReadLocked() {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.readLock();
->
+        Thread t = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                long rs = lock.tryReadLock();
->
+                assertValid(lock, rs);
->
+                lock.unlockRead(rs);
->
+            }});
->
->
+        awaitTermination(t);
->
+        lock.unlockRead(s);
->
+    }
->
->
+    /**
->
+     * tryWriteLock fails when read locked
->
+     */
->
+    public void testTryWriteLockWhenReadLocked() {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.readLock();
->
+        Thread t = newStartedThread(new CheckedRunnable() {
->
+            public void realRun() {
->
+                assertEquals(0L, lock.tryWriteLock());
->
+            }});
->
->
+        awaitTermination(t);
->
+        lock.unlockRead(s);
->
+    }
->
->
+    /**
->
+     * timed lock operations time out if lock not available
->
+     */
->
+    public void testTimedLock_Timeout() throws Exception {
->
+        ArrayList<Future<?>> futures = new ArrayList<>();
->
->
+        // Write locked
->
+        final StampedLock lock = new StampedLock();
->
+        long stamp = lock.writeLock();
->
+        assertEquals(0L, lock.tryReadLock(0L, DAYS));
->
+        assertEquals(0L, lock.tryReadLock(Long.MIN_VALUE, DAYS));
->
+        assertFalse(lock.asReadLock().tryLock(0L, DAYS));
->
+        assertFalse(lock.asReadLock().tryLock(Long.MIN_VALUE, DAYS));
->
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
->
+        assertEquals(0L, lock.tryWriteLock(Long.MIN_VALUE, DAYS));
->
+        assertFalse(lock.asWriteLock().tryLock(0L, DAYS));
->
+        assertFalse(lock.asWriteLock().tryLock(Long.MIN_VALUE, DAYS));
->
->
+        futures.add(cachedThreadPool.submit(new CheckedRunnable() {
->
+            public void realRun() throws InterruptedException {
->
+                long startTime = System.nanoTime();
->
+                assertEquals(0L, lock.tryWriteLock(timeoutMillis(), MILLISECONDS));
->
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
->
+            }}));
->
->
+        futures.add(cachedThreadPool.submit(new CheckedRunnable() {
->
+            public void realRun() throws InterruptedException {
->
+                long startTime = System.nanoTime();
->
+                assertEquals(0L, lock.tryReadLock(timeoutMillis(), MILLISECONDS));
->
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
->
+            }}));
->
->
+        // Read locked
->
+        final StampedLock lock2 = new StampedLock();
->
+        long stamp2 = lock2.readLock();
->
+        assertEquals(0L, lock2.tryWriteLock(0L, DAYS));
->
+        assertEquals(0L, lock2.tryWriteLock(Long.MIN_VALUE, DAYS));
->
+        assertFalse(lock2.asWriteLock().tryLock(0L, DAYS));
->
+        assertFalse(lock2.asWriteLock().tryLock(Long.MIN_VALUE, DAYS));
->
->
+        futures.add(cachedThreadPool.submit(new CheckedRunnable() {
->
+            public void realRun() throws InterruptedException {
->
+                long startTime = System.nanoTime();
->
+                assertEquals(0L, lock2.tryWriteLock(timeoutMillis(), MILLISECONDS));
->
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
->
+            }}));
->
->
+        for (Future<?> future : futures)
->
+            assertNull(future.get());
->
->
+        releaseWriteLock(lock, stamp);
->
+        releaseReadLock(lock2, stamp2);
->
+    }
->
->
+    /**
->
+     * writeLockInterruptibly succeeds if unlocked
->
+     */
->
+    public void testWriteLockInterruptibly() throws InterruptedException {
->
+        final StampedLock lock = new StampedLock();
->
+        long s = lock.writeLockInterruptibly();
->
+        assertTrue(lock.isWriteLocked());
->
+        releaseWriteLock(lock, s);
->
+    }
->
->
+    /**
->
+     * readLockInterruptibly succeeds if lock free
->
+     */
->
+    public void testReadLockInterruptibly() throws InterruptedException {
->
+        final StampedLock lock = new StampedLock();
->
->
+        long s = assertValid(lock, lock.readLockInterruptibly());
->
+        assertTrue(lock.isReadLocked());
->
+        lock.unlockRead(s);
->
->
+        lock.asReadLock().lockInterruptibly();
->
+        assertTrue(lock.isReadLocked());
->
+        lock.asReadLock().unlock();
->
+    }
->
->
+    /**
->
+     * A serialized lock deserializes as unlocked
->
+     */
->
+    public void testSerialization() {
->
+        StampedLock lock = new StampedLock();
->
+        lock.writeLock();
->
+        StampedLock clone = serialClone(lock);
->
+        assertTrue(lock.isWriteLocked());
->
+        assertFalse(clone.isWriteLocked());
->
+        long s = clone.writeLock();
->
+        assertTrue(clone.isWriteLocked());
->
+        clone.unlockWrite(s);
->
+        assertFalse(clone.isWriteLocked());
->
+    }
->
->
+    /**
->
+     * toString indicates current lock state
->
+     */
->
+    public void testToString() {
->
+        StampedLock lock = new StampedLock();
->
+        assertTrue(lock.toString().contains("Unlocked"));
->
+        long s = lock.writeLock();
->
+        assertTrue(lock.toString().contains("Write-locked"));
->
+        lock.unlockWrite(s);
->
+        s = lock.readLock();
->
+        assertTrue(lock.toString().contains("Read-locks"));
->
+        releaseReadLock(lock, s);
->
+    }
->
->
+    /**
->
+     * tryOptimisticRead succeeds and validates if unlocked, fails if
->
+     * exclusively locked
->
+     */
->
+    public void testValidateOptimistic() throws InterruptedException {
->
+        StampedLock lock = new StampedLock();
->
->
+        assertValid(lock, lock.tryOptimisticRead());
->
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers()) {
->
+            long s = assertValid(lock, writeLocker.apply(lock));
->
+            assertEquals(0L, lock.tryOptimisticRead());
->
+            releaseWriteLock(lock, s);
->
+        }
->
->
+        for (Function<StampedLock, Long> readLocker : readLockers()) {
->
+            long s = assertValid(lock, readLocker.apply(lock));
->
+            long p = assertValid(lock, lock.tryOptimisticRead());
->
+            releaseReadLock(lock, s);
->
+            assertTrue(lock.validate(p));
->
+        }
->
->
+        assertValid(lock, lock.tryOptimisticRead());
->
+    }
->
->
+    /**
->
+     * tryOptimisticRead stamp does not validate if a write lock intervenes
->
+     */
->
+    public void testValidateOptimisticWriteLocked() {
->
+        final StampedLock lock = new StampedLock();
->
+        final long p = assertValid(lock, lock.tryOptimisticRead());
->
+        final long s = assertValid(lock, lock.writeLock());
->
+        assertFalse(lock.validate(p));
->
+        assertEquals(0L, lock.tryOptimisticRead());
->
+        assertTrue(lock.validate(s));
->
+        lock.unlockWrite(s);
->
+    }
->
->
+    /**
->
+     * tryOptimisticRead stamp does not validate if a write lock
->
+     * intervenes in another thread
->
+     */
->
+    public void testValidateOptimisticWriteLocked2()
->
+            throws InterruptedException {
->
+        final CountDownLatch locked = new CountDownLatch(1);
->
+        final StampedLock lock = new StampedLock();
->
+        final long p = assertValid(lock, lock.tryOptimisticRead());
->
->
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
->
+            public void realRun() throws InterruptedException {
->
+                lock.writeLockInterruptibly();
->
+                locked.countDown();
->
+                lock.writeLockInterruptibly();
->
+            }});
->
->
+        await(locked);
->
+        assertFalse(lock.validate(p));
->
+        assertEquals(0L, lock.tryOptimisticRead());
->
+        assertThreadBlocks(t, Thread.State.WAITING);
->
+        t.interrupt();
->
+        awaitTermination(t);
->
+        assertTrue(lock.isWriteLocked());
->
+    }
->
->
+    /**
->
+     * tryConvertToOptimisticRead succeeds and validates if successfully locked
->
+     */
->
+    public void testTryConvertToOptimisticRead() throws InterruptedException {
->
+        StampedLock lock = new StampedLock();
->
+        long s, p, q;
->
+        assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
->
->
+        s = assertValid(lock, lock.tryOptimisticRead());
->
+        assertEquals(s, lock.tryConvertToOptimisticRead(s));
->
+        assertTrue(lock.validate(s));
->
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers()) {
->
+            s = assertValid(lock, writeLocker.apply(lock));
->
+            p = assertValid(lock, lock.tryConvertToOptimisticRead(s));
->
+            assertFalse(lock.validate(s));
->
+            assertTrue(lock.validate(p));
->
+            assertUnlocked(lock);
->
+        }
->
->
+        for (Function<StampedLock, Long> readLocker : readLockers()) {
->
+            s = assertValid(lock, readLocker.apply(lock));
->
+            q = assertValid(lock, lock.tryOptimisticRead());
->
+            assertEquals(q, lock.tryConvertToOptimisticRead(q));
->
+            assertTrue(lock.validate(q));
->
+            assertTrue(lock.isReadLocked());
->
+            p = assertValid(lock, lock.tryConvertToOptimisticRead(s));
->
+            assertTrue(lock.validate(p));
->
+            assertTrue(lock.validate(s));
->
+            assertUnlocked(lock);
->
+            assertEquals(q, lock.tryConvertToOptimisticRead(q));
->
+            assertTrue(lock.validate(q));
->
+        }
->
+    }
->
->
+    /**
->
+     * tryConvertToReadLock succeeds for valid stamps
->
+     */
->
+    public void testTryConvertToReadLock() throws InterruptedException {
->
+        StampedLock lock = new StampedLock();
->
+        long s, p;
->
->
+        assertEquals(0L, lock.tryConvertToReadLock(0L));
->
->
+        s = assertValid(lock, lock.tryOptimisticRead());
->
+        p = assertValid(lock, lock.tryConvertToReadLock(s));
->
+        assertTrue(lock.isReadLocked());
->
+        assertEquals(1, lock.getReadLockCount());
->
+        assertTrue(lock.validate(s));
->
+        lock.unlockRead(p);
->
->
+        s = assertValid(lock, lock.tryOptimisticRead());
->
+        lock.readLock();
->
+        p = assertValid(lock, lock.tryConvertToReadLock(s));
->
+        assertTrue(lock.isReadLocked());
->
+        assertEquals(2, lock.getReadLockCount());
->
+        lock.unlockRead(p);
->
+        lock.unlockRead(p);
->
+        assertUnlocked(lock);
->
->
+        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
->
+            for (Function<StampedLock, Long> writeLocker : writeLockers()) {
->
+                s = assertValid(lock, writeLocker.apply(lock));
->
+                p = assertValid(lock, lock.tryConvertToReadLock(s));
->
+                assertFalse(lock.validate(s));
->
+                assertTrue(lock.isReadLocked());
->
+                assertEquals(1, lock.getReadLockCount());
->
+                readUnlocker.accept(lock, p);
->
+            }
->
->
+            for (Function<StampedLock, Long> readLocker : readLockers()) {
->
+                s = assertValid(lock, readLocker.apply(lock));
->
+                assertEquals(s, lock.tryConvertToReadLock(s));
->
+                assertTrue(lock.validate(s));
->
+                assertTrue(lock.isReadLocked());
->
+                assertEquals(1, lock.getReadLockCount());
->
+                readUnlocker.accept(lock, s);
->
+            }
->
+        }
->
+    }
->
->
+    /**
->
+     * tryConvertToWriteLock succeeds if lock available; fails if multiply read locked
->
+     */
->
+    public void testTryConvertToWriteLock() throws InterruptedException {
->
+        StampedLock lock = new StampedLock();
->
+        long s, p;
->
->
+        assertEquals(0L, lock.tryConvertToWriteLock(0L));
->
->
+        assertTrue((s = lock.tryOptimisticRead()) != 0L);
->
+        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
->
+        assertTrue(lock.isWriteLocked());
->
+        lock.unlockWrite(p);
->
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            for (Function<StampedLock, Long> writeLocker : writeLockers()) {
->
+                s = assertValid(lock, writeLocker.apply(lock));
->
+                assertEquals(s, lock.tryConvertToWriteLock(s));
->
+                assertTrue(lock.validate(s));
->
+                assertTrue(lock.isWriteLocked());
->
+                writeUnlocker.accept(lock, s);
->
+            }
->
->
+            for (Function<StampedLock, Long> readLocker : readLockers()) {
->
+                s = assertValid(lock, readLocker.apply(lock));
->
+                p = assertValid(lock, lock.tryConvertToWriteLock(s));
->
+                assertFalse(lock.validate(s));
->
+                assertTrue(lock.validate(p));
->
+                assertTrue(lock.isWriteLocked());
->
+                writeUnlocker.accept(lock, p);
->
+            }
->
+        }
->
->
+        // failure if multiply read locked
->
+        for (Function<StampedLock, Long> readLocker : readLockers()) {
->
+            s = assertValid(lock, readLocker.apply(lock));
->
+            p = assertValid(lock, readLocker.apply(lock));
->
+            assertEquals(0L, lock.tryConvertToWriteLock(s));
->
+            assertTrue(lock.validate(s));
->
+            assertTrue(lock.validate(p));
->
+            assertEquals(2, lock.getReadLockCount());
->
+            lock.unlock(p);
->
+            lock.unlock(s);
->
+            assertUnlocked(lock);
->
+        }
->
+    }
->
->
+    /**
->
+     * asWriteLock can be locked and unlocked
->
+     */
->
+    public void testAsWriteLock() throws Throwable {
->
+        StampedLock sl = new StampedLock();
->
+        Lock lock = sl.asWriteLock();
->
+        for (Action locker : lockLockers(lock)) {
->
+            locker.run();
->
+            assertTrue(sl.isWriteLocked());
->
+            assertFalse(sl.isReadLocked());
->
+            assertFalse(lock.tryLock());
->
+            lock.unlock();
->
+            assertUnlocked(sl);
->
+        }
->
+    }
->
->
+    /**
->
+     * asReadLock can be locked and unlocked
->
+     */
->
+    public void testAsReadLock() throws Throwable {
->
+        StampedLock sl = new StampedLock();
->
+        Lock lock = sl.asReadLock();
->
+        for (Action locker : lockLockers(lock)) {
->
+            locker.run();
->
+            assertTrue(sl.isReadLocked());
->
+            assertFalse(sl.isWriteLocked());
->
+            assertEquals(1, sl.getReadLockCount());
->
+            locker.run();
->
+            assertTrue(sl.isReadLocked());
->
+            assertEquals(2, sl.getReadLockCount());
->
+            lock.unlock();
->
+            lock.unlock();
->
+            assertUnlocked(sl);
->
+        }
->
+    }
->
->
+    /**
->
+     * asReadWriteLock.writeLock can be locked and unlocked
->
+     */
->
+    public void testAsReadWriteLockWriteLock() throws Throwable {
->
+        StampedLock sl = new StampedLock();
->
+        Lock lock = sl.asReadWriteLock().writeLock();
->
+        for (Action locker : lockLockers(lock)) {
->
+            locker.run();
->
+            assertTrue(sl.isWriteLocked());
->
+            assertFalse(sl.isReadLocked());
->
+            assertFalse(lock.tryLock());
->
+            lock.unlock();
->
+            assertUnlocked(sl);
->
+        }
->
+    }
->
->
+    /**
->
+     * asReadWriteLock.readLock can be locked and unlocked
->
+     */
->
+    public void testAsReadWriteLockReadLock() throws Throwable {
->
+        StampedLock sl = new StampedLock();
->
+        Lock lock = sl.asReadWriteLock().readLock();
->
+        for (Action locker : lockLockers(lock)) {
->
+            locker.run();
->
+            assertTrue(sl.isReadLocked());
->
+            assertFalse(sl.isWriteLocked());
->
+            assertEquals(1, sl.getReadLockCount());
->
+            locker.run();
->
+            assertTrue(sl.isReadLocked());
->
+            assertEquals(2, sl.getReadLockCount());
->
+            lock.unlock();
->
+            lock.unlock();
->
+            assertUnlocked(sl);
->
+        }
->
+    }
->
->
+    /**
->
+     * Lock.newCondition throws UnsupportedOperationException
->
+     */
->
+    public void testLockViewsDoNotSupportConditions() {
->
+        StampedLock sl = new StampedLock();
->
+        assertThrows(UnsupportedOperationException.class,
->
+                     () -> sl.asWriteLock().newCondition(),
->
+                     () -> sl.asReadLock().newCondition(),
->
+                     () -> sl.asReadWriteLock().writeLock().newCondition(),
->
+                     () -> sl.asReadWriteLock().readLock().newCondition());
->
+    }
->
->
+    /**
->
+     * Passing optimistic read stamps to unlock operations result in
->
+     * IllegalMonitorStateException
->
+     */
->
+    public void testCannotUnlockOptimisticReadStamps() {
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = assertValid(sl, sl.tryOptimisticRead());
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockRead(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryOptimisticRead();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryOptimisticRead();
->
+            sl.writeLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            sl.readLock();
->
+            long stamp = assertValid(sl, sl.tryOptimisticRead());
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockRead(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            sl.readLock();
->
+            long stamp = assertValid(sl, sl.tryOptimisticRead());
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
->
+            assertValid(sl, stamp);
->
+            sl.writeLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockWrite(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
->
+            sl.writeLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
->
+            sl.readLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockRead(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
->
+            sl.readLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
->
+            assertValid(sl, stamp);
->
+            sl.writeLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockWrite(stamp));
->
+            }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
->
+            sl.writeLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
->
+            sl.readLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockRead(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            sl.readLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
->
+            assertValid(sl, stamp);
->
+            sl.readLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlockRead(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
->
+            sl.readLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
+        {
->
+            StampedLock sl = new StampedLock();
->
+            sl.readLock();
->
+            long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
->
+            sl.readLock();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                () -> sl.unlock(stamp));
->
+        }
->
+    }
->
->
+    static long writeLockInterruptiblyUninterrupted(StampedLock sl) {
->
+        try { return sl.writeLockInterruptibly(); }
->
+        catch (InterruptedException ex) { throw new AssertionError(ex); }
->
+    }
->
->
+    static long tryWriteLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
->
+        try { return sl.tryWriteLock(time, unit); }
->
+        catch (InterruptedException ex) { throw new AssertionError(ex); }
->
+    }
->
->
+    static long readLockInterruptiblyUninterrupted(StampedLock sl) {
->
+        try { return sl.readLockInterruptibly(); }
->
+        catch (InterruptedException ex) { throw new AssertionError(ex); }
->
+    }
->
->
+    static long tryReadLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
->
+        try { return sl.tryReadLock(time, unit); }
->
+        catch (InterruptedException ex) { throw new AssertionError(ex); }
->
+    }
->
->
+    /**
->
+     * Invalid stamps result in IllegalMonitorStateException
->
+     */
->
+    public void testInvalidStampsThrowIllegalMonitorStateException() {
->
+        final StampedLock sl = new StampedLock();
->
->
+        assertThrows(IllegalMonitorStateException.class,
->
+                     () -> sl.unlockWrite(0L),
->
+                     () -> sl.unlockRead(0L),
->
+                     () -> sl.unlock(0L));
->
->
+        final long optimisticStamp = sl.tryOptimisticRead();
->
+        final long readStamp = sl.readLock();
->
+        sl.unlockRead(readStamp);
->
+        final long writeStamp = sl.writeLock();
->
+        sl.unlockWrite(writeStamp);
->
+        assertTrue(optimisticStamp != 0L && readStamp != 0L && writeStamp != 0L);
->
+        final long[] noLongerValidStamps = { optimisticStamp, readStamp, writeStamp };
->
+        final Runnable assertNoLongerValidStampsThrow = () -> {
->
+            for (long noLongerValidStamp : noLongerValidStamps)
->
+                assertThrows(IllegalMonitorStateException.class,
->
+                             () -> sl.unlockWrite(noLongerValidStamp),
->
+                             () -> sl.unlockRead(noLongerValidStamp),
->
+                             () -> sl.unlock(noLongerValidStamp));
->
+        };
->
+        assertNoLongerValidStampsThrow.run();
->
->
+        for (Function<StampedLock, Long> readLocker : readLockers())
->
+        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
->
+            final long stamp = readLocker.apply(sl);
->
+            assertValid(sl, stamp);
->
+            assertNoLongerValidStampsThrow.run();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                         () -> sl.unlockWrite(stamp),
->
+                         () -> sl.unlockRead(sl.tryOptimisticRead()),
->
+                         () -> sl.unlockRead(0L));
->
+            readUnlocker.accept(sl, stamp);
->
+            assertUnlocked(sl);
->
+            assertNoLongerValidStampsThrow.run();
->
+        }
->
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers())
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            final long stamp = writeLocker.apply(sl);
->
+            assertValid(sl, stamp);
->
+            assertNoLongerValidStampsThrow.run();
->
+            assertThrows(IllegalMonitorStateException.class,
->
+                         () -> sl.unlockRead(stamp),
->
+                         () -> sl.unlockWrite(0L));
->
+            writeUnlocker.accept(sl, stamp);
->
+            assertUnlocked(sl);
->
+            assertNoLongerValidStampsThrow.run();
->
+        }
->
+    }
->
->
+    /**
->
+     * Read locks can be very deeply nested
->
+     */
->
+    public void testDeeplyNestedReadLocks() {
->
+        final StampedLock lock = new StampedLock();
->
+        final int depth = 300;
->
+        final long[] stamps = new long[depth];
->
+        final List<Function<StampedLock, Long>> readLockers = readLockers();
->
+        final List<BiConsumer<StampedLock, Long>> readUnlockers = readUnlockers();
->
+        for (int i = 0; i < depth; i++) {
->
+            Function<StampedLock, Long> readLocker
->
+                = readLockers.get(i % readLockers.size());
->
+            long stamp = readLocker.apply(lock);
->
+            assertEquals(i + 1, lock.getReadLockCount());
->
+            assertTrue(lock.isReadLocked());
->
+            stamps[i] = stamp;
->
+        }
->
+        for (int i = 0; i < depth; i++) {
->
+            BiConsumer<StampedLock, Long> readUnlocker
->
+                = readUnlockers.get(i % readUnlockers.size());
->
+            assertEquals(depth - i, lock.getReadLockCount());
->
+            assertTrue(lock.isReadLocked());
->
+            readUnlocker.accept(lock, stamps[depth - 1 - i]);
->
+        }
->
+        assertUnlocked(lock);
->
+    }
->
->
+    /**
->
+     * Stamped locks are not reentrant.
->
+     */
->
+    public void testNonReentrant() throws InterruptedException {
->
+        final StampedLock lock = new StampedLock();
->
+        long stamp;
->
->
+        stamp = lock.writeLock();
->
+        assertValid(lock, stamp);
->
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
->
+        assertEquals(0L, lock.tryReadLock(0L, DAYS));
->
+        assertValid(lock, stamp);
->
+        lock.unlockWrite(stamp);
->
->
+        stamp = lock.tryWriteLock(1L, DAYS);
->
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
->
+        assertValid(lock, stamp);
->
+        lock.unlockWrite(stamp);
->
->
+        stamp = lock.readLock();
->
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
->
+        assertValid(lock, stamp);
->
+        lock.unlockRead(stamp);
->
+    }
->
->
+    /**
->
+     * """StampedLocks have no notion of ownership. Locks acquired in
->
+     * one thread can be released or converted in another."""
->
+     */
->
+    public void testNoOwnership() throws Throwable {
->
+        ArrayList<Future<?>> futures = new ArrayList<>();
->
+        for (Function<StampedLock, Long> writeLocker : writeLockers())
->
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
->
+            StampedLock lock = new StampedLock();
->
+            long stamp = writeLocker.apply(lock);
->
+            futures.add(cachedThreadPool.submit(new CheckedRunnable() {
->
+                public void realRun() {
->
+                    writeUnlocker.accept(lock, stamp);
->
+                    assertUnlocked(lock);
->
+                    assertFalse(lock.validate(stamp));
->
+                }}));
->
+        }
->
+        for (Future<?> future : futures)
->
+            assertNull(future.get());
->
+    }
->
->
+    /** Tries out sample usage code from StampedLock javadoc. */
->
+    public void testSampleUsage() throws Throwable {
->
+        class Point {
->
+            private double x, y;
->
+            private final StampedLock sl = new StampedLock();
->
->
+            void move(double deltaX, double deltaY) { // an exclusively locked method
->
+                long stamp = sl.writeLock();
->
+                try {
->
+                    x += deltaX;
->
+                    y += deltaY;
->
+                } finally {
->
+                    sl.unlockWrite(stamp);
->
+                }
->
+            }
->
->
+            double distanceFromOrigin() { // A read-only method
->
+                double currentX, currentY;
->
+                long stamp = sl.tryOptimisticRead();
->
+                do {
->
+                    if (stamp == 0L)
->
+                        stamp = sl.readLock();
->
+                    try {
->
+                        // possibly racy reads
->
+                        currentX = x;
->
+                        currentY = y;
->
+                    } finally {
->
+                        stamp = sl.tryConvertToOptimisticRead(stamp);
->
+                    }
->
+                } while (stamp == 0);
->
+                return Math.hypot(currentX, currentY);
->
+            }
->
->
+            double distanceFromOrigin2() {
->
+                long stamp = sl.tryOptimisticRead();
->
+                try {
->
+                    retryHoldingLock:
->
+                    for (;; stamp = sl.readLock()) {
->
+                        if (stamp == 0L)
->
+                            continue retryHoldingLock;
->
+                        // possibly racy reads
->
+                        double currentX = x;
->
+                        double currentY = y;
->
+                        if (!sl.validate(stamp))
->
+                            continue retryHoldingLock;
->
+                        return Math.hypot(currentX, currentY);
->
+                    }
->
+                } finally {
->
+                    if (StampedLock.isReadLockStamp(stamp))
->
+                        sl.unlockRead(stamp);
->
+                }
->
+            }
->
->
+            void moveIfAtOrigin(double newX, double newY) {
->
+                long stamp = sl.readLock();
->
+                try {
->
+                    while (x == 0.0 && y == 0.0) {
->
+                        long ws = sl.tryConvertToWriteLock(stamp);
->
+                        if (ws != 0L) {
->
+                            stamp = ws;
->
+                            x = newX;
->
+                            y = newY;
->
+                            return;
->
+                        }
->
+                        else {
->
+                            sl.unlockRead(stamp);
->
+                            stamp = sl.writeLock();
->
+                        }
->
+                    }
->
+                } finally {
->
+                    sl.unlock(stamp);
->
+                }
->
+            }
->
+        }
->
->
+        Point p = new Point();
->
+        p.move(3.0, 4.0);
->
+        assertEquals(5.0, p.distanceFromOrigin());
->
+        p.moveIfAtOrigin(5.0, 12.0);
->
+        assertEquals(5.0, p.distanceFromOrigin2());
->
+    }
->
->
+    /**
->
+     * Stamp inspection methods work as expected, and do not inspect
->
+     * the state of the lock itself.
->
+     */
->
+    public void testStampStateInspectionMethods() {
->
+        StampedLock lock = new StampedLock();
->
->
+        assertFalse(isWriteLockStamp(0L));
->
+        assertFalse(isReadLockStamp(0L));
->
+        assertFalse(isLockStamp(0L));
->
+        assertFalse(isOptimisticReadStamp(0L));
->
->
+        {
->
+            long stamp = lock.writeLock();
->
+            for (int i = 0; i < 2; i++) {
->
+                assertTrue(isWriteLockStamp(stamp));
->
+                assertFalse(isReadLockStamp(stamp));
->
+                assertTrue(isLockStamp(stamp));
->
+                assertFalse(isOptimisticReadStamp(stamp));
->
+                if (i == 0)
->
+                    lock.unlockWrite(stamp);
->
+            }
->
+        }
->
->
+        {
->
+            long stamp = lock.readLock();
->
+            for (int i = 0; i < 2; i++) {
->
+                assertFalse(isWriteLockStamp(stamp));
->
+                assertTrue(isReadLockStamp(stamp));
->
+                assertTrue(isLockStamp(stamp));
->
+                assertFalse(isOptimisticReadStamp(stamp));
->
+                if (i == 0)
->
+                    lock.unlockRead(stamp);
->
+            }
->
+        }
->
->
+        {
->
+            long optimisticStamp = lock.tryOptimisticRead();
->
+            long readStamp = lock.tryConvertToReadLock(optimisticStamp);
->
+            long writeStamp = lock.tryConvertToWriteLock(readStamp);
->
+            for (int i = 0; i < 2; i++) {
->
+                assertFalse(isWriteLockStamp(optimisticStamp));
->
+                assertFalse(isReadLockStamp(optimisticStamp));
->
+                assertFalse(isLockStamp(optimisticStamp));
->
+                assertTrue(isOptimisticReadStamp(optimisticStamp));
->
->
+                assertFalse(isWriteLockStamp(readStamp));
->
+                assertTrue(isReadLockStamp(readStamp));
->
+                assertTrue(isLockStamp(readStamp));
->
+                assertFalse(isOptimisticReadStamp(readStamp));
->
->
+                assertTrue(isWriteLockStamp(writeStamp));
->
+                assertFalse(isReadLockStamp(writeStamp));
->
+                assertTrue(isLockStamp(writeStamp));
->
+                assertFalse(isOptimisticReadStamp(writeStamp));
->
+                if (i == 0)
->
+                    lock.unlockWrite(writeStamp);
->
+            }
->
+        }
->
+    }
->
->
+    /**
->
+     * Multiple threads repeatedly contend for the same lock.
->
+     */
->
+    public void testConcurrentAccess() throws Exception {
->
+        final StampedLock sl = new StampedLock();
->
+        final Lock wl = sl.asWriteLock();
->
+        final Lock rl = sl.asReadLock();
->
+        final long testDurationMillis = expensiveTests ? 1000 : 2;
->
+        final int nTasks = ThreadLocalRandom.current().nextInt(1, 10);
->
+        final AtomicBoolean done = new AtomicBoolean(false);
->
+        final List<CompletableFuture<?>> futures = new ArrayList<>();
->
+        final List<Callable<Long>> stampedWriteLockers = List.of(
->
+            () -> sl.writeLock(),
->
+            () -> writeLockInterruptiblyUninterrupted(sl),
->
+            () -> tryWriteLockUninterrupted(sl, LONG_DELAY_MS, MILLISECONDS),
->
+            () -> {
->
+                long stamp;
->
+                do { stamp = sl.tryConvertToWriteLock(sl.tryOptimisticRead()); }
->
+                while (stamp == 0L);
->
+                return stamp;
->
+            },
->
+            () -> {
->
+              long stamp;
->
+              do { stamp = sl.tryWriteLock(); } while (stamp == 0L);
->
+              return stamp;
->
+            },
->
+            () -> {
->
+              long stamp;
->
+              do { stamp = sl.tryWriteLock(0L, DAYS); } while (stamp == 0L);
->
+              return stamp;
->
+            });
->
+        final List<Callable<Long>> stampedReadLockers = List.of(
->
+            () -> sl.readLock(),
->
+            () -> readLockInterruptiblyUninterrupted(sl),
->
+            () -> tryReadLockUninterrupted(sl, LONG_DELAY_MS, MILLISECONDS),
->
+            () -> {
->
+                long stamp;
->
+                do { stamp = sl.tryConvertToReadLock(sl.tryOptimisticRead()); }
->
+                while (stamp == 0L);
->
+                return stamp;
->
+            },
->
+            () -> {
->
+              long stamp;
->
+              do { stamp = sl.tryReadLock(); } while (stamp == 0L);
->
+              return stamp;
->
+            },
->
+            () -> {
->
+              long stamp;
->
+              do { stamp = sl.tryReadLock(0L, DAYS); } while (stamp == 0L);
->
+              return stamp;
->
+            });
->
+        final List<Consumer<Long>> stampedWriteUnlockers = List.of(
->
+            stamp -> sl.unlockWrite(stamp),
->
+            stamp -> sl.unlock(stamp),
->
+            stamp -> assertTrue(sl.tryUnlockWrite()),
->
+            stamp -> wl.unlock(),
->
+            stamp -> sl.tryConvertToOptimisticRead(stamp));
->
+        final List<Consumer<Long>> stampedReadUnlockers = List.of(
->
+            stamp -> sl.unlockRead(stamp),
->
+            stamp -> sl.unlock(stamp),
->
+            stamp -> assertTrue(sl.tryUnlockRead()),
->
+            stamp -> rl.unlock(),
->
+            stamp -> sl.tryConvertToOptimisticRead(stamp));
->
+        final Action writer = () -> {
->
+            // repeatedly acquires write lock
->
+            var locker = chooseRandomly(stampedWriteLockers);
->
+            var unlocker = chooseRandomly(stampedWriteUnlockers);
->
+            while (!done.getAcquire()) {
->
+                long stamp = locker.call();
->
+                try {
->
+                    assertTrue(isWriteLockStamp(stamp));
->
+                    assertTrue(sl.isWriteLocked());
->
+                    assertFalse(isReadLockStamp(stamp));
->
+                    assertFalse(sl.isReadLocked());
->
+                    assertEquals(0, sl.getReadLockCount());
->
+                    assertTrue(sl.validate(stamp));
->
+                } finally {
->
+                    unlocker.accept(stamp);
->
+                }
->
+            }
->
+        };
->
+        final Action reader = () -> {
->
+            // repeatedly acquires read lock
->
+            var locker = chooseRandomly(stampedReadLockers);
->
+            var unlocker = chooseRandomly(stampedReadUnlockers);
->
+            while (!done.getAcquire()) {
->
+                long stamp = locker.call();
->
+                try {
->
+                    assertFalse(isWriteLockStamp(stamp));
->
+                    assertFalse(sl.isWriteLocked());
->
+                    assertTrue(isReadLockStamp(stamp));
->
+                    assertTrue(sl.isReadLocked());
->
+                    assertTrue(sl.getReadLockCount() > 0);
->
+                    assertTrue(sl.validate(stamp));
->
+                } finally {
->
+                    unlocker.accept(stamp);
->
+                }
->
+            }
->
+        };
->
+        for (int i = nTasks; i--> 0; ) {
->
+            Action task = chooseRandomly(writer, reader);
->
+            futures.add(CompletableFuture.runAsync(checkedRunnable(task)));
->
+        }
->
+        Thread.sleep(testDurationMillis);
->
+        done.setRelease(true);
->
+        for (var future : futures)
->
+            checkTimedGet(future, null);
->
+    }

Diff Legend

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

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents): Revision 1.2 by jsr166, Fri Feb 1 21:44:41 2013 UTC vs. Revision 1.47 by dl, Tue Jan 26 13:33:06 2021 UTC

Diff Legend

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.2 by jsr166, Fri Feb 1 21:44:41 2013 UTC vs.
Revision 1.47 by dl, Tue Jan 26 13:33:06 2021 UTC