[jboss-cvs] jbossretro/src/test/org/jboss/test/concurrent ...
Kabir Khan
kkhan at jboss.com
Mon Sep 18 12:20:05 EDT 2006
User: kkhan
Date: 06/09/18 12:20:05
Added: src/test/org/jboss/test/concurrent
ReentrantReadWriteLockTest.java
Log:
Fork backport concurrent ReentrantReadWriteLock so that its readLock() and writeLock() methods return the concrete inner classes rather than the Lock interface. This makes it in line with how java.util.concurrent does it, and makes weaving easier.
Revision Changes Path
1.5 +918 -863 jbossretro/src/test/org/jboss/test/concurrent/ReentrantReadWriteLockTest.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: ReentrantReadWriteLockTest.java
===================================================================
RCS file: ReentrantReadWriteLockTest.java
diff -N ReentrantReadWriteLockTest.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ReentrantReadWriteLockTest.java 18 Sep 2006 16:20:05 -0000 1.5
@@ -0,0 +1,1708 @@
+package org.jboss.test.concurrent;
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
+ */
+
+import junit.framework.*;
+import java.util.concurrent.*;
+import java.util.concurrent.locks.*;
+import java.io.*;
+
+public class ReentrantReadWriteLockTest extends JSR166TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(ReentrantReadWriteLockTest.class);
+ }
+
+ /**
+ * A runnable calling lockInterruptibly
+ */
+ class InterruptibleLockRunnable implements Runnable {
+ final ReentrantReadWriteLock lock;
+ InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
+ public void run() {
+ try {
+ lock.writeLock().lockInterruptibly();
+ } catch(InterruptedException success){}
+ }
+ }
+
+
+ /**
+ * A runnable calling lockInterruptibly that expects to be
+ * interrupted
+ */
+ class InterruptedLockRunnable implements Runnable {
+ final ReentrantReadWriteLock lock;
+ InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
+ public void run() {
+ try {
+ lock.writeLock().lockInterruptibly();
+ threadShouldThrow();
+ } catch(InterruptedException success){}
+ }
+ }
+
+ /**
+ * Subclass to expose protected methods
+ */
+ static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
+ PublicReentrantReadWriteLock() { super(); }
+// public Collection getQueuedThreads() {
+// return super.getQueuedThreads();
+// }
+// public Collection getWaitingThreads(Condition c) {
+// return super.getWaitingThreads(c);
+// }
+ }
+
+ /**
+ * Constructor sets given fairness, and is in unlocked state
+ */
+ public void testConstructor() {
+ ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+ assertFalse(rl.isFair());
+ assertFalse(rl.isWriteLocked());
+ assertEquals(0, rl.getReadLockCount());
+// ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
+// assertTrue(r2.isFair());
+// assertFalse(r2.isWriteLocked());
+// assertEquals(0, r2.getReadLockCount());
+ }
+
+ /**
+ * write-locking and read-locking an unlocked lock succeed
+ */
+ public void testLock() {
+ ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+ rl.writeLock().lock();
+ assertTrue(rl.isWriteLocked());
+ assertTrue(rl.isWriteLockedByCurrentThread());
+ //Does not exist in java.util.concurrent
+ //assertTrue(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
+ assertEquals(0, rl.getReadLockCount());
+ rl.writeLock().unlock();
+ assertFalse(rl.isWriteLocked());
+ assertFalse(rl.isWriteLockedByCurrentThread());
+ //Does not exist in java.util.concurrent
+ //assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
+ assertEquals(0, rl.getReadLockCount());
+ rl.readLock().lock();
+ assertFalse(rl.isWriteLocked());
+ assertFalse(rl.isWriteLockedByCurrentThread());
+ //Does not exist in java.util.concurrent
+ //assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
+ assertEquals(1, rl.getReadLockCount());
+ rl.readLock().unlock();
+ assertFalse(rl.isWriteLocked());
+ assertFalse(rl.isWriteLockedByCurrentThread());
+ //Does not exist in java.util.concurrent
+ //assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
+ assertEquals(0, rl.getReadLockCount());
+ }
+
+
+// /**
+// * locking an unlocked fair lock succeeds
+// */
+// public void testFairLock() {
+// ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
+// rl.writeLock().lock();
+// assertTrue(rl.isWriteLocked());
+// assertTrue(rl.isWriteLockedByCurrentThread());
+// assertTrue(rl.writeLock().isHeldByCurrentThread());
+// assertEquals(0, rl.getReadLockCount());
+// rl.writeLock().unlock();
+// assertFalse(rl.isWriteLocked());
+// assertFalse(rl.isWriteLockedByCurrentThread());
+// assertFalse(rl.writeLock().isHeldByCurrentThread());
+// assertEquals(0, rl.getReadLockCount());
+// rl.readLock().lock();
+// assertFalse(rl.isWriteLocked());
+// assertFalse(rl.isWriteLockedByCurrentThread());
+// assertFalse(rl.writeLock().isHeldByCurrentThread());
+// assertEquals(1, rl.getReadLockCount());
+// rl.readLock().unlock();
+// assertFalse(rl.isWriteLocked());
+// assertFalse(rl.isWriteLockedByCurrentThread());
+// assertFalse(rl.writeLock().isHeldByCurrentThread());
+// assertEquals(0, rl.getReadLockCount());
+// }
+
+ /**
+ * getWriteHoldCount returns number of recursive holds
+ */
+ public void testGetWriteHoldCount() {
+ ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ 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() {
+ ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ for(int i = 1; i <= SIZE; i++) {
+ lock.writeLock().lock();
+ //Does not exist in java.util.concurrent
+ //assertEquals(i,((ReentrantReadWriteLock.WriteLock)lock.writeLock()).getHoldCount());
+ }
+ for(int i = SIZE; i > 0; i--) {
+ lock.writeLock().unlock();
+ //Does not exist in java.util.concurrent
+ //assertEquals(i-1,((ReentrantReadWriteLock.WriteLock)lock.writeLock()).getHoldCount());
+ }
+ }
+
+ /**
+ * getReadHoldCount returns number of recursive holds
+ */
+ public void testGetReadHoldCount() {
+ ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ for(int i = 1; i <= SIZE; i++) {
+ lock.readLock().lock();
+ //Does not exist in java.util.concurrent
+ //assertEquals(i,lock.getReadHoldCount());
+ }
+ for(int i = SIZE; i > 0; i--) {
+ lock.readLock().unlock();
+ //Does not exist in java.util.concurrent
+ //assertEquals(i-1,lock.getReadHoldCount());
+ }
+ }
+
+
+ /**
+ * write-unlocking an unlocked lock throws IllegalMonitorStateException
+ */
+ public void testUnlock_IllegalMonitorStateException() {
+ ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+ try {
+ rl.writeLock().unlock();
+ shouldThrow();
+ } catch(IllegalMonitorStateException success){}
+ }
+
+
+ /**
+ * write-lockInterruptibly is interruptible
+ */
+ public void testWriteLockInterruptibly_Interrupted() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lockInterruptibly();
+ lock.writeLock().unlock();
+ lock.writeLock().lockInterruptibly();
+ lock.writeLock().unlock();
+ } catch(InterruptedException success){}
+ }
+ });
+ try {
+ lock.writeLock().lock();
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.writeLock().unlock();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed write-tryLock is interruptible
+ */
+ public void testWriteTryLock_Interrupted() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
+ } catch(InterruptedException success){}
+ }
+ });
+ try {
+ t.start();
+ t.interrupt();
+ lock.writeLock().unlock();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * read-lockInterruptibly is interruptible
+ */
+ public void testReadLockInterruptibly_Interrupted() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.readLock().lockInterruptibly();
+ } catch(InterruptedException success){}
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.writeLock().unlock();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed read-tryLock is interruptible
+ */
+ public void testReadTryLock_Interrupted() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch(InterruptedException success){}
+ }
+ });
+ try {
+ t.start();
+ t.interrupt();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * write-tryLock fails if locked
+ */
+ public void testWriteTryLockWhenLocked() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ threadAssertFalse(lock.writeLock().tryLock());
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.writeLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * read-tryLock fails if locked
+ */
+ public void testReadTryLockWhenLocked() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ threadAssertFalse(lock.readLock().tryLock());
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.writeLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Multiple threads can hold a read lock when not write-locked
+ */
+ public void testMultipleReadLocks() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.readLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ threadAssertTrue(lock.readLock().tryLock());
+ lock.readLock().unlock();
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.readLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * A writelock succeeds after reading threads unlock
+ */
+ public void testWriteAfterMultipleReadLocks() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.readLock().lock();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ }
+ });
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.readLock().unlock();
+ t1.join(MEDIUM_DELAY_MS);
+ t2.join(MEDIUM_DELAY_MS);
+ assertTrue(!t1.isAlive());
+ assertTrue(!t2.isAlive());
+
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Readlocks succeed after a writing thread unlocks
+ */
+ public void testReadAfterWriteLock() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ }
+ });
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.writeLock().unlock();
+ t1.join(MEDIUM_DELAY_MS);
+ t2.join(MEDIUM_DELAY_MS);
+ assertTrue(!t1.isAlive());
+ assertTrue(!t2.isAlive());
+
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Read trylock succeeds if write locked by current thread
+ */
+ public void testReadHoldingWriteLock() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ assertTrue(lock.readLock().tryLock());
+ lock.readLock().unlock();
+ lock.writeLock().unlock();
+ }
+
+ /**
+ * Read lock succeeds if write locked by current thread even if
+ * other threads are waiting for readlock
+ */
+ public void testReadHoldingWriteLock2() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ }
+ });
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ lock.writeLock().unlock();
+ t1.join(MEDIUM_DELAY_MS);
+ t2.join(MEDIUM_DELAY_MS);
+ assertTrue(!t1.isAlive());
+ assertTrue(!t2.isAlive());
+
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Read lock succeeds if write locked by current thread even if
+ * other threads are waiting for writelock
+ */
+ public void testReadHoldingWriteLock3() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ }
+ });
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.readLock().lock();
+ lock.readLock().unlock();
+ lock.writeLock().unlock();
+ t1.join(MEDIUM_DELAY_MS);
+ t2.join(MEDIUM_DELAY_MS);
+ assertTrue(!t1.isAlive());
+ assertTrue(!t2.isAlive());
+
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * Write lock succeeds if write locked by current thread even if
+ * other threads are waiting for writelock
+ */
+ public void testWriteHoldingWriteLock4() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ }
+ });
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ lock.writeLock().unlock();
+ t1.join(MEDIUM_DELAY_MS);
+ t2.join(MEDIUM_DELAY_MS);
+ assertTrue(!t1.isAlive());
+ assertTrue(!t2.isAlive());
+
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+// /**
+// * Fair Read trylock succeeds if write locked by current thread
+// */
+// public void testReadHoldingWriteLockFair() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+// lock.writeLock().lock();
+// assertTrue(lock.readLock().tryLock());
+// lock.readLock().unlock();
+// lock.writeLock().unlock();
+// }
+
+// /**
+// * Fair Read lock succeeds if write locked by current thread even if
+// * other threads are waiting for readlock
+// */
+// public void testReadHoldingWriteLockFair2() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+// lock.writeLock().lock();
+// Thread t1 = new Thread(new Runnable() {
+// public void run() {
+// lock.readLock().lock();
+// lock.readLock().unlock();
+// }
+// });
+// Thread t2 = new Thread(new Runnable() {
+// public void run() {
+// lock.readLock().lock();
+// lock.readLock().unlock();
+// }
+// });
+//
+// try {
+// t1.start();
+// t2.start();
+// lock.readLock().lock();
+// lock.readLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.readLock().lock();
+// lock.readLock().unlock();
+// lock.writeLock().unlock();
+// t1.join(MEDIUM_DELAY_MS);
+// t2.join(MEDIUM_DELAY_MS);
+// assertTrue(!t1.isAlive());
+// assertTrue(!t2.isAlive());
+//
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+
+
+// /**
+// * Fair Read lock succeeds if write locked by current thread even if
+// * other threads are waiting for writelock
+// */
+// public void testReadHoldingWriteLockFair3() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+// lock.writeLock().lock();
+// Thread t1 = new Thread(new Runnable() {
+// public void run() {
+// lock.writeLock().lock();
+// lock.writeLock().unlock();
+// }
+// });
+// Thread t2 = new Thread(new Runnable() {
+// public void run() {
+// lock.writeLock().lock();
+// lock.writeLock().unlock();
+// }
+// });
+//
+// try {
+// t1.start();
+// t2.start();
+// lock.readLock().lock();
+// lock.readLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.readLock().lock();
+// lock.readLock().unlock();
+// lock.writeLock().unlock();
+// t1.join(MEDIUM_DELAY_MS);
+// t2.join(MEDIUM_DELAY_MS);
+// assertTrue(!t1.isAlive());
+// assertTrue(!t2.isAlive());
+//
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+
+
+// /**
+// * Fair Write lock succeeds if write locked by current thread even if
+// * other threads are waiting for writelock
+// */
+// public void testWriteHoldingWriteLockFair4() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+// lock.writeLock().lock();
+// Thread t1 = new Thread(new Runnable() {
+// public void run() {
+// lock.writeLock().lock();
+// lock.writeLock().unlock();
+// }
+// });
+// Thread t2 = new Thread(new Runnable() {
+// public void run() {
+// lock.writeLock().lock();
+// lock.writeLock().unlock();
+// }
+// });
+//
+// try {
+// t1.start();
+// t2.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertTrue(lock.isWriteLockedByCurrentThread());
+// assertTrue(lock.getWriteHoldCount() == 1);
+// lock.writeLock().lock();
+// assertTrue(lock.getWriteHoldCount() == 2);
+// lock.writeLock().unlock();
+// lock.writeLock().lock();
+// lock.writeLock().unlock();
+// lock.writeLock().unlock();
+// t1.join(MEDIUM_DELAY_MS);
+// t2.join(MEDIUM_DELAY_MS);
+// assertTrue(!t1.isAlive());
+// assertTrue(!t2.isAlive());
+//
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+
+
+ /**
+ * Read tryLock succeeds if readlocked but not writelocked
+ */
+ public void testTryLockWhenReadLocked() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.readLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ threadAssertTrue(lock.readLock().tryLock());
+ lock.readLock().unlock();
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.readLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+
+ /**
+ * write tryLock fails when readlocked
+ */
+ public void testWriteTryLockWhenReadLocked() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.readLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ threadAssertFalse(lock.writeLock().tryLock());
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.readLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+// /**
+// * Fair Read tryLock succeeds if readlocked but not writelocked
+// */
+// public void testTryLockWhenReadLockedFair() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+// lock.readLock().lock();
+// Thread t = new Thread(new Runnable() {
+// public void run() {
+// threadAssertTrue(lock.readLock().tryLock());
+// lock.readLock().unlock();
+// }
+// });
+// try {
+// t.start();
+// t.join();
+// lock.readLock().unlock();
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+
+
+
+// /**
+// * Fair write tryLock fails when readlocked
+// */
+// public void testWriteTryLockWhenReadLockedFair() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+// lock.readLock().lock();
+// Thread t = new Thread(new Runnable() {
+// public void run() {
+// threadAssertFalse(lock.writeLock().tryLock());
+// }
+// });
+// try {
+// t.start();
+// t.join();
+// lock.readLock().unlock();
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+
+
+
+ /**
+ * write timed tryLock times out if locked
+ */
+ public void testWriteTryLock_Timeout() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
+ } catch (Exception ex) {
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.writeLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * read timed tryLock times out if write-locked
+ */
+ public void testReadTryLock_Timeout() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ lock.writeLock().lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
+ } catch (Exception ex) {
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.writeLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * write lockInterruptibly succeeds if lock free else is interruptible
+ */
+ public void testWriteLockInterruptibly() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ try {
+ lock.writeLock().lockInterruptibly();
+ } catch(Exception e) {
+ unexpectedException();
+ }
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lockInterruptibly();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.join();
+ lock.writeLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * read lockInterruptibly succeeds if lock free else is interruptible
+ */
+ public void testReadLockInterruptibly() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ try {
+ lock.writeLock().lockInterruptibly();
+ } catch(Exception e) {
+ unexpectedException();
+ }
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.readLock().lockInterruptibly();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ lock.writeLock().unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Calling await without holding lock throws IllegalMonitorStateException
+ */
+ public void testAwait_IllegalMonitor() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ try {
+ c.await();
+ shouldThrow();
+ }
+ catch (IllegalMonitorStateException success) {
+ }
+ catch (Exception ex) {
+ shouldThrow();
+ }
+ }
+
+ /**
+ * Calling signal without holding lock throws IllegalMonitorStateException
+ */
+ public void testSignal_IllegalMonitor() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ try {
+ c.signal();
+ shouldThrow();
+ }
+ catch (IllegalMonitorStateException success) {
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+// Kabir: ignored this test
+// /**
+// * awaitNanos without a signal times out
+// */
+// public void testAwaitNanos_Timeout() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = lock.writeLock().newCondition();
+// try {
+// lock.writeLock().lock();
+// long t = Utils.awaitNanos(c, 100);
+// assertTrue(t <= 0);
+// lock.writeLock().unlock();
+// }
+// catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+
+
+ /**
+ * timed await without a signal times out
+ */
+ public void testAwait_Timeout() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ try {
+ lock.writeLock().lock();
+ lock.writeLock().unlock();
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * awaitUntil without a signal times out
+ */
+ public void testAwaitUntil_Timeout() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ try {
+ lock.writeLock().lock();
+ java.util.Date d = new java.util.Date();
+ lock.writeLock().unlock();
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * await returns when signalled
+ */
+ public void testAwait() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lock();
+ c.await();
+ lock.writeLock().unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.writeLock().lock();
+ c.signal();
+ lock.writeLock().unlock();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /** A helper class for uninterruptible wait tests */
+ class UninterruptableThread extends Thread {
+ private Lock lock;
+ private Condition c;
+
+ public volatile boolean canAwake = false;
+ public volatile boolean interrupted = false;
+ public volatile boolean lockStarted = false;
+
+ public UninterruptableThread(Lock lock, Condition c) {
+ this.lock = lock;
+ this.c = c;
+ }
+
+ public synchronized void run() {
+ lock.lock();
+ lockStarted = true;
+
+ while (!canAwake) {
+ c.awaitUninterruptibly();
+ }
+
+ interrupted = isInterrupted();
+ lock.unlock();
+ }
+ }
+
+ /**
+ * awaitUninterruptibly doesn't abort on interrupt
+ */
+ public void testAwaitUninterruptibly() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c);
+
+ try {
+ thread.start();
+
+ while (!thread.lockStarted) {
+ Thread.sleep(100);
+ }
+
+ lock.writeLock().lock();
+ try {
+ thread.interrupt();
+ thread.canAwake = true;
+ c.signal();
+ } finally {
+ lock.writeLock().unlock();
+ }
+
+ thread.join();
+ assertTrue(thread.interrupted);
+ assertFalse(thread.isAlive());
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * await is interruptible
+ */
+ public void testAwait_Interrupt() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lock();
+ c.await();
+ lock.writeLock().unlock();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+// Kabir: ignored this test
+// /**
+// * awaitNanos is interruptible
+// */
+// public void testAwaitNanos_Interrupt() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = lock.writeLock().newCondition();
+// Thread t = new Thread(new Runnable() {
+// public void run() {
+// try {
+// lock.writeLock().lock();
+// Utils.awaitNanos(c, SHORT_DELAY_MS * 2 * 1000000);
+// lock.writeLock().unlock();
+// threadShouldThrow();
+// }
+// catch(InterruptedException success) {
+// }
+// }
+// });
+//
+// try {
+// t.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// t.interrupt();
+// t.join(SHORT_DELAY_MS);
+// assertFalse(t.isAlive());
+// }
+// catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+
+ /**
+ * awaitUntil is interruptible
+ */
+ public void testAwaitUntil_Interrupt() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lock();
+ java.util.Date d = new java.util.Date();
+ c.awaitUntil(new java.util.Date(d.getTime() + 10000));
+ lock.writeLock().unlock();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * signalAll wakes up all threads
+ */
+ public void testSignalAll() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ final Condition c = lock.writeLock().newCondition();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lock();
+ c.await();
+ lock.writeLock().unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.writeLock().lock();
+ c.await();
+ lock.writeLock().unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.writeLock().lock();
+ c.signalAll();
+ lock.writeLock().unlock();
+ t1.join(SHORT_DELAY_MS);
+ t2.join(SHORT_DELAY_MS);
+ assertFalse(t1.isAlive());
+ assertFalse(t2.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * A serialized lock deserializes as unlocked
+ */
+ public void testSerialization() {
+ ReentrantReadWriteLock l = new ReentrantReadWriteLock();
+ l.readLock().lock();
+ l.readLock().unlock();
+
+ try {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+ ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+ out.writeObject(l);
+ out.close();
+
+ ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+ ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+ ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
+ r.readLock().lock();
+ r.readLock().unlock();
+ } catch(Exception e){
+ e.printStackTrace();
+ unexpectedException();
+ }
+ }
+
+ /**
+ * hasQueuedThreads reports whether there are waiting threads
+ */
+ public void testhasQueuedThreads() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+ try {
+ assertFalse(lock.hasQueuedThreads());
+ lock.writeLock().lock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.hasQueuedThreads());
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.hasQueuedThreads());
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.hasQueuedThreads());
+ lock.writeLock().unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertFalse(lock.hasQueuedThreads());
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+// /**
+// * hasQueuedThread(null) throws NPE
+// */
+// public void testHasQueuedThreadNPE() {
+// final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
+// try {
+// sync.hasQueuedThread(null);
+// shouldThrow();
+// } catch (NullPointerException success) {
+// }
+// }
+//
+// /**
+// * hasQueuedThread reports whether a thread is queued.
+// */
+// public void testHasQueuedThread() {
+// final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
+// Thread t1 = new Thread(new InterruptedLockRunnable(sync));
+// Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
+// try {
+// assertFalse(sync.hasQueuedThread(t1));
+// assertFalse(sync.hasQueuedThread(t2));
+// sync.writeLock().lock();
+// t1.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertTrue(sync.hasQueuedThread(t1));
+// t2.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertTrue(sync.hasQueuedThread(t1));
+// assertTrue(sync.hasQueuedThread(t2));
+// t1.interrupt();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertFalse(sync.hasQueuedThread(t1));
+// assertTrue(sync.hasQueuedThread(t2));
+// sync.writeLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertFalse(sync.hasQueuedThread(t1));
+// Thread.sleep(SHORT_DELAY_MS);
+// assertFalse(sync.hasQueuedThread(t2));
+// t1.join();
+// t2.join();
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+
+
+ /**
+ * getQueueLength reports number of waiting threads
+ */
+ public void testGetQueueLength() {
+ final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+ try {
+ assertEquals(0, lock.getQueueLength());
+ lock.writeLock().lock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(1, lock.getQueueLength());
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(2, lock.getQueueLength());
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(1, lock.getQueueLength());
+ lock.writeLock().unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(0, lock.getQueueLength());
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+// /**
+// * getQueuedThreads includes waiting threads
+// */
+// public void testGetQueuedThreads() {
+// final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+// Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+// Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+// try {
+// assertTrue(lock.getQueuedThreads().isEmpty());
+// lock.writeLock().lock();
+// assertTrue(lock.getQueuedThreads().isEmpty());
+// t1.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertTrue(lock.getQueuedThreads().contains(t1));
+// t2.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertTrue(lock.getQueuedThreads().contains(t1));
+// assertTrue(lock.getQueuedThreads().contains(t2));
+// t1.interrupt();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertFalse(lock.getQueuedThreads().contains(t1));
+// assertTrue(lock.getQueuedThreads().contains(t2));
+// lock.writeLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// assertTrue(lock.getQueuedThreads().isEmpty());
+// t1.join();
+// t2.join();
+// } catch(Exception e){
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * hasWaiters throws NPE if null
+// */
+// public void testHasWaitersNPE() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// try {
+// lock.hasWaiters(null);
+// shouldThrow();
+// } catch (NullPointerException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * getWaitQueueLength throws NPE if null
+// */
+// public void testGetWaitQueueLengthNPE() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// try {
+// lock.getWaitQueueLength(null);
+// shouldThrow();
+// } catch (NullPointerException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+//
+// /**
+// * getWaitingThreads throws NPE if null
+// */
+// public void testGetWaitingThreadsNPE() {
+// final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+// try {
+// lock.getWaitingThreads(null);
+// shouldThrow();
+// } catch (NullPointerException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * hasWaiters throws IAE if not owned
+// */
+// public void testHasWaitersIAE() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
+// try {
+// lock2.hasWaiters(c);
+// shouldThrow();
+// } catch (IllegalArgumentException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * hasWaiters throws IMSE if not locked
+// */
+// public void testHasWaitersIMSE() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// try {
+// lock.hasWaiters(c);
+// shouldThrow();
+// } catch (IllegalMonitorStateException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+//
+// /**
+// * getWaitQueueLength throws IAE if not owned
+// */
+// public void testGetWaitQueueLengthIAE() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
+// try {
+// lock2.getWaitQueueLength(c);
+// shouldThrow();
+// } catch (IllegalArgumentException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * getWaitQueueLength throws IMSE if not locked
+// */
+// public void testGetWaitQueueLengthIMSE() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// try {
+// lock.getWaitQueueLength(c);
+// shouldThrow();
+// } catch (IllegalMonitorStateException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+//
+// /**
+// * getWaitingThreads throws IAE if not owned
+// */
+// public void testGetWaitingThreadsIAE() {
+// final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
+// try {
+// lock2.getWaitingThreads(c);
+// shouldThrow();
+// } catch (IllegalArgumentException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * getWaitingThreads throws IMSE if not locked
+// */
+// public void testGetWaitingThreadsIMSE() {
+// final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// try {
+// lock.getWaitingThreads(c);
+// shouldThrow();
+// } catch (IllegalMonitorStateException success) {
+// } catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+//
+// /**
+// * hasWaiters returns true when a thread is waiting, else false
+// */
+// public void testHasWaiters() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// Thread t = new Thread(new Runnable() {
+// public void run() {
+// try {
+// lock.writeLock().lock();
+// threadAssertFalse(lock.hasWaiters(c));
+// threadAssertEquals(0, lock.getWaitQueueLength(c));
+// c.await();
+// lock.writeLock().unlock();
+// }
+// catch(InterruptedException e) {
+// threadUnexpectedException();
+// }
+// }
+// });
+//
+// try {
+// t.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.writeLock().lock();
+// assertTrue(lock.hasWaiters(c));
+// assertEquals(1, lock.getWaitQueueLength(c));
+// c.signal();
+// lock.writeLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.writeLock().lock();
+// assertFalse(lock.hasWaiters(c));
+// assertEquals(0, lock.getWaitQueueLength(c));
+// lock.writeLock().unlock();
+// t.join(SHORT_DELAY_MS);
+// assertFalse(t.isAlive());
+// }
+// catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+// /**
+// * getWaitQueueLength returns number of waiting threads
+// */
+// public void testGetWaitQueueLength() {
+// final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+// final Condition c = (lock.writeLock().newCondition());
+// Thread t = new Thread(new Runnable() {
+// public void run() {
+// try {
+// lock.writeLock().lock();
+// threadAssertFalse(lock.hasWaiters(c));
+// threadAssertEquals(0, lock.getWaitQueueLength(c));
+// c.await();
+// lock.writeLock().unlock();
+// }
+// catch(InterruptedException e) {
+// threadUnexpectedException();
+// }
+// }
+// });
+//
+// try {
+// t.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.writeLock().lock();
+// assertTrue(lock.hasWaiters(c));
+// assertEquals(1, lock.getWaitQueueLength(c));
+// c.signal();
+// lock.writeLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.writeLock().lock();
+// assertFalse(lock.hasWaiters(c));
+// assertEquals(0, lock.getWaitQueueLength(c));
+// lock.writeLock().unlock();
+// t.join(SHORT_DELAY_MS);
+// assertFalse(t.isAlive());
+// }
+// catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+//
+//
+// /**
+// * getWaitingThreads returns only and all waiting threads
+// */
+// public void testGetWaitingThreads() {
+// final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+// final Condition c = lock.writeLock().newCondition();
+// Thread t1 = new Thread(new Runnable() {
+// public void run() {
+// try {
+// lock.writeLock().lock();
+// threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
+// c.await();
+// lock.writeLock().unlock();
+// }
+// catch(InterruptedException e) {
+// threadUnexpectedException();
+// }
+// }
+// });
+//
+// Thread t2 = new Thread(new Runnable() {
+// public void run() {
+// try {
+// lock.writeLock().lock();
+// threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
+// c.await();
+// lock.writeLock().unlock();
+// }
+// catch(InterruptedException e) {
+// threadUnexpectedException();
+// }
+// }
+// });
+//
+// try {
+// lock.writeLock().lock();
+// assertTrue(lock.getWaitingThreads(c).isEmpty());
+// lock.writeLock().unlock();
+// t1.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// t2.start();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.writeLock().lock();
+// assertTrue(lock.hasWaiters(c));
+// assertTrue(lock.getWaitingThreads(c).contains(t1));
+// assertTrue(lock.getWaitingThreads(c).contains(t2));
+// c.signalAll();
+// lock.writeLock().unlock();
+// Thread.sleep(SHORT_DELAY_MS);
+// lock.writeLock().lock();
+// assertFalse(lock.hasWaiters(c));
+// assertTrue(lock.getWaitingThreads(c).isEmpty());
+// lock.writeLock().unlock();
+// t1.join(SHORT_DELAY_MS);
+// t2.join(SHORT_DELAY_MS);
+// assertFalse(t1.isAlive());
+// assertFalse(t2.isAlive());
+// }
+// catch (Exception ex) {
+// unexpectedException();
+// }
+// }
+
+ /**
+ * toString indicates current lock state
+ */
+ public void testToString() {
+ ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ String us = lock.toString();
+ assertTrue(us.indexOf("Write locks = 0") >= 0);
+ assertTrue(us.indexOf("Read locks = 0") >= 0);
+ lock.writeLock().lock();
+ String ws = lock.toString();
+ assertTrue(ws.indexOf("Write locks = 1") >= 0);
+ assertTrue(ws.indexOf("Read locks = 0") >= 0);
+ lock.writeLock().unlock();
+ lock.readLock().lock();
+ lock.readLock().lock();
+ String rs = lock.toString();
+ assertTrue(rs.indexOf("Write locks = 0") >= 0);
+ assertTrue(rs.indexOf("Read locks = 2") >= 0);
+ }
+
+ /**
+ * readLock.toString indicates current lock state
+ */
+ public void testReadLockToString() {
+ ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ String us = lock.readLock().toString();
+ assertTrue(us.indexOf("Read locks = 0") >= 0);
+ lock.readLock().lock();
+ lock.readLock().lock();
+ String rs = lock.readLock().toString();
+ assertTrue(rs.indexOf("Read locks = 2") >= 0);
+ }
+
+ /**
+ * writeLock.toString indicates current lock state
+ */
+ public void testWriteLockToString() {
+ ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+ String us = lock.writeLock().toString();
+ assertTrue(us.indexOf("Unlocked") >= 0);
+ lock.writeLock().lock();
+ String ls = lock.writeLock().toString();
+ assertTrue(ls.indexOf("Locked") >= 0);
+ }
+
+}
More information about the jboss-cvs-commits
mailing list