--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2003/12/04 20:54:46	1.7
+++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2003/12/28 22:44:59	1.14
@@ -1,8 +1,9 @@
 /*
- * Written by members of JCP JSR-166 Expert Group and released to the
- * public domain. Use, modify, and redistribute this code in any way
- * without acknowledgement. Other contributors include Andrew Wright,
- * Jeffrey Hayes, Pat Fischer, Mike Judd.
+ * 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.*;
@@ -56,17 +57,9 @@ public class ReentrantReadWriteLockTest
         public Collection<Thread> getQueuedThreads() { 
             return super.getQueuedThreads(); 
         }
-        public PublicCondition newCondition() { 
-            return new PublicCondition(this);
+        public Collection<Thread> getWaitingThreads(Condition c) { 
+            return super.getWaitingThreads(c); 
         }
-
-        static class PublicCondition extends AbstractReentrantLock.ConditionObject {
-            PublicCondition(PublicReentrantReadWriteLock l) { super(l); }
-            public Collection<Thread> getWaitingThreads() { 
-                return super.getWaitingThreads(); 
-            }
-        }
-
     }
 
     /**
@@ -76,11 +69,11 @@ public class ReentrantReadWriteLockTest
 	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
         assertFalse(rl.isFair());
         assertFalse(rl.isWriteLocked());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
 	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
         assertTrue(r2.isFair());
         assertFalse(r2.isWriteLocked());
-        assertEquals(0, r2.getReadLocks());
+        assertEquals(0, r2.getReadLockCount());
     }
 
     /**
@@ -91,19 +84,19 @@ public class ReentrantReadWriteLockTest
         rl.writeLock().lock();
         assertTrue(rl.isWriteLocked());
         assertTrue(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
         rl.writeLock().unlock();
         assertFalse(rl.isWriteLocked());
         assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
         rl.readLock().lock();
         assertFalse(rl.isWriteLocked());
         assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(1, rl.getReadLocks());
+        assertEquals(1, rl.getReadLockCount());
         rl.readLock().unlock();
         assertFalse(rl.isWriteLocked());
         assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
     }
 
 
@@ -115,19 +108,19 @@ public class ReentrantReadWriteLockTest
         rl.writeLock().lock();
         assertTrue(rl.isWriteLocked());
         assertTrue(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
         rl.writeLock().unlock();
         assertFalse(rl.isWriteLocked());
         assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
         rl.readLock().lock();
         assertFalse(rl.isWriteLocked());
         assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(1, rl.getReadLocks());
+        assertEquals(1, rl.getReadLockCount());
         rl.readLock().unlock();
         assertFalse(rl.isWriteLocked());
         assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLocks());
+        assertEquals(0, rl.getReadLockCount());
     }
 
     /**
@@ -855,6 +848,35 @@ public class ReentrantReadWriteLockTest
     }
 
     /**
+     * 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();
+        }
+    } 
+
+    /**
      * getQueueLength reports number of waiting threads
      */
     public void testGetQueueLength() { 
@@ -916,17 +938,156 @@ public class ReentrantReadWriteLockTest
     } 
 
     /**
+     * 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 AbstractReentrantLock.ConditionObject c = (AbstractReentrantLock.ConditionObject)(lock.writeLock().newCondition());
+	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(c.hasWaiters());
-                        threadAssertEquals(0, c.getWaitQueueLength());
+                        threadAssertFalse(lock.hasWaiters(c));
+                        threadAssertEquals(0, lock.getWaitQueueLength(c));
                         c.await();
                         lock.writeLock().unlock();
 		    }
@@ -940,14 +1101,14 @@ public class ReentrantReadWriteLockTest
             t.start();
             Thread.sleep(SHORT_DELAY_MS);
             lock.writeLock().lock();
-            assertTrue(c.hasWaiters());
-            assertEquals(1, c.getWaitQueueLength());
+            assertTrue(lock.hasWaiters(c));
+            assertEquals(1, lock.getWaitQueueLength(c));
             c.signal();
             lock.writeLock().unlock();
             Thread.sleep(SHORT_DELAY_MS);
             lock.writeLock().lock();
-            assertFalse(c.hasWaiters());
-            assertEquals(0, c.getWaitQueueLength());
+            assertFalse(lock.hasWaiters(c));
+            assertEquals(0, lock.getWaitQueueLength(c));
             lock.writeLock().unlock();
             t.join(SHORT_DELAY_MS);
             assertFalse(t.isAlive());
@@ -961,29 +1122,14 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength returns number of waiting threads
      */
     public void testGetWaitQueueLength() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();	
-        final AbstractReentrantLock.ConditionObject c = (AbstractReentrantLock.ConditionObject)(lock.writeLock().newCondition());
-	Thread t1 = new Thread(new Runnable() { 
-		public void run() {
-		    try {
-			lock.writeLock().lock();
-                        threadAssertFalse(c.hasWaiters());
-                        threadAssertEquals(0, c.getWaitQueueLength());
-                        c.await();
-                        lock.writeLock().unlock();
-		    }
-		    catch(InterruptedException e) {
-                        threadUnexpectedException();
-                    }
-		}
-	    });
-
-	Thread t2 = new Thread(new Runnable() { 
+	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final Condition c = (lock.writeLock().newCondition());
+	Thread t = new Thread(new Runnable() { 
 		public void run() {
 		    try {
 			lock.writeLock().lock();
-                        threadAssertTrue(c.hasWaiters());
-                        threadAssertEquals(1, c.getWaitQueueLength());
+                        threadAssertFalse(lock.hasWaiters(c));
+                        threadAssertEquals(0, lock.getWaitQueueLength(c));
                         c.await();
                         lock.writeLock().unlock();
 		    }
@@ -994,41 +1140,38 @@ public class ReentrantReadWriteLockTest
 	    });
 
         try {
-            t1.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t2.start();
+            t.start();
             Thread.sleep(SHORT_DELAY_MS);
             lock.writeLock().lock();
-            assertTrue(c.hasWaiters());
-            assertEquals(2, c.getWaitQueueLength());
-            c.signalAll();
+            assertTrue(lock.hasWaiters(c));
+            assertEquals(1, lock.getWaitQueueLength(c));
+            c.signal();
             lock.writeLock().unlock();
             Thread.sleep(SHORT_DELAY_MS);
             lock.writeLock().lock();
-            assertFalse(c.hasWaiters());
-            assertEquals(0, c.getWaitQueueLength());
+            assertFalse(lock.hasWaiters(c));
+            assertEquals(0, lock.getWaitQueueLength(c));
             lock.writeLock().unlock();
-            t1.join(SHORT_DELAY_MS);
-            t2.join(SHORT_DELAY_MS);
-            assertFalse(t1.isAlive());
-            assertFalse(t2.isAlive());
+            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 PublicReentrantReadWriteLock.PublicCondition c = (PublicReentrantReadWriteLock.PublicCondition)lock.newCondition();
+        final Condition c = lock.writeLock().newCondition();
 	Thread t1 = new Thread(new Runnable() { 
 		public void run() {
 		    try {
 			lock.writeLock().lock();
-                        threadAssertTrue(c.getWaitingThreads().isEmpty());
+                        threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
                         c.await();
                         lock.writeLock().unlock();
 		    }
@@ -1042,7 +1185,7 @@ public class ReentrantReadWriteLockTest
 		public void run() {
 		    try {
 			lock.writeLock().lock();
-                        threadAssertFalse(c.getWaitingThreads().isEmpty());
+                        threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
                         c.await();
                         lock.writeLock().unlock();
 		    }
@@ -1054,22 +1197,22 @@ public class ReentrantReadWriteLockTest
 
         try {
             lock.writeLock().lock();
-            assertTrue(c.getWaitingThreads().isEmpty());
+            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(c.hasWaiters());
-            assertTrue(c.getWaitingThreads().contains(t1));
-            assertTrue(c.getWaitingThreads().contains(t2));
+            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(c.hasWaiters());
-            assertTrue(c.getWaitingThreads().isEmpty());
+            assertFalse(lock.hasWaiters(c));
+            assertTrue(lock.getWaitingThreads(c).isEmpty());
             lock.writeLock().unlock();
             t1.join(SHORT_DELAY_MS);
             t2.join(SHORT_DELAY_MS);