--- jsr166/src/test/tck/StampedLockTest.java 2014/12/31 19:05:43 1.10 +++ jsr166/src/test/tck/StampedLockTest.java 2016/06/07 22:10:33 1.21 @@ -16,7 +16,7 @@ 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); @@ -166,9 +166,9 @@ public class StampedLockTest extends JSR */ public void testWriteUnlock_IMSE2() { StampedLock lock = new StampedLock(); + long s = lock.writeLock(); + lock.unlockWrite(s); try { - long s = lock.writeLock(); - lock.unlockWrite(s); lock.unlockWrite(s); shouldThrow(); } catch (IllegalMonitorStateException success) {} @@ -179,8 +179,8 @@ public class StampedLockTest extends JSR */ public void testWriteUnlock_IMSE3() { StampedLock lock = new StampedLock(); + long s = lock.readLock(); try { - long s = lock.readLock(); lock.unlockWrite(s); shouldThrow(); } catch (IllegalMonitorStateException success) {} @@ -191,9 +191,9 @@ public class StampedLockTest extends JSR */ public void testReadUnlock_IMSE() { StampedLock lock = new StampedLock(); + long s = lock.readLock(); + lock.unlockRead(s); try { - long s = lock.readLock(); - lock.unlockRead(s); lock.unlockRead(s); shouldThrow(); } catch (IllegalMonitorStateException success) {} @@ -215,8 +215,8 @@ public class StampedLockTest extends JSR */ public void testReadUnlock_IMSE3() { StampedLock lock = new StampedLock(); + long s = lock.writeLock(); try { - long s = lock.writeLock(); lock.unlockRead(s); shouldThrow(); } catch (IllegalMonitorStateException success) {} @@ -233,57 +233,50 @@ public class StampedLockTest extends JSR /** * A stamp obtained from a successful lock operation validates */ - public void testValidate() { - try { - StampedLock lock = new StampedLock(); - long s = lock.writeLock(); - assertTrue(lock.validate(s)); - lock.unlockWrite(s); - s = lock.readLock(); - assertTrue(lock.validate(s)); - lock.unlockRead(s); - assertTrue((s = lock.tryWriteLock()) != 0L); - assertTrue(lock.validate(s)); - lock.unlockWrite(s); - assertTrue((s = lock.tryReadLock()) != 0L); - assertTrue(lock.validate(s)); - lock.unlockRead(s); - assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); - assertTrue(lock.validate(s)); - lock.unlockWrite(s); - assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); - assertTrue(lock.validate(s)); - lock.unlockRead(s); - assertTrue((s = lock.tryOptimisticRead()) != 0L); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void testValidate() throws InterruptedException { + StampedLock lock = new StampedLock(); + long s = lock.writeLock(); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + s = lock.readLock(); + assertTrue(lock.validate(s)); + lock.unlockRead(s); + assertTrue((s = lock.tryWriteLock()) != 0L); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + assertTrue((s = lock.tryReadLock()) != 0L); + assertTrue(lock.validate(s)); + lock.unlockRead(s); + assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); + assertTrue(lock.validate(s)); + lock.unlockRead(s); + assertTrue((s = lock.tryOptimisticRead()) != 0L); } /** * A stamp obtained from an unsuccessful lock operation does not validate */ - public void testValidate2() { - try { - StampedLock lock = new StampedLock(); - long s; - assertTrue((s = lock.writeLock()) != 0L); - assertTrue(lock.validate(s)); - assertFalse(lock.validate(lock.tryWriteLock())); - assertFalse(lock.validate(lock.tryWriteLock(10L, MILLISECONDS))); - assertFalse(lock.validate(lock.tryReadLock())); - assertFalse(lock.validate(lock.tryReadLock(10L, MILLISECONDS))); - assertFalse(lock.validate(lock.tryOptimisticRead())); - lock.unlockWrite(s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void testValidate2() throws InterruptedException { + StampedLock lock = new StampedLock(); + long s; + assertTrue((s = lock.writeLock()) != 0L); + assertTrue(lock.validate(s)); + assertFalse(lock.validate(lock.tryWriteLock())); + assertFalse(lock.validate(lock.tryWriteLock(10L, MILLISECONDS))); + assertFalse(lock.validate(lock.tryReadLock())); + assertFalse(lock.validate(lock.tryReadLock(10L, MILLISECONDS))); + assertFalse(lock.validate(lock.tryOptimisticRead())); + lock.unlockWrite(s); } /** * writeLockInterruptibly is interruptible */ - public void testWriteLockInterruptibly_Interruptible() { + public void testWriteLockInterruptibly_Interruptible() + throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); long s = lock.writeLock(); @@ -292,21 +285,18 @@ public class StampedLockTest extends JSR running.countDown(); lock.writeLockInterruptibly(); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - t.interrupt(); - awaitTermination(t); - releaseWriteLock(lock, s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + + running.await(); + waitForThreadToEnterWaitState(t, 100); + t.interrupt(); + awaitTermination(t); + releaseWriteLock(lock, s); } /** * timed tryWriteLock is interruptible */ - public void testWriteTryLock_Interruptible() { + public void testWriteTryLock_Interruptible() throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); long s = lock.writeLock(); @@ -315,21 +305,19 @@ public class StampedLockTest extends JSR running.countDown(); lock.tryWriteLock(2 * LONG_DELAY_MS, MILLISECONDS); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - t.interrupt(); - awaitTermination(t); - releaseWriteLock(lock, s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + + running.await(); + waitForThreadToEnterWaitState(t, 100); + t.interrupt(); + awaitTermination(t); + releaseWriteLock(lock, s); } /** * readLockInterruptibly is interruptible */ - public void testReadLockInterruptibly_Interruptible() { + public void testReadLockInterruptibly_Interruptible() + throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); long s = lock.writeLock(); @@ -338,21 +326,18 @@ public class StampedLockTest extends JSR running.countDown(); lock.readLockInterruptibly(); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - t.interrupt(); - awaitTermination(t); - releaseWriteLock(lock, s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + + running.await(); + waitForThreadToEnterWaitState(t, 100); + t.interrupt(); + awaitTermination(t); + releaseWriteLock(lock, s); } /** * timed tryReadLock is interruptible */ - public void testReadTryLock_Interruptible() { + public void testReadTryLock_Interruptible() throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); long s = lock.writeLock(); @@ -361,15 +346,12 @@ public class StampedLockTest extends JSR running.countDown(); lock.tryReadLock(2 * LONG_DELAY_MS, MILLISECONDS); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - t.interrupt(); - awaitTermination(t); - releaseWriteLock(lock, s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + + running.await(); + waitForThreadToEnterWaitState(t, 100); + t.interrupt(); + awaitTermination(t); + releaseWriteLock(lock, s); } /** @@ -442,7 +424,7 @@ public class StampedLockTest extends JSR /** * A writelock succeeds only after a reading thread unlocks */ - public void testWriteAfterReadLock() { + public void testWriteAfterReadLock() throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); long rs = lock.readLock(); @@ -452,16 +434,13 @@ public class StampedLockTest extends JSR long s = lock.writeLock(); lock.unlockWrite(s); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - assertFalse(lock.isWriteLocked()); - lock.unlockRead(rs); - awaitTermination(t); - assertFalse(lock.isWriteLocked()); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + + running.await(); + waitForThreadToEnterWaitState(t, 100); + assertFalse(lock.isWriteLocked()); + lock.unlockRead(rs); + awaitTermination(t); + assertFalse(lock.isWriteLocked()); } /** @@ -475,6 +454,7 @@ public class StampedLockTest extends JSR long rs = lock.readLock(); lock.unlockRead(rs); }}); + awaitTermination(t1); Thread t2 = newStartedThread(new CheckedRunnable() { @@ -482,6 +462,7 @@ public class StampedLockTest extends JSR long ws = lock.writeLock(); lock.unlockWrite(ws); }}); + assertFalse(lock.isWriteLocked()); lock.unlockRead(s); awaitTermination(t2); @@ -585,62 +566,45 @@ public class StampedLockTest extends JSR /** * writeLockInterruptibly succeeds if unlocked, else is interruptible */ - public void testWriteLockInterruptibly() { + public void testWriteLockInterruptibly() throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); - long s = 0L; - try { - s = lock.writeLockInterruptibly(); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + long s = lock.writeLockInterruptibly(); Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { running.countDown(); lock.writeLockInterruptibly(); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - t.interrupt(); - assertTrue(lock.isWriteLocked()); - awaitTermination(t); - releaseWriteLock(lock, s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } - + running.await(); + waitForThreadToEnterWaitState(t, 100); + t.interrupt(); + assertTrue(lock.isWriteLocked()); + awaitTermination(t); + releaseWriteLock(lock, s); } /** * readLockInterruptibly succeeds if lock free else is interruptible */ - public void testReadLockInterruptibly() { + public void testReadLockInterruptibly() throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); - long s = 0L; - try { - s = lock.readLockInterruptibly(); - lock.unlockRead(s); - s = lock.writeLockInterruptibly(); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + long s; + s = lock.readLockInterruptibly(); + lock.unlockRead(s); + s = lock.writeLockInterruptibly(); Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { running.countDown(); lock.readLockInterruptibly(); }}); - try { - running.await(); - waitForThreadToEnterWaitState(t, 100); - t.interrupt(); - awaitTermination(t); - releaseWriteLock(lock, s); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + + running.await(); + waitForThreadToEnterWaitState(t, 100); + t.interrupt(); + awaitTermination(t); + releaseWriteLock(lock, s); } /** @@ -674,44 +638,40 @@ public class StampedLockTest extends JSR /** * tryOptimisticRead succeeds and validates if unlocked, fails if locked */ - public void testValidateOptimistic() { - try { - StampedLock lock = new StampedLock(); - long s, p; - assertTrue((p = lock.tryOptimisticRead()) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.writeLock()) != 0L); - assertFalse((p = lock.tryOptimisticRead()) != 0L); - assertTrue(lock.validate(s)); - lock.unlockWrite(s); - assertTrue((p = lock.tryOptimisticRead()) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.readLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryOptimisticRead()) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(s); - assertTrue((s = lock.tryWriteLock()) != 0L); - assertTrue(lock.validate(s)); - assertFalse((p = lock.tryOptimisticRead()) != 0L); - lock.unlockWrite(s); - assertTrue((s = lock.tryReadLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryOptimisticRead()) != 0L); - lock.unlockRead(s); - assertTrue(lock.validate(p)); - assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); - assertFalse((p = lock.tryOptimisticRead()) != 0L); - assertTrue(lock.validate(s)); - lock.unlockWrite(s); - assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryOptimisticRead()) != 0L); - lock.unlockRead(s); - assertTrue((p = lock.tryOptimisticRead()) != 0L); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void testValidateOptimistic() throws InterruptedException { + StampedLock lock = new StampedLock(); + long s, p; + assertTrue((p = lock.tryOptimisticRead()) != 0L); + assertTrue(lock.validate(p)); + assertTrue((s = lock.writeLock()) != 0L); + assertFalse((p = lock.tryOptimisticRead()) != 0L); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + assertTrue((p = lock.tryOptimisticRead()) != 0L); + assertTrue(lock.validate(p)); + assertTrue((s = lock.readLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryOptimisticRead()) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(s); + assertTrue((s = lock.tryWriteLock()) != 0L); + assertTrue(lock.validate(s)); + assertFalse((p = lock.tryOptimisticRead()) != 0L); + lock.unlockWrite(s); + assertTrue((s = lock.tryReadLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryOptimisticRead()) != 0L); + lock.unlockRead(s); + assertTrue(lock.validate(p)); + assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); + assertFalse((p = lock.tryOptimisticRead()) != 0L); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryOptimisticRead()) != 0L); + lock.unlockRead(s); + assertTrue((p = lock.tryOptimisticRead()) != 0L); } /** @@ -732,156 +692,162 @@ public class StampedLockTest extends JSR * tryOptimisticRead stamp does not validate if a write lock * intervenes in another thread */ - public void testValidateOptimisticWriteLocked2() { + public void testValidateOptimisticWriteLocked2() + throws InterruptedException { final CountDownLatch running = new CountDownLatch(1); final StampedLock lock = new StampedLock(); long s, p; assertTrue((p = lock.tryOptimisticRead()) != 0L); Thread t = newStartedThread(new CheckedInterruptedRunnable() { - public void realRun() throws InterruptedException { - lock.writeLockInterruptibly(); - running.countDown(); - lock.writeLockInterruptibly(); - }}); - try { - running.await(); - assertFalse(lock.validate(p)); - assertFalse((p = lock.tryOptimisticRead()) != 0L); - t.interrupt(); - awaitTermination(t); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void realRun() throws InterruptedException { + lock.writeLockInterruptibly(); + running.countDown(); + lock.writeLockInterruptibly(); + }}); + + running.await(); + assertFalse(lock.validate(p)); + assertFalse((p = lock.tryOptimisticRead()) != 0L); + t.interrupt(); + awaitTermination(t); } /** * tryConvertToOptimisticRead succeeds and validates if successfully locked, */ - public void testTryConvertToOptimisticRead() { - try { - StampedLock lock = new StampedLock(); - long s, p; - s = 0L; - assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue((s = lock.tryOptimisticRead()) != 0L); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue((s = lock.writeLock()) != 0L); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.readLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.tryWriteLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.tryReadLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue(lock.validate(p)); - assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); - assertTrue(lock.validate(p)); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void testTryConvertToOptimisticRead() throws InterruptedException { + StampedLock lock = new StampedLock(); + long s, p; + assertEquals(0L, lock.tryConvertToOptimisticRead(0L)); + + assertTrue((s = lock.tryOptimisticRead()) != 0L); + assertEquals(s, lock.tryConvertToOptimisticRead(s)); + assertTrue(lock.validate(s)); + + assertTrue((p = lock.readLock()) != 0L); + assertTrue((s = lock.tryOptimisticRead()) != 0L); + assertEquals(s, lock.tryConvertToOptimisticRead(s)); + assertTrue(lock.validate(s)); + lock.unlockRead(p); + + assertTrue((s = lock.writeLock()) != 0L); + assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); + assertTrue(lock.validate(p)); + + assertTrue((s = lock.readLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); + assertTrue(lock.validate(p)); + + assertTrue((s = lock.tryWriteLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); + assertTrue(lock.validate(p)); + + assertTrue((s = lock.tryReadLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); + assertTrue(lock.validate(p)); + + assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); + assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); + assertTrue(lock.validate(p)); + + assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); + assertTrue(lock.validate(p)); } /** * tryConvertToReadLock succeeds and validates if successfully locked * or lock free; */ - public void testTryConvertToReadLock() { - try { - StampedLock lock = new StampedLock(); - long s, p; - s = 0L; - assertFalse((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue((s = lock.tryOptimisticRead()) != 0L); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - lock.unlockRead(p); - assertTrue((s = lock.writeLock()) != 0L); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(p); - assertTrue((s = lock.readLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(p); - assertTrue((s = lock.tryWriteLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(p); - assertTrue((s = lock.tryReadLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(p); - assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(p); - assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockRead(p); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void testTryConvertToReadLock() throws InterruptedException { + StampedLock lock = new StampedLock(); + long s, p; + s = 0L; + assertFalse((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue((s = lock.tryOptimisticRead()) != 0L); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + lock.unlockRead(p); + assertTrue((s = lock.writeLock()) != 0L); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(p); + assertTrue((s = lock.readLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(p); + assertTrue((s = lock.tryWriteLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(p); + assertTrue((s = lock.tryReadLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(p); + assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(p); + assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockRead(p); } /** * tryConvertToWriteLock succeeds and validates if successfully locked * or lock free; */ - public void testTryConvertToWriteLock() { - try { - StampedLock lock = new StampedLock(); - long s, p; - s = 0L; - assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue((s = lock.tryOptimisticRead()) != 0L); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - lock.unlockWrite(p); - assertTrue((s = lock.writeLock()) != 0L); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockWrite(p); - assertTrue((s = lock.readLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockWrite(p); - assertTrue((s = lock.tryWriteLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockWrite(p); - assertTrue((s = lock.tryReadLock()) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockWrite(p); - assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockWrite(p); - assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); - assertTrue(lock.validate(s)); - assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); - assertTrue(lock.validate(p)); - lock.unlockWrite(p); - } catch (InterruptedException ie) { - threadUnexpectedException(ie); - } + public void testTryConvertToWriteLock() throws InterruptedException { + StampedLock lock = new StampedLock(); + long s, p; + + assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L); + + assertTrue((s = lock.tryOptimisticRead()) != 0L); + assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); + lock.unlockWrite(p); + + assertTrue((s = lock.writeLock()) != 0L); + assertEquals(s, lock.tryConvertToWriteLock(s)); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + + assertTrue((s = lock.readLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockWrite(p); + + assertTrue((s = lock.tryWriteLock()) != 0L); + assertTrue(lock.validate(s)); + assertEquals(s, lock.tryConvertToWriteLock(s)); + assertTrue(lock.validate(s)); + lock.unlockWrite(s); + + assertTrue((s = lock.tryReadLock()) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockWrite(p); + + assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); + assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockWrite(p); + + assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); + assertTrue(lock.validate(s)); + assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); + assertTrue(lock.validate(p)); + lock.unlockWrite(p); } /** @@ -930,4 +896,124 @@ public class StampedLockTest extends JSR assertTrue(lock.tryLock()); } + /** + * 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() { + Runnable[] actions = { + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryOptimisticRead(); + assertTrue(stamp != 0); + sl.unlockRead(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryOptimisticRead(); + sl.unlock(stamp); + }, + + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryOptimisticRead(); + sl.writeLock(); + sl.unlock(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryOptimisticRead(); + sl.readLock(); + sl.unlockRead(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryOptimisticRead(); + sl.readLock(); + sl.unlock(stamp); + }, + + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); + assertTrue(stamp != 0); + sl.writeLock(); + sl.unlockWrite(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); + sl.writeLock(); + sl.unlock(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); + sl.readLock(); + sl.unlockRead(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); + sl.readLock(); + sl.unlock(stamp); + }, + + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); + assertTrue(stamp != 0); + sl.writeLock(); + sl.unlockWrite(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); + sl.writeLock(); + sl.unlock(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); + sl.readLock(); + sl.unlockRead(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + sl.readLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); + assertTrue(stamp != 0); + sl.readLock(); + sl.unlockRead(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); + sl.readLock(); + sl.unlock(stamp); + }, + () -> { + StampedLock sl = new StampedLock(); + sl.readLock(); + long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); + sl.readLock(); + sl.unlock(stamp); + }, + }; + + assertThrows(IllegalMonitorStateException.class, actions); + } + }