--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2003/12/29 19:05:40	1.15
+++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2005/01/20 00:39:13	1.21
@@ -156,16 +156,18 @@ public class ReentrantReadWriteLockTest
      */
     public void testWriteLockInterruptibly_Interrupted() { 
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
 	Thread t = new Thread(new Runnable() {
                 public void run() {
                     try {
 			lock.writeLock().lockInterruptibly();
-			threadShouldThrow();
+                        lock.writeLock().unlock();
+			lock.writeLock().lockInterruptibly();
+                        lock.writeLock().unlock();
 		    } catch(InterruptedException success){}
 		}
 	    });
         try {
+            lock.writeLock().lock();
             t.start();
             t.interrupt();
             lock.writeLock().unlock();
@@ -185,7 +187,6 @@ public class ReentrantReadWriteLockTest
                 public void run() {
                     try {
 			lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
-			threadShouldThrow();
 		    } catch(InterruptedException success){}
 		}
 	    });
@@ -209,7 +210,6 @@ public class ReentrantReadWriteLockTest
                 public void run() {
                     try {
 			lock.readLock().lockInterruptibly();
-			threadShouldThrow();
 		    } catch(InterruptedException success){}
 		}
 	    });
@@ -376,6 +376,106 @@ public class ReentrantReadWriteLockTest
         }
     } 
 
+    /**
+     * 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
+     */
+    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();
+        }
+    } 
+
+    /**
+     * 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
+     */
+    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();
+        }
+    } 
+
 
     /**
      * Read tryLock succeeds if readlocked but not writelocked
@@ -591,7 +691,6 @@ public class ReentrantReadWriteLockTest
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.writeLock().lock();
-            assertFalse(c.await(10, TimeUnit.MILLISECONDS));
             lock.writeLock().unlock();
         }
         catch (Exception ex) {
@@ -608,7 +707,6 @@ public class ReentrantReadWriteLockTest
         try {
             lock.writeLock().lock();
             java.util.Date d = new java.util.Date();
-            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
             lock.writeLock().unlock();
         }
         catch (Exception ex) {
@@ -877,6 +975,53 @@ public class ReentrantReadWriteLockTest
     } 
 
     /**
+     * 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() { 
@@ -1224,4 +1369,49 @@ public class ReentrantReadWriteLockTest
         }
     }
 
+    /**
+     * 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);
+    }
+
 }